@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,81 +6,11 @@ export interface CreateDhcpOptionsCommandInput extends CreateDhcpOptionsRequest
 }
 export interface CreateDhcpOptionsCommandOutput extends CreateDhcpOptionsResult, __MetadataBearer {
 }
-/**
- * <p>Creates a set of DHCP options for your VPC. After creating the set, you must
- * 				associate it with the VPC, causing all existing and new instances that you launch in
- * 				the VPC to use this set of DHCP options. The following are the individual DHCP
- * 				options you can specify. For more information about the options, see <a href="http://www.ietf.org/rfc/rfc2132.txt">RFC 2132</a>.</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <code>domain-name-servers</code> - The IP addresses of up to four domain name
- *                     servers, or AmazonProvidedDNS. The default DHCP option set specifies
- *                     AmazonProvidedDNS. If specifying more than one domain name server, specify the
- *                     IP addresses in a single parameter, separated by commas. To have your instance
- *                     receive a custom DNS hostname as specified in <code>domain-name</code>, you must
- *                     set <code>domain-name-servers</code> to a custom DNS server.</p>
- *            </li>
- *             <li>
- *                <p>
- *                   <code>domain-name</code> - If you're using AmazonProvidedDNS in
- *                    <code>us-east-1</code>, specify <code>ec2.internal</code>. If you're using
- *                    AmazonProvidedDNS in another Region, specify
- *                    <code>region.compute.internal</code> (for example,
- *                    <code>ap-northeast-1.compute.internal</code>). Otherwise, specify a domain
- *                    name (for example, <code>ExampleCompany.com</code>). This value is used to complete
- *                    unqualified DNS hostnames. <b>Important</b>: Some
- *                    Linux operating systems accept multiple domain names separated by spaces.
- *                    However, Windows and other Linux operating systems treat the value as a single
- *                    domain, which results in unexpected behavior. If your DHCP options set is
- *                    associated with a VPC that has instances with multiple operating systems,
- *                    specify only one domain name.</p>
- *            </li>
- *             <li>
- *                <p>
- *                   <code>ntp-servers</code> - The IP addresses of up to four Network Time Protocol (NTP)
- *                    servers.</p>
- *            </li>
- *             <li>
- *                <p>
- *                   <code>netbios-name-servers</code> - The IP addresses of up to four NetBIOS name
- *                    servers.</p>
- *            </li>
- *             <li>
- *                <p>
- *                   <code>netbios-node-type</code> - The NetBIOS node type (1, 2, 4, or 8). We recommend that
- *                    you specify 2 (broadcast and multicast are not currently supported). For more information
- *                    about these node types, see <a href="http://www.ietf.org/rfc/rfc2132.txt">RFC 2132</a>.</p>
- *            </li>
- *          </ul>
- *
- *          <p>Your VPC automatically starts out with a set of DHCP options that includes only a DNS
- * 			server that we provide (AmazonProvidedDNS). If you create a set of options, and if your
- * 			VPC has an internet gateway, make sure to set the <code>domain-name-servers</code>
- * 			option either to <code>AmazonProvidedDNS</code> or to a domain name server of your
- * 			choice. 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateDhcpOptionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateDhcpOptionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateDhcpOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDhcpOptionsCommandInput} for command's `input` shape.
- * @see {@link CreateDhcpOptionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateDhcpOptionsCommand extends $Command<CreateDhcpOptionsCommandInput, CreateDhcpOptionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateDhcpOptionsCommandInput;
     constructor(input: CreateDhcpOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDhcpOptionsCommandInput, CreateDhcpOptionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface CreateEgressOnlyInternetGatewayCommandInput extends CreateEgres
 }
 export interface CreateEgressOnlyInternetGatewayCommandOutput extends CreateEgressOnlyInternetGatewayResult, __MetadataBearer {
 }
-/**
- * <p>[IPv6 only] Creates an egress-only internet gateway for your VPC. An egress-only
- * 			internet gateway is used to enable outbound communication over IPv6 from instances in
- * 			your VPC to the internet, and prevents hosts outside of your VPC from initiating an IPv6
- * 			connection with your instance.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateEgressOnlyInternetGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateEgressOnlyInternetGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateEgressOnlyInternetGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateEgressOnlyInternetGatewayCommandInput} for command's `input` shape.
- * @see {@link CreateEgressOnlyInternetGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateEgressOnlyInternetGatewayCommand extends $Command<CreateEgressOnlyInternetGatewayCommandInput, CreateEgressOnlyInternetGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateEgressOnlyInternetGatewayCommandInput;
     constructor(input: CreateEgressOnlyInternetGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEgressOnlyInternetGatewayCommandInput, CreateEgressOnlyInternetGatewayCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,37 +1,17 @@
 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 { CreateFleetRequest, CreateFleetResult } from "../models/models_0";
+import { CreateFleetRequest } from "../models/models_0";
+import { CreateFleetResult } from "../models/models_1";
 export interface CreateFleetCommandInput extends CreateFleetRequest {
 }
 export interface CreateFleetCommandOutput extends CreateFleetResult, __MetadataBearer {
 }
-/**
- * <p>Launches an EC2 Fleet.</p>
- *          <p>You can create a single EC2 Fleet that includes multiple launch specifications that vary by
- *          instance type, AMI, Availability Zone, or subnet.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet.html">Launching an EC2 Fleet</a> in the <i>Amazon EC2 User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateFleetCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateFleetCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateFleetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateFleetCommandInput} for command's `input` shape.
- * @see {@link CreateFleetCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateFleetCommand extends $Command<CreateFleetCommandInput, CreateFleetCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateFleetCommandInput;
     constructor(input: CreateFleetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFleetCommandInput, CreateFleetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,47 +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 { CreateFlowLogsRequest, CreateFlowLogsResult } from "../models/models_0";
+import { CreateFlowLogsRequest, CreateFlowLogsResult } from "../models/models_1";
 export interface CreateFlowLogsCommandInput extends CreateFlowLogsRequest {
 }
 export interface CreateFlowLogsCommandOutput extends CreateFlowLogsResult, __MetadataBearer {
 }
-/**
- * <p>Creates one or more flow logs to capture information about IP traffic for a specific network interface,
- *             subnet, or VPC. </p>
- *
- *         <p>Flow log data for a monitored network interface is recorded as flow log records, which are log events
- *             consisting of fields that describe the traffic flow. For more information, see
- *             <a href="https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records">Flow log records</a>
- *             in the <i>Amazon Virtual Private Cloud User Guide</i>.</p>
- *
- *         <p>When publishing to CloudWatch Logs, flow log records are published to a log group, and each network
- *             interface has a unique log stream in the log group. When publishing to Amazon S3, flow log records for all
- *             of the monitored network interfaces are published to a single log file object that is stored in the specified
- *             bucket.</p>
- *
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html">VPC Flow Logs</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, CreateFlowLogsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateFlowLogsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateFlowLogsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateFlowLogsCommandInput} for command's `input` shape.
- * @see {@link CreateFlowLogsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateFlowLogsCommand extends $Command<CreateFlowLogsCommandInput, CreateFlowLogsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateFlowLogsCommandInput;
     constructor(input: CreateFlowLogsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFlowLogsCommandInput, CreateFlowLogsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,39 +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 { CreateFpgaImageRequest, CreateFpgaImageResult } from "../models/models_0";
+import { CreateFpgaImageRequest, CreateFpgaImageResult } from "../models/models_1";
 export interface CreateFpgaImageCommandInput extends CreateFpgaImageRequest {
 }
 export interface CreateFpgaImageCommandOutput extends CreateFpgaImageResult, __MetadataBearer {
 }
-/**
- * <p>Creates an Amazon FPGA Image (AFI) from the specified design checkpoint (DCP).</p>
- *          <p>The create operation is asynchronous. To verify that the AFI is ready for use,
- *          check the output logs.</p>
- *          <p>An AFI contains the FPGA bitstream that is ready to download to an FPGA.
- *          You can securely deploy an AFI on multiple FPGA-accelerated instances.
- *          For more information, see the <a href="https://github.com/aws/aws-fpga/">AWS FPGA Hardware Development Kit</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateFpgaImageCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateFpgaImageCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateFpgaImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateFpgaImageCommandInput} for command's `input` shape.
- * @see {@link CreateFpgaImageCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateFpgaImageCommand extends $Command<CreateFpgaImageCommandInput, CreateFpgaImageCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateFpgaImageCommandInput;
     constructor(input: CreateFpgaImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFpgaImageCommandInput, CreateFpgaImageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,44 +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 { CreateImageRequest, CreateImageResult } from "../models/models_0";
+import { CreateImageRequest, CreateImageResult } from "../models/models_1";
 export interface CreateImageCommandInput extends CreateImageRequest {
 }
 export interface CreateImageCommandOutput extends CreateImageResult, __MetadataBearer {
 }
-/**
- * <p>Creates an Amazon EBS-backed AMI from an Amazon EBS-backed instance
- *      	that is either running or stopped.</p>
- *
- *
- *
- *
- *    	     <p>If you customized your instance with instance store volumes or Amazon EBS volumes in addition to the root device volume, the
- *      	new AMI contains block device mapping information for those volumes. When you launch an instance from this new AMI,
- *      	the instance automatically launches with those additional volumes.</p>
- *    	     <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html">Creating Amazon EBS-Backed Linux AMIs</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, CreateImageCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateImageCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateImageCommandInput} for command's `input` shape.
- * @see {@link CreateImageCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateImageCommand extends $Command<CreateImageCommandInput, CreateImageCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateImageCommandInput;
     constructor(input: CreateImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateImageCommandInput, CreateImageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,59 +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 { CreateInstanceEventWindowRequest } from "../models/models_0";
-import { CreateInstanceEventWindowResult } from "../models/models_1";
+import { CreateInstanceEventWindowRequest, CreateInstanceEventWindowResult } from "../models/models_1";
 export interface CreateInstanceEventWindowCommandInput extends CreateInstanceEventWindowRequest {
 }
 export interface CreateInstanceEventWindowCommandOutput extends CreateInstanceEventWindowResult, __MetadataBearer {
 }
-/**
- * <p>Creates an event window in which scheduled events for the associated Amazon EC2 instances can
- *          run.</p>
- *          <p>You can define either a set of time ranges or a cron expression when creating the event
- *          window, but not both. All event window times are in UTC.</p>
- *          <p>You can create up to 200 event windows per Amazon Web Services Region.</p>
- *          <p>When you create the event window, targets (instance IDs, Dedicated Host IDs, or tags)
- *          are not yet associated with it. To ensure that the event window can be used, you must
- *          associate one or more targets with it by using the <a>AssociateInstanceEventWindow</a> API.</p>
- *
- *          <important>
- *             <p>Event windows are applicable only for scheduled events that stop, reboot, or
- *             terminate instances.</p>
- *             <p>Event windows are <i>not</i> applicable for:</p>
- *             <ul>
- *                <li>
- *                   <p>Expedited scheduled events and network maintenance events. </p>
- *                </li>
- *                <li>
- *                            <p>Unscheduled maintenance such as AutoRecovery and unplanned reboots.</p>
- *                </li>
- *             </ul>
- *          </important>
- *
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define event windows for scheduled
- *             events</a> in the <i>Amazon EC2 User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateInstanceEventWindowCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateInstanceEventWindowCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateInstanceEventWindowCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateInstanceEventWindowCommandInput} for command's `input` shape.
- * @see {@link CreateInstanceEventWindowCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateInstanceEventWindowCommand extends $Command<CreateInstanceEventWindowCommandInput, CreateInstanceEventWindowCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateInstanceEventWindowCommandInput;
     constructor(input: CreateInstanceEventWindowCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInstanceEventWindowCommandInput, CreateInstanceEventWindowCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface CreateInstanceExportTaskCommandInput extends CreateInstanceExpo
 }
 export interface CreateInstanceExportTaskCommandOutput extends CreateInstanceExportTaskResult, __MetadataBearer {
 }
-/**
- * <p>Exports a running or stopped instance to an Amazon S3 bucket.</p>
- *          <p>For information about the supported operating systems, image formats, and known limitations
- *    for the types of instances you can export, see <a href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmexport.html">Exporting an instance as a VM Using VM Import/Export</a>
- *    in the <i>VM Import/Export User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateInstanceExportTaskCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateInstanceExportTaskCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateInstanceExportTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateInstanceExportTaskCommandInput} for command's `input` shape.
- * @see {@link CreateInstanceExportTaskCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateInstanceExportTaskCommand extends $Command<CreateInstanceExportTaskCommandInput, CreateInstanceExportTaskCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateInstanceExportTaskCommandInput;
     constructor(input: CreateInstanceExportTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInstanceExportTaskCommandInput, CreateInstanceExportTaskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CreateInternetGatewayCommandInput extends CreateInternetGateway
 }
 export interface CreateInternetGatewayCommandOutput extends CreateInternetGatewayResult, __MetadataBearer {
 }
-/**
- * <p>Creates an internet gateway for use with a VPC. After creating the internet gateway,
- * 			you attach it to a VPC using <a>AttachInternetGateway</a>.</p>
- *          <p>For more information about your VPC and internet gateway, see the <a href="https://docs.aws.amazon.com/vpc/latest/userguide/">Amazon Virtual Private Cloud User Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateInternetGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateInternetGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateInternetGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateInternetGatewayCommandInput} for command's `input` shape.
- * @see {@link CreateInternetGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateInternetGatewayCommand extends $Command<CreateInternetGatewayCommandInput, CreateInternetGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateInternetGatewayCommandInput;
     constructor(input: CreateInternetGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInternetGatewayCommandInput, CreateInternetGatewayCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface CreateKeyPairCommandInput extends CreateKeyPairRequest {
 }
 export interface CreateKeyPairCommandOutput extends KeyPair, __MetadataBearer {
 }
-/**
- * <p>Creates an ED25519 or 2048-bit RSA key pair with the specified name. Amazon EC2 stores the public
- *             key and displays the private key for you to save to a file. The private key is returned
- *             as an unencrypted PEM encoded PKCS#1 private key. If a key with the specified name
- *             already exists, Amazon EC2 returns an error.</p>
- * 		       <p>The key pair returned to you is available only in the Amazon Web Services Region in which you create it.
- *             If you prefer, you can create your own key pair using a third-party tool and upload it
- *             to any Region using <a>ImportKeyPair</a>.</p>
- *          <p>You can have up to 5,000 key pairs per Amazon Web Services Region.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Amazon EC2 key pairs</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, CreateKeyPairCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateKeyPairCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateKeyPairCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateKeyPairCommandInput} for command's `input` shape.
- * @see {@link CreateKeyPairCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateKeyPairCommand extends $Command<CreateKeyPairCommandInput, CreateKeyPairCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateKeyPairCommandInput;
     constructor(input: CreateKeyPairCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateKeyPairCommandInput, CreateKeyPairCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface CreateLaunchTemplateCommandInput extends CreateLaunchTemplateRe
 }
 export interface CreateLaunchTemplateCommandOutput extends CreateLaunchTemplateResult, __MetadataBearer {
 }
-/**
- * <p>Creates a launch template. A launch template contains the parameters to launch an
- *             instance. When you launch an instance using <a>RunInstances</a>, you can
- *             specify a launch template instead of providing the launch parameters in the request. For
- *             more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html">Launching an instance from a
- *                 launch template</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, CreateLaunchTemplateCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateLaunchTemplateCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateLaunchTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLaunchTemplateCommandInput} for command's `input` shape.
- * @see {@link CreateLaunchTemplateCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateLaunchTemplateCommand extends $Command<CreateLaunchTemplateCommandInput, CreateLaunchTemplateCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateLaunchTemplateCommandInput;
     constructor(input: CreateLaunchTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLaunchTemplateCommandInput, CreateLaunchTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface CreateLaunchTemplateVersionCommandInput extends CreateLaunchTem
 }
 export interface CreateLaunchTemplateVersionCommandOutput extends CreateLaunchTemplateVersionResult, __MetadataBearer {
 }
-/**
- * <p>Creates a new version for a launch template. You can specify an existing version of
- *             launch template from which to base the new version.</p>
- *         <p>Launch template versions are numbered in the order in which they are created. You
- *             cannot specify, change, or replace the numbering of launch template versions.</p>
- *         <p>For
- *             more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#manage-launch-template-versions">Managing launch template versions</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, CreateLaunchTemplateVersionCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateLaunchTemplateVersionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateLaunchTemplateVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLaunchTemplateVersionCommandInput} for command's `input` shape.
- * @see {@link CreateLaunchTemplateVersionCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateLaunchTemplateVersionCommand extends $Command<CreateLaunchTemplateVersionCommandInput, CreateLaunchTemplateVersionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateLaunchTemplateVersionCommandInput;
     constructor(input: CreateLaunchTemplateVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLaunchTemplateVersionCommandInput, CreateLaunchTemplateVersionCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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