@aws-sdk/client-ec2 3.295.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeleteNetworkInterfacePermissionRequest, DeleteNetworkInterfacePermissionResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeleteNetworkInterfacePermissionCommand}.
  */
 export interface DeleteNetworkInterfacePermissionCommandInput extends DeleteNetworkInterfacePermissionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteNetworkInterfacePermissionCommand}.
  */
 export interface DeleteNetworkInterfacePermissionCommandOutput extends DeleteNetworkInterfacePermissionResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a permission for a network interface. By default, you cannot delete the
  * 			permission if the account for which you're removing the permission has attached the
  * 			network interface to an instance. However, you can force delete the permission,
@@ -28,6 +33,8 @@ export interface DeleteNetworkInterfacePermissionCommandOutput extends DeleteNet
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteNetworkInterfacePermissionCommandInput - {@link DeleteNetworkInterfacePermissionCommandInput}
+ * @returns {@link DeleteNetworkInterfacePermissionCommandOutput}
  * @see {@link DeleteNetworkInterfacePermissionCommandInput} for command's `input` shape.
  * @see {@link DeleteNetworkInterfacePermissionCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -37,11 +44,20 @@ export interface DeleteNetworkInterfacePermissionCommandOutput extends DeleteNet
 export declare class DeleteNetworkInterfacePermissionCommand extends $Command<DeleteNetworkInterfacePermissionCommandInput, DeleteNetworkInterfacePermissionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteNetworkInterfacePermissionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteNetworkInterfacePermissionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteNetworkInterfacePermissionCommandInput, DeleteNetworkInterfacePermissionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeletePlacementGroupRequest } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeletePlacementGroupCommand}.
  */
 export interface DeletePlacementGroupCommandInput extends DeletePlacementGroupRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeletePlacementGroupCommand}.
  */
 export interface DeletePlacementGroupCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified placement group. You must terminate all instances in the
  *             placement group before you can delete the placement group. For more information, see
  *                 <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html">Placement groups</a> in the <i>Amazon EC2 User Guide</i>.</p>
