@aws-sdk/client-ec2 3.295.0 → 3.297.0

package/dist-types/commands/CreateReplaceRootVolumeTaskCommand.d.ts

@@ -2,18 +2,24 @@ import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
 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 { CreateReplaceRootVolumeTaskRequest, CreateReplaceRootVolumeTaskResult } from "../models/models_1";
+import { CreateReplaceRootVolumeTaskRequest } from "../models/models_1";
+import { CreateReplaceRootVolumeTaskResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateReplaceRootVolumeTaskCommand}.
  */
 export interface CreateReplaceRootVolumeTaskCommandInput extends CreateReplaceRootVolumeTaskRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateReplaceRootVolumeTaskCommand}.
  */
 export interface CreateReplaceRootVolumeTaskCommandOutput extends CreateReplaceRootVolumeTaskResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Replaces the EBS-backed root volume for a <code>running</code> instance with a new
  *       volume that is restored to the original root volume's launch state, that is restored to a
  *       specific snapshot taken from the original root volume, or that is restored from an AMI
@@ -29,6 +35,8 @@ export interface CreateReplaceRootVolumeTaskCommandOutput extends CreateReplaceR
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateReplaceRootVolumeTaskCommandInput - {@link CreateReplaceRootVolumeTaskCommandInput}
+ * @returns {@link CreateReplaceRootVolumeTaskCommandOutput}
  * @see {@link CreateReplaceRootVolumeTaskCommandInput} for command's `input` shape.
  * @see {@link CreateReplaceRootVolumeTaskCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -38,11 +46,20 @@ export interface CreateReplaceRootVolumeTaskCommandOutput extends CreateReplaceR
 export declare class CreateReplaceRootVolumeTaskCommand extends $Command<CreateReplaceRootVolumeTaskCommandInput, CreateReplaceRootVolumeTaskCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateReplaceRootVolumeTaskCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateReplaceRootVolumeTaskCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateReplaceRootVolumeTaskCommandInput, CreateReplaceRootVolumeTaskCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateReservedInstancesListingCommand.d.ts

@@ -2,18 +2,23 @@ import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
 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 { CreateReservedInstancesListingRequest, CreateReservedInstancesListingResult } from "../models/models_1";
+import { CreateReservedInstancesListingRequest, CreateReservedInstancesListingResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateReservedInstancesListingCommand}.
  */
 export interface CreateReservedInstancesListingCommandInput extends CreateReservedInstancesListingRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateReservedInstancesListingCommand}.
  */
 export interface CreateReservedInstancesListingCommandOutput extends CreateReservedInstancesListingResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a listing for Amazon EC2 Standard Reserved Instances to be sold in the Reserved Instance
  * 			Marketplace. You can submit one Standard Reserved Instance listing at a time. To get a list of your
  * 			Standard Reserved Instances, you can use the <a>DescribeReservedInstances</a> operation.</p>
@@ -40,6 +45,8 @@ export interface CreateReservedInstancesListingCommandOutput extends CreateReser
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateReservedInstancesListingCommandInput - {@link CreateReservedInstancesListingCommandInput}
+ * @returns {@link CreateReservedInstancesListingCommandOutput}
  * @see {@link CreateReservedInstancesListingCommandInput} for command's `input` shape.
  * @see {@link CreateReservedInstancesListingCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -49,11 +56,20 @@ export interface CreateReservedInstancesListingCommandOutput extends CreateReser
 export declare class CreateReservedInstancesListingCommand extends $Command<CreateReservedInstancesListingCommandInput, CreateReservedInstancesListingCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateReservedInstancesListingCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateReservedInstancesListingCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateReservedInstancesListingCommandInput, CreateReservedInstancesListingCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateRestoreImageTaskCommand.d.ts

@@ -2,18 +2,23 @@ import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
 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 { CreateRestoreImageTaskRequest, CreateRestoreImageTaskResult } from "../models/models_1";
+import { CreateRestoreImageTaskRequest, CreateRestoreImageTaskResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateRestoreImageTaskCommand}.
  */
 export interface CreateRestoreImageTaskCommandInput extends CreateRestoreImageTaskRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateRestoreImageTaskCommand}.
  */
 export interface CreateRestoreImageTaskCommandOutput extends CreateRestoreImageTaskResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Starts a task that restores an AMI from an Amazon S3 object that was previously created by using
  *       <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateStoreImageTask.html">CreateStoreImageTask</a>.</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
