@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,30 +6,11 @@ export interface CreateManagedPrefixListCommandInput extends CreateManagedPrefix
 }
 export interface CreateManagedPrefixListCommandOutput extends CreateManagedPrefixListResult, __MetadataBearer {
 }
-/**
- * <p>Creates a managed prefix list. You can specify one or more entries for the prefix list.
- *             Each entry consists of a CIDR block and an optional description.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateManagedPrefixListCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateManagedPrefixListCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateManagedPrefixListCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateManagedPrefixListCommandInput} for command's `input` shape.
- * @see {@link CreateManagedPrefixListCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateManagedPrefixListCommand extends $Command<CreateManagedPrefixListCommandInput, CreateManagedPrefixListCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateManagedPrefixListCommandInput;
     constructor(input: CreateManagedPrefixListCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateManagedPrefixListCommandInput, CreateManagedPrefixListCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface CreateNatGatewayCommandInput extends CreateNatGatewayRequest {
 }
 export interface CreateNatGatewayCommandOutput extends CreateNatGatewayResult, __MetadataBearer {
 }
-/**
- * <p>Creates a NAT gateway in the specified subnet. This action creates a network interface
- *           in the specified subnet with a private IP address from the IP address range of the
- *           subnet. You can create either a public NAT gateway or a private NAT gateway.</p>
- *          <p>With a public NAT gateway, internet-bound traffic from a private subnet can be routed
- *           to the NAT gateway, so that instances in a private subnet can connect to the internet.</p>
- *          <p>With a private NAT gateway, private communication is routed across VPCs and on-premises
- *             networks through a transit gateway or virtual private gateway. Common use cases include
- *             running large workloads behind a small pool of allowlisted IPv4 addresses, preserving
- *             private IPv4 addresses, and communicating between overlapping networks.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html">NAT gateways</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, CreateNatGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateNatGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateNatGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateNatGatewayCommandInput} for command's `input` shape.
- * @see {@link CreateNatGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateNatGatewayCommand extends $Command<CreateNatGatewayCommandInput, CreateNatGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateNatGatewayCommandInput;
     constructor(input: CreateNatGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNatGatewayCommandInput, CreateNatGatewayCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CreateNetworkAclCommandInput extends CreateNetworkAclRequest {
 }
 export interface CreateNetworkAclCommandOutput extends CreateNetworkAclResult, __MetadataBearer {
 }
-/**
- * <p>Creates a network ACL in a VPC. Network ACLs provide an optional layer of security (in addition to security groups) for the instances in your VPC.</p>
- * 		       <p>For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_ACLs.html">Network ACLs</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, CreateNetworkAclCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateNetworkAclCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateNetworkAclCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateNetworkAclCommandInput} for command's `input` shape.
- * @see {@link CreateNetworkAclCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateNetworkAclCommand extends $Command<CreateNetworkAclCommandInput, CreateNetworkAclCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateNetworkAclCommandInput;
     constructor(input: CreateNetworkAclCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkAclCommandInput, CreateNetworkAclCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface CreateNetworkAclEntryCommandInput extends CreateNetworkAclEntry
 }
 export interface CreateNetworkAclEntryCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Creates an entry (a rule) in a network ACL with the specified rule number. Each network ACL has a set of numbered ingress rules
- * 		        and a separate set of numbered egress rules. When determining whether a packet should be allowed in or out of a subnet associated
- * 		        with the ACL, we process the entries in the ACL according to the rule numbers, in ascending order. Each network ACL has a set of
- * 		        ingress rules and a separate set of egress rules.</p>
- * 		       <p>We recommend that you leave room between the rule numbers (for example, 100, 110, 120, ...), and not number them one right after the
- * 		        other (for example, 101, 102, 103, ...). This makes it easier to add a rule between existing ones without having to renumber the rules.</p>
- * 		       <p>After you add an entry, you can't modify it; you must either replace it, or create an entry and delete the old one.</p>
- *          <p>For more information about network ACLs, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_ACLs.html">Network ACLs</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, CreateNetworkAclEntryCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateNetworkAclEntryCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateNetworkAclEntryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateNetworkAclEntryCommandInput} for command's `input` shape.
- * @see {@link CreateNetworkAclEntryCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateNetworkAclEntryCommand extends $Command<CreateNetworkAclEntryCommandInput, CreateNetworkAclEntryCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateNetworkAclEntryCommandInput;
     constructor(input: CreateNetworkAclEntryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkAclEntryCommandInput, CreateNetworkAclEntryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface CreateNetworkInsightsPathCommandInput extends CreateNetworkInsi
 }
 export interface CreateNetworkInsightsPathCommandOutput extends CreateNetworkInsightsPathResult, __MetadataBearer {
 }
-/**
- * <p>Creates a path to analyze for reachability.</p>
- *          <p>Reachability Analyzer enables you to analyze and debug network reachability between
- *           two resources in your virtual private cloud (VPC). For more information, see
- *           <a href="https://docs.aws.amazon.com/vpc/latest/reachability/">What is Reachability Analyzer</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateNetworkInsightsPathCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateNetworkInsightsPathCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateNetworkInsightsPathCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateNetworkInsightsPathCommandInput} for command's `input` shape.
- * @see {@link CreateNetworkInsightsPathCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateNetworkInsightsPathCommand extends $Command<CreateNetworkInsightsPathCommandInput, CreateNetworkInsightsPathCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateNetworkInsightsPathCommandInput;
     constructor(input: CreateNetworkInsightsPathCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkInsightsPathCommandInput, CreateNetworkInsightsPathCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CreateNetworkInterfaceCommandInput extends CreateNetworkInterfa
 }
 export interface CreateNetworkInterfaceCommandOutput extends CreateNetworkInterfaceResult, __MetadataBearer {
 }
-/**
- * <p>Creates a network interface in the specified subnet.</p>
- *         <p>For more information about network interfaces, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html">Elastic Network Interfaces</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, CreateNetworkInterfaceCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateNetworkInterfaceCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateNetworkInterfaceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateNetworkInterfaceCommandInput} for command's `input` shape.
- * @see {@link CreateNetworkInterfaceCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateNetworkInterfaceCommand extends $Command<CreateNetworkInterfaceCommandInput, CreateNetworkInterfaceCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateNetworkInterfaceCommandInput;
     constructor(input: CreateNetworkInterfaceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkInterfaceCommandInput, CreateNetworkInterfaceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CreateNetworkInterfacePermissionCommandInput extends CreateNetw
 }
 export interface CreateNetworkInterfacePermissionCommandOutput extends CreateNetworkInterfacePermissionResult, __MetadataBearer {
 }
-/**
- * <p>Grants an Amazon Web Services-authorized account permission to attach the specified network interface to
- *             an instance in their account.</p>
- * 	        <p>You can grant permission to a single Amazon Web Services account only, and only one account at a time.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateNetworkInterfacePermissionCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateNetworkInterfacePermissionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateNetworkInterfacePermissionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateNetworkInterfacePermissionCommandInput} for command's `input` shape.
- * @see {@link CreateNetworkInterfacePermissionCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateNetworkInterfacePermissionCommand extends $Command<CreateNetworkInterfacePermissionCommandInput, CreateNetworkInterfacePermissionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateNetworkInterfacePermissionCommandInput;
     constructor(input: CreateNetworkInterfacePermissionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkInterfacePermissionCommandInput, CreateNetworkInterfacePermissionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface CreatePlacementGroupCommandInput extends CreatePlacementGroupRe
 }
 export interface CreatePlacementGroupCommandOutput extends CreatePlacementGroupResult, __MetadataBearer {
 }
-/**
- * <p>Creates a placement group in which to launch instances. The strategy of the placement
- *             group determines how the instances are organized within the group. </p>
- *         <p>A <code>cluster</code> placement group is a logical grouping of instances within a
- *             single Availability Zone that benefit from low network latency, high network throughput.
- *             A <code>spread</code> placement group places instances on distinct hardware. A
- *                 <code>partition</code> placement group places groups of instances in different
- *             partitions, where instances in one partition do not share the same hardware with
- *             instances in another partition.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html">Placement groups</a> in the
- *                 <i>Amazon EC2 User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreatePlacementGroupCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreatePlacementGroupCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreatePlacementGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreatePlacementGroupCommandInput} for command's `input` shape.
- * @see {@link CreatePlacementGroupCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreatePlacementGroupCommand extends $Command<CreatePlacementGroupCommandInput, CreatePlacementGroupCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreatePlacementGroupCommandInput;
     constructor(input: CreatePlacementGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePlacementGroupCommandInput, CreatePlacementGroupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface CreateReplaceRootVolumeTaskCommandInput extends CreateReplaceRo
 }
 export interface CreateReplaceRootVolumeTaskCommandOutput extends CreateReplaceRootVolumeTaskResult, __MetadataBearer {
 }
-/**
- * <p>Creates a root volume replacement task for an Amazon EC2 instance. The root volume
- *       can either be restored to its initial launch state, or it can be restored using a
- *       specific snapshot.</p>
- *
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-restoring-volume.html#replace-root">Replace a root 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, CreateReplaceRootVolumeTaskCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateReplaceRootVolumeTaskCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateReplaceRootVolumeTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateReplaceRootVolumeTaskCommandInput} for command's `input` shape.
- * @see {@link CreateReplaceRootVolumeTaskCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateReplaceRootVolumeTaskCommand extends $Command<CreateReplaceRootVolumeTaskCommandInput, CreateReplaceRootVolumeTaskCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateReplaceRootVolumeTaskCommandInput;
     constructor(input: CreateReplaceRootVolumeTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateReplaceRootVolumeTaskCommandInput, CreateReplaceRootVolumeTaskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,44 +6,11 @@ export interface CreateReservedInstancesListingCommandInput extends CreateReserv
 }
 export interface CreateReservedInstancesListingCommandOutput extends CreateReservedInstancesListingResult, __MetadataBearer {
 }
-/**
- * <p>Creates a listing for Amazon EC2 Standard Reserved Instances to be sold in the Reserved Instance
- * 			Marketplace. You can submit one Standard Reserved Instance listing at a time. To get a list of your
- * 			Standard Reserved Instances, you can use the <a>DescribeReservedInstances</a> operation.</p>
- *          <note>
- *             <p>Only Standard Reserved Instances can be sold in the Reserved Instance Marketplace.
- *        Convertible Reserved Instances cannot be sold.</p>
- *          </note>
- * 		       <p>The Reserved Instance Marketplace matches sellers who want to resell Standard Reserved Instance capacity that they no longer need with buyers who want to purchase additional capacity. Reserved Instances bought and sold through the Reserved Instance Marketplace work like any other Reserved Instances.</p>
- * 		       <p>To sell your Standard Reserved Instances, you must first register as a seller in the Reserved Instance
- *       Marketplace. After completing the registration process, you can create a Reserved Instance
- *       Marketplace listing of some or all of your Standard Reserved Instances, and specify the upfront price
- *       to receive for them. Your Standard Reserved Instance listings then become available for purchase. To
- *       view the details of your Standard Reserved Instance listing, you can use the
- *         <a>DescribeReservedInstancesListings</a> operation.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html">Reserved Instance Marketplace</a> in the
- * 				<i>Amazon EC2 User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateReservedInstancesListingCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateReservedInstancesListingCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateReservedInstancesListingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateReservedInstancesListingCommandInput} for command's `input` shape.
- * @see {@link CreateReservedInstancesListingCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateReservedInstancesListingCommand extends $Command<CreateReservedInstancesListingCommandInput, CreateReservedInstancesListingCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateReservedInstancesListingCommandInput;
     constructor(input: CreateReservedInstancesListingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateReservedInstancesListingCommandInput, CreateReservedInstancesListingCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface CreateRestoreImageTaskCommandInput extends CreateRestoreImageTa
 }
 export interface CreateRestoreImageTaskCommandOutput extends CreateRestoreImageTaskResult, __MetadataBearer {
 }
-/**
- * <p>Starts a task that restores an AMI from an Amazon S3 object that was previously created by using
- *       <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateStoreImageTask.html">CreateStoreImageTask</a>.</p>
- *          <p>To use this API, you must have the required permissions. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html#ami-s3-permissions">Permissions for storing and restoring AMIs using Amazon S3</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/ami-store-restore.html">Store and restore an AMI using
- *     	Amazon S3</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, CreateRestoreImageTaskCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateRestoreImageTaskCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateRestoreImageTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateRestoreImageTaskCommandInput} for command's `input` shape.
- * @see {@link CreateRestoreImageTaskCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateRestoreImageTaskCommand extends $Command<CreateRestoreImageTaskCommandInput, CreateRestoreImageTaskCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateRestoreImageTaskCommandInput;
     constructor(input: CreateRestoreImageTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRestoreImageTaskCommandInput, CreateRestoreImageTaskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,49 +6,11 @@ export interface CreateRouteCommandInput extends CreateRouteRequest {
 }
 export interface CreateRouteCommandOutput extends CreateRouteResult, __MetadataBearer {
 }
-/**
- * <p>Creates a route in a route table within a VPC.</p>
- *          <p>You must specify one of the following targets: internet gateway or virtual private
- * 			gateway, NAT instance, NAT gateway, VPC peering connection, network interface, egress-only internet gateway, or transit gateway.</p>
- *          <p>When determining how to route traffic, we use the route with the most specific match.
- *             For example, traffic is destined for the IPv4 address <code>192.0.2.3</code>, and the
- *             route table includes the following two IPv4 routes:</p>
- * 			      <ul>
- *             <li>
- * 					          <p>
- *                   <code>192.0.2.0/24</code> (goes to some target A)</p>
- * 				        </li>
- *             <li>
- * 					          <p>
- *                   <code>192.0.2.0/28</code> (goes to some target B)</p>
- * 				        </li>
- *          </ul>
- * 		       <p>Both routes apply to the traffic destined for <code>192.0.2.3</code>. However, the second route
- * 				in the list covers a smaller number of IP addresses and is therefore more specific,
- * 				so we use that route to determine where to target the traffic.</p>
- *          <p>For more information about route tables, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route tables</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, CreateRouteCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateRouteCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateRouteCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateRouteCommandInput} for command's `input` shape.
- * @see {@link CreateRouteCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateRouteCommand extends $Command<CreateRouteCommandInput, CreateRouteCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateRouteCommandInput;
     constructor(input: CreateRouteCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRouteCommandInput, CreateRouteCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CreateRouteTableCommandInput extends CreateRouteTableRequest {
 }
 export interface CreateRouteTableCommandOutput extends CreateRouteTableResult, __MetadataBearer {
 }
-/**
- * <p>Creates a route table for the specified VPC. After you create a route table, you can add routes and associate the table with a subnet.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route tables</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, CreateRouteTableCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateRouteTableCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateRouteTableCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateRouteTableCommandInput} for command's `input` shape.
- * @see {@link CreateRouteTableCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateRouteTableCommand extends $Command<CreateRouteTableCommandInput, CreateRouteTableCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateRouteTableCommandInput;
     constructor(input: CreateRouteTableCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRouteTableCommandInput, CreateRouteTableCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,43 +6,11 @@ export interface CreateSecurityGroupCommandInput extends CreateSecurityGroupRequ
 }
 export interface CreateSecurityGroupCommandOutput extends CreateSecurityGroupResult, __MetadataBearer {
 }
-/**
- * <p>Creates a security group.</p>
- *          <p>A security group acts as a virtual firewall for your instance to control inbound and outbound traffic.
- *          For more information, see
- * 				<a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html">Amazon EC2 security groups</a> in
- * 				the <i>Amazon Elastic Compute Cloud User Guide</i> and
- * 				<a href="https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_SecurityGroups.html">Security groups for your VPC</a> in the
- * 				<i>Amazon Virtual Private Cloud User Guide</i>.</p>
- *          <p>When you create a security group, you specify a friendly name of your choice. You can have a security group for use in EC2-Classic with the same name as a security group for use in a VPC. However, you can't have two security groups for use in EC2-Classic with the same name or two security groups for use in a VPC with the same name.</p>
- *          <p>You have a default security group for use in EC2-Classic and a default security group for use in your VPC. If you don't specify a security group when you launch an instance, the instance is launched into the appropriate default security group. A default security group includes a default rule that grants instances unrestricted network access to each other.</p>
- *          <p>You can add or remove rules from your security groups using
- * 					<a>AuthorizeSecurityGroupIngress</a>,
- * 					<a>AuthorizeSecurityGroupEgress</a>,
- * 					<a>RevokeSecurityGroupIngress</a>, and
- * 					<a>RevokeSecurityGroupEgress</a>.</p>
- *          <p>For more information about VPC security group limits, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html">Amazon VPC Limits</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateSecurityGroupCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateSecurityGroupCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateSecurityGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSecurityGroupCommandInput} for command's `input` shape.
- * @see {@link CreateSecurityGroupCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSecurityGroupCommand extends $Command<CreateSecurityGroupCommandInput, CreateSecurityGroupCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateSecurityGroupCommandInput;
     constructor(input: CreateSecurityGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSecurityGroupCommandInput, CreateSecurityGroupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,56 +6,11 @@ export interface CreateSnapshotCommandInput extends CreateSnapshotRequest {
 }
 export interface CreateSnapshotCommandOutput extends Snapshot, __MetadataBearer {
 }
-/**
- * <p>Creates a snapshot of an EBS volume and stores it in Amazon S3. You can use snapshots for
- *   	backups, to make copies of EBS volumes, and to save data before shutting down an
- *   	instance.</p>
- *
- *
- *          <p>You can create snapshots of volumes in a Region and volumes on an Outpost. If you
- *     	create a snapshot of a volume in a Region, the snapshot must be stored in the same
- *     	Region as the volume. If you create a snapshot of a volume on an Outpost, the snapshot
- *     	can be stored on the same Outpost as the volume, or in the Region for that Outpost.</p>
- *
- *          <p>When a snapshot is created, any Amazon Web Services Marketplace product codes that are associated with the
- *       source volume are propagated to the snapshot.</p>
- *          <p>You can take a snapshot of an attached volume that is in use. However, snapshots only
- *       capture data that has been written to your Amazon EBS volume at the time the snapshot command is
- *       issued; this might exclude any data that has been cached by any applications or the operating
- *       system. If you can pause any file systems on the volume long enough to take a snapshot, your
- *       snapshot should be complete. However, if you cannot pause all file writes to the volume, you
- *       should unmount the volume from within the instance, issue the snapshot command, and then
- *       remount the volume to ensure a consistent and complete snapshot. You may remount and use your
- *       volume while the snapshot status is <code>pending</code>.</p>
- *          <p>To create a snapshot for Amazon EBS volumes that serve as root devices, you should stop the
- *       instance before taking the snapshot.</p>
- *          <p>Snapshots that are taken from encrypted volumes are automatically encrypted. Volumes that
- *       are created from encrypted snapshots are also automatically encrypted. Your encrypted volumes
- *       and any associated snapshots always remain protected.</p>
- *          <p>You can tag your snapshots 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/AmazonEBS.html">Amazon Elastic Block Store</a> and <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateSnapshotCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateSnapshotCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSnapshotCommandInput} for command's `input` shape.
- * @see {@link CreateSnapshotCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSnapshotCommand extends $Command<CreateSnapshotCommandInput, CreateSnapshotCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateSnapshotCommandInput;
     constructor(input: CreateSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSnapshotCommandInput, CreateSnapshotCommandOutput>;
     private serialize;
     private deserialize;