@@ -27,6 +32,8 @@ export interface DeletePlacementGroupCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeletePlacementGroupCommandInput - {@link DeletePlacementGroupCommandInput}
+ * @returns {@link DeletePlacementGroupCommandOutput}
  * @see {@link DeletePlacementGroupCommandInput} for command's `input` shape.
  * @see {@link DeletePlacementGroupCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -48,11 +55,20 @@ export interface DeletePlacementGroupCommandOutput extends __MetadataBearer {
 export declare class DeletePlacementGroupCommand extends $Command<DeletePlacementGroupCommandInput, DeletePlacementGroupCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeletePlacementGroupCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeletePlacementGroupCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePlacementGroupCommandInput, DeletePlacementGroupCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeletePublicIpv4PoolRequest, DeletePublicIpv4PoolResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeletePublicIpv4PoolCommand}.
  */
 export interface DeletePublicIpv4PoolCommandInput extends DeletePublicIpv4PoolRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeletePublicIpv4PoolCommand}.
  */
 export interface DeletePublicIpv4PoolCommandOutput extends DeletePublicIpv4PoolResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Delete a public IPv4 pool. A public IPv4 pool is an EC2 IP address pool required for the public IPv4 CIDRs that you own and bring to Amazon Web Services to manage with IPAM. IPv6 addresses you bring to Amazon Web Services, however, use IPAM pools only.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeletePublicIpv4PoolCommandOutput extends DeletePublicIpv4PoolR
  * const response = await client.send(command);
  * ```
  *
+ * @param DeletePublicIpv4PoolCommandInput - {@link DeletePublicIpv4PoolCommandInput}
+ * @returns {@link DeletePublicIpv4PoolCommandOutput}
  * @see {@link DeletePublicIpv4PoolCommandInput} for command's `input` shape.
  * @see {@link DeletePublicIpv4PoolCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -34,11 +41,20 @@ export interface DeletePublicIpv4PoolCommandOutput extends DeletePublicIpv4PoolR
 export declare class DeletePublicIpv4PoolCommand extends $Command<DeletePublicIpv4PoolCommandInput, DeletePublicIpv4PoolCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeletePublicIpv4PoolCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeletePublicIpv4PoolCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePublicIpv4PoolCommandInput, DeletePublicIpv4PoolCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeleteQueuedReservedInstancesRequest, DeleteQueuedReservedInstancesResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeleteQueuedReservedInstancesCommand}.
  */
 export interface DeleteQueuedReservedInstancesCommandInput extends DeleteQueuedReservedInstancesRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteQueuedReservedInstancesCommand}.
  */
 export interface DeleteQueuedReservedInstancesCommandOutput extends DeleteQueuedReservedInstancesResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the queued purchases for the specified Reserved Instances.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteQueuedReservedInstancesCommandOutput extends DeleteQueued
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteQueuedReservedInstancesCommandInput - {@link DeleteQueuedReservedInstancesCommandInput}
+ * @returns {@link DeleteQueuedReservedInstancesCommandOutput}
  * @see {@link DeleteQueuedReservedInstancesCommandInput} for command's `input` shape.
  * @see {@link DeleteQueuedReservedInstancesCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -34,11 +41,20 @@ export interface DeleteQueuedReservedInstancesCommandOutput extends DeleteQueued
 export declare class DeleteQueuedReservedInstancesCommand extends $Command<DeleteQueuedReservedInstancesCommandInput, DeleteQueuedReservedInstancesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteQueuedReservedInstancesCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteQueuedReservedInstancesCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteQueuedReservedInstancesCommandInput, DeleteQueuedReservedInstancesCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeleteRouteRequest } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeleteRouteCommand}.
  */
 export interface DeleteRouteCommandInput extends DeleteRouteRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteRouteCommand}.
  */
 export interface DeleteRouteCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified route from the specified route table.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteRouteCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteRouteCommandInput - {@link DeleteRouteCommandInput}
+ * @returns {@link DeleteRouteCommandOutput}
  * @see {@link DeleteRouteCommandInput} for command's `input` shape.
  * @see {@link DeleteRouteCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -46,11 +53,20 @@ export interface DeleteRouteCommandOutput extends __MetadataBearer {
 export declare class DeleteRouteCommand extends $Command<DeleteRouteCommandInput, DeleteRouteCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteRouteCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteRouteCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRouteCommandInput, DeleteRouteCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeleteRouteTableRequest } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeleteRouteTableCommand}.
  */
 export interface DeleteRouteTableCommandInput extends DeleteRouteTableRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteRouteTableCommand}.
  */
 export interface DeleteRouteTableCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified route table. You must disassociate the route table from any subnets before you can delete it. You can't delete the main route table.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteRouteTableCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteRouteTableCommandInput - {@link DeleteRouteTableCommandInput}
+ * @returns {@link DeleteRouteTableCommandOutput}
  * @see {@link DeleteRouteTableCommandInput} for command's `input` shape.
  * @see {@link DeleteRouteTableCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -45,11 +52,20 @@ export interface DeleteRouteTableCommandOutput extends __MetadataBearer {
 export declare class DeleteRouteTableCommand extends $Command<DeleteRouteTableCommandInput, DeleteRouteTableCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteRouteTableCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteRouteTableCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRouteTableCommandInput, DeleteRouteTableCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeleteSecurityGroupRequest } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeleteSecurityGroupCommand}.
  */
 export interface DeleteSecurityGroupCommandInput extends DeleteSecurityGroupRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteSecurityGroupCommand}.
  */
 export interface DeleteSecurityGroupCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a security group.</p>
  *          <p>If you attempt to delete a security group that is associated with an instance, or is
  * 			  referenced by another security group, the operation fails with
@@ -32,6 +37,8 @@ export interface DeleteSecurityGroupCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteSecurityGroupCommandInput - {@link DeleteSecurityGroupCommandInput}
+ * @returns {@link DeleteSecurityGroupCommandOutput}
  * @see {@link DeleteSecurityGroupCommandInput} for command's `input` shape.
  * @see {@link DeleteSecurityGroupCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -52,11 +59,20 @@ export interface DeleteSecurityGroupCommandOutput extends __MetadataBearer {
 export declare class DeleteSecurityGroupCommand extends $Command<DeleteSecurityGroupCommandInput, DeleteSecurityGroupCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteSecurityGroupCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteSecurityGroupCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSecurityGroupCommandInput, DeleteSecurityGroupCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeleteSnapshotRequest } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeleteSnapshotCommand}.
  */
 export interface DeleteSnapshotCommandInput extends DeleteSnapshotRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteSnapshotCommand}.
  */
 export interface DeleteSnapshotCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified snapshot.</p>
  *          <p>When you make periodic snapshots of a volume, the snapshots are incremental, and only the
  *       blocks on the device that have changed since your last snapshot are saved in the new snapshot.
@@ -34,6 +39,8 @@ export interface DeleteSnapshotCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteSnapshotCommandInput - {@link DeleteSnapshotCommandInput}
+ * @returns {@link DeleteSnapshotCommandOutput}
  * @see {@link DeleteSnapshotCommandInput} for command's `input` shape.
  * @see {@link DeleteSnapshotCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -54,11 +61,20 @@ export interface DeleteSnapshotCommandOutput extends __MetadataBearer {
 export declare class DeleteSnapshotCommand extends $Command<DeleteSnapshotCommandInput, DeleteSnapshotCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSnapshotCommandInput, DeleteSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeleteSpotDatafeedSubscriptionRequest } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeleteSpotDatafeedSubscriptionCommand}.
  */
 export interface DeleteSpotDatafeedSubscriptionCommandInput extends DeleteSpotDatafeedSubscriptionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteSpotDatafeedSubscriptionCommand}.
  */
 export interface DeleteSpotDatafeedSubscriptionCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the data feed for Spot Instances.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteSpotDatafeedSubscriptionCommandOutput extends __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteSpotDatafeedSubscriptionCommandInput - {@link DeleteSpotDatafeedSubscriptionCommandInput}
+ * @returns {@link DeleteSpotDatafeedSubscriptionCommandOutput}
  * @see {@link DeleteSpotDatafeedSubscriptionCommandInput} for command's `input` shape.
  * @see {@link DeleteSpotDatafeedSubscriptionCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -43,11 +50,20 @@ export interface DeleteSpotDatafeedSubscriptionCommandOutput extends __MetadataB
 export declare class DeleteSpotDatafeedSubscriptionCommand extends $Command<DeleteSpotDatafeedSubscriptionCommandInput, DeleteSpotDatafeedSubscriptionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteSpotDatafeedSubscriptionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteSpotDatafeedSubscriptionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSpotDatafeedSubscriptionCommandInput, DeleteSpotDatafeedSubscriptionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteSubnetCidrReservationCommand.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 { DeleteSubnetCidrReservationRequest, DeleteSubnetCidrReservationResult } from "../models/models_2";
+import { DeleteSubnetCidrReservationRequest, DeleteSubnetCidrReservationResult } from "../models/models_3";
 /**
+ * @public
+ *
  * The input for {@link DeleteSubnetCidrReservationCommand}.
  */
 export interface DeleteSubnetCidrReservationCommandInput extends DeleteSubnetCidrReservationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteSubnetCidrReservationCommand}.
  */
 export interface DeleteSubnetCidrReservationCommandOutput extends DeleteSubnetCidrReservationResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a subnet CIDR reservation.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteSubnetCidrReservationCommandOutput extends DeleteSubnetCi
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteSubnetCidrReservationCommandInput - {@link DeleteSubnetCidrReservationCommandInput}
+ * @returns {@link DeleteSubnetCidrReservationCommandOutput}
  * @see {@link DeleteSubnetCidrReservationCommandInput} for command's `input` shape.
  * @see {@link DeleteSubnetCidrReservationCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -34,11 +41,20 @@ export interface DeleteSubnetCidrReservationCommandOutput extends DeleteSubnetCi
 export declare class DeleteSubnetCidrReservationCommand extends $Command<DeleteSubnetCidrReservationCommandInput, DeleteSubnetCidrReservationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteSubnetCidrReservationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteSubnetCidrReservationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSubnetCidrReservationCommandInput, DeleteSubnetCidrReservationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteSubnetCommand.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 { DeleteSubnetRequest } from "../models/models_2";
+import { DeleteSubnetRequest } from "../models/models_3";
 /**
+ * @public
+ *
  * The input for {@link DeleteSubnetCommand}.
  */
 export interface DeleteSubnetCommandInput extends DeleteSubnetRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteSubnetCommand}.
  */
 export interface DeleteSubnetCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified subnet. You must terminate all running instances in the subnet before you can delete the subnet.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteSubnetCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteSubnetCommandInput - {@link DeleteSubnetCommandInput}
+ * @returns {@link DeleteSubnetCommandOutput}
  * @see {@link DeleteSubnetCommandInput} for command's `input` shape.
  * @see {@link DeleteSubnetCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -45,11 +52,20 @@ export interface DeleteSubnetCommandOutput extends __MetadataBearer {
 export declare class DeleteSubnetCommand extends $Command<DeleteSubnetCommandInput, DeleteSubnetCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteSubnetCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteSubnetCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSubnetCommandInput, DeleteSubnetCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteTagsCommand.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 { DeleteTagsRequest } from "../models/models_2";
+import { DeleteTagsRequest } from "../models/models_3";
 /**
+ * @public
+ *
  * The input for {@link DeleteTagsCommand}.
  */
 export interface DeleteTagsCommandInput extends DeleteTagsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteTagsCommand}.
  */
 export interface DeleteTagsCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified set of tags from the specified set of resources.</p>
  *          <p>To list the current tags, use <a>DescribeTags</a>. For more information about
  *          tags, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tag
@@ -29,6 +34,8 @@ export interface DeleteTagsCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteTagsCommandInput - {@link DeleteTagsCommandInput}
+ * @returns {@link DeleteTagsCommandOutput}
  * @see {@link DeleteTagsCommandInput} for command's `input` shape.
  * @see {@link DeleteTagsCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -57,11 +64,20 @@ export interface DeleteTagsCommandOutput extends __MetadataBearer {
 export declare class DeleteTagsCommand extends $Command<DeleteTagsCommandInput, DeleteTagsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteTagsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteTagsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTagsCommandInput, DeleteTagsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }