@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

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

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

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

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

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

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

@@ -6,31 +6,11 @@ export interface DescribeConversionTasksCommandInput extends DescribeConversionT
 }
 export interface DescribeConversionTasksCommandOutput extends DescribeConversionTasksResult, __MetadataBearer {
 }
-/**
- * <p>Describes the specified conversion tasks or all your conversion tasks. For more information, see the
- *    <a href="https://docs.aws.amazon.com/vm-import/latest/userguide/">VM Import/Export User Guide</a>.</p>
- *          <p>For information about the import manifest referenced by this API action, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/manifest.html">VM Import Manifest</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeConversionTasksCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeConversionTasksCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeConversionTasksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeConversionTasksCommandInput} for command's `input` shape.
- * @see {@link DescribeConversionTasksCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeConversionTasksCommand extends $Command<DescribeConversionTasksCommandInput, DescribeConversionTasksCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeConversionTasksCommandInput;
     constructor(input: DescribeConversionTasksCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeConversionTasksCommandInput, DescribeConversionTasksCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,31 +6,11 @@ export interface DescribeDhcpOptionsCommandInput extends DescribeDhcpOptionsRequ
 }
 export interface DescribeDhcpOptionsCommandOutput extends DescribeDhcpOptionsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more of your DHCP options sets.</p>
- * 		       <p>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, DescribeDhcpOptionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeDhcpOptionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeDhcpOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDhcpOptionsCommandInput} for command's `input` shape.
- * @see {@link DescribeDhcpOptionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDhcpOptionsCommand extends $Command<DescribeDhcpOptionsCommandInput, DescribeDhcpOptionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeDhcpOptionsCommandInput;
     constructor(input: DescribeDhcpOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDhcpOptionsCommandInput, DescribeDhcpOptionsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface DescribeElasticGpusCommandInput extends DescribeElasticGpusRequ
 }
 export interface DescribeElasticGpusCommandOutput extends DescribeElasticGpusResult, __MetadataBearer {
 }
-/**
- * <p>Describes the Elastic Graphics accelerator associated with your instances. For more information
- *             about Elastic Graphics, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/elastic-graphics.html">Amazon Elastic Graphics</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeElasticGpusCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeElasticGpusCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeElasticGpusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeElasticGpusCommandInput} for command's `input` shape.
- * @see {@link DescribeElasticGpusCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeElasticGpusCommand extends $Command<DescribeElasticGpusCommandInput, DescribeElasticGpusCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeElasticGpusCommandInput;
     constructor(input: DescribeElasticGpusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeElasticGpusCommandInput, DescribeElasticGpusCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,33 +6,11 @@ export interface DescribeFleetHistoryCommandInput extends DescribeFleetHistoryRe
 }
 export interface DescribeFleetHistoryCommandOutput extends DescribeFleetHistoryResult, __MetadataBearer {
 }
-/**
- * <p>Describes the events for the specified EC2 Fleet during the specified time.</p>
- *          <p>EC2 Fleet events are delayed by up to 30 seconds before they can be described. This ensures
- *          that you can query by the last evaluated time and not miss a recorded event. EC2 Fleet events
- *          are available for 48 hours.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet.html#monitor-ec2-fleet">Monitoring your 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, DescribeFleetHistoryCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeFleetHistoryCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeFleetHistoryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeFleetHistoryCommandInput} for command's `input` shape.
- * @see {@link DescribeFleetHistoryCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeFleetHistoryCommand extends $Command<DescribeFleetHistoryCommandInput, DescribeFleetHistoryCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeFleetHistoryCommandInput;
     constructor(input: DescribeFleetHistoryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFleetHistoryCommandInput, DescribeFleetHistoryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeFleetInstancesCommandInput extends DescribeFleetInstanc
 }
 export interface DescribeFleetInstancesCommandOutput extends DescribeFleetInstancesResult, __MetadataBearer {
 }
-/**
- * <p>Describes the running instances for the specified EC2 Fleet.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet.html#monitor-ec2-fleet">Monitoring your 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, DescribeFleetInstancesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeFleetInstancesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeFleetInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeFleetInstancesCommandInput} for command's `input` shape.
- * @see {@link DescribeFleetInstancesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeFleetInstancesCommand extends $Command<DescribeFleetInstancesCommandInput, DescribeFleetInstancesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeFleetInstancesCommandInput;
     constructor(input: DescribeFleetInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFleetInstancesCommandInput, DescribeFleetInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeFleetsCommandInput extends DescribeFleetsRequest {
 }
 export interface DescribeFleetsCommandOutput extends DescribeFleetsResult, __MetadataBearer {
 }
-/**
- * <p>Describes the specified EC2 Fleets or all of your EC2 Fleets.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet.html#monitor-ec2-fleet">Monitoring your 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, DescribeFleetsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeFleetsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeFleetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeFleetsCommandInput} for command's `input` shape.
- * @see {@link DescribeFleetsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeFleetsCommand extends $Command<DescribeFleetsCommandInput, DescribeFleetsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeFleetsCommandInput;
     constructor(input: DescribeFleetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFleetsCommandInput, DescribeFleetsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeFlowLogsCommandInput extends DescribeFlowLogsRequest {
 }
 export interface DescribeFlowLogsCommandOutput extends DescribeFlowLogsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more flow logs. To view the information in your flow logs (the log
- *             streams for the network interfaces), you must use the CloudWatch Logs console or the CloudWatch Logs
- *             API.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeFlowLogsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeFlowLogsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeFlowLogsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeFlowLogsCommandInput} for command's `input` shape.
- * @see {@link DescribeFlowLogsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeFlowLogsCommand extends $Command<DescribeFlowLogsCommandInput, DescribeFlowLogsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeFlowLogsCommandInput;
     constructor(input: DescribeFlowLogsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFlowLogsCommandInput, DescribeFlowLogsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,31 +6,11 @@ export interface DescribeFpgaImagesCommandInput extends DescribeFpgaImagesReques
 }
 export interface DescribeFpgaImagesCommandOutput extends DescribeFpgaImagesResult, __MetadataBearer {
 }
-/**
- * <p>Describes the Amazon FPGA Images (AFIs) available to you. These include public AFIs,
- * 			private AFIs that you own, and AFIs owned by other AWS accounts for which you have load
- * 			permissions.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeFpgaImagesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeFpgaImagesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeFpgaImagesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeFpgaImagesCommandInput} for command's `input` shape.
- * @see {@link DescribeFpgaImagesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeFpgaImagesCommand extends $Command<DescribeFpgaImagesCommandInput, DescribeFpgaImagesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeFpgaImagesCommandInput;
     constructor(input: DescribeFpgaImagesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFpgaImagesCommandInput, DescribeFpgaImagesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface DescribeHostReservationOfferingsCommandInput extends DescribeHo
 }
 export interface DescribeHostReservationOfferingsCommandOutput extends DescribeHostReservationOfferingsResult, __MetadataBearer {
 }
-/**
- * <p>Describes the Dedicated Host reservations that are available to purchase.</p>
- *         <p>The results describe all of the Dedicated Host reservation offerings, including
- * 			offerings that might not match the instance family and Region of your Dedicated Hosts.
- * 			When purchasing an offering, ensure that the instance family and Region of the offering
- * 			matches that of the Dedicated Hosts with which it is to be associated. For more
- * 			information about supported instance types, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-hosts-overview.html">Dedicated Hosts</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, DescribeHostReservationOfferingsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeHostReservationOfferingsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeHostReservationOfferingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeHostReservationOfferingsCommandInput} for command's `input` shape.
- * @see {@link DescribeHostReservationOfferingsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeHostReservationOfferingsCommand extends $Command<DescribeHostReservationOfferingsCommandInput, DescribeHostReservationOfferingsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeHostReservationOfferingsCommandInput;
     constructor(input: DescribeHostReservationOfferingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeHostReservationOfferingsCommandInput, DescribeHostReservationOfferingsCommandOutput>;
     private serialize;
     private deserialize;