@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,37 +6,11 @@ export interface AssociateVpcCidrBlockCommandInput extends AssociateVpcCidrBlock
 }
 export interface AssociateVpcCidrBlockCommandOutput extends AssociateVpcCidrBlockResult, __MetadataBearer {
 }
-/**
- * <p>Associates a CIDR block with your VPC. You can associate a secondary IPv4 CIDR block,
- *             an Amazon-provided IPv6 CIDR block, or an IPv6 CIDR block from an IPv6 address pool that
- *             you provisioned through bring your own IP addresses (<a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">BYOIP</a>). The IPv6 CIDR block size is fixed
- *             at /56.</p>
- *         <p>You must specify one of the following in the request: an IPv4 CIDR block, an IPv6
- *             pool, or an Amazon-provided IPv6 CIDR block.</p>
- *         <p>For more information about associating CIDR blocks with your VPC and applicable
- *             restrictions, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html#VPC_Sizing">VPC and subnet sizing</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, AssociateVpcCidrBlockCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AssociateVpcCidrBlockCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AssociateVpcCidrBlockCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateVpcCidrBlockCommandInput} for command's `input` shape.
- * @see {@link AssociateVpcCidrBlockCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateVpcCidrBlockCommand extends $Command<AssociateVpcCidrBlockCommandInput, AssociateVpcCidrBlockCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateVpcCidrBlockCommandInput;
     constructor(input: AssociateVpcCidrBlockCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateVpcCidrBlockCommandInput, AssociateVpcCidrBlockCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface AttachClassicLinkVpcCommandInput extends AttachClassicLinkVpcRe
 }
 export interface AttachClassicLinkVpcCommandOutput extends AttachClassicLinkVpcResult, __MetadataBearer {
 }
-/**
- * <p>Links an EC2-Classic instance to a ClassicLink-enabled VPC through one or more of the VPC's
- * 			security groups. You cannot link an EC2-Classic instance to more than one VPC at a time. You
- * 			can only link an instance that's in the <code>running</code> state. An instance is
- * 			automatically unlinked from a VPC when it's stopped - you can link it to the VPC again when
- * 			you restart it.</p>
- * 		       <p>After you've linked an instance, you cannot change the VPC security groups that are associated with it. To change the security groups, you must first unlink the instance, and then link it again.</p>
- * 		       <p>Linking your instance to a VPC is sometimes referred to as <i>attaching</i> your instance.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AttachClassicLinkVpcCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AttachClassicLinkVpcCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AttachClassicLinkVpcCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AttachClassicLinkVpcCommandInput} for command's `input` shape.
- * @see {@link AttachClassicLinkVpcCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AttachClassicLinkVpcCommand extends $Command<AttachClassicLinkVpcCommandInput, AttachClassicLinkVpcCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AttachClassicLinkVpcCommandInput;
     constructor(input: AttachClassicLinkVpcCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AttachClassicLinkVpcCommandInput, AttachClassicLinkVpcCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface AttachInternetGatewayCommandInput extends AttachInternetGateway
 }
 export interface AttachInternetGatewayCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Attaches an internet gateway or a virtual private gateway to a VPC, enabling connectivity between the internet and
- * 			the VPC. For more information about your VPC and internet gateway, see the <a href="https://docs.aws.amazon.com/vpc/latest/userguide/">Amazon Virtual Private Cloud User Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AttachInternetGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AttachInternetGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AttachInternetGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AttachInternetGatewayCommandInput} for command's `input` shape.
- * @see {@link AttachInternetGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AttachInternetGatewayCommand extends $Command<AttachInternetGatewayCommandInput, AttachInternetGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AttachInternetGatewayCommandInput;
     constructor(input: AttachInternetGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AttachInternetGatewayCommandInput, AttachInternetGatewayCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,53 +6,11 @@ export interface AttachVolumeCommandInput extends AttachVolumeRequest {
 }
 export interface AttachVolumeCommandOutput extends VolumeAttachment, __MetadataBearer {
 }
-/**
- * <p>Attaches an EBS volume to a running or stopped instance and exposes it to the instance
- *       with the specified device name.</p>
- *          <p>Encrypted EBS volumes must be attached to instances that support Amazon EBS encryption. 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>After you attach an EBS volume, you must make it available. For more information, see
- *       <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-using-volumes.html">Make an EBS volume available for use</a>.</p>
- *          <p>If a volume has an Amazon Web Services Marketplace product code:</p>
- *          <ul>
- *             <li>
- *                <p>The volume can be attached only to a stopped instance.</p>
- *             </li>
- *             <li>
- *                <p>Amazon Web Services Marketplace product codes are copied from the volume to the instance.</p>
- *             </li>
- *             <li>
- *                <p>You must be subscribed to the product.</p>
- *             </li>
- *             <li>
- *                <p>The instance type and operating system of the instance must support the product. For
- *           example, you can't detach a volume from a Windows instance and attach it to a Linux
- *           instance.</p>
- *             </li>
- *          </ul>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-attaching-volume.html">Attach an Amazon EBS volume to an instance</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, AttachVolumeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AttachVolumeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AttachVolumeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AttachVolumeCommandInput} for command's `input` shape.
- * @see {@link AttachVolumeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AttachVolumeCommand extends $Command<AttachVolumeCommandInput, AttachVolumeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AttachVolumeCommandInput;
     constructor(input: AttachVolumeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AttachVolumeCommandInput, AttachVolumeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface AttachVpnGatewayCommandInput extends AttachVpnGatewayRequest {
 }
 export interface AttachVpnGatewayCommandOutput extends AttachVpnGatewayResult, __MetadataBearer {
 }
-/**
- * <p>Attaches a virtual private gateway to a VPC. You can attach one virtual private
- *             gateway to one VPC at a time.</p>
- *         <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AttachVpnGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AttachVpnGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AttachVpnGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AttachVpnGatewayCommandInput} for command's `input` shape.
- * @see {@link AttachVpnGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AttachVpnGatewayCommand extends $Command<AttachVpnGatewayCommandInput, AttachVpnGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AttachVpnGatewayCommandInput;
     constructor(input: AttachVpnGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AttachVpnGatewayCommandInput, AttachVpnGatewayCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface AuthorizeClientVpnIngressCommandInput extends AuthorizeClientVp
 }
 export interface AuthorizeClientVpnIngressCommandOutput extends AuthorizeClientVpnIngressResult, __MetadataBearer {
 }
-/**
- * <p>Adds an ingress authorization rule to a Client VPN endpoint. Ingress authorization rules act as
- * 			firewall rules that grant access to networks. You must configure ingress authorization rules to
- * 			enable clients to access resources in Amazon Web Services or on-premises networks.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AuthorizeClientVpnIngressCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AuthorizeClientVpnIngressCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AuthorizeClientVpnIngressCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AuthorizeClientVpnIngressCommandInput} for command's `input` shape.
- * @see {@link AuthorizeClientVpnIngressCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AuthorizeClientVpnIngressCommand extends $Command<AuthorizeClientVpnIngressCommandInput, AuthorizeClientVpnIngressCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AuthorizeClientVpnIngressCommandInput;
     constructor(input: AuthorizeClientVpnIngressCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AuthorizeClientVpnIngressCommandInput, AuthorizeClientVpnIngressCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface AuthorizeSecurityGroupEgressCommandInput extends AuthorizeSecur
 }
 export interface AuthorizeSecurityGroupEgressCommandOutput extends AuthorizeSecurityGroupEgressResult, __MetadataBearer {
 }
-/**
- * <p>[VPC only] Adds the specified outbound (egress) rules to a security group for use with a VPC.</p>
- *          <p>An outbound rule permits instances to send traffic to the specified IPv4 or IPv6 CIDR address
- *       ranges, or to the instances that are associated with the specified destination security groups.</p>
- *          <p>You specify a protocol for each rule (for example, TCP).
- *        For the TCP and UDP protocols, you must also specify the destination port or port range.
- *        For the ICMP protocol, you must also specify the ICMP type and code.
- *        You can use -1 for the type or code to mean all types or all codes.</p>
- *          <p>Rule changes are propagated to affected instances as quickly as possible. However, a small delay might occur.</p>
- *          <p>For information about VPC security group quotas, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html">Amazon VPC quotas</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AuthorizeSecurityGroupEgressCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AuthorizeSecurityGroupEgressCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AuthorizeSecurityGroupEgressCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AuthorizeSecurityGroupEgressCommandInput} for command's `input` shape.
- * @see {@link AuthorizeSecurityGroupEgressCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AuthorizeSecurityGroupEgressCommand extends $Command<AuthorizeSecurityGroupEgressCommandInput, AuthorizeSecurityGroupEgressCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AuthorizeSecurityGroupEgressCommandInput;
     constructor(input: AuthorizeSecurityGroupEgressCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AuthorizeSecurityGroupEgressCommandInput, AuthorizeSecurityGroupEgressCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface AuthorizeSecurityGroupIngressCommandInput extends AuthorizeSecu
 }
 export interface AuthorizeSecurityGroupIngressCommandOutput extends AuthorizeSecurityGroupIngressResult, __MetadataBearer {
 }
-/**
- * <p>Adds the specified inbound (ingress) rules to a security group.</p>
- *          <p>An inbound rule permits instances to receive traffic from the specified IPv4 or IPv6 CIDR
- *        address range, or from the instances that are associated with the specified destination security
- *        groups.</p>
- *          <p>You specify a protocol for each rule (for example, TCP).
- *        For TCP and UDP, you must also specify the destination port or port range.
- *        For ICMP/ICMPv6, you must also specify the ICMP/ICMPv6 type and code.
- *        You can use -1 to mean all types or all codes.</p>
- *          <p>Rule changes are propagated to instances within the security group as quickly as possible.
- *          However, a small delay might occur.</p>
- *          <p>For more information about VPC security group quotas, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html">Amazon VPC quotas</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AuthorizeSecurityGroupIngressCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AuthorizeSecurityGroupIngressCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AuthorizeSecurityGroupIngressCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AuthorizeSecurityGroupIngressCommandInput} for command's `input` shape.
- * @see {@link AuthorizeSecurityGroupIngressCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AuthorizeSecurityGroupIngressCommand extends $Command<AuthorizeSecurityGroupIngressCommandInput, AuthorizeSecurityGroupIngressCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AuthorizeSecurityGroupIngressCommandInput;
     constructor(input: AuthorizeSecurityGroupIngressCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AuthorizeSecurityGroupIngressCommandInput, AuthorizeSecurityGroupIngressCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface BundleInstanceCommandInput extends BundleInstanceRequest {
 }
 export interface BundleInstanceCommandOutput extends BundleInstanceResult, __MetadataBearer {
 }
-/**
- * <p>Bundles an Amazon instance store-backed Windows instance.</p>
- *          <p>During bundling, only the root device volume (C:\) is bundled. Data on other instance store volumes is not preserved.</p>
- *          <note>
- *             <p>This action is not applicable for Linux/Unix instances or Windows instances that are backed by Amazon EBS.</p>
- * 			      </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, BundleInstanceCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, BundleInstanceCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new BundleInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link BundleInstanceCommandInput} for command's `input` shape.
- * @see {@link BundleInstanceCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class BundleInstanceCommand extends $Command<BundleInstanceCommandInput, BundleInstanceCommandOutput, EC2ClientResolvedConfig> {
     readonly input: BundleInstanceCommandInput;
     constructor(input: BundleInstanceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BundleInstanceCommandInput, BundleInstanceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CancelBundleTaskCommandInput extends CancelBundleTaskRequest {
 }
 export interface CancelBundleTaskCommandOutput extends CancelBundleTaskResult, __MetadataBearer {
 }
-/**
- * <p>Cancels a bundling operation for an instance store-backed Windows instance.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CancelBundleTaskCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CancelBundleTaskCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CancelBundleTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CancelBundleTaskCommandInput} for command's `input` shape.
- * @see {@link CancelBundleTaskCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CancelBundleTaskCommand extends $Command<CancelBundleTaskCommandInput, CancelBundleTaskCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CancelBundleTaskCommandInput;
     constructor(input: CancelBundleTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelBundleTaskCommandInput, CancelBundleTaskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface CancelCapacityReservationCommandInput extends CancelCapacityRes
 }
 export interface CancelCapacityReservationCommandOutput extends CancelCapacityReservationResult, __MetadataBearer {
 }
-/**
- * <p>Cancels the specified Capacity Reservation, releases the reserved capacity, and changes the Capacity Reservation's state to
- * 			<code>cancelled</code>.</p>
- * 		       <p>Instances running in the reserved capacity continue running until you stop them. Stopped
- * 			instances that target the Capacity Reservation can no longer launch. Modify these instances to either
- * 			target a different Capacity Reservation, launch On-Demand Instance capacity, or run in any open Capacity Reservation
- * 			that has matching attributes and sufficient capacity.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CancelCapacityReservationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CancelCapacityReservationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CancelCapacityReservationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CancelCapacityReservationCommandInput} for command's `input` shape.
- * @see {@link CancelCapacityReservationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CancelCapacityReservationCommand extends $Command<CancelCapacityReservationCommandInput, CancelCapacityReservationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CancelCapacityReservationCommandInput;
     constructor(input: CancelCapacityReservationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelCapacityReservationCommandInput, CancelCapacityReservationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,43 +6,11 @@ export interface CancelCapacityReservationFleetsCommandInput extends CancelCapac
 }
 export interface CancelCapacityReservationFleetsCommandOutput extends CancelCapacityReservationFleetsResult, __MetadataBearer {
 }
-/**
- * <p>Cancels one or more Capacity Reservation Fleets. When you cancel a Capacity Reservation
- * 			Fleet, the following happens:</p>
- * 		       <ul>
- *             <li>
- * 				           <p>The Capacity Reservation Fleet's status changes to <code>cancelled</code>.</p>
- * 			         </li>
- *             <li>
- * 				           <p>The individual Capacity Reservations in the Fleet are cancelled. Instances running
- * 					in the Capacity Reservations at the time of cancelling the Fleet continue to run in
- * 					shared capacity.</p>
- * 			         </li>
- *             <li>
- * 				           <p>The Fleet stops creating new Capacity Reservations.</p>
- * 			         </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CancelCapacityReservationFleetsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CancelCapacityReservationFleetsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CancelCapacityReservationFleetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CancelCapacityReservationFleetsCommandInput} for command's `input` shape.
- * @see {@link CancelCapacityReservationFleetsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CancelCapacityReservationFleetsCommand extends $Command<CancelCapacityReservationFleetsCommandInput, CancelCapacityReservationFleetsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CancelCapacityReservationFleetsCommandInput;
     constructor(input: CancelCapacityReservationFleetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelCapacityReservationFleetsCommandInput, CancelCapacityReservationFleetsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface CancelConversionTaskCommandInput extends CancelConversionReques
 }
 export interface CancelConversionTaskCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Cancels an active conversion task. The task can be the import of an instance or volume. The action removes all
- *    artifacts of the conversion, including a partially uploaded volume or instance. If the conversion is complete or is
- *    in the process of transferring the final disk image, the command fails and returns an exception.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/CommandLineReference/ec2-cli-vmimport-export.html">Importing a Virtual Machine Using the Amazon
- *     EC2 CLI</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CancelConversionTaskCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CancelConversionTaskCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CancelConversionTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CancelConversionTaskCommandInput} for command's `input` shape.
- * @see {@link CancelConversionTaskCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CancelConversionTaskCommand extends $Command<CancelConversionTaskCommandInput, CancelConversionTaskCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CancelConversionTaskCommandInput;
     constructor(input: CancelConversionTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelConversionTaskCommandInput, CancelConversionTaskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CancelExportTaskCommandInput extends CancelExportTaskRequest {
 }
 export interface CancelExportTaskCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Cancels an active export task. The request removes all artifacts of the export, including any partially-created
- *    Amazon S3 objects. If the export task is complete or is in the process of transferring the final disk image, the
- *    command fails and returns an error.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CancelExportTaskCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CancelExportTaskCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CancelExportTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CancelExportTaskCommandInput} for command's `input` shape.
- * @see {@link CancelExportTaskCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CancelExportTaskCommand extends $Command<CancelExportTaskCommandInput, CancelExportTaskCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CancelExportTaskCommandInput;
     constructor(input: CancelExportTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelExportTaskCommandInput, CancelExportTaskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CancelImportTaskCommandInput extends CancelImportTaskRequest {
 }
 export interface CancelImportTaskCommandOutput extends CancelImportTaskResult, __MetadataBearer {
 }
-/**
- * <p>Cancels an in-process import virtual machine or import snapshot task.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CancelImportTaskCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CancelImportTaskCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CancelImportTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CancelImportTaskCommandInput} for command's `input` shape.
- * @see {@link CancelImportTaskCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CancelImportTaskCommand extends $Command<CancelImportTaskCommandInput, CancelImportTaskCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CancelImportTaskCommandInput;
     constructor(input: CancelImportTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelImportTaskCommandInput, CancelImportTaskCommandOutput>;
     private serialize;
     private deserialize;