@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

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

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

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

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

@@ -6,55 +6,11 @@ export interface DeleteFleetsCommandInput extends DeleteFleetsRequest {
 }
 export interface DeleteFleetsCommandOutput extends DeleteFleetsResult, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified EC2 Fleet.</p>
- *          <p>After you delete an EC2 Fleet, it launches no new instances.</p>
- *          <p>You must specify whether a deleted EC2 Fleet should also terminate its instances. If you
- *          choose to terminate the instances, the EC2 Fleet enters the <code>deleted_terminating</code>
- *          state. Otherwise, the EC2 Fleet enters the <code>deleted_running</code> state, and the instances
- *          continue to run until they are interrupted or you terminate them manually.</p>
- *          <p>For <code>instant</code> fleets, EC2 Fleet must terminate the instances when the fleet is
- *          deleted. A deleted <code>instant</code> fleet with running instances is not
- *          supported.</p>
- *          <p class="title">
- *             <b>Restrictions</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>You can delete up to 25 <code>instant</code> fleets in a single request. If you exceed this
- *                number, no <code>instant</code> fleets are deleted and an error is returned. There is no
- *                restriction on the number of fleets of type <code>maintain</code> or <code>request</code> that can be deleted
- *                in a single request.</p>
- *             </li>
- *             <li>
- *                <p>Up to 1000 instances can be terminated in a single request to delete
- *                <code>instant</code> fleets.</p>
- *             </li>
- *          </ul>
- *
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#delete-fleet">Deleting an EC2
- *          Fleet</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, DeleteFleetsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteFleetsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteFleetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteFleetsCommandInput} for command's `input` shape.
- * @see {@link DeleteFleetsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteFleetsCommand extends $Command<DeleteFleetsCommandInput, DeleteFleetsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteFleetsCommandInput;
     constructor(input: DeleteFleetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFleetsCommandInput, DeleteFleetsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,31 +6,11 @@ export interface DeleteInstanceEventWindowCommandInput extends DeleteInstanceEve
 }
 export interface DeleteInstanceEventWindowCommandOutput extends DeleteInstanceEventWindowResult, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified event window.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define event windows for scheduled
- *             events</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, DeleteInstanceEventWindowCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteInstanceEventWindowCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteInstanceEventWindowCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteInstanceEventWindowCommandInput} for command's `input` shape.
- * @see {@link DeleteInstanceEventWindowCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteInstanceEventWindowCommand extends $Command<DeleteInstanceEventWindowCommandInput, DeleteInstanceEventWindowCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteInstanceEventWindowCommandInput;
     constructor(input: DeleteInstanceEventWindowCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteInstanceEventWindowCommandInput, DeleteInstanceEventWindowCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteInternetGatewayCommandInput extends DeleteInternetGateway
 }
 export interface DeleteInternetGatewayCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified internet gateway. You must detach the internet gateway from the
- * 			VPC 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, DeleteInternetGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteInternetGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteInternetGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteInternetGatewayCommandInput} for command's `input` shape.
- * @see {@link DeleteInternetGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteInternetGatewayCommand extends $Command<DeleteInternetGatewayCommandInput, DeleteInternetGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteInternetGatewayCommandInput;
     constructor(input: DeleteInternetGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteInternetGatewayCommandInput, DeleteInternetGatewayCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,32 +6,11 @@ export interface DeleteLaunchTemplateVersionsCommandInput extends DeleteLaunchTe
 }
 export interface DeleteLaunchTemplateVersionsCommandOutput extends DeleteLaunchTemplateVersionsResult, __MetadataBearer {
 }
-/**
- * <p>Deletes one or more versions of a launch template. You cannot delete the default
- *             version of a launch template; you must first assign a different version as the default.
- *             If the default version is the only version for the launch template, you must delete the
- *             entire launch template using <a>DeleteLaunchTemplate</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteLaunchTemplateVersionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteLaunchTemplateVersionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteLaunchTemplateVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLaunchTemplateVersionsCommandInput} for command's `input` shape.
- * @see {@link DeleteLaunchTemplateVersionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteLaunchTemplateVersionsCommand extends $Command<DeleteLaunchTemplateVersionsCommandInput, DeleteLaunchTemplateVersionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteLaunchTemplateVersionsCommandInput;
     constructor(input: DeleteLaunchTemplateVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLaunchTemplateVersionsCommandInput, DeleteLaunchTemplateVersionsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface DeleteManagedPrefixListCommandInput extends DeleteManagedPrefix
 }
 export interface DeleteManagedPrefixListCommandOutput extends DeleteManagedPrefixListResult, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified managed prefix list. You must first remove all references to the prefix list in your resources.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteManagedPrefixListCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteManagedPrefixListCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteManagedPrefixListCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteManagedPrefixListCommandInput} for command's `input` shape.
- * @see {@link DeleteManagedPrefixListCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteManagedPrefixListCommand extends $Command<DeleteManagedPrefixListCommandInput, DeleteManagedPrefixListCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteManagedPrefixListCommandInput;
     constructor(input: DeleteManagedPrefixListCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteManagedPrefixListCommandInput, DeleteManagedPrefixListCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeleteNatGatewayCommandInput extends DeleteNatGatewayRequest {
 }
 export interface DeleteNatGatewayCommandOutput extends DeleteNatGatewayResult, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified NAT gateway. Deleting a public NAT gateway disassociates its Elastic IP address,
- *           but does not release the address from your account. Deleting a NAT gateway does not delete any NAT gateway
- *           routes in your route tables.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteNatGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteNatGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteNatGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteNatGatewayCommandInput} for command's `input` shape.
- * @see {@link DeleteNatGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteNatGatewayCommand extends $Command<DeleteNatGatewayCommandInput, DeleteNatGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteNatGatewayCommandInput;
     constructor(input: DeleteNatGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteNatGatewayCommandInput, DeleteNatGatewayCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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