@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,33 +6,11 @@ export interface DeleteVolumeCommandInput extends DeleteVolumeRequest {
 }
 export interface DeleteVolumeCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified EBS volume. The volume must be in the <code>available</code> state
- *       (not attached to an instance).</p>
- *          <p>The volume can remain in the <code>deleting</code> state for several minutes.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-deleting-volume.html">Delete an Amazon EBS volume</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, DeleteVolumeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteVolumeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteVolumeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteVolumeCommandInput} for command's `input` shape.
- * @see {@link DeleteVolumeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteVolumeCommand extends $Command<DeleteVolumeCommandInput, DeleteVolumeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteVolumeCommandInput;
     constructor(input: DeleteVolumeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVolumeCommandInput, DeleteVolumeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteVpcCommandInput extends DeleteVpcRequest {
 }
 export interface DeleteVpcCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified VPC. You must detach or delete all gateways and resources that are associated with the VPC before you can delete it. For example, you must terminate all instances running in the VPC, delete all security groups associated with the VPC (except the default one), delete all route tables associated with the VPC (except the default one), and so on.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteVpcCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteVpcCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteVpcCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteVpcCommandInput} for command's `input` shape.
- * @see {@link DeleteVpcCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteVpcCommand extends $Command<DeleteVpcCommandInput, DeleteVpcCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteVpcCommandInput;
     constructor(input: DeleteVpcCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVpcCommandInput, DeleteVpcCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,32 +6,11 @@ export interface DeleteVpcEndpointServiceConfigurationsCommandInput extends Dele
 }
 export interface DeleteVpcEndpointServiceConfigurationsCommandOutput extends DeleteVpcEndpointServiceConfigurationsResult, __MetadataBearer {
 }
-/**
- * <p>Deletes one or more VPC endpoint service configurations in your account. Before you
- *             delete the endpoint service configuration, you must reject any <code>Available</code> or
- *                 <code>PendingAcceptance</code> interface endpoint connections that are attached to
- *             the service.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteVpcEndpointServiceConfigurationsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteVpcEndpointServiceConfigurationsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteVpcEndpointServiceConfigurationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteVpcEndpointServiceConfigurationsCommandInput} for command's `input` shape.
- * @see {@link DeleteVpcEndpointServiceConfigurationsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteVpcEndpointServiceConfigurationsCommand extends $Command<DeleteVpcEndpointServiceConfigurationsCommandInput, DeleteVpcEndpointServiceConfigurationsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteVpcEndpointServiceConfigurationsCommandInput;
     constructor(input: DeleteVpcEndpointServiceConfigurationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVpcEndpointServiceConfigurationsCommandInput, DeleteVpcEndpointServiceConfigurationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,53 +6,11 @@ export interface DeleteVpcEndpointsCommandInput extends DeleteVpcEndpointsReques
 }
 export interface DeleteVpcEndpointsCommandOutput extends DeleteVpcEndpointsResult, __MetadataBearer {
 }
-/**
- * <p>Deletes one or more specified VPC endpoints. You can delete any of the following types of VPC endpoints.  </p>
- *         <ul>
- *             <li>
- *                <p>Gateway endpoint,</p>
- *             </li>
- *             <li>
- *                <p>Gateway Load Balancer endpoint,</p>
- *             </li>
- *             <li>
- *                <p>Interface endpoint</p>
- *             </li>
- *          </ul>
- *         <p>The following rules apply when you delete a VPC endpoint:</p>
- *         <ul>
- *             <li>
- *                 <p>When you delete a gateway endpoint, we delete the endpoint routes in the route tables that are associated with the endpoint.</p>
- *             </li>
- *             <li>
- *                 <p>When you delete a Gateway Load Balancer endpoint, we delete the endpoint network interfaces. </p>
- *                 <p>You can only delete Gateway Load Balancer endpoints when the routes that are associated with the endpoint are deleted.</p>
- *             </li>
- *             <li>
- *                 <p>When you delete an interface endpoint, we delete the  endpoint network interfaces.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteVpcEndpointsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteVpcEndpointsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteVpcEndpointsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteVpcEndpointsCommandInput} for command's `input` shape.
- * @see {@link DeleteVpcEndpointsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteVpcEndpointsCommand extends $Command<DeleteVpcEndpointsCommandInput, DeleteVpcEndpointsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteVpcEndpointsCommandInput;
     constructor(input: DeleteVpcEndpointsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVpcEndpointsCommandInput, DeleteVpcEndpointsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DeleteVpcPeeringConnectionCommandInput extends DeleteVpcPeering
 }
 export interface DeleteVpcPeeringConnectionCommandOutput extends DeleteVpcPeeringConnectionResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a VPC peering connection. Either the owner of the requester VPC or the owner
- *             of the accepter VPC can delete the VPC peering connection if it's in the
- *                 <code>active</code> state. The owner of the requester VPC can delete a VPC peering
- *             connection in the <code>pending-acceptance</code> state. You cannot delete a VPC peering
- *             connection that's in the <code>failed</code> state.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteVpcPeeringConnectionCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteVpcPeeringConnectionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteVpcPeeringConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteVpcPeeringConnectionCommandInput} for command's `input` shape.
- * @see {@link DeleteVpcPeeringConnectionCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteVpcPeeringConnectionCommand extends $Command<DeleteVpcPeeringConnectionCommandInput, DeleteVpcPeeringConnectionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteVpcPeeringConnectionCommandInput;
     constructor(input: DeleteVpcPeeringConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVpcPeeringConnectionCommandInput, DeleteVpcPeeringConnectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface DeleteVpnConnectionCommandInput extends DeleteVpnConnectionRequ
 }
 export interface DeleteVpnConnectionCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified VPN connection.</p>
- *         <p>If you're deleting the VPC and its associated components, we recommend that you detach
- *             the virtual private gateway from the VPC and delete the VPC before deleting the VPN
- *             connection. If you believe that the tunnel credentials for your VPN connection have been
- *             compromised, you can delete the VPN connection and create a new one that has new keys,
- *             without needing to delete the VPC or virtual private gateway. If you create a new VPN
- *             connection, you must reconfigure the customer gateway device using the new configuration
- *             information returned with the new VPN connection ID.</p>
- *         <p>For certificate-based authentication, delete all Certificate Manager (ACM) private
- *             certificates used for the Amazon Web Services-side tunnel endpoints for the VPN
- *             connection before deleting the VPN connection.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteVpnConnectionCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteVpnConnectionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteVpnConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteVpnConnectionCommandInput} for command's `input` shape.
- * @see {@link DeleteVpnConnectionCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteVpnConnectionCommand extends $Command<DeleteVpnConnectionCommandInput, DeleteVpnConnectionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteVpnConnectionCommandInput;
     constructor(input: DeleteVpnConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVpnConnectionCommandInput, DeleteVpnConnectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteVpnConnectionRouteCommandInput extends DeleteVpnConnectio
 }
 export interface DeleteVpnConnectionRouteCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified static route associated with a VPN connection between an
- *             existing virtual private gateway and a VPN customer gateway. The static route allows
- *             traffic to be routed from the virtual private gateway to the VPN customer
- *             gateway.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteVpnConnectionRouteCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteVpnConnectionRouteCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteVpnConnectionRouteCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteVpnConnectionRouteCommandInput} for command's `input` shape.
- * @see {@link DeleteVpnConnectionRouteCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteVpnConnectionRouteCommand extends $Command<DeleteVpnConnectionRouteCommandInput, DeleteVpnConnectionRouteCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteVpnConnectionRouteCommandInput;
     constructor(input: DeleteVpnConnectionRouteCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVpnConnectionRouteCommandInput, DeleteVpnConnectionRouteCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteVpnGatewayCommandInput extends DeleteVpnGatewayRequest {
 }
 export interface DeleteVpnGatewayCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified virtual private gateway. You must first detach the virtual
- *             private gateway from the VPC. Note that you don't need to delete the virtual private
- *             gateway if you plan to delete and recreate the VPN connection between your VPC and your
- *             network.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteVpnGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteVpnGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteVpnGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteVpnGatewayCommandInput} for command's `input` shape.
- * @see {@link DeleteVpnGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteVpnGatewayCommand extends $Command<DeleteVpnGatewayCommandInput, DeleteVpnGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteVpnGatewayCommandInput;
     constructor(input: DeleteVpnGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVpnGatewayCommandInput, DeleteVpnGatewayCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeprovisionByoipCidrCommandInput extends DeprovisionByoipCidrRe
 }
 export interface DeprovisionByoipCidrCommandOutput extends DeprovisionByoipCidrResult, __MetadataBearer {
 }
-/**
- * <p>Releases the specified address range that you provisioned for use with your Amazon Web Services resources
- *          through bring your own IP addresses (BYOIP) and deletes the corresponding address pool.</p>
- *          <p>Before you can release an address range, you must stop advertising it using <a>WithdrawByoipCidr</a> and you must not have any IP addresses allocated from its
- *          address range.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeprovisionByoipCidrCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeprovisionByoipCidrCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeprovisionByoipCidrCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeprovisionByoipCidrCommandInput} for command's `input` shape.
- * @see {@link DeprovisionByoipCidrCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeprovisionByoipCidrCommand extends $Command<DeprovisionByoipCidrCommandInput, DeprovisionByoipCidrCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeprovisionByoipCidrCommandInput;
     constructor(input: DeprovisionByoipCidrCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeprovisionByoipCidrCommandInput, DeprovisionByoipCidrCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface DeregisterImageCommandInput extends DeregisterImageRequest {
 }
 export interface DeregisterImageCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deregisters the specified AMI. After you deregister an AMI, it can't be used to launch
- * 			new instances; however, it doesn't affect any instances that you've already launched
- * 			from the AMI. You'll continue to incur usage costs for those instances until you
- * 			terminate them.</p>
- *    	     <p>When you deregister an Amazon EBS-backed AMI, it doesn't affect the snapshot that was
- * 			created for the root volume of the instance during the AMI creation process. When you
- * 			deregister an instance store-backed AMI, it doesn't affect the files that you uploaded
- * 			to Amazon S3 when you created the AMI.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeregisterImageCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeregisterImageCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeregisterImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeregisterImageCommandInput} for command's `input` shape.
- * @see {@link DeregisterImageCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeregisterImageCommand extends $Command<DeregisterImageCommandInput, DeregisterImageCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeregisterImageCommandInput;
     constructor(input: DeregisterImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterImageCommandInput, DeregisterImageCommandOutput>;
     private serialize;
     private deserialize;