@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

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

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

@@ -6,32 +6,11 @@ export interface DeleteNetworkInterfacePermissionCommandInput extends DeleteNetw
 }
 export interface DeleteNetworkInterfacePermissionCommandOutput extends DeleteNetworkInterfacePermissionResult, __MetadataBearer {
 }
-/**
- * <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,
- * 			regardless of any attachment.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteNetworkInterfacePermissionCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteNetworkInterfacePermissionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteNetworkInterfacePermissionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteNetworkInterfacePermissionCommandInput} for command's `input` shape.
- * @see {@link DeleteNetworkInterfacePermissionCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteNetworkInterfacePermissionCommand extends $Command<DeleteNetworkInterfacePermissionCommandInput, DeleteNetworkInterfacePermissionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteNetworkInterfacePermissionCommandInput;
     constructor(input: DeleteNetworkInterfacePermissionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteNetworkInterfacePermissionCommandInput, DeleteNetworkInterfacePermissionCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

@@ -6,33 +6,11 @@ export interface DeleteSecurityGroupCommandInput extends DeleteSecurityGroupRequ
 }
 export interface DeleteSecurityGroupCommandOutput extends __MetadataBearer {
 }
-/**
- * <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
- * 				<code>InvalidGroup.InUse</code> in EC2-Classic or
- * 				<code>DependencyViolation</code> in EC2-VPC.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteSecurityGroupCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteSecurityGroupCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteSecurityGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteSecurityGroupCommandInput} for command's `input` shape.
- * @see {@link DeleteSecurityGroupCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteSecurityGroupCommand extends $Command<DeleteSecurityGroupCommandInput, DeleteSecurityGroupCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteSecurityGroupCommandInput;
     constructor(input: DeleteSecurityGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSecurityGroupCommandInput, DeleteSecurityGroupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface DeleteSnapshotCommandInput extends DeleteSnapshotRequest {
 }
 export interface DeleteSnapshotCommandOutput extends __MetadataBearer {
 }
-/**
- * <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.
- *       When you delete a snapshot, only the data not needed for any other snapshot is removed. So
- *       regardless of which prior snapshots have been deleted, all active snapshots will have access
- *       to all the information needed to restore the volume.</p>
- *          <p>You cannot delete a snapshot of the root device of an EBS volume used by a registered AMI.
- *       You must first de-register the AMI before you can delete the snapshot.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-deleting-snapshot.html">Delete an Amazon EBS snapshot</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, DeleteSnapshotCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteSnapshotCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteSnapshotCommandInput} for command's `input` shape.
- * @see {@link DeleteSnapshotCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteSnapshotCommand extends $Command<DeleteSnapshotCommandInput, DeleteSnapshotCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteSnapshotCommandInput;
     constructor(input: DeleteSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSnapshotCommandInput, DeleteSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface DeleteTrafficMirrorFilterCommandInput extends DeleteTrafficMirr
 }
 export interface DeleteTrafficMirrorFilterCommandOutput extends DeleteTrafficMirrorFilterResult, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified Traffic Mirror filter.</p>
- *          <p>You cannot delete a Traffic Mirror filter that is in use by a Traffic Mirror session.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteTrafficMirrorFilterCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteTrafficMirrorFilterCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteTrafficMirrorFilterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTrafficMirrorFilterCommandInput} for command's `input` shape.
- * @see {@link DeleteTrafficMirrorFilterCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteTrafficMirrorFilterCommand extends $Command<DeleteTrafficMirrorFilterCommandInput, DeleteTrafficMirrorFilterCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteTrafficMirrorFilterCommandInput;
     constructor(input: DeleteTrafficMirrorFilterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTrafficMirrorFilterCommandInput, DeleteTrafficMirrorFilterCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface DeleteTrafficMirrorTargetCommandInput extends DeleteTrafficMirr
 }
 export interface DeleteTrafficMirrorTargetCommandOutput extends DeleteTrafficMirrorTargetResult, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified Traffic Mirror target.</p>
- *          <p>You cannot delete a Traffic Mirror target that is in use by a Traffic Mirror session.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteTrafficMirrorTargetCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteTrafficMirrorTargetCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteTrafficMirrorTargetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTrafficMirrorTargetCommandInput} for command's `input` shape.
- * @see {@link DeleteTrafficMirrorTargetCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteTrafficMirrorTargetCommand extends $Command<DeleteTrafficMirrorTargetCommandInput, DeleteTrafficMirrorTargetCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteTrafficMirrorTargetCommandInput;
     constructor(input: DeleteTrafficMirrorTargetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTrafficMirrorTargetCommandInput, DeleteTrafficMirrorTargetCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface DeleteTransitGatewayConnectCommandInput extends DeleteTransitGa
 }
 export interface DeleteTransitGatewayConnectCommandOutput extends DeleteTransitGatewayConnectResult, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified Connect attachment. You must first delete any Connect peers for
- *             the attachment.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteTransitGatewayConnectCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteTransitGatewayConnectCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteTransitGatewayConnectCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTransitGatewayConnectCommandInput} for command's `input` shape.
- * @see {@link DeleteTransitGatewayConnectCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteTransitGatewayConnectCommand extends $Command<DeleteTransitGatewayConnectCommandInput, DeleteTransitGatewayConnectCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteTransitGatewayConnectCommandInput;
     constructor(input: DeleteTransitGatewayConnectCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTransitGatewayConnectCommandInput, DeleteTransitGatewayConnectCommandOutput>;
     private serialize;
     private deserialize;

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

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