@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

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

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

@@ -6,32 +6,11 @@ export interface CreateTransitGatewayVpcAttachmentCommandInput extends CreateTra
 }
 export interface CreateTransitGatewayVpcAttachmentCommandOutput extends CreateTransitGatewayVpcAttachmentResult, __MetadataBearer {
 }
-/**
- * <p>Attaches the specified VPC to the specified transit gateway.</p>
- *          <p>If you attach a VPC with a CIDR range that overlaps the CIDR range of a VPC that is already attached,
- *          the new VPC CIDR range is not propagated to the default propagation route table.</p>
- *          <p>To send VPC traffic to an attached transit gateway, add a route to the VPC route table using <a>CreateRoute</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateTransitGatewayVpcAttachmentCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateTransitGatewayVpcAttachmentCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateTransitGatewayVpcAttachmentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTransitGatewayVpcAttachmentCommandInput} for command's `input` shape.
- * @see {@link CreateTransitGatewayVpcAttachmentCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTransitGatewayVpcAttachmentCommand extends $Command<CreateTransitGatewayVpcAttachmentCommandInput, CreateTransitGatewayVpcAttachmentCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayVpcAttachmentCommandInput;
     constructor(input: CreateTransitGatewayVpcAttachmentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayVpcAttachmentCommandInput, CreateTransitGatewayVpcAttachmentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface CreateVolumeCommandInput extends CreateVolumeRequest {
 }
 export interface CreateVolumeCommandOutput extends Volume, __MetadataBearer {
 }
-/**
- * <p>Creates an EBS volume that can be attached to an instance in the same Availability Zone.</p>
- *          <p>You can create a new empty volume or restore a volume from an EBS snapshot.
- *       Any Amazon Web Services Marketplace product codes from the snapshot are propagated to the volume.</p>
- *          <p>You can create encrypted volumes. Encrypted volumes must be attached to instances that
- *       support Amazon EBS encryption. Volumes that are created from encrypted snapshots are also automatically
- *       encrypted. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html">Amazon EBS encryption</a>
- *       in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- *          <p>You can tag your volumes during creation. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tag your Amazon EC2
- *         resources</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-creating-volume.html">Create 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, CreateVolumeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateVolumeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateVolumeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateVolumeCommandInput} for command's `input` shape.
- * @see {@link CreateVolumeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateVolumeCommand extends $Command<CreateVolumeCommandInput, CreateVolumeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateVolumeCommandInput;
     constructor(input: CreateVolumeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVolumeCommandInput, CreateVolumeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,41 +6,11 @@ export interface CreateVpcCommandInput extends CreateVpcRequest {
 }
 export interface CreateVpcCommandOutput extends CreateVpcResult, __MetadataBearer {
 }
-/**
- * <p>Creates a VPC with the specified IPv4 CIDR block. The smallest VPC you can create
- * 			uses a /28 netmask (16 IPv4 addresses), and the largest uses a /16 netmask (65,536 IPv4
- * 			addresses). For more information about how large to make your VPC, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html">Your VPC and
- * 				subnets</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.</p>
- *          <p>You can optionally request an IPv6 CIDR block for the VPC. You can request an Amazon-provided
- *            IPv6 CIDR block from Amazon's pool of IPv6 addresses, or an IPv6 CIDR block from an IPv6 address
- *            pool that you provisioned through bring your own IP addresses (<a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">BYOIP</a>).</p>
- * 	        <p>By default, each instance you launch in the VPC has the default DHCP options, which
- * 			include only a default DNS server that we provide (AmazonProvidedDNS). For more
- * 			information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html">DHCP options sets</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.</p>
- *          <p>You can specify the instance tenancy value for the VPC when you create it. You can't change
- *           this value for the VPC after you create it. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-instance.html">Dedicated Instances</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, CreateVpcCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateVpcCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateVpcCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateVpcCommandInput} for command's `input` shape.
- * @see {@link CreateVpcCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateVpcCommand extends $Command<CreateVpcCommandInput, CreateVpcCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateVpcCommandInput;
     constructor(input: CreateVpcCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVpcCommandInput, CreateVpcCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,43 +6,11 @@ export interface CreateVpcEndpointCommandInput extends CreateVpcEndpointRequest
 }
 export interface CreateVpcEndpointCommandOutput extends CreateVpcEndpointResult, __MetadataBearer {
 }
-/**
- * <p>Creates a VPC endpoint for a specified service. An endpoint enables you to create a
- *             private connection between your VPC and the service. The service may be provided by AWS,
- *             an AWS Marketplace Partner, or another AWS account. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html">VPC Endpoints</a> in
- *             the <i>Amazon Virtual Private Cloud User Guide</i>.</p>
- *         <p>A <code>gateway</code> endpoint serves as a target for a route in your route table for
- *             traffic destined for the AWS service. You can specify an endpoint policy to attach to
- *             the endpoint, which will control access to the service from your VPC. You can also
- *             specify the VPC route tables that use the endpoint.</p>
- *         <p>An <code>interface</code> endpoint is a network interface in your subnet that
- *             serves as an endpoint for communicating with the specified service. You can specify the
- *             subnets in which to create an endpoint, and the security groups to associate with the
- *             endpoint network interface.</p>
- *         <p>A <code>GatewayLoadBalancer</code> endpoint is a network interface in your subnet that serves an endpoint for communicating with a Gateway Load Balancer that you've configured as a VPC endpoint service.</p>
- *         <p>Use <a>DescribeVpcEndpointServices</a> to get a list of supported
- *             services.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateVpcEndpointCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateVpcEndpointCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateVpcEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateVpcEndpointCommandInput} for command's `input` shape.
- * @see {@link CreateVpcEndpointCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateVpcEndpointCommand extends $Command<CreateVpcEndpointCommandInput, CreateVpcEndpointCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateVpcEndpointCommandInput;
     constructor(input: CreateVpcEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVpcEndpointCommandInput, CreateVpcEndpointCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface CreateVpcEndpointConnectionNotificationCommandInput extends Cre
 }
 export interface CreateVpcEndpointConnectionNotificationCommandOutput extends CreateVpcEndpointConnectionNotificationResult, __MetadataBearer {
 }
-/**
- * <p>Creates a connection notification for a specified VPC endpoint or VPC endpoint
- *             service. A connection notification notifies you of specific endpoint events. You must
- *             create an SNS topic to receive notifications. For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html">Create a Topic</a> in
- *             the <i>Amazon Simple Notification Service Developer Guide</i>.</p>
- *         <p>You can create a connection notification for interface endpoints only.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateVpcEndpointConnectionNotificationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateVpcEndpointConnectionNotificationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateVpcEndpointConnectionNotificationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateVpcEndpointConnectionNotificationCommandInput} for command's `input` shape.
- * @see {@link CreateVpcEndpointConnectionNotificationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateVpcEndpointConnectionNotificationCommand extends $Command<CreateVpcEndpointConnectionNotificationCommandInput, CreateVpcEndpointConnectionNotificationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateVpcEndpointConnectionNotificationCommandInput;
     constructor(input: CreateVpcEndpointConnectionNotificationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVpcEndpointConnectionNotificationCommandInput, CreateVpcEndpointConnectionNotificationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,53 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { CreateVpcEndpointServiceConfigurationRequest, CreateVpcEndpointServiceConfigurationResult } from "../models/models_1";
+import { CreateVpcEndpointServiceConfigurationRequest, CreateVpcEndpointServiceConfigurationResult } from "../models/models_2";
 export interface CreateVpcEndpointServiceConfigurationCommandInput extends CreateVpcEndpointServiceConfigurationRequest {
 }
 export interface CreateVpcEndpointServiceConfigurationCommandOutput extends CreateVpcEndpointServiceConfigurationResult, __MetadataBearer {
 }
-/**
- * <p>Creates a VPC endpoint service configuration to which service consumers (AWS accounts,
- *             IAM users, and IAM roles) can connect.</p>
- *         <p>To create an endpoint service configuration, you must first create one of the
- *             following for your service:</p>
- *         <ul>
- *             <li>
- *                 <p>A <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/network/introduction.html">Network Load Balancer</a>. Service consumers connect to your service using an
- *                     interface endpoint.</p>
- *             </li>
- *             <li>
- *                 <p>A <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/introduction.html">Gateway Load Balancer</a>. Service consumers connect to your service using a
- *                     Gateway Load Balancer endpoint.</p>
- *             </li>
- *          </ul>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-service.html">VPC Endpoint Services</a> in the
- *                 <i>Amazon Virtual Private Cloud User Guide</i>. </p>
- *         <p>If you set the private DNS name, you must prove that you own the private DNS domain
- *             name. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-dns-validation.html">VPC Endpoint Service
- *                 Private DNS Name Verification</a> in the
- *             <i>Amazon Virtual Private Cloud User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateVpcEndpointServiceConfigurationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateVpcEndpointServiceConfigurationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateVpcEndpointServiceConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateVpcEndpointServiceConfigurationCommandInput} for command's `input` shape.
- * @see {@link CreateVpcEndpointServiceConfigurationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateVpcEndpointServiceConfigurationCommand extends $Command<CreateVpcEndpointServiceConfigurationCommandInput, CreateVpcEndpointServiceConfigurationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateVpcEndpointServiceConfigurationCommandInput;
     constructor(input: CreateVpcEndpointServiceConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVpcEndpointServiceConfigurationCommandInput, CreateVpcEndpointServiceConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,46 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { CreateVpcPeeringConnectionRequest, CreateVpcPeeringConnectionResult } from "../models/models_1";
+import { CreateVpcPeeringConnectionRequest, CreateVpcPeeringConnectionResult } from "../models/models_2";
 export interface CreateVpcPeeringConnectionCommandInput extends CreateVpcPeeringConnectionRequest {
 }
 export interface CreateVpcPeeringConnectionCommandOutput extends CreateVpcPeeringConnectionResult, __MetadataBearer {
 }
-/**
- * <p>Requests a VPC peering connection between two VPCs: a requester VPC that you own and
- * 		  an accepter VPC with which to create the connection. The accepter VPC can belong to
- * 		  another Amazon Web Services account and can be in a different Region to the requester VPC.
- *           The requester VPC and accepter VPC cannot have overlapping CIDR blocks.</p>
- *          <note>
- *             <p>Limitations and rules apply to a VPC peering connection. For more information, see
- *           the <a href="https://docs.aws.amazon.com/vpc/latest/peering/vpc-peering-basics.html#vpc-peering-limitations">limitations</a> section in the <i>VPC Peering Guide</i>.</p>
- *          </note>
- *          <p>The owner of the accepter VPC must accept the peering request to activate the peering
- *             connection. The VPC peering connection request expires after 7 days, after which it
- *             cannot be accepted or rejected.</p>
- *          <p>If you create a VPC peering connection request between VPCs with overlapping CIDR
- *             blocks, the VPC peering connection has a status of <code>failed</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateVpcPeeringConnectionCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateVpcPeeringConnectionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateVpcPeeringConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateVpcPeeringConnectionCommandInput} for command's `input` shape.
- * @see {@link CreateVpcPeeringConnectionCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateVpcPeeringConnectionCommand extends $Command<CreateVpcPeeringConnectionCommandInput, CreateVpcPeeringConnectionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateVpcPeeringConnectionCommandInput;
     constructor(input: CreateVpcPeeringConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVpcPeeringConnectionCommandInput, CreateVpcPeeringConnectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,51 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { CreateVpnConnectionRequest } from "../models/models_1";
-import { CreateVpnConnectionResult } from "../models/models_2";
+import { CreateVpnConnectionRequest, CreateVpnConnectionResult } from "../models/models_2";
 export interface CreateVpnConnectionCommandInput extends CreateVpnConnectionRequest {
 }
 export interface CreateVpnConnectionCommandOutput extends CreateVpnConnectionResult, __MetadataBearer {
 }
-/**
- * <p>Creates a VPN connection between an existing virtual private gateway or transit
- *             gateway and a customer gateway. The supported connection type is
- *             <code>ipsec.1</code>.</p>
- *         <p>The response includes information that you need to give to your network administrator
- *             to configure your customer gateway.</p>
- *         <important>
- *             <p>We strongly recommend that you use HTTPS when calling this operation because the
- *                 response contains sensitive cryptographic information for configuring your customer
- *                 gateway device.</p>
- *         </important>
- *         <p>If you decide to shut down your VPN connection for any reason and later create a new
- *             VPN connection, you must reconfigure your customer gateway with the new information
- *             returned from this call.</p>
- *         <p>This is an idempotent operation. If you perform the operation more than once, Amazon
- *             EC2 doesn't return an error.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN
- *                 User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateVpnConnectionCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateVpnConnectionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateVpnConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateVpnConnectionCommandInput} for command's `input` shape.
- * @see {@link CreateVpnConnectionCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateVpnConnectionCommand extends $Command<CreateVpnConnectionCommandInput, CreateVpnConnectionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateVpnConnectionCommandInput;
     constructor(input: CreateVpnConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVpnConnectionCommandInput, CreateVpnConnectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface CreateVpnConnectionRouteCommandInput extends CreateVpnConnectio
 }
 export interface CreateVpnConnectionRouteCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Creates a 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>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN
- *                 User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateVpnConnectionRouteCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateVpnConnectionRouteCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateVpnConnectionRouteCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateVpnConnectionRouteCommandInput} for command's `input` shape.
- * @see {@link CreateVpnConnectionRouteCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateVpnConnectionRouteCommand extends $Command<CreateVpnConnectionRouteCommandInput, CreateVpnConnectionRouteCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateVpnConnectionRouteCommandInput;
     constructor(input: CreateVpnConnectionRouteCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVpnConnectionRouteCommandInput, CreateVpnConnectionRouteCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface CreateVpnGatewayCommandInput extends CreateVpnGatewayRequest {
 }
 export interface CreateVpnGatewayCommandOutput extends CreateVpnGatewayResult, __MetadataBearer {
 }
-/**
- * <p>Creates a virtual private gateway. A virtual private gateway is the endpoint on the
- *             VPC side of your VPN connection. You can create a virtual private gateway before
- *             creating the VPC itself.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN
- *                 User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateVpnGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateVpnGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateVpnGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateVpnGatewayCommandInput} for command's `input` shape.
- * @see {@link CreateVpnGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateVpnGatewayCommand extends $Command<CreateVpnGatewayCommandInput, CreateVpnGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateVpnGatewayCommandInput;
     constructor(input: CreateVpnGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVpnGatewayCommandInput, CreateVpnGatewayCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DeleteCarrierGatewayCommandInput extends DeleteCarrierGatewayRe
 }
 export interface DeleteCarrierGatewayCommandOutput extends DeleteCarrierGatewayResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a carrier gateway.</p>
- *         <important>
- *             <p>If you do not delete the route that contains the carrier gateway as the
- *                 Target, the route is a blackhole route. For information about how to delete a route, see
- *                 <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteRoute.html">DeleteRoute</a>.</p>
- *         </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteCarrierGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteCarrierGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteCarrierGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteCarrierGatewayCommandInput} for command's `input` shape.
- * @see {@link DeleteCarrierGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteCarrierGatewayCommand extends $Command<DeleteCarrierGatewayCommandInput, DeleteCarrierGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteCarrierGatewayCommandInput;
     constructor(input: DeleteCarrierGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCarrierGatewayCommandInput, DeleteCarrierGatewayCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,32 +6,11 @@ export interface DeleteClientVpnRouteCommandInput extends DeleteClientVpnRouteRe
 }
 export interface DeleteClientVpnRouteCommandOutput extends DeleteClientVpnRouteResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a route from a Client VPN endpoint. You can only delete routes that you manually added using
- * 			the <b>CreateClientVpnRoute</b> action. You cannot delete routes that were
- * 			automatically added when associating a subnet. To remove routes that have been automatically added,
- * 			disassociate the target subnet from the Client VPN endpoint.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeleteClientVpnRouteCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeleteClientVpnRouteCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeleteClientVpnRouteCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteClientVpnRouteCommandInput} for command's `input` shape.
- * @see {@link DeleteClientVpnRouteCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteClientVpnRouteCommand extends $Command<DeleteClientVpnRouteCommandInput, DeleteClientVpnRouteCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteClientVpnRouteCommandInput;
     constructor(input: DeleteClientVpnRouteCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteClientVpnRouteCommandInput, DeleteClientVpnRouteCommandOutput>;
     private serialize;
     private deserialize;

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

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