@@ -30,6 +35,8 @@ export interface CreateRestoreImageTaskCommandOutput extends CreateRestoreImageT
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateRestoreImageTaskCommandInput - {@link CreateRestoreImageTaskCommandInput}
+ * @returns {@link CreateRestoreImageTaskCommandOutput}
  * @see {@link CreateRestoreImageTaskCommandInput} for command's `input` shape.
  * @see {@link CreateRestoreImageTaskCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -39,11 +46,20 @@ export interface CreateRestoreImageTaskCommandOutput extends CreateRestoreImageT
 export declare class CreateRestoreImageTaskCommand extends $Command<CreateRestoreImageTaskCommandInput, CreateRestoreImageTaskCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateRestoreImageTaskCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateRestoreImageTaskCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRestoreImageTaskCommandInput, CreateRestoreImageTaskCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateRouteCommand.d.ts

@@ -2,18 +2,23 @@ import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
 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 { CreateRouteRequest, CreateRouteResult } from "../models/models_1";
+import { CreateRouteRequest, CreateRouteResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateRouteCommand}.
  */
 export interface CreateRouteCommandInput extends CreateRouteRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateRouteCommand}.
  */
 export interface CreateRouteCommandOutput extends CreateRouteResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a route in a route table within a VPC.</p>
  *          <p>You must specify either a destination CIDR block or a prefix list ID. You must also specify
  *          exactly one of the resources from the parameter list.</p>
@@ -45,6 +50,8 @@ export interface CreateRouteCommandOutput extends CreateRouteResult, __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateRouteCommandInput - {@link CreateRouteCommandInput}
+ * @returns {@link CreateRouteCommandOutput}
  * @see {@link CreateRouteCommandInput} for command's `input` shape.
  * @see {@link CreateRouteCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -67,11 +74,20 @@ export interface CreateRouteCommandOutput extends CreateRouteResult, __MetadataB
 export declare class CreateRouteCommand extends $Command<CreateRouteCommandInput, CreateRouteCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateRouteCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateRouteCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRouteCommandInput, CreateRouteCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateRouteTableCommand.d.ts

@@ -2,19 +2,23 @@ import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
 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 { CreateRouteTableRequest } from "../models/models_1";
-import { CreateRouteTableResult } from "../models/models_2";
+import { CreateRouteTableRequest, CreateRouteTableResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateRouteTableCommand}.
  */
 export interface CreateRouteTableCommandInput extends CreateRouteTableRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateRouteTableCommand}.
  */
 export interface CreateRouteTableCommandOutput extends CreateRouteTableResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a route table for the specified VPC. After you create a route table, you can add routes and associate the table with a subnet.</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>
@@ -28,6 +32,8 @@ export interface CreateRouteTableCommandOutput extends CreateRouteTableResult, _
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateRouteTableCommandInput - {@link CreateRouteTableCommandInput}
+ * @returns {@link CreateRouteTableCommandOutput}
  * @see {@link CreateRouteTableCommandInput} for command's `input` shape.
  * @see {@link CreateRouteTableCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -66,11 +72,20 @@ export interface CreateRouteTableCommandOutput extends CreateRouteTableResult, _
 export declare class CreateRouteTableCommand extends $Command<CreateRouteTableCommandInput, CreateRouteTableCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateRouteTableCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateRouteTableCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRouteTableCommandInput, CreateRouteTableCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateSecurityGroupCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateSecurityGroupRequest, CreateSecurityGroupResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateSecurityGroupCommand}.
  */
 export interface CreateSecurityGroupCommandInput extends CreateSecurityGroupRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateSecurityGroupCommand}.
  */
 export interface CreateSecurityGroupCommandOutput extends CreateSecurityGroupResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a security group.</p>
  *          <p>A security group acts as a virtual firewall for your instance to control inbound and outbound traffic.
  *          For more information, see
@@ -42,6 +47,8 @@ export interface CreateSecurityGroupCommandOutput extends CreateSecurityGroupRes
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateSecurityGroupCommandInput - {@link CreateSecurityGroupCommandInput}
+ * @returns {@link CreateSecurityGroupCommandOutput}
  * @see {@link CreateSecurityGroupCommandInput} for command's `input` shape.
  * @see {@link CreateSecurityGroupCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -69,11 +76,20 @@ export interface CreateSecurityGroupCommandOutput extends CreateSecurityGroupRes
 export declare class CreateSecurityGroupCommand extends $Command<CreateSecurityGroupCommandInput, CreateSecurityGroupCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateSecurityGroupCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateSecurityGroupCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSecurityGroupCommandInput, CreateSecurityGroupCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateSnapshotCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateSnapshotRequest, Snapshot } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateSnapshotCommand}.
  */
 export interface CreateSnapshotCommandInput extends CreateSnapshotRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateSnapshotCommand}.
  */
 export interface CreateSnapshotCommandOutput extends Snapshot, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a snapshot of an EBS volume and stores it in Amazon S3. You can use snapshots for
  *   	backups, to make copies of EBS volumes, and to save data before shutting down an
  *   	instance.</p>
