@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,40 +6,11 @@ export interface ReleaseAddressCommandInput extends ReleaseAddressRequest {
 }
 export interface ReleaseAddressCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Releases the specified Elastic IP address.</p>
- *          <p>[EC2-Classic, default VPC] Releasing an Elastic IP address automatically disassociates it
- * 				from any instance that it's associated with. To disassociate an Elastic IP address without
- * 				releasing it, use <a>DisassociateAddress</a>.</p>
- *          <p>[Nondefault VPC] You must use <a>DisassociateAddress</a> to disassociate the Elastic IP address
- * 			  before you can release it. Otherwise, Amazon EC2 returns an error (<code>InvalidIPAddress.InUse</code>).</p>
- *          <p>After releasing an Elastic IP address, it is released to the IP address pool.
- *         Be sure to update your DNS records and any servers or devices that communicate with the address.
- *         If you attempt to release an Elastic IP address that you already released, you'll get an
- *        <code>AuthFailure</code> error if the address is already allocated to another Amazon Web Services account.</p>
- *          <p>[EC2-VPC] After you release an Elastic IP address for use in a VPC, you might be able to recover it.
- *         For more information, see <a>AllocateAddress</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ReleaseAddressCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ReleaseAddressCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ReleaseAddressCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ReleaseAddressCommandInput} for command's `input` shape.
- * @see {@link ReleaseAddressCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ReleaseAddressCommand extends $Command<ReleaseAddressCommandInput, ReleaseAddressCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ReleaseAddressCommandInput;
     constructor(input: ReleaseAddressCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ReleaseAddressCommandInput, ReleaseAddressCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface ReleaseHostsCommandInput extends ReleaseHostsRequest {
 }
 export interface ReleaseHostsCommandOutput extends ReleaseHostsResult, __MetadataBearer {
 }
-/**
- * <p>When you no longer want to use an On-Demand Dedicated Host it can be released.
- *             On-Demand billing is stopped and the host goes into <code>released</code> state. The
- *             host ID of Dedicated Hosts that have been released can no longer be specified in another
- *             request, for example, to modify the host. You must stop or terminate all instances on a
- *             host before it can be released.</p>
- *         <p>When Dedicated Hosts are released, it may take some time for them to stop counting
- *             toward your limit and you may receive capacity errors when trying to allocate new
- *             Dedicated Hosts. Wait a few minutes and then try again.</p>
- *         <p>Released hosts still appear in a <a>DescribeHosts</a> response.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ReleaseHostsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ReleaseHostsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ReleaseHostsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ReleaseHostsCommandInput} for command's `input` shape.
- * @see {@link ReleaseHostsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ReleaseHostsCommand extends $Command<ReleaseHostsCommandInput, ReleaseHostsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ReleaseHostsCommandInput;
     constructor(input: ReleaseHostsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ReleaseHostsCommandInput, ReleaseHostsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ReplaceIamInstanceProfileAssociationCommandInput extends Replac
 }
 export interface ReplaceIamInstanceProfileAssociationCommandOutput extends ReplaceIamInstanceProfileAssociationResult, __MetadataBearer {
 }
-/**
- * <p>Replaces an IAM instance profile for the specified running instance. You can use
- *             this action to change the IAM instance profile that's associated with an instance
- *             without having to disassociate the existing IAM instance profile first.</p>
- *         <p>Use <a>DescribeIamInstanceProfileAssociations</a> to get the association
- *             ID.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ReplaceIamInstanceProfileAssociationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ReplaceIamInstanceProfileAssociationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ReplaceIamInstanceProfileAssociationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ReplaceIamInstanceProfileAssociationCommandInput} for command's `input` shape.
- * @see {@link ReplaceIamInstanceProfileAssociationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ReplaceIamInstanceProfileAssociationCommand extends $Command<ReplaceIamInstanceProfileAssociationCommandInput, ReplaceIamInstanceProfileAssociationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ReplaceIamInstanceProfileAssociationCommandInput;
     constructor(input: ReplaceIamInstanceProfileAssociationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ReplaceIamInstanceProfileAssociationCommandInput, ReplaceIamInstanceProfileAssociationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ReplaceNetworkAclAssociationCommandInput extends ReplaceNetwork
 }
 export interface ReplaceNetworkAclAssociationCommandOutput extends ReplaceNetworkAclAssociationResult, __MetadataBearer {
 }
-/**
- * <p>Changes which network ACL a subnet is associated with. By default when you create a
- * 			subnet, it's automatically associated with the default network ACL. For more
- * 			information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_ACLs.html">Network
- * 			ACLs</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.</p>
- *         <p>This is an idempotent operation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ReplaceNetworkAclAssociationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ReplaceNetworkAclAssociationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ReplaceNetworkAclAssociationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ReplaceNetworkAclAssociationCommandInput} for command's `input` shape.
- * @see {@link ReplaceNetworkAclAssociationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ReplaceNetworkAclAssociationCommand extends $Command<ReplaceNetworkAclAssociationCommandInput, ReplaceNetworkAclAssociationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ReplaceNetworkAclAssociationCommandInput;
     constructor(input: ReplaceNetworkAclAssociationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ReplaceNetworkAclAssociationCommandInput, ReplaceNetworkAclAssociationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ReplaceNetworkAclEntryCommandInput extends ReplaceNetworkAclEnt
 }
 export interface ReplaceNetworkAclEntryCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Replaces an entry (rule) in a network ACL. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_ACLs.html">Network ACLs</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, ReplaceNetworkAclEntryCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ReplaceNetworkAclEntryCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ReplaceNetworkAclEntryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ReplaceNetworkAclEntryCommandInput} for command's `input` shape.
- * @see {@link ReplaceNetworkAclEntryCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ReplaceNetworkAclEntryCommand extends $Command<ReplaceNetworkAclEntryCommandInput, ReplaceNetworkAclEntryCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ReplaceNetworkAclEntryCommandInput;
     constructor(input: ReplaceNetworkAclEntryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ReplaceNetworkAclEntryCommandInput, ReplaceNetworkAclEntryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface ReplaceRouteCommandInput extends ReplaceRouteRequest {
 }
 export interface ReplaceRouteCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Replaces an existing route within a route table in a VPC. You must provide only one of
- *             the following: internet gateway, virtual private gateway, NAT instance, NAT gateway, VPC
- *             peering connection, network interface, egress-only internet gateway, or transit
- *             gateway.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route tables</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, ReplaceRouteCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ReplaceRouteCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ReplaceRouteCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ReplaceRouteCommandInput} for command's `input` shape.
- * @see {@link ReplaceRouteCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ReplaceRouteCommand extends $Command<ReplaceRouteCommandInput, ReplaceRouteCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ReplaceRouteCommandInput;
     constructor(input: ReplaceRouteCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ReplaceRouteCommandInput, ReplaceRouteCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ReplaceRouteTableAssociationCommandInput extends ReplaceRouteTa
 }
 export interface ReplaceRouteTableAssociationCommandOutput extends ReplaceRouteTableAssociationResult, __MetadataBearer {
 }
-/**
- * <p>Changes the route table associated with a given subnet, internet gateway, or virtual private gateway in a VPC. After the operation
- *         completes, the subnet or gateway uses the routes in the new route table. For more
- *         information about route tables, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
- *         tables</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.</p>
- *          <p>You can also use this operation to change which table is the main route table in the VPC. Specify the main route table's association ID and the route table ID of the new main route table.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ReplaceRouteTableAssociationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ReplaceRouteTableAssociationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ReplaceRouteTableAssociationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ReplaceRouteTableAssociationCommandInput} for command's `input` shape.
- * @see {@link ReplaceRouteTableAssociationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ReplaceRouteTableAssociationCommand extends $Command<ReplaceRouteTableAssociationCommandInput, ReplaceRouteTableAssociationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ReplaceRouteTableAssociationCommandInput;
     constructor(input: ReplaceRouteTableAssociationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ReplaceRouteTableAssociationCommandInput, ReplaceRouteTableAssociationCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,33 +6,11 @@ export interface ReportInstanceStatusCommandInput extends ReportInstanceStatusRe
 }
 export interface ReportInstanceStatusCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Submits feedback about the status of an instance. The instance must be in the
- *                 <code>running</code> state. If your experience with the instance differs from the
- *             instance status returned by <a>DescribeInstanceStatus</a>, use <a>ReportInstanceStatus</a> to report your experience with the instance. Amazon
- *             EC2 collects this information to improve the accuracy of status checks.</p>
- *         <p>Use of this action does not change the value returned by <a>DescribeInstanceStatus</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ReportInstanceStatusCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ReportInstanceStatusCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ReportInstanceStatusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ReportInstanceStatusCommandInput} for command's `input` shape.
- * @see {@link ReportInstanceStatusCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ReportInstanceStatusCommand extends $Command<ReportInstanceStatusCommandInput, ReportInstanceStatusCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ReportInstanceStatusCommandInput;
     constructor(input: ReportInstanceStatusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ReportInstanceStatusCommandInput, ReportInstanceStatusCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,48 +6,11 @@ export interface RequestSpotFleetCommandInput extends RequestSpotFleetRequest {
 }
 export interface RequestSpotFleetCommandOutput extends RequestSpotFleetResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a Spot Fleet request.</p>
- *         <p>The Spot Fleet request specifies the total target capacity and the On-Demand target
- *             capacity. Amazon EC2 calculates the difference between the total capacity and On-Demand
- *             capacity, and launches the difference as Spot capacity.</p>
- *         <p>You can submit a single request that includes multiple launch specifications that vary
- *             by instance type, AMI, Availability Zone, or subnet.</p>
- *         <p>By default, the Spot Fleet requests Spot Instances in the Spot Instance pool where the
- *             price per unit is the lowest. Each launch specification can include its own instance
- *             weighting that reflects the value of the instance type to your application
- *             workload.</p>
- *         <p>Alternatively, you can specify that the Spot Fleet distribute the target capacity
- *             across the Spot pools included in its launch specifications. By ensuring that the Spot
- *             Instances in your Spot Fleet are in different Spot pools, you can improve the
- *             availability of your fleet.</p>
- *         <p>You can specify tags for the Spot Fleet request and instances launched by the fleet.
- *             You cannot tag other resource types in a Spot Fleet request because only the
- *                 <code>spot-fleet-request</code> and <code>instance</code> resource types are
- *             supported.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-requests.html">Spot Fleet requests</a>
- *             in the <i>Amazon EC2 User Guide for Linux Instances</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, RequestSpotFleetCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, RequestSpotFleetCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new RequestSpotFleetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RequestSpotFleetCommandInput} for command's `input` shape.
- * @see {@link RequestSpotFleetCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RequestSpotFleetCommand extends $Command<RequestSpotFleetCommandInput, RequestSpotFleetCommandOutput, EC2ClientResolvedConfig> {
     readonly input: RequestSpotFleetCommandInput;
     constructor(input: RequestSpotFleetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RequestSpotFleetCommandInput, RequestSpotFleetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface RequestSpotInstancesCommandInput extends RequestSpotInstancesRe
 }
 export interface RequestSpotInstancesCommandOutput extends RequestSpotInstancesResult, __MetadataBearer {
 }
-/**
- * <p>Creates a Spot Instance request.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html">Spot Instance requests</a> in
- *             the <i>Amazon EC2 User Guide for Linux Instances</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, RequestSpotInstancesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, RequestSpotInstancesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new RequestSpotInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RequestSpotInstancesCommandInput} for command's `input` shape.
- * @see {@link RequestSpotInstancesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RequestSpotInstancesCommand extends $Command<RequestSpotInstancesCommandInput, RequestSpotInstancesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: RequestSpotInstancesCommandInput;
     constructor(input: RequestSpotInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RequestSpotInstancesCommandInput, RequestSpotInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,34 +6,11 @@ export interface ResetEbsDefaultKmsKeyIdCommandInput extends ResetEbsDefaultKmsK
 }
 export interface ResetEbsDefaultKmsKeyIdCommandOutput extends ResetEbsDefaultKmsKeyIdResult, __MetadataBearer {
 }
-/**
- * <p>Resets the default KMS key for EBS encryption for your account in this Region
- *       to the Amazon Web Services managed KMS key for EBS.</p>
- *          <p>After resetting the default KMS key to the Amazon Web Services managed KMS key, you can continue to encrypt by a
- *       customer managed KMS key by specifying it when you create the 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ResetEbsDefaultKmsKeyIdCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ResetEbsDefaultKmsKeyIdCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ResetEbsDefaultKmsKeyIdCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ResetEbsDefaultKmsKeyIdCommandInput} for command's `input` shape.
- * @see {@link ResetEbsDefaultKmsKeyIdCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ResetEbsDefaultKmsKeyIdCommand extends $Command<ResetEbsDefaultKmsKeyIdCommandInput, ResetEbsDefaultKmsKeyIdCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ResetEbsDefaultKmsKeyIdCommandInput;
     constructor(input: ResetEbsDefaultKmsKeyIdCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetEbsDefaultKmsKeyIdCommandInput, ResetEbsDefaultKmsKeyIdCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ResetFpgaImageAttributeCommandInput extends ResetFpgaImageAttri
 }
 export interface ResetFpgaImageAttributeCommandOutput extends ResetFpgaImageAttributeResult, __MetadataBearer {
 }
-/**
- * <p>Resets the specified attribute of the specified Amazon FPGA Image (AFI) to its default value.
- * 		    You can only reset the load permission attribute.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ResetFpgaImageAttributeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ResetFpgaImageAttributeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ResetFpgaImageAttributeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ResetFpgaImageAttributeCommandInput} for command's `input` shape.
- * @see {@link ResetFpgaImageAttributeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ResetFpgaImageAttributeCommand extends $Command<ResetFpgaImageAttributeCommandInput, ResetFpgaImageAttributeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ResetFpgaImageAttributeCommandInput;
     constructor(input: ResetFpgaImageAttributeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetFpgaImageAttributeCommandInput, ResetFpgaImageAttributeCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,37 +6,11 @@ export interface ResetInstanceAttributeCommandInput extends ResetInstanceAttribu
 }
 export interface ResetInstanceAttributeCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Resets an attribute of an instance to its default value. To reset the
- *                 <code>kernel</code> or <code>ramdisk</code>, the instance must be in a stopped
- *             state. To reset the <code>sourceDestCheck</code>, the instance can be either running or
- *             stopped.</p>
- *         <p>The <code>sourceDestCheck</code> attribute controls whether source/destination
- *             checking is enabled. The default value is <code>true</code>, which means checking is
- *             enabled. This value must be <code>false</code> for a NAT instance to perform NAT. For
- *             more information, see <a href="https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html">NAT Instances</a> in the
- *                 <i>Amazon VPC User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ResetInstanceAttributeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ResetInstanceAttributeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ResetInstanceAttributeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ResetInstanceAttributeCommandInput} for command's `input` shape.
- * @see {@link ResetInstanceAttributeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ResetInstanceAttributeCommand extends $Command<ResetInstanceAttributeCommandInput, ResetInstanceAttributeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ResetInstanceAttributeCommandInput;
     constructor(input: ResetInstanceAttributeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetInstanceAttributeCommandInput, ResetInstanceAttributeCommandOutput>;
     private serialize;
     private deserialize;

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

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