@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,33 +6,11 @@ export interface DisassociateTrunkInterfaceCommandInput extends DisassociateTrun
 }
 export interface DisassociateTrunkInterfaceCommandOutput extends DisassociateTrunkInterfaceResult, __MetadataBearer {
 }
-/**
- * <note>
- *             <p>This API action is currently in <b>limited preview only</b>.
- *                 If you are interested in using this feature, contact your account manager.</p>
- *         </note>
- *         <p>Removes an association between a branch network interface with a trunk network interface.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DisassociateTrunkInterfaceCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisassociateTrunkInterfaceCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisassociateTrunkInterfaceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateTrunkInterfaceCommandInput} for command's `input` shape.
- * @see {@link DisassociateTrunkInterfaceCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateTrunkInterfaceCommand extends $Command<DisassociateTrunkInterfaceCommandInput, DisassociateTrunkInterfaceCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisassociateTrunkInterfaceCommandInput;
     constructor(input: DisassociateTrunkInterfaceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateTrunkInterfaceCommandInput, DisassociateTrunkInterfaceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DisassociateVpcCidrBlockCommandInput extends DisassociateVpcCid
 }
 export interface DisassociateVpcCidrBlockCommandOutput extends DisassociateVpcCidrBlockResult, __MetadataBearer {
 }
-/**
- * <p>Disassociates a CIDR block from a VPC. To disassociate the CIDR block, you must
- *             specify its association ID. You can get the association ID by using
- *                 <a>DescribeVpcs</a>. You must detach or delete all gateways and resources that
- *             are associated with the CIDR block before you can disassociate it. </p>
- * 		       <p>You cannot disassociate the CIDR block with which you originally created the VPC (the
- * 			primary CIDR block).</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DisassociateVpcCidrBlockCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisassociateVpcCidrBlockCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisassociateVpcCidrBlockCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateVpcCidrBlockCommandInput} for command's `input` shape.
- * @see {@link DisassociateVpcCidrBlockCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateVpcCidrBlockCommand extends $Command<DisassociateVpcCidrBlockCommandInput, DisassociateVpcCidrBlockCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisassociateVpcCidrBlockCommandInput;
     constructor(input: DisassociateVpcCidrBlockCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateVpcCidrBlockCommandInput, DisassociateVpcCidrBlockCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,40 +6,11 @@ export interface EnableEbsEncryptionByDefaultCommandInput extends EnableEbsEncry
 }
 export interface EnableEbsEncryptionByDefaultCommandOutput extends EnableEbsEncryptionByDefaultResult, __MetadataBearer {
 }
-/**
- * <p>Enables EBS encryption by default for your account in the current Region.</p>
- *          <p>After you enable encryption by default, the EBS volumes that you create are
- *     	always encrypted, either using the default KMS key or the KMS key that you specified
- *       when you created each volume. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html">Amazon EBS encryption</a> in the
- *       <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- *   	      <p>You can specify the default KMS key for encryption by default using <a>ModifyEbsDefaultKmsKeyId</a>
- *       or <a>ResetEbsDefaultKmsKeyId</a>.</p>
- *          <p>Enabling encryption by default has no effect on the encryption status of your
- *       existing volumes.</p>
- *          <p>After you enable encryption by default, you can no longer launch instances
- *       using instance types that do not support encryption. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances">Supported
- *         instance types</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, EnableEbsEncryptionByDefaultCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, EnableEbsEncryptionByDefaultCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new EnableEbsEncryptionByDefaultCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableEbsEncryptionByDefaultCommandInput} for command's `input` shape.
- * @see {@link EnableEbsEncryptionByDefaultCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class EnableEbsEncryptionByDefaultCommand extends $Command<EnableEbsEncryptionByDefaultCommandInput, EnableEbsEncryptionByDefaultCommandOutput, EC2ClientResolvedConfig> {
     readonly input: EnableEbsEncryptionByDefaultCommandInput;
     constructor(input: EnableEbsEncryptionByDefaultCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableEbsEncryptionByDefaultCommandInput, EnableEbsEncryptionByDefaultCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface EnableFastSnapshotRestoresCommandInput extends EnableFastSnapsh
 }
 export interface EnableFastSnapshotRestoresCommandOutput extends EnableFastSnapshotRestoresResult, __MetadataBearer {
 }
-/**
- * <p>Enables fast snapshot restores for the specified snapshots in the specified Availability Zones.</p>
- *          <p>You get the full benefit of fast snapshot restores after they enter the <code>enabled</code> state.
- *       To get the current state of fast snapshot restores, use <a>DescribeFastSnapshotRestores</a>.
- *       To disable fast snapshot restores, use <a>DisableFastSnapshotRestores</a>.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-fast-snapshot-restore.html">Amazon EBS fast snapshot
- *       restore</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, EnableFastSnapshotRestoresCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, EnableFastSnapshotRestoresCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new EnableFastSnapshotRestoresCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableFastSnapshotRestoresCommandInput} for command's `input` shape.
- * @see {@link EnableFastSnapshotRestoresCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class EnableFastSnapshotRestoresCommand extends $Command<EnableFastSnapshotRestoresCommandInput, EnableFastSnapshotRestoresCommandOutput, EC2ClientResolvedConfig> {
     readonly input: EnableFastSnapshotRestoresCommandInput;
     constructor(input: EnableFastSnapshotRestoresCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableFastSnapshotRestoresCommandInput, EnableFastSnapshotRestoresCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface EnableImageDeprecationCommandInput extends EnableImageDeprecati
 }
 export interface EnableImageDeprecationCommandOutput extends EnableImageDeprecationResult, __MetadataBearer {
 }
-/**
- * <p>Enables deprecation of the specified AMI at the specified date and time.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deprecate.html">Deprecate 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, EnableImageDeprecationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, EnableImageDeprecationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new EnableImageDeprecationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableImageDeprecationCommandInput} for command's `input` shape.
- * @see {@link EnableImageDeprecationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class EnableImageDeprecationCommand extends $Command<EnableImageDeprecationCommandInput, EnableImageDeprecationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: EnableImageDeprecationCommandInput;
     constructor(input: EnableImageDeprecationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableImageDeprecationCommandInput, EnableImageDeprecationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface EnableSerialConsoleAccessCommandInput extends EnableSerialConso
 }
 export interface EnableSerialConsoleAccessCommandOutput extends EnableSerialConsoleAccessResult, __MetadataBearer {
 }
-/**
- * <p>Enables access to the EC2 serial console of all instances for your account. By default,
- * 			access to the EC2 serial console is disabled for your account. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configure-access-to-serial-console.html#serial-console-account-access">Manage account access to the EC2 serial console</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, EnableSerialConsoleAccessCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, EnableSerialConsoleAccessCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new EnableSerialConsoleAccessCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableSerialConsoleAccessCommandInput} for command's `input` shape.
- * @see {@link EnableSerialConsoleAccessCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class EnableSerialConsoleAccessCommand extends $Command<EnableSerialConsoleAccessCommandInput, EnableSerialConsoleAccessCommandOutput, EC2ClientResolvedConfig> {
     readonly input: EnableSerialConsoleAccessCommandInput;
     constructor(input: EnableSerialConsoleAccessCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableSerialConsoleAccessCommandInput, EnableSerialConsoleAccessCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface EnableVgwRoutePropagationCommandInput extends EnableVgwRoutePro
 }
 export interface EnableVgwRoutePropagationCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Enables a virtual private gateway (VGW) to propagate routes to the specified route
- *             table of a VPC.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, EnableVgwRoutePropagationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, EnableVgwRoutePropagationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new EnableVgwRoutePropagationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableVgwRoutePropagationCommandInput} for command's `input` shape.
- * @see {@link EnableVgwRoutePropagationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class EnableVgwRoutePropagationCommand extends $Command<EnableVgwRoutePropagationCommandInput, EnableVgwRoutePropagationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: EnableVgwRoutePropagationCommandInput;
     constructor(input: EnableVgwRoutePropagationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableVgwRoutePropagationCommandInput, EnableVgwRoutePropagationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface EnableVolumeIOCommandInput extends EnableVolumeIORequest {
 }
 export interface EnableVolumeIOCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Enables I/O operations for a volume that had I/O operations disabled because the data on
- *       the volume was potentially inconsistent.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, EnableVolumeIOCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, EnableVolumeIOCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new EnableVolumeIOCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableVolumeIOCommandInput} for command's `input` shape.
- * @see {@link EnableVolumeIOCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class EnableVolumeIOCommand extends $Command<EnableVolumeIOCommandInput, EnableVolumeIOCommandOutput, EC2ClientResolvedConfig> {
     readonly input: EnableVolumeIOCommandInput;
     constructor(input: EnableVolumeIOCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableVolumeIOCommandInput, EnableVolumeIOCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface EnableVpcClassicLinkCommandInput extends EnableVpcClassicLinkRe
 }
 export interface EnableVpcClassicLinkCommandOutput extends EnableVpcClassicLinkResult, __MetadataBearer {
 }
-/**
- * <p>Enables a VPC for ClassicLink. You can then link EC2-Classic instances to your
- * 			ClassicLink-enabled VPC to allow communication over private IP addresses. You cannot
- * 			enable your VPC for ClassicLink if any of your VPC route tables have existing routes for
- * 			address ranges within the <code>10.0.0.0/8</code> IP address range, excluding local
- * 			routes for VPCs in the <code>10.0.0.0/16</code> and <code>10.1.0.0/16</code> IP address
- * 			ranges. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/vpc-classiclink.html">ClassicLink</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, EnableVpcClassicLinkCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, EnableVpcClassicLinkCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new EnableVpcClassicLinkCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableVpcClassicLinkCommandInput} for command's `input` shape.
- * @see {@link EnableVpcClassicLinkCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class EnableVpcClassicLinkCommand extends $Command<EnableVpcClassicLinkCommandInput, EnableVpcClassicLinkCommandOutput, EC2ClientResolvedConfig> {
     readonly input: EnableVpcClassicLinkCommandInput;
     constructor(input: EnableVpcClassicLinkCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableVpcClassicLinkCommandInput, EnableVpcClassicLinkCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface EnableVpcClassicLinkDnsSupportCommandInput extends EnableVpcCla
 }
 export interface EnableVpcClassicLinkDnsSupportCommandOutput extends EnableVpcClassicLinkDnsSupportResult, __MetadataBearer {
 }
-/**
- * <p>Enables a VPC to support DNS hostname resolution for ClassicLink. If enabled, the DNS
- * 			hostname of a linked EC2-Classic instance resolves to its private IP address when
- * 			addressed from an instance in the VPC to which it's linked. Similarly, the DNS hostname
- * 			of an instance in a VPC resolves to its private IP address when addressed from a linked
- * 			EC2-Classic instance. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/vpc-classiclink.html">ClassicLink</a> in the
- * 				<i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- *          <p>You must specify a VPC ID in the request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, EnableVpcClassicLinkDnsSupportCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, EnableVpcClassicLinkDnsSupportCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new EnableVpcClassicLinkDnsSupportCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableVpcClassicLinkDnsSupportCommandInput} for command's `input` shape.
- * @see {@link EnableVpcClassicLinkDnsSupportCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class EnableVpcClassicLinkDnsSupportCommand extends $Command<EnableVpcClassicLinkDnsSupportCommandInput, EnableVpcClassicLinkDnsSupportCommandOutput, EC2ClientResolvedConfig> {
     readonly input: EnableVpcClassicLinkDnsSupportCommandInput;
     constructor(input: EnableVpcClassicLinkDnsSupportCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableVpcClassicLinkDnsSupportCommandInput, EnableVpcClassicLinkDnsSupportCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ExportClientVpnClientCertificateRevocationListCommandInput exte
 }
 export interface ExportClientVpnClientCertificateRevocationListCommandOutput extends ExportClientVpnClientCertificateRevocationListResult, __MetadataBearer {
 }
-/**
- * <p>Downloads the client certificate revocation list 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, ExportClientVpnClientCertificateRevocationListCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ExportClientVpnClientCertificateRevocationListCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ExportClientVpnClientCertificateRevocationListCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ExportClientVpnClientCertificateRevocationListCommandInput} for command's `input` shape.
- * @see {@link ExportClientVpnClientCertificateRevocationListCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ExportClientVpnClientCertificateRevocationListCommand extends $Command<ExportClientVpnClientCertificateRevocationListCommandInput, ExportClientVpnClientCertificateRevocationListCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ExportClientVpnClientCertificateRevocationListCommandInput;
     constructor(input: ExportClientVpnClientCertificateRevocationListCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExportClientVpnClientCertificateRevocationListCommandInput, ExportClientVpnClientCertificateRevocationListCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface ExportClientVpnClientConfigurationCommandInput extends ExportCl
 }
 export interface ExportClientVpnClientConfigurationCommandOutput extends ExportClientVpnClientConfigurationResult, __MetadataBearer {
 }
-/**
- * <p>Downloads the contents of the Client VPN endpoint configuration file for the specified Client VPN endpoint. The Client VPN endpoint configuration
- * 			file includes the Client VPN endpoint and certificate information clients need to establish a connection
- * 			with the Client VPN endpoint.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ExportClientVpnClientConfigurationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ExportClientVpnClientConfigurationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ExportClientVpnClientConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ExportClientVpnClientConfigurationCommandInput} for command's `input` shape.
- * @see {@link ExportClientVpnClientConfigurationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ExportClientVpnClientConfigurationCommand extends $Command<ExportClientVpnClientConfigurationCommandInput, ExportClientVpnClientConfigurationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ExportClientVpnClientConfigurationCommandInput;
     constructor(input: ExportClientVpnClientConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExportClientVpnClientConfigurationCommandInput, ExportClientVpnClientConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface ExportImageCommandInput extends ExportImageRequest {
 }
 export interface ExportImageCommandOutput extends ExportImageResult, __MetadataBearer {
 }
-/**
- * <p>Exports an Amazon Machine Image (AMI) to a VM file. For more information, see <a href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmexport_image.html">Exporting a VM
- *     directly from an Amazon Machine Image (AMI)</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, ExportImageCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ExportImageCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ExportImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ExportImageCommandInput} for command's `input` shape.
- * @see {@link ExportImageCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ExportImageCommand extends $Command<ExportImageCommandInput, ExportImageCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ExportImageCommandInput;
     constructor(input: ExportImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExportImageCommandInput, ExportImageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ExportTransitGatewayRoutesCommandInput extends ExportTransitGat
 }
 export interface ExportTransitGatewayRoutesCommandOutput extends ExportTransitGatewayRoutesResult, __MetadataBearer {
 }
-/**
- * <p>Exports routes from the specified transit gateway route table to the specified S3 bucket.
- *          By default, all routes are exported. Alternatively, you can filter by CIDR range.</p>
- *          <p>The routes are saved to the specified bucket in a JSON file. For more information, see
- *                 <a href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#tgw-export-route-tables">Export Route Tables
- *                 to Amazon S3</a> in <i>Transit Gateways</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ExportTransitGatewayRoutesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ExportTransitGatewayRoutesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ExportTransitGatewayRoutesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ExportTransitGatewayRoutesCommandInput} for command's `input` shape.
- * @see {@link ExportTransitGatewayRoutesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ExportTransitGatewayRoutesCommand extends $Command<ExportTransitGatewayRoutesCommandInput, ExportTransitGatewayRoutesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ExportTransitGatewayRoutesCommandInput;
     constructor(input: ExportTransitGatewayRoutesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExportTransitGatewayRoutesCommandInput, ExportTransitGatewayRoutesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface GetAssociatedEnclaveCertificateIamRolesCommandInput extends Get
 }
 export interface GetAssociatedEnclaveCertificateIamRolesCommandOutput extends GetAssociatedEnclaveCertificateIamRolesResult, __MetadataBearer {
 }
-/**
- * <p>Returns the IAM roles that are associated with the specified ACM (ACM) certificate.
- * 			It also returns the name of the Amazon S3 bucket and the Amazon S3 object key where the certificate,
- * 			certificate chain, and encrypted private key bundle are stored, and the ARN of the KMS key
- * 			that's used to encrypt the private key.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetAssociatedEnclaveCertificateIamRolesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetAssociatedEnclaveCertificateIamRolesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetAssociatedEnclaveCertificateIamRolesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAssociatedEnclaveCertificateIamRolesCommandInput} for command's `input` shape.
- * @see {@link GetAssociatedEnclaveCertificateIamRolesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAssociatedEnclaveCertificateIamRolesCommand extends $Command<GetAssociatedEnclaveCertificateIamRolesCommandInput, GetAssociatedEnclaveCertificateIamRolesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetAssociatedEnclaveCertificateIamRolesCommandInput;
     constructor(input: GetAssociatedEnclaveCertificateIamRolesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAssociatedEnclaveCertificateIamRolesCommandInput, GetAssociatedEnclaveCertificateIamRolesCommandOutput>;
     private serialize;
     private deserialize;

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

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