@@ -31,8 +36,8 @@ export interface CreateSnapshotCommandOutput extends Snapshot, __MetadataBearer
  *       should unmount the volume from within the instance, issue the snapshot command, and then
  *       remount the volume to ensure a consistent and complete snapshot. You may remount and use your
  *       volume while the snapshot status is <code>pending</code>.</p>
- *          <p>To create a snapshot for Amazon EBS volumes that serve as root devices, you should stop the
- *       instance before taking the snapshot.</p>
+ *          <p>When you create a snapshot for an EBS volume that serves as a root device, we recommend
+ *       that you stop the instance before taking the snapshot.</p>
  *          <p>Snapshots that are taken from encrypted volumes are automatically encrypted. Volumes that
  *       are created from encrypted snapshots are also automatically encrypted. Your encrypted volumes
  *       and any associated snapshots always remain protected.</p>
@@ -49,6 +54,8 @@ export interface CreateSnapshotCommandOutput extends Snapshot, __MetadataBearer
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateSnapshotCommandInput - {@link CreateSnapshotCommandInput}
+ * @returns {@link CreateSnapshotCommandOutput}
  * @see {@link CreateSnapshotCommandInput} for command's `input` shape.
  * @see {@link CreateSnapshotCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -82,11 +89,20 @@ export interface CreateSnapshotCommandOutput extends Snapshot, __MetadataBearer
 export declare class CreateSnapshotCommand extends $Command<CreateSnapshotCommandInput, CreateSnapshotCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSnapshotCommandInput, CreateSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateSnapshotsCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateSnapshotsRequest, CreateSnapshotsResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateSnapshotsCommand}.
  */
 export interface CreateSnapshotsCommandInput extends CreateSnapshotsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateSnapshotsCommand}.
  */
 export interface CreateSnapshotsCommandOutput extends CreateSnapshotsResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates crash-consistent snapshots of multiple EBS volumes and stores the data in S3.
  *     Volumes are chosen by specifying an instance. Any attached volumes will produce one snapshot
  *     each that is crash-consistent across the instance.</p>
@@ -34,6 +39,8 @@ export interface CreateSnapshotsCommandOutput extends CreateSnapshotsResult, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateSnapshotsCommandInput - {@link CreateSnapshotsCommandInput}
+ * @returns {@link CreateSnapshotsCommandOutput}
  * @see {@link CreateSnapshotsCommandInput} for command's `input` shape.
  * @see {@link CreateSnapshotsCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -43,11 +50,20 @@ export interface CreateSnapshotsCommandOutput extends CreateSnapshotsResult, __M
 export declare class CreateSnapshotsCommand extends $Command<CreateSnapshotsCommandInput, CreateSnapshotsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateSnapshotsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateSnapshotsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSnapshotsCommandInput, CreateSnapshotsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateSpotDatafeedSubscriptionCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateSpotDatafeedSubscriptionRequest, CreateSpotDatafeedSubscriptionResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateSpotDatafeedSubscriptionCommand}.
  */
 export interface CreateSpotDatafeedSubscriptionCommandInput extends CreateSpotDatafeedSubscriptionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateSpotDatafeedSubscriptionCommand}.
  */
 export interface CreateSpotDatafeedSubscriptionCommandOutput extends CreateSpotDatafeedSubscriptionResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a data feed for Spot Instances, enabling you to view Spot Instance usage logs.
  *             You can create one data feed per Amazon Web Services account. For more information, see
  *             <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-data-feeds.html">Spot Instance data feed</a>
