@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,29 +6,11 @@ export interface DescribeSecurityGroupReferencesCommandInput extends DescribeSec
 }
 export interface DescribeSecurityGroupReferencesCommandOutput extends DescribeSecurityGroupReferencesResult, __MetadataBearer {
 }
-/**
- * <p>[VPC only] Describes the VPCs on the other side of a VPC peering connection that are referencing the security groups you've specified in this request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeSecurityGroupReferencesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeSecurityGroupReferencesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeSecurityGroupReferencesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSecurityGroupReferencesCommandInput} for command's `input` shape.
- * @see {@link DescribeSecurityGroupReferencesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSecurityGroupReferencesCommand extends $Command<DescribeSecurityGroupReferencesCommandInput, DescribeSecurityGroupReferencesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeSecurityGroupReferencesCommandInput;
     constructor(input: DescribeSecurityGroupReferencesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSecurityGroupReferencesCommandInput, DescribeSecurityGroupReferencesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,35 +6,11 @@ export interface DescribeSecurityGroupsCommandInput extends DescribeSecurityGrou
 }
 export interface DescribeSecurityGroupsCommandOutput extends DescribeSecurityGroupsResult, __MetadataBearer {
 }
-/**
- * <p>Describes the specified security groups or all of your security groups.</p>
- *          <p>A security group is for use with instances either in the EC2-Classic platform
- * 				or in a specific VPC. For more information, see
- * 				<a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html">Amazon EC2 security groups</a> in
- * 				the <i>Amazon Elastic Compute Cloud User Guide</i> and
- * 				<a href="https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_SecurityGroups.html">Security groups for your VPC</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, DescribeSecurityGroupsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeSecurityGroupsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeSecurityGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSecurityGroupsCommandInput} for command's `input` shape.
- * @see {@link DescribeSecurityGroupsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSecurityGroupsCommand extends $Command<DescribeSecurityGroupsCommandInput, DescribeSecurityGroupsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeSecurityGroupsCommandInput;
     constructor(input: DescribeSecurityGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSecurityGroupsCommandInput, DescribeSecurityGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeSnapshotAttributeCommandInput extends DescribeSnapshotA
 }
 export interface DescribeSnapshotAttributeCommandOutput extends DescribeSnapshotAttributeResult, __MetadataBearer {
 }
-/**
- * <p>Describes the specified attribute of the specified snapshot. You can specify only one
- *       attribute at a time.</p>
- *          <p>For more information about EBS snapshots, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSSnapshots.html">Amazon EBS snapshots</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, DescribeSnapshotAttributeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeSnapshotAttributeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeSnapshotAttributeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSnapshotAttributeCommandInput} for command's `input` shape.
- * @see {@link DescribeSnapshotAttributeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSnapshotAttributeCommand extends $Command<DescribeSnapshotAttributeCommandInput, DescribeSnapshotAttributeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeSnapshotAttributeCommandInput;
     constructor(input: DescribeSnapshotAttributeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSnapshotAttributeCommandInput, DescribeSnapshotAttributeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,75 +6,11 @@ export interface DescribeSnapshotsCommandInput extends DescribeSnapshotsRequest
 }
 export interface DescribeSnapshotsCommandOutput extends DescribeSnapshotsResult, __MetadataBearer {
 }
-/**
- * <p>Describes the specified EBS snapshots available to you or all of the EBS snapshots
- *       available to you.</p>
- *          <p>The snapshots available to you include public snapshots, private snapshots that you own,
- *       and private snapshots owned by other Amazon Web Services accounts for which you have explicit create volume
- *       permissions.</p>
- *          <p>The create volume permissions fall into the following categories:</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <i>public</i>: The owner of the snapshot granted create volume
- *           permissions for the snapshot to the <code>all</code> group. All Amazon Web Services accounts have create
- *           volume permissions for these snapshots.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <i>explicit</i>: The owner of the snapshot granted create volume
- *           permissions to a specific Amazon Web Services account.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <i>implicit</i>: An Amazon Web Services account has implicit create volume permissions
- *           for all snapshots it owns.</p>
- *             </li>
- *          </ul>
- *          <p>The list of snapshots returned can be filtered by specifying snapshot IDs, snapshot
- *       owners, or Amazon Web Services accounts with create volume permissions. If no options are specified,
- *       Amazon EC2 returns all snapshots for which you have create volume permissions.</p>
- *          <p>If you specify one or more snapshot IDs, only snapshots that have the specified IDs are
- *       returned. If you specify an invalid snapshot ID, an error is returned. If you specify a
- *       snapshot ID for which you do not have access, it is not included in the returned
- *       results.</p>
- *          <p>If you specify one or more snapshot owners using the <code>OwnerIds</code> option, only
- *       snapshots from the specified owners and for which you have access are returned. The results
- *       can include the Amazon Web Services account IDs of the specified owners, <code>amazon</code> for snapshots
- *       owned by Amazon, or <code>self</code> for snapshots that you own.</p>
- *          <p>If you specify a list of restorable users, only snapshots with create snapshot permissions
- *       for those users are returned. You can specify Amazon Web Services account IDs (if you own the snapshots),
- *         <code>self</code> for snapshots for which you own or have explicit permissions, or
- *         <code>all</code> for public snapshots.</p>
- *          <p>If you are describing a long list of snapshots, we recommend that you paginate the output to make the
- *       list more manageable. The <code>MaxResults</code> parameter sets the maximum number of results
- *       returned in a single page. If the list of results exceeds your <code>MaxResults</code> value,
- *       then that number of results is returned along with a <code>NextToken</code> value that can be
- *       passed to a subsequent <code>DescribeSnapshots</code> request to retrieve the remaining
- *       results.</p>
- *          <p>To get the state of fast snapshot restores for a snapshot, use <a>DescribeFastSnapshotRestores</a>.</p>
- *          <p>For more information about EBS snapshots, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSSnapshots.html">Amazon EBS snapshots</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, DescribeSnapshotsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeSnapshotsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeSnapshotsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSnapshotsCommandInput} for command's `input` shape.
- * @see {@link DescribeSnapshotsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSnapshotsCommand extends $Command<DescribeSnapshotsCommandInput, DescribeSnapshotsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeSnapshotsCommandInput;
     constructor(input: DescribeSnapshotsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSnapshotsCommandInput, DescribeSnapshotsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeSpotDatafeedSubscriptionCommandInput extends DescribeSp
 }
 export interface DescribeSpotDatafeedSubscriptionCommandOutput extends DescribeSpotDatafeedSubscriptionResult, __MetadataBearer {
 }
-/**
- * <p>Describes the data feed for Spot Instances. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-data-feeds.html">Spot
- *                 Instance data feed</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, DescribeSpotDatafeedSubscriptionCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeSpotDatafeedSubscriptionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeSpotDatafeedSubscriptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSpotDatafeedSubscriptionCommandInput} for command's `input` shape.
- * @see {@link DescribeSpotDatafeedSubscriptionCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSpotDatafeedSubscriptionCommand extends $Command<DescribeSpotDatafeedSubscriptionCommandInput, DescribeSpotDatafeedSubscriptionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeSpotDatafeedSubscriptionCommandInput;
     constructor(input: DescribeSpotDatafeedSubscriptionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSpotDatafeedSubscriptionCommandInput, DescribeSpotDatafeedSubscriptionCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,33 +6,11 @@ export interface DescribeSpotFleetRequestHistoryCommandInput extends DescribeSpo
 }
 export interface DescribeSpotFleetRequestHistoryCommandOutput extends DescribeSpotFleetRequestHistoryResponse, __MetadataBearer {
 }
-/**
- * <p>Describes the events for the specified Spot Fleet request during the specified
- *             time.</p>
- *         <p>Spot Fleet events are delayed by up to 30 seconds before they can be described. This
- *             ensures that you can query by the last evaluated time and not miss a recorded event.
- *             Spot Fleet events are available for 48 hours.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeSpotFleetRequestHistoryCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeSpotFleetRequestHistoryCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeSpotFleetRequestHistoryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSpotFleetRequestHistoryCommandInput} for command's `input` shape.
- * @see {@link DescribeSpotFleetRequestHistoryCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSpotFleetRequestHistoryCommand extends $Command<DescribeSpotFleetRequestHistoryCommandInput, DescribeSpotFleetRequestHistoryCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeSpotFleetRequestHistoryCommandInput;
     constructor(input: DescribeSpotFleetRequestHistoryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSpotFleetRequestHistoryCommandInput, DescribeSpotFleetRequestHistoryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeSpotFleetRequestsCommandInput extends DescribeSpotFleet
 }
 export interface DescribeSpotFleetRequestsCommandOutput extends DescribeSpotFleetRequestsResponse, __MetadataBearer {
 }
-/**
- * <p>Describes your Spot Fleet requests.</p>
- *         <p>Spot Fleet requests are deleted 48 hours after they are canceled and their instances
- *             are terminated.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeSpotFleetRequestsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeSpotFleetRequestsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeSpotFleetRequestsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSpotFleetRequestsCommandInput} for command's `input` shape.
- * @see {@link DescribeSpotFleetRequestsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSpotFleetRequestsCommand extends $Command<DescribeSpotFleetRequestsCommandInput, DescribeSpotFleetRequestsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeSpotFleetRequestsCommandInput;
     constructor(input: DescribeSpotFleetRequestsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSpotFleetRequestsCommandInput, DescribeSpotFleetRequestsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,44 +6,11 @@ export interface DescribeSpotInstanceRequestsCommandInput extends DescribeSpotIn
 }
 export interface DescribeSpotInstanceRequestsCommandOutput extends DescribeSpotInstanceRequestsResult, __MetadataBearer {
 }
-/**
- * <p>Describes the specified Spot Instance requests.</p>
- *         <p>You can use <code>DescribeSpotInstanceRequests</code> to find a running Spot Instance by
- *             examining the response. If the status of the Spot Instance is <code>fulfilled</code>, the
- *             instance ID appears in the response and contains the identifier of the instance.
- *             Alternatively, you can use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances">DescribeInstances</a>
- *             with a filter to look for instances where the instance lifecycle is
- *             <code>spot</code>.</p>
- *         <p>We recommend that you set <code>MaxResults</code> to a value between 5 and 1000 to
- *             limit the number of results returned. This paginates the output, which makes the list
- *             more manageable and returns the results faster. If the list of results exceeds your
- *                 <code>MaxResults</code> value, then that number of results is returned along with a
- *                 <code>NextToken</code> value that can be passed to a subsequent
- *                 <code>DescribeSpotInstanceRequests</code> request to retrieve the remaining
- *             results.</p>
- *         <p>Spot Instance requests are deleted four hours after they are canceled and their instances are
- *             terminated.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeSpotInstanceRequestsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeSpotInstanceRequestsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeSpotInstanceRequestsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSpotInstanceRequestsCommandInput} for command's `input` shape.
- * @see {@link DescribeSpotInstanceRequestsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSpotInstanceRequestsCommand extends $Command<DescribeSpotInstanceRequestsCommandInput, DescribeSpotInstanceRequestsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeSpotInstanceRequestsCommandInput;
     constructor(input: DescribeSpotInstanceRequestsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSpotInstanceRequestsCommandInput, DescribeSpotInstanceRequestsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DescribeSpotPriceHistoryCommandInput extends DescribeSpotPriceH
 }
 export interface DescribeSpotPriceHistoryCommandOutput extends DescribeSpotPriceHistoryResult, __MetadataBearer {
 }
-/**
- * <p>Describes the Spot price history. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances-history.html">Spot Instance pricing history</a> in the
- *             <i>Amazon EC2 User Guide for Linux Instances</i>.</p>
- *         <p>When you specify a start and end time, the operation returns the prices of the
- *             instance types within that time range. It also returns the last price change before the
- *             start time, which is the effective price as of the start time.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeSpotPriceHistoryCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeSpotPriceHistoryCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeSpotPriceHistoryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSpotPriceHistoryCommandInput} for command's `input` shape.
- * @see {@link DescribeSpotPriceHistoryCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSpotPriceHistoryCommand extends $Command<DescribeSpotPriceHistoryCommandInput, DescribeSpotPriceHistoryCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeSpotPriceHistoryCommandInput;
     constructor(input: DescribeSpotPriceHistoryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSpotPriceHistoryCommandInput, DescribeSpotPriceHistoryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeStaleSecurityGroupsCommandInput extends DescribeStaleSe
 }
 export interface DescribeStaleSecurityGroupsCommandOutput extends DescribeStaleSecurityGroupsResult, __MetadataBearer {
 }
-/**
- * <p>[VPC only] Describes the stale security group rules for security groups in a specified VPC. Rules are stale when they reference a deleted security group in a peer VPC, or a security group in a peer VPC for which the VPC peering connection has been deleted.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeStaleSecurityGroupsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeStaleSecurityGroupsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeStaleSecurityGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeStaleSecurityGroupsCommandInput} for command's `input` shape.
- * @see {@link DescribeStaleSecurityGroupsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeStaleSecurityGroupsCommand extends $Command<DescribeStaleSecurityGroupsCommandInput, DescribeStaleSecurityGroupsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeStaleSecurityGroupsCommandInput;
     constructor(input: DescribeStaleSecurityGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStaleSecurityGroupsCommandInput, DescribeStaleSecurityGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,40 +6,11 @@ export interface DescribeStoreImageTasksCommandInput extends DescribeStoreImageT
 }
 export interface DescribeStoreImageTasksCommandOutput extends DescribeStoreImageTasksResult, __MetadataBearer {
 }
-/**
- * <p>Describes the progress of the AMI store tasks. You can describe the store tasks for
- *       specified AMIs. If you don't specify the AMIs, you get a paginated list of store tasks from
- *       the last 31 days.</p>
- *          <p>For each AMI task, the response indicates if the task is <code>InProgress</code>,
- *         <code>Completed</code>, or <code>Failed</code>. For tasks <code>InProgress</code>, the
- *       response shows the estimated progress as a percentage.</p>
- *          <p>Tasks are listed in reverse chronological order. Currently, only tasks from the past 31
- *       days can be viewed.</p>
- *          <p>To use this API, you must have the required permissions. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html#ami-s3-permissions">Permissions for storing and restoring AMIs using Amazon S3</a> in the
- *         <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html">Store and restore an AMI using
- *     	Amazon S3</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, DescribeStoreImageTasksCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeStoreImageTasksCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeStoreImageTasksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeStoreImageTasksCommandInput} for command's `input` shape.
- * @see {@link DescribeStoreImageTasksCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeStoreImageTasksCommand extends $Command<DescribeStoreImageTasksCommandInput, DescribeStoreImageTasksCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeStoreImageTasksCommandInput;
     constructor(input: DescribeStoreImageTasksCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStoreImageTasksCommandInput, DescribeStoreImageTasksCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeSubnetsCommandInput extends DescribeSubnetsRequest {
 }
 export interface DescribeSubnetsCommandOutput extends DescribeSubnetsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more of your subnets.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html">Your VPC and subnets</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, DescribeSubnetsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeSubnetsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeSubnetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSubnetsCommandInput} for command's `input` shape.
- * @see {@link DescribeSubnetsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSubnetsCommand extends $Command<DescribeSubnetsCommandInput, DescribeSubnetsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeSubnetsCommandInput;
     constructor(input: DescribeSubnetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSubnetsCommandInput, DescribeSubnetsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,36 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { DescribeTagsRequest, DescribeTagsResult } from "../models/models_3";
+import { DescribeTagsRequest, DescribeTagsResult } from "../models/models_4";
 export interface DescribeTagsCommandInput extends DescribeTagsRequest {
 }
 export interface DescribeTagsCommandOutput extends DescribeTagsResult, __MetadataBearer {
 }
-/**
- * <p>Describes the specified tags for your EC2 resources.</p>
- *          <p>For more information about tags, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tagging Your Resources</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, DescribeTagsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeTagsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTagsCommandInput} for command's `input` shape.
- * @see {@link DescribeTagsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTagsCommand extends $Command<DescribeTagsCommandInput, DescribeTagsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeTagsCommandInput;
     constructor(input: DescribeTagsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTagsCommandInput, DescribeTagsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,34 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { DescribeTrafficMirrorFiltersRequest, DescribeTrafficMirrorFiltersResult } from "../models/models_3";
+import { DescribeTrafficMirrorFiltersRequest, DescribeTrafficMirrorFiltersResult } from "../models/models_4";
 export interface DescribeTrafficMirrorFiltersCommandInput extends DescribeTrafficMirrorFiltersRequest {
 }
 export interface DescribeTrafficMirrorFiltersCommandOutput extends DescribeTrafficMirrorFiltersResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more Traffic Mirror filters.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeTrafficMirrorFiltersCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeTrafficMirrorFiltersCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeTrafficMirrorFiltersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTrafficMirrorFiltersCommandInput} for command's `input` shape.
- * @see {@link DescribeTrafficMirrorFiltersCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTrafficMirrorFiltersCommand extends $Command<DescribeTrafficMirrorFiltersCommandInput, DescribeTrafficMirrorFiltersCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeTrafficMirrorFiltersCommandInput;
     constructor(input: DescribeTrafficMirrorFiltersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTrafficMirrorFiltersCommandInput, DescribeTrafficMirrorFiltersCommandOutput>;
     private serialize;
     private deserialize;