@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

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

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

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

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

@@ -6,35 +6,11 @@ export interface ModifyVolumeAttributeCommandInput extends ModifyVolumeAttribute
 }
 export interface ModifyVolumeAttributeCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Modifies a volume attribute.</p>
- *          <p>By default, all I/O operations for the volume are suspended when the data on the volume is
- *       determined to be potentially inconsistent, to prevent undetectable, latent data corruption.
- *       The I/O access to the volume can be resumed by first enabling I/O access and then checking the
- *       data consistency on your volume.</p>
- *          <p>You can change the default behavior to resume I/O operations. We recommend that you change
- *       this only for boot volumes or for volumes that are stateless or disposable.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyVolumeAttributeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyVolumeAttributeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyVolumeAttributeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyVolumeAttributeCommandInput} for command's `input` shape.
- * @see {@link ModifyVolumeAttributeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyVolumeAttributeCommand extends $Command<ModifyVolumeAttributeCommandInput, ModifyVolumeAttributeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyVolumeAttributeCommandInput;
     constructor(input: ModifyVolumeAttributeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyVolumeAttributeCommandInput, ModifyVolumeAttributeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,44 +6,11 @@ export interface ModifyVolumeCommandInput extends ModifyVolumeRequest {
 }
 export interface ModifyVolumeCommandOutput extends ModifyVolumeResult, __MetadataBearer {
 }
-/**
- * <p>You can modify several parameters of an existing EBS volume, including volume size, volume
- *       type, and IOPS capacity. If your EBS volume is attached to a current-generation EC2 instance
- *       type, you might be able to apply these changes without stopping the instance or detaching the
- *       volume from it. For more information about modifying EBS volumes, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-modify-volume.html">Amazon EBS Elastic Volumes</a> (Linux instances)
- *       or <a href="https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ebs-modify-volume.html">Amazon EBS Elastic Volumes</a> (Windows instances).</p>
- *          <p>When you complete a resize operation on your volume, you need to extend the volume's
- *       file-system size to take advantage of the new storage capacity. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-expand-volume.html#recognize-expanded-volume-linux">Extend a Linux file system</a> or
- *       <a href="https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ebs-expand-volume.html#recognize-expanded-volume-windows">Extend a Windows file system</a>.</p>
- *          <p> You can use CloudWatch Events to check the status of a modification to an EBS volume. For
- *       information about CloudWatch Events, see the <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/">Amazon CloudWatch Events User Guide</a>. You can also track the status of a
- *       modification using <a>DescribeVolumesModifications</a>. For information
- *       about tracking status changes using either method, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-volume-modifications.html">Monitor the progress of volume modifications</a>.</p>
- *          <p>With previous-generation instance types, resizing an EBS volume might require detaching and
- *       reattaching the volume or stopping and restarting the instance.</p>
- *          <p>If you reach the maximum volume modification rate per volume limit, you must wait
- *       at least six hours before applying further modifications to the affected EBS volume.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyVolumeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyVolumeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyVolumeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyVolumeCommandInput} for command's `input` shape.
- * @see {@link ModifyVolumeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyVolumeCommand extends $Command<ModifyVolumeCommandInput, ModifyVolumeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyVolumeCommandInput;
     constructor(input: ModifyVolumeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyVolumeCommandInput, ModifyVolumeCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,32 +6,11 @@ export interface ModifyVpcEndpointCommandInput extends ModifyVpcEndpointRequest
 }
 export interface ModifyVpcEndpointCommandOutput extends ModifyVpcEndpointResult, __MetadataBearer {
 }
-/**
- * <p>Modifies attributes of a specified VPC endpoint. The attributes that you can modify
- *             depend on the type of VPC endpoint (interface, gateway, or Gateway Load Balancer). 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyVpcEndpointCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyVpcEndpointCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyVpcEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyVpcEndpointCommandInput} for command's `input` shape.
- * @see {@link ModifyVpcEndpointCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyVpcEndpointCommand extends $Command<ModifyVpcEndpointCommandInput, ModifyVpcEndpointCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyVpcEndpointCommandInput;
     constructor(input: ModifyVpcEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyVpcEndpointCommandInput, ModifyVpcEndpointCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ModifyVpcEndpointConnectionNotificationCommandInput extends Mod
 }
 export interface ModifyVpcEndpointConnectionNotificationCommandOutput extends ModifyVpcEndpointConnectionNotificationResult, __MetadataBearer {
 }
-/**
- * <p>Modifies a connection notification for VPC endpoint or VPC endpoint service. You
- *             can change the SNS topic for the notification, or the events for which to be notified. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyVpcEndpointConnectionNotificationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyVpcEndpointConnectionNotificationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyVpcEndpointConnectionNotificationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyVpcEndpointConnectionNotificationCommandInput} for command's `input` shape.
- * @see {@link ModifyVpcEndpointConnectionNotificationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyVpcEndpointConnectionNotificationCommand extends $Command<ModifyVpcEndpointConnectionNotificationCommandInput, ModifyVpcEndpointConnectionNotificationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyVpcEndpointConnectionNotificationCommandInput;
     constructor(input: ModifyVpcEndpointConnectionNotificationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyVpcEndpointConnectionNotificationCommandInput, ModifyVpcEndpointConnectionNotificationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface ModifyVpcEndpointServiceConfigurationCommandInput extends Modif
 }
 export interface ModifyVpcEndpointServiceConfigurationCommandOutput extends ModifyVpcEndpointServiceConfigurationResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the attributes of your VPC endpoint service configuration. You can change the
- *             Network Load Balancers or Gateway Load Balancers for your service, and you can specify whether acceptance is
- *             required for requests to connect to your endpoint service through an interface VPC
- *             endpoint.</p>
- * 	        <p>If you set or modify 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, ModifyVpcEndpointServiceConfigurationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyVpcEndpointServiceConfigurationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyVpcEndpointServiceConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyVpcEndpointServiceConfigurationCommandInput} for command's `input` shape.
- * @see {@link ModifyVpcEndpointServiceConfigurationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyVpcEndpointServiceConfigurationCommand extends $Command<ModifyVpcEndpointServiceConfigurationCommandInput, ModifyVpcEndpointServiceConfigurationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyVpcEndpointServiceConfigurationCommandInput;
     constructor(input: ModifyVpcEndpointServiceConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyVpcEndpointServiceConfigurationCommandInput, ModifyVpcEndpointServiceConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ModifyVpcEndpointServicePermissionsCommandInput extends ModifyV
 }
 export interface ModifyVpcEndpointServicePermissionsCommandOutput extends ModifyVpcEndpointServicePermissionsResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the permissions for your <a href="https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-service.html">VPC endpoint service</a>. You can add or remove permissions for service consumers (IAM users,
- * 	        IAM roles, and AWS accounts) to connect to your endpoint service.</p>
- * 	        <p>If you grant permissions to all principals, the service is public. Any users who know the name of a
- * 	        public service can send a request to attach an endpoint. If the service does not require manual approval,
- * 	        attachments are automatically approved.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyVpcEndpointServicePermissionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyVpcEndpointServicePermissionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyVpcEndpointServicePermissionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyVpcEndpointServicePermissionsCommandInput} for command's `input` shape.
- * @see {@link ModifyVpcEndpointServicePermissionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyVpcEndpointServicePermissionsCommand extends $Command<ModifyVpcEndpointServicePermissionsCommandInput, ModifyVpcEndpointServicePermissionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyVpcEndpointServicePermissionsCommandInput;
     constructor(input: ModifyVpcEndpointServicePermissionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyVpcEndpointServicePermissionsCommandInput, ModifyVpcEndpointServicePermissionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,50 +6,11 @@ export interface ModifyVpcPeeringConnectionOptionsCommandInput extends ModifyVpc
 }
 export interface ModifyVpcPeeringConnectionOptionsCommandOutput extends ModifyVpcPeeringConnectionOptionsResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the VPC peering connection options on one side of a VPC peering connection. You can do the following:</p>
- *          <ul>
- *             <li>
- *                <p>Enable/disable communication over the peering connection between an EC2-Classic instance that's linked to your VPC (using ClassicLink) and instances in the peer VPC.</p>
- *             </li>
- *             <li>
- *                <p>Enable/disable communication over the peering connection between instances in your VPC and an EC2-Classic instance that's linked to the peer VPC.</p>
- *             </li>
- *             <li>
- *                <p>Enable/disable the ability to resolve public DNS hostnames to private IP
- *                     addresses when queried from instances in the peer VPC.</p>
- *             </li>
- *          </ul>
- *          <p>If the peered VPCs are in the same Amazon Web Services account, you can enable DNS resolution
- *         for queries from the local VPC. This ensures that queries from the local VPC resolve to private IP
- *         addresses in the peer VPC. This option is not available if the peered VPCs are in different
- *         different Amazon Web Services accounts or different Regions. For peered VPCs in different
- *         Amazon Web Services accounts, each Amazon Web Services account owner must initiate a separate request
- *         to modify the peering connection options. For inter-region peering connections, you must use the
- *         Region for the requester VPC to modify the requester VPC peering options and the Region for the
- *         accepter VPC to modify the accepter VPC peering options. To verify which VPCs are the accepter and
- *         the requester for a VPC peering connection, use the <a>DescribeVpcPeeringConnections</a> command.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyVpcPeeringConnectionOptionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyVpcPeeringConnectionOptionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyVpcPeeringConnectionOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyVpcPeeringConnectionOptionsCommandInput} for command's `input` shape.
- * @see {@link ModifyVpcPeeringConnectionOptionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyVpcPeeringConnectionOptionsCommand extends $Command<ModifyVpcPeeringConnectionOptionsCommandInput, ModifyVpcPeeringConnectionOptionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyVpcPeeringConnectionOptionsCommandInput;
     constructor(input: ModifyVpcPeeringConnectionOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyVpcPeeringConnectionOptionsCommandInput, ModifyVpcPeeringConnectionOptionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface ModifyVpcTenancyCommandInput extends ModifyVpcTenancyRequest {
 }
 export interface ModifyVpcTenancyCommandOutput extends ModifyVpcTenancyResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the instance tenancy attribute of the specified VPC. You can change the
- *             instance tenancy attribute of a VPC to <code>default</code> only. You cannot change the
- *             instance tenancy attribute to <code>dedicated</code>.</p>
- *         <p>After you modify the tenancy of the VPC, any new instances that you launch into the
- *             VPC have a tenancy of <code>default</code>, unless you specify otherwise during launch.
- *             The tenancy of any existing instances in the VPC is not affected.</p>
- *         <p>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, ModifyVpcTenancyCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyVpcTenancyCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyVpcTenancyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyVpcTenancyCommandInput} for command's `input` shape.
- * @see {@link ModifyVpcTenancyCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyVpcTenancyCommand extends $Command<ModifyVpcTenancyCommandInput, ModifyVpcTenancyCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyVpcTenancyCommandInput;
     constructor(input: ModifyVpcTenancyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyVpcTenancyCommandInput, ModifyVpcTenancyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,66 +6,11 @@ export interface ModifyVpnConnectionCommandInput extends ModifyVpnConnectionRequ
 }
 export interface ModifyVpnConnectionCommandOutput extends ModifyVpnConnectionResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the customer gateway or the target gateway of an Amazon Web Services Site-to-Site VPN connection. To
- *             modify the target gateway, the following migration options are available:</p>
- *         <ul>
- *             <li>
- *                 <p>An existing virtual private gateway to a new virtual private gateway</p>
- *             </li>
- *             <li>
- *                 <p>An existing virtual private gateway to a transit gateway</p>
- *             </li>
- *             <li>
- *                 <p>An existing transit gateway to a new transit gateway</p>
- *             </li>
- *             <li>
- *                 <p>An existing transit gateway to a virtual private gateway</p>
- *             </li>
- *          </ul>
- *         <p>Before you perform the migration to the new gateway, you must configure the new
- *             gateway. Use <a>CreateVpnGateway</a> to create a virtual private gateway, or
- *                 <a>CreateTransitGateway</a> to create a transit gateway.</p>
- *         <p>This step is required when you migrate from a virtual private gateway with static
- *             routes to a transit gateway. </p>
- *         <p>You must delete the static routes before you migrate to the new gateway.</p>
- *
- *         <p>Keep a copy of the static route before you delete it. You will need to add back these
- *             routes to the transit gateway after the VPN connection migration is complete.</p>
- *
- *         <p>After you migrate to the new gateway, you might need to modify your VPC route table.
- *             Use <a>CreateRoute</a> and <a>DeleteRoute</a> to make the changes
- *             described in <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/modify-vpn-target.html#step-update-routing">Update VPC route
- *                 tables</a> in the <i>Amazon Web Services Site-to-Site VPN User Guide</i>.</p>
- *         <p>When the new gateway is a transit gateway, modify the transit gateway route table to
- *             allow traffic between the VPC and the Amazon Web Services Site-to-Site VPN connection.
- *             Use <a>CreateTransitGatewayRoute</a> to add the routes.</p>
- *         <p> If you deleted VPN static routes, you must add the static routes to the transit
- *             gateway route table.</p>
- *         <p>After you perform this operation, the VPN endpoint's IP addresses on the Amazon Web Services side and the tunnel options remain intact. Your Amazon Web Services Site-to-Site VPN connection will
- *             be temporarily unavailable for a brief period while we provision the new
- *             endpoints.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyVpnConnectionCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyVpnConnectionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyVpnConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyVpnConnectionCommandInput} for command's `input` shape.
- * @see {@link ModifyVpnConnectionCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyVpnConnectionCommand extends $Command<ModifyVpnConnectionCommandInput, ModifyVpnConnectionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyVpnConnectionCommandInput;
     constructor(input: ModifyVpnConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyVpnConnectionCommandInput, ModifyVpnConnectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ModifyVpnConnectionOptionsCommandInput extends ModifyVpnConnect
 }
 export interface ModifyVpnConnectionOptionsCommandOutput extends ModifyVpnConnectionOptionsResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the connection options for your Site-to-Site VPN connection.</p>
- *         <p>When you modify the VPN connection options, the VPN endpoint IP addresses on the
- *                 Amazon Web Services side do not change, and the tunnel options do not change. Your
- *             VPN connection will be temporarily unavailable for a brief period while the VPN
- *             connection is updated.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyVpnConnectionOptionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyVpnConnectionOptionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyVpnConnectionOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyVpnConnectionOptionsCommandInput} for command's `input` shape.
- * @see {@link ModifyVpnConnectionOptionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyVpnConnectionOptionsCommand extends $Command<ModifyVpnConnectionOptionsCommandInput, ModifyVpnConnectionOptionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyVpnConnectionOptionsCommandInput;
     constructor(input: ModifyVpnConnectionOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyVpnConnectionOptionsCommandInput, ModifyVpnConnectionOptionsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,32 +6,11 @@ export interface ModifyVpnTunnelOptionsCommandInput extends ModifyVpnTunnelOptio
 }
 export interface ModifyVpnTunnelOptionsCommandOutput extends ModifyVpnTunnelOptionsResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the options for a VPN tunnel in an Amazon Web Services Site-to-Site VPN connection. You can modify
- *             multiple options for a tunnel in a single request, but you can only modify one tunnel at
- *             a time. For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPNTunnels.html">Site-to-Site VPN tunnel options for your Site-to-Site VPN
- *                 connection</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, ModifyVpnTunnelOptionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyVpnTunnelOptionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyVpnTunnelOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyVpnTunnelOptionsCommandInput} for command's `input` shape.
- * @see {@link ModifyVpnTunnelOptionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyVpnTunnelOptionsCommand extends $Command<ModifyVpnTunnelOptionsCommandInput, ModifyVpnTunnelOptionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyVpnTunnelOptionsCommandInput;
     constructor(input: ModifyVpnTunnelOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyVpnTunnelOptionsCommandInput, ModifyVpnTunnelOptionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface MonitorInstancesCommandInput extends MonitorInstancesRequest {
 }
 export interface MonitorInstancesCommandOutput extends MonitorInstancesResult, __MetadataBearer {
 }
-/**
- * <p>Enables detailed monitoring for a running instance. Otherwise, basic monitoring is
- *             enabled. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch.html">Monitoring your instances and
- *                 volumes</a> in the <i>Amazon EC2 User Guide</i>.</p>
- *         <p>To disable detailed monitoring, see .</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, MonitorInstancesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, MonitorInstancesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new MonitorInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link MonitorInstancesCommandInput} for command's `input` shape.
- * @see {@link MonitorInstancesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class MonitorInstancesCommand extends $Command<MonitorInstancesCommandInput, MonitorInstancesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: MonitorInstancesCommandInput;
     constructor(input: MonitorInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<MonitorInstancesCommandInput, MonitorInstancesCommandOutput>;
     private serialize;
     private deserialize;