@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,31 +6,11 @@ export interface GetCapacityReservationUsageCommandInput extends GetCapacityRese
 }
 export interface GetCapacityReservationUsageCommandOutput extends GetCapacityReservationUsageResult, __MetadataBearer {
 }
-/**
- * <p>Gets usage information about a Capacity Reservation. If the Capacity Reservation is shared, it shows usage information for the Capacity Reservation owner
- * 			and each Amazon Web Services account that is currently using the shared capacity. If the Capacity Reservation is not shared, it shows only
- * 			the Capacity Reservation owner's usage.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetCapacityReservationUsageCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetCapacityReservationUsageCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetCapacityReservationUsageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetCapacityReservationUsageCommandInput} for command's `input` shape.
- * @see {@link GetCapacityReservationUsageCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetCapacityReservationUsageCommand extends $Command<GetCapacityReservationUsageCommandInput, GetCapacityReservationUsageCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetCapacityReservationUsageCommandInput;
     constructor(input: GetCapacityReservationUsageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCapacityReservationUsageCommandInput, GetCapacityReservationUsageCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,41 +6,11 @@ export interface GetConsoleOutputCommandInput extends GetConsoleOutputRequest {
 }
 export interface GetConsoleOutputCommandOutput extends GetConsoleOutputResult, __MetadataBearer {
 }
-/**
- * <p>Gets the console output for the specified instance. For Linux instances, the instance
- *             console output displays the exact console output that would normally be displayed on a
- *             physical monitor attached to a computer. For Windows instances, the instance console
- *             output includes the last three system event log errors.</p>
- *         <p>By default, the console output returns buffered information that was posted shortly
- *             after an instance transition state (start, stop, reboot, or terminate). This information
- *             is available for at least one hour after the most recent post. Only the most recent 64
- *             KB of console output is available.</p>
- *         <p>You can optionally retrieve the latest serial console output at any time during the
- *             instance lifecycle. This option is supported on instance types that use the Nitro
- *             hypervisor.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-console.html#instance-console-console-output">Instance
- *                 console output</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, GetConsoleOutputCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetConsoleOutputCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetConsoleOutputCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetConsoleOutputCommandInput} for command's `input` shape.
- * @see {@link GetConsoleOutputCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetConsoleOutputCommand extends $Command<GetConsoleOutputCommandInput, GetConsoleOutputCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetConsoleOutputCommandInput;
     constructor(input: GetConsoleOutputCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConsoleOutputCommandInput, GetConsoleOutputCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetConsoleScreenshotCommandInput extends GetConsoleScreenshotRe
 }
 export interface GetConsoleScreenshotCommandOutput extends GetConsoleScreenshotResult, __MetadataBearer {
 }
-/**
- * <p>Retrieve a JPG-format screenshot of a running instance to help with
- *             troubleshooting.</p>
- *         <p>The returned content is Base64-encoded.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetConsoleScreenshotCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetConsoleScreenshotCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetConsoleScreenshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetConsoleScreenshotCommandInput} for command's `input` shape.
- * @see {@link GetConsoleScreenshotCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetConsoleScreenshotCommand extends $Command<GetConsoleScreenshotCommandInput, GetConsoleScreenshotCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetConsoleScreenshotCommandInput;
     constructor(input: GetConsoleScreenshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConsoleScreenshotCommandInput, GetConsoleScreenshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetDefaultCreditSpecificationCommandInput extends GetDefaultCre
 }
 export interface GetDefaultCreditSpecificationCommandOutput extends GetDefaultCreditSpecificationResult, __MetadataBearer {
 }
-/**
- * <p>Describes the default credit option for CPU usage of a burstable performance instance family.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html">Burstable
- *             performance instances</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, GetDefaultCreditSpecificationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetDefaultCreditSpecificationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetDefaultCreditSpecificationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDefaultCreditSpecificationCommandInput} for command's `input` shape.
- * @see {@link GetDefaultCreditSpecificationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDefaultCreditSpecificationCommand extends $Command<GetDefaultCreditSpecificationCommandInput, GetDefaultCreditSpecificationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetDefaultCreditSpecificationCommandInput;
     constructor(input: GetDefaultCreditSpecificationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDefaultCreditSpecificationCommandInput, GetDefaultCreditSpecificationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface GetEbsDefaultKmsKeyIdCommandInput extends GetEbsDefaultKmsKeyId
 }
 export interface GetEbsDefaultKmsKeyIdCommandOutput extends GetEbsDefaultKmsKeyIdResult, __MetadataBearer {
 }
-/**
- * <p>Describes the default KMS key for EBS encryption by default for your account in this Region.
- *   		You can change the default KMS key for encryption by default using <a>ModifyEbsDefaultKmsKeyId</a> or
- *       <a>ResetEbsDefaultKmsKeyId</a>.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html">Amazon EBS encryption</a>
- *       in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetEbsDefaultKmsKeyIdCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetEbsDefaultKmsKeyIdCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetEbsDefaultKmsKeyIdCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEbsDefaultKmsKeyIdCommandInput} for command's `input` shape.
- * @see {@link GetEbsDefaultKmsKeyIdCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetEbsDefaultKmsKeyIdCommand extends $Command<GetEbsDefaultKmsKeyIdCommandInput, GetEbsDefaultKmsKeyIdCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetEbsDefaultKmsKeyIdCommandInput;
     constructor(input: GetEbsDefaultKmsKeyIdCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEbsDefaultKmsKeyIdCommandInput, GetEbsDefaultKmsKeyIdCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface GetEbsEncryptionByDefaultCommandInput extends GetEbsEncryptionB
 }
 export interface GetEbsEncryptionByDefaultCommandOutput extends GetEbsEncryptionByDefaultResult, __MetadataBearer {
 }
-/**
- * <p>Describes whether EBS encryption by default is enabled for your account in the current
- *       Region.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html">Amazon EBS encryption</a>
- *       in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetEbsEncryptionByDefaultCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetEbsEncryptionByDefaultCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetEbsEncryptionByDefaultCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEbsEncryptionByDefaultCommandInput} for command's `input` shape.
- * @see {@link GetEbsEncryptionByDefaultCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetEbsEncryptionByDefaultCommand extends $Command<GetEbsEncryptionByDefaultCommandInput, GetEbsEncryptionByDefaultCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetEbsEncryptionByDefaultCommandInput;
     constructor(input: GetEbsEncryptionByDefaultCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEbsEncryptionByDefaultCommandInput, GetEbsEncryptionByDefaultCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,46 +6,11 @@ export interface GetFlowLogsIntegrationTemplateCommandInput extends GetFlowLogsI
 }
 export interface GetFlowLogsIntegrationTemplateCommandOutput extends GetFlowLogsIntegrationTemplateResult, __MetadataBearer {
 }
-/**
- * <p>Generates a CloudFormation template that streamlines and automates the integration of VPC flow logs
- *             with Amazon Athena. This make it easier for you to query and gain insights from VPC flow logs data.
- *             Based on the information that you provide, we configure resources in the template to do the following:</p>
- *         <ul>
- *             <li>
- *                 <p>Create a table in Athena that maps fields to a custom log format</p>
- *             </li>
- *             <li>
- *                 <p>Create a Lambda function that updates the table with new partitions on a daily, weekly, or
- *                     monthly basis</p>
- *             </li>
- *             <li>
- *                 <p>Create a table partitioned between two timestamps in the past</p>
- *             </li>
- *             <li>
- *                 <p>Create a set of named queries in Athena that you can use to get started quickly</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetFlowLogsIntegrationTemplateCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetFlowLogsIntegrationTemplateCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetFlowLogsIntegrationTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetFlowLogsIntegrationTemplateCommandInput} for command's `input` shape.
- * @see {@link GetFlowLogsIntegrationTemplateCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetFlowLogsIntegrationTemplateCommand extends $Command<GetFlowLogsIntegrationTemplateCommandInput, GetFlowLogsIntegrationTemplateCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetFlowLogsIntegrationTemplateCommandInput;
     constructor(input: GetFlowLogsIntegrationTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFlowLogsIntegrationTemplateCommandInput, GetFlowLogsIntegrationTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetGroupsForCapacityReservationCommandInput extends GetGroupsFo
 }
 export interface GetGroupsForCapacityReservationCommandOutput extends GetGroupsForCapacityReservationResult, __MetadataBearer {
 }
-/**
- * <p>Lists the resource groups to which a Capacity Reservation has been added.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetGroupsForCapacityReservationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetGroupsForCapacityReservationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetGroupsForCapacityReservationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetGroupsForCapacityReservationCommandInput} for command's `input` shape.
- * @see {@link GetGroupsForCapacityReservationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetGroupsForCapacityReservationCommand extends $Command<GetGroupsForCapacityReservationCommandInput, GetGroupsForCapacityReservationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetGroupsForCapacityReservationCommandInput;
     constructor(input: GetGroupsForCapacityReservationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGroupsForCapacityReservationCommandInput, GetGroupsForCapacityReservationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface GetHostReservationPurchasePreviewCommandInput extends GetHostRe
 }
 export interface GetHostReservationPurchasePreviewCommandOutput extends GetHostReservationPurchasePreviewResult, __MetadataBearer {
 }
-/**
- * <p>Preview a reservation purchase with configurations that match those of your
- *             Dedicated Host. You must have active Dedicated Hosts in your account before you purchase
- *             a reservation.</p>
- *         <p>This is a preview of the <a>PurchaseHostReservation</a> action and does
- *             not result in the offering being purchased.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetHostReservationPurchasePreviewCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetHostReservationPurchasePreviewCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetHostReservationPurchasePreviewCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetHostReservationPurchasePreviewCommandInput} for command's `input` shape.
- * @see {@link GetHostReservationPurchasePreviewCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetHostReservationPurchasePreviewCommand extends $Command<GetHostReservationPurchasePreviewCommandInput, GetHostReservationPurchasePreviewCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetHostReservationPurchasePreviewCommandInput;
     constructor(input: GetHostReservationPurchasePreviewCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetHostReservationPurchasePreviewCommandInput, GetHostReservationPurchasePreviewCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +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 { GetInstanceTypesFromInstanceRequirementsRequest, GetInstanceTypesFromInstanceRequirementsResult } from "../models/models_4";
+export interface GetInstanceTypesFromInstanceRequirementsCommandInput extends GetInstanceTypesFromInstanceRequirementsRequest {
+}
+export interface GetInstanceTypesFromInstanceRequirementsCommandOutput extends GetInstanceTypesFromInstanceRequirementsResult, __MetadataBearer {
+}
+
+export declare class GetInstanceTypesFromInstanceRequirementsCommand extends $Command<GetInstanceTypesFromInstanceRequirementsCommandInput, GetInstanceTypesFromInstanceRequirementsCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: GetInstanceTypesFromInstanceRequirementsCommandInput;
+    constructor(input: GetInstanceTypesFromInstanceRequirementsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetInstanceTypesFromInstanceRequirementsCommandInput, GetInstanceTypesFromInstanceRequirementsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -6,33 +6,11 @@ export interface GetLaunchTemplateDataCommandInput extends GetLaunchTemplateData
 }
 export interface GetLaunchTemplateDataCommandOutput extends GetLaunchTemplateDataResult, __MetadataBearer {
 }
-/**
- * <p>Retrieves the configuration data of the specified instance. You can use this data
- *             to create a launch template. </p>
- *         <p>This action calls on other describe actions to get instance information. Depending on your instance configuration, you may need to allow the following
- *             actions in your IAM policy: DescribeSpotInstanceRequests, DescribeInstanceCreditSpecifications, DescribeVolumes, DescribeInstanceAttribute, and DescribeElasticGpus. Or, you can allow
- *         <code>describe*</code> depending on your instance requirements.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetLaunchTemplateDataCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetLaunchTemplateDataCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetLaunchTemplateDataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetLaunchTemplateDataCommandInput} for command's `input` shape.
- * @see {@link GetLaunchTemplateDataCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetLaunchTemplateDataCommand extends $Command<GetLaunchTemplateDataCommandInput, GetLaunchTemplateDataCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetLaunchTemplateDataCommandInput;
     constructor(input: GetLaunchTemplateDataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLaunchTemplateDataCommandInput, GetLaunchTemplateDataCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetManagedPrefixListAssociationsCommandInput extends GetManaged
 }
 export interface GetManagedPrefixListAssociationsCommandOutput extends GetManagedPrefixListAssociationsResult, __MetadataBearer {
 }
-/**
- * <p>Gets information about the resources that are associated with the specified managed prefix list.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetManagedPrefixListAssociationsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetManagedPrefixListAssociationsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetManagedPrefixListAssociationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetManagedPrefixListAssociationsCommandInput} for command's `input` shape.
- * @see {@link GetManagedPrefixListAssociationsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetManagedPrefixListAssociationsCommand extends $Command<GetManagedPrefixListAssociationsCommandInput, GetManagedPrefixListAssociationsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetManagedPrefixListAssociationsCommandInput;
     constructor(input: GetManagedPrefixListAssociationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetManagedPrefixListAssociationsCommandInput, GetManagedPrefixListAssociationsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,41 +6,11 @@ export interface GetPasswordDataCommandInput extends GetPasswordDataRequest {
 }
 export interface GetPasswordDataCommandOutput extends GetPasswordDataResult, __MetadataBearer {
 }
-/**
- * <p>Retrieves the encrypted administrator password for a running Windows instance.</p>
- *         <p>The Windows password is generated at boot by the <code>EC2Config</code> service or
- *                 <code>EC2Launch</code> scripts (Windows Server 2016 and later). This usually only
- *             happens the first time an instance is launched. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/UsingConfig_WinAMI.html">EC2Config</a> and <a href="https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2launch.html">EC2Launch</a> in the
- *             <i>Amazon EC2 User Guide</i>.</p>
- *         <p>For the <code>EC2Config</code> service, the password is not generated for rebundled
- *             AMIs unless <code>Ec2SetPassword</code> is enabled before bundling.</p>
- *         <p>The password is encrypted using the key pair that you specified when you launched the
- *             instance. You must provide the corresponding key pair file.</p>
- *         <p>When you launch an instance, password generation and encryption may take a few
- *             minutes. If you try to retrieve the password before it's available, the output returns
- *             an empty string. We recommend that you wait up to 15 minutes after launching an instance
- *             before trying to retrieve the generated password.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetPasswordDataCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetPasswordDataCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetPasswordDataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetPasswordDataCommandInput} for command's `input` shape.
- * @see {@link GetPasswordDataCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetPasswordDataCommand extends $Command<GetPasswordDataCommandInput, GetPasswordDataCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetPasswordDataCommandInput;
     constructor(input: GetPasswordDataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetPasswordDataCommandInput, GetPasswordDataCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetReservedInstancesExchangeQuoteCommandInput extends GetReserv
 }
 export interface GetReservedInstancesExchangeQuoteCommandOutput extends GetReservedInstancesExchangeQuoteResult, __MetadataBearer {
 }
-/**
- * <p>Returns a quote and exchange information for exchanging one or more specified
- *             Convertible Reserved Instances for a new Convertible Reserved Instance. If the exchange
- *             cannot be performed, the reason is returned in the response. Use <a>AcceptReservedInstancesExchangeQuote</a> to perform the exchange.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetReservedInstancesExchangeQuoteCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetReservedInstancesExchangeQuoteCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetReservedInstancesExchangeQuoteCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetReservedInstancesExchangeQuoteCommandInput} for command's `input` shape.
- * @see {@link GetReservedInstancesExchangeQuoteCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetReservedInstancesExchangeQuoteCommand extends $Command<GetReservedInstancesExchangeQuoteCommandInput, GetReservedInstancesExchangeQuoteCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetReservedInstancesExchangeQuoteCommandInput;
     constructor(input: GetReservedInstancesExchangeQuoteCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetReservedInstancesExchangeQuoteCommandInput, GetReservedInstancesExchangeQuoteCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface GetSerialConsoleAccessStatusCommandInput extends GetSerialConso
 }
 export interface GetSerialConsoleAccessStatusCommandOutput extends GetSerialConsoleAccessStatusResult, __MetadataBearer {
 }
-/**
- * <p>Retrieves the access status of your account to the EC2 serial console of all instances. By
- * 			default, access to the EC2 serial console is disabled for your account. For more
- * 			information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configure-access-to-serial-console.html#serial-console-account-access">Manage account access to the EC2 serial console</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, GetSerialConsoleAccessStatusCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetSerialConsoleAccessStatusCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetSerialConsoleAccessStatusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSerialConsoleAccessStatusCommandInput} for command's `input` shape.
- * @see {@link GetSerialConsoleAccessStatusCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetSerialConsoleAccessStatusCommand extends $Command<GetSerialConsoleAccessStatusCommandInput, GetSerialConsoleAccessStatusCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetSerialConsoleAccessStatusCommandInput;
     constructor(input: GetSerialConsoleAccessStatusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSerialConsoleAccessStatusCommandInput, GetSerialConsoleAccessStatusCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +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 { GetSpotPlacementScoresRequest, GetSpotPlacementScoresResult } from "../models/models_4";
+export interface GetSpotPlacementScoresCommandInput extends GetSpotPlacementScoresRequest {
+}
+export interface GetSpotPlacementScoresCommandOutput extends GetSpotPlacementScoresResult, __MetadataBearer {
+}
+
+export declare class GetSpotPlacementScoresCommand extends $Command<GetSpotPlacementScoresCommandInput, GetSpotPlacementScoresCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: GetSpotPlacementScoresCommandInput;
+    constructor(input: GetSpotPlacementScoresCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSpotPlacementScoresCommandInput, GetSpotPlacementScoresCommandOutput>;
+    private serialize;
+    private deserialize;
+}