@@ -28,6 +33,8 @@ export interface CreateSpotDatafeedSubscriptionCommandOutput extends CreateSpotD
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateSpotDatafeedSubscriptionCommandInput - {@link CreateSpotDatafeedSubscriptionCommandInput}
+ * @returns {@link CreateSpotDatafeedSubscriptionCommandOutput}
  * @see {@link CreateSpotDatafeedSubscriptionCommandInput} for command's `input` shape.
  * @see {@link CreateSpotDatafeedSubscriptionCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -59,11 +66,20 @@ export interface CreateSpotDatafeedSubscriptionCommandOutput extends CreateSpotD
 export declare class CreateSpotDatafeedSubscriptionCommand extends $Command<CreateSpotDatafeedSubscriptionCommandInput, CreateSpotDatafeedSubscriptionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateSpotDatafeedSubscriptionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateSpotDatafeedSubscriptionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSpotDatafeedSubscriptionCommandInput, CreateSpotDatafeedSubscriptionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateStoreImageTaskCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateStoreImageTaskRequest, CreateStoreImageTaskResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateStoreImageTaskCommand}.
  */
 export interface CreateStoreImageTaskCommandInput extends CreateStoreImageTaskRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateStoreImageTaskCommand}.
  */
 export interface CreateStoreImageTaskCommandOutput extends CreateStoreImageTaskResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Stores an AMI as a single object in an Amazon S3 bucket.</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 EC2 User Guide</i>.</p>
@@ -29,6 +34,8 @@ export interface CreateStoreImageTaskCommandOutput extends CreateStoreImageTaskR
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateStoreImageTaskCommandInput - {@link CreateStoreImageTaskCommandInput}
+ * @returns {@link CreateStoreImageTaskCommandOutput}
  * @see {@link CreateStoreImageTaskCommandInput} for command's `input` shape.
  * @see {@link CreateStoreImageTaskCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -38,11 +45,20 @@ export interface CreateStoreImageTaskCommandOutput extends CreateStoreImageTaskR
 export declare class CreateStoreImageTaskCommand extends $Command<CreateStoreImageTaskCommandInput, CreateStoreImageTaskCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateStoreImageTaskCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateStoreImageTaskCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateStoreImageTaskCommandInput, CreateStoreImageTaskCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateSubnetCidrReservationCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateSubnetCidrReservationRequest, CreateSubnetCidrReservationResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateSubnetCidrReservationCommand}.
  */
 export interface CreateSubnetCidrReservationCommandInput extends CreateSubnetCidrReservationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateSubnetCidrReservationCommand}.
  */
 export interface CreateSubnetCidrReservationCommandOutput extends CreateSubnetCidrReservationResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a subnet CIDR reservation. For information about subnet CIDR reservations, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/subnet-cidr-reservation.html">Subnet CIDR reservations</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.
@@ -25,6 +30,8 @@ export interface CreateSubnetCidrReservationCommandOutput extends CreateSubnetCi
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateSubnetCidrReservationCommandInput - {@link CreateSubnetCidrReservationCommandInput}
+ * @returns {@link CreateSubnetCidrReservationCommandOutput}
  * @see {@link CreateSubnetCidrReservationCommandInput} for command's `input` shape.
  * @see {@link CreateSubnetCidrReservationCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -34,11 +41,20 @@ export interface CreateSubnetCidrReservationCommandOutput extends CreateSubnetCi
 export declare class CreateSubnetCidrReservationCommand extends $Command<CreateSubnetCidrReservationCommandInput, CreateSubnetCidrReservationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateSubnetCidrReservationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateSubnetCidrReservationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSubnetCidrReservationCommandInput, CreateSubnetCidrReservationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateSubnetCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateSubnetRequest, CreateSubnetResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateSubnetCommand}.
  */
 export interface CreateSubnetCommandInput extends CreateSubnetRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateSubnetCommand}.
  */
 export interface CreateSubnetCommandOutput extends CreateSubnetResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a subnet in the specified VPC. For an IPv4 only subnet, specify an IPv4 CIDR block.
  *             If the VPC has an IPv6 CIDR block, you can create an IPv6 only subnet or a dual stack subnet instead.
  *             For an IPv6 only subnet, specify an IPv6 CIDR block. For a dual stack subnet, specify both
@@ -41,6 +46,8 @@ export interface CreateSubnetCommandOutput extends CreateSubnetResult, __Metadat
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateSubnetCommandInput - {@link CreateSubnetCommandInput}
+ * @returns {@link CreateSubnetCommandOutput}
  * @see {@link CreateSubnetCommandInput} for command's `input` shape.
  * @see {@link CreateSubnetCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -74,11 +81,20 @@ export interface CreateSubnetCommandOutput extends CreateSubnetResult, __Metadat
 export declare class CreateSubnetCommand extends $Command<CreateSubnetCommandInput, CreateSubnetCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateSubnetCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateSubnetCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSubnetCommandInput, CreateSubnetCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }