@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -1,40 +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 { ModifyInstanceMetadataOptionsRequest, ModifyInstanceMetadataOptionsResult } from "../models/models_4";
+import { ModifyInstanceMetadataOptionsRequest, ModifyInstanceMetadataOptionsResult } from "../models/models_5";
 export interface ModifyInstanceMetadataOptionsCommandInput extends ModifyInstanceMetadataOptionsRequest {
 }
 export interface ModifyInstanceMetadataOptionsCommandOutput extends ModifyInstanceMetadataOptionsResult, __MetadataBearer {
 }
-/**
- * <p>Modify the instance metadata parameters on a running or stopped instance. When you
- *             modify the parameters on a stopped instance, they are applied when the instance is
- *             started. When you modify the parameters on a running instance, the API responds with a
- *             state of “pending”. After the parameter modifications are successfully applied to the
- *             instance, the state of the modifications changes from “pending” to “applied” in
- *             subsequent describe-instances API calls. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html">Instance metadata and user data</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, ModifyInstanceMetadataOptionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyInstanceMetadataOptionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyInstanceMetadataOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyInstanceMetadataOptionsCommandInput} for command's `input` shape.
- * @see {@link ModifyInstanceMetadataOptionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyInstanceMetadataOptionsCommand extends $Command<ModifyInstanceMetadataOptionsCommandInput, ModifyInstanceMetadataOptionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyInstanceMetadataOptionsCommandInput;
     constructor(input: ModifyInstanceMetadataOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyInstanceMetadataOptionsCommandInput, ModifyInstanceMetadataOptionsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ModifyInstancePlacementCommand.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 { ModifyInstancePlacementRequest, ModifyInstancePlacementResult } from "../models/models_4";
+import { ModifyInstancePlacementRequest, ModifyInstancePlacementResult } from "../models/models_5";
 export interface ModifyInstancePlacementCommandInput extends ModifyInstancePlacementRequest {
 }
 export interface ModifyInstancePlacementCommandOutput extends ModifyInstancePlacementResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the placement attributes for a specified instance. You can do the
- *             following:</p>
- *         <ul>
- *             <li>
- *                 <p>Modify the affinity between an instance and a <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-hosts-overview.html">Dedicated
- *                         Host</a>. When affinity is set to <code>host</code> and the instance is
- *                     not associated with a specific Dedicated Host, the next time the instance is
- *                     launched, it is automatically associated with the host on which it lands. If the
- *                     instance is restarted or rebooted, this relationship persists.</p>
- *             </li>
- *             <li>
- *                 <p>Change the Dedicated Host with which an instance is associated.</p>
- *             </li>
- *             <li>
- *                 <p>Change the instance tenancy of an instance.</p>
- *             </li>
- *             <li>
- *                 <p>Move an instance to or from a <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html">placement
- *                     group</a>.</p>
- *             </li>
- *          </ul>
- *         <p>At least one attribute for affinity, host ID, tenancy, or placement group name must
- *             be specified in the request. Affinity and tenancy can be modified in the same
- *             request.</p>
- *         <p>To modify the host ID, tenancy, placement group, or partition for an instance, the
- *             instance must be in the <code>stopped</code> state.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyInstancePlacementCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyInstancePlacementCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyInstancePlacementCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyInstancePlacementCommandInput} for command's `input` shape.
- * @see {@link ModifyInstancePlacementCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyInstancePlacementCommand extends $Command<ModifyInstancePlacementCommandInput, ModifyInstancePlacementCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyInstancePlacementCommandInput;
     constructor(input: ModifyInstancePlacementCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyInstancePlacementCommandInput, ModifyInstancePlacementCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,36 +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 { ModifyLaunchTemplateRequest, ModifyLaunchTemplateResult } from "../models/models_4";
+import { ModifyLaunchTemplateRequest, ModifyLaunchTemplateResult } from "../models/models_5";
 export interface ModifyLaunchTemplateCommandInput extends ModifyLaunchTemplateRequest {
 }
 export interface ModifyLaunchTemplateCommandOutput extends ModifyLaunchTemplateResult, __MetadataBearer {
 }
-/**
- * <p>Modifies a launch template. You can specify which version of the launch template to
- *             set as the default version. When launching an instance, the default version applies when
- *             a launch template version is not specified.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyLaunchTemplateCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyLaunchTemplateCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyLaunchTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyLaunchTemplateCommandInput} for command's `input` shape.
- * @see {@link ModifyLaunchTemplateCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyLaunchTemplateCommand extends $Command<ModifyLaunchTemplateCommandInput, ModifyLaunchTemplateCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyLaunchTemplateCommandInput;
     constructor(input: ModifyLaunchTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyLaunchTemplateCommandInput, ModifyLaunchTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,38 +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 { ModifyManagedPrefixListRequest, ModifyManagedPrefixListResult } from "../models/models_4";
+import { ModifyManagedPrefixListRequest, ModifyManagedPrefixListResult } from "../models/models_5";
 export interface ModifyManagedPrefixListCommandInput extends ModifyManagedPrefixListRequest {
 }
 export interface ModifyManagedPrefixListCommandOutput extends ModifyManagedPrefixListResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the specified managed prefix list.</p>
- *         <p>Adding or removing entries in a prefix list creates a new version of the prefix list.
- *             Changing the name of the prefix list does not affect the version.</p>
- *         <p>If you specify a current version number that does not match the true current version
- *             number, the request fails.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyManagedPrefixListCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyManagedPrefixListCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyManagedPrefixListCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyManagedPrefixListCommandInput} for command's `input` shape.
- * @see {@link ModifyManagedPrefixListCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyManagedPrefixListCommand extends $Command<ModifyManagedPrefixListCommandInput, ModifyManagedPrefixListCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyManagedPrefixListCommandInput;
     constructor(input: ModifyManagedPrefixListCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyManagedPrefixListCommandInput, ModifyManagedPrefixListCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,36 +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 { ModifyNetworkInterfaceAttributeRequest } from "../models/models_4";
+import { ModifyNetworkInterfaceAttributeRequest } from "../models/models_5";
 export interface ModifyNetworkInterfaceAttributeCommandInput extends ModifyNetworkInterfaceAttributeRequest {
 }
 export interface ModifyNetworkInterfaceAttributeCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Modifies the specified network interface attribute. You can specify only one
- *             attribute at a time. You can use this action to attach and detach security groups from
- *             an existing EC2 instance.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyNetworkInterfaceAttributeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyNetworkInterfaceAttributeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyNetworkInterfaceAttributeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyNetworkInterfaceAttributeCommandInput} for command's `input` shape.
- * @see {@link ModifyNetworkInterfaceAttributeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyNetworkInterfaceAttributeCommand extends $Command<ModifyNetworkInterfaceAttributeCommandInput, ModifyNetworkInterfaceAttributeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyNetworkInterfaceAttributeCommandInput;
     constructor(input: ModifyNetworkInterfaceAttributeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyNetworkInterfaceAttributeCommandInput, ModifyNetworkInterfaceAttributeCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ModifyReservedInstancesCommand.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 { ModifyReservedInstancesRequest, ModifyReservedInstancesResult } from "../models/models_4";
+import { ModifyReservedInstancesRequest, ModifyReservedInstancesResult } from "../models/models_5";
 export interface ModifyReservedInstancesCommandInput extends ModifyReservedInstancesRequest {
 }
 export interface ModifyReservedInstancesCommandOutput extends ModifyReservedInstancesResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the Availability Zone, instance count, instance type, or network platform
- *             (EC2-Classic or EC2-VPC) of your Reserved Instances. The Reserved Instances to be
- *             modified must be identical, except for Availability Zone, network platform, and instance
- *             type.</p>
- * 		       <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-modifying.html">Modifying Reserved
- * 				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, ModifyReservedInstancesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyReservedInstancesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyReservedInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyReservedInstancesCommandInput} for command's `input` shape.
- * @see {@link ModifyReservedInstancesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyReservedInstancesCommand extends $Command<ModifyReservedInstancesCommandInput, ModifyReservedInstancesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyReservedInstancesCommandInput;
     constructor(input: ModifyReservedInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyReservedInstancesCommandInput, ModifyReservedInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,34 +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 { ModifySecurityGroupRulesRequest, ModifySecurityGroupRulesResult } from "../models/models_4";
+import { ModifySecurityGroupRulesRequest, ModifySecurityGroupRulesResult } from "../models/models_5";
 export interface ModifySecurityGroupRulesCommandInput extends ModifySecurityGroupRulesRequest {
 }
 export interface ModifySecurityGroupRulesCommandOutput extends ModifySecurityGroupRulesResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the rules of a security group.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifySecurityGroupRulesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifySecurityGroupRulesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifySecurityGroupRulesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifySecurityGroupRulesCommandInput} for command's `input` shape.
- * @see {@link ModifySecurityGroupRulesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifySecurityGroupRulesCommand extends $Command<ModifySecurityGroupRulesCommandInput, ModifySecurityGroupRulesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifySecurityGroupRulesCommandInput;
     constructor(input: ModifySecurityGroupRulesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifySecurityGroupRulesCommandInput, ModifySecurityGroupRulesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,41 +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 { ModifySnapshotAttributeRequest } from "../models/models_4";
+import { ModifySnapshotAttributeRequest } from "../models/models_5";
 export interface ModifySnapshotAttributeCommandInput extends ModifySnapshotAttributeRequest {
 }
 export interface ModifySnapshotAttributeCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Adds or removes permission settings for the specified snapshot. You may add or remove
- *       specified Amazon Web Services account IDs from a snapshot's list of create volume permissions, but you cannot
- *       do both in a single operation. If you need to both add and remove account IDs for a snapshot,
- *       you must use multiple operations. You can make up to 500 modifications to a snapshot in a single operation.</p>
- *          <p>Encrypted snapshots and snapshots with Amazon Web Services Marketplace product codes cannot be made
- *       public. Snapshots encrypted with your default KMS key cannot be shared with other accounts.</p>
- *          <p>For more information about modifying snapshot permissions, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-modifying-snapshot-permissions.html">Share a snapshot</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, ModifySnapshotAttributeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifySnapshotAttributeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifySnapshotAttributeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifySnapshotAttributeCommandInput} for command's `input` shape.
- * @see {@link ModifySnapshotAttributeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifySnapshotAttributeCommand extends $Command<ModifySnapshotAttributeCommandInput, ModifySnapshotAttributeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifySnapshotAttributeCommandInput;
     constructor(input: ModifySnapshotAttributeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifySnapshotAttributeCommandInput, ModifySnapshotAttributeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,58 +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 { ModifySpotFleetRequestRequest, ModifySpotFleetRequestResponse } from "../models/models_4";
+import { ModifySpotFleetRequestRequest, ModifySpotFleetRequestResponse } from "../models/models_5";
 export interface ModifySpotFleetRequestCommandInput extends ModifySpotFleetRequestRequest {
 }
 export interface ModifySpotFleetRequestCommandOutput extends ModifySpotFleetRequestResponse, __MetadataBearer {
 }
-/**
- * <p>Modifies the specified Spot Fleet request.</p>
- *         <p>You can only modify a Spot Fleet request of type <code>maintain</code>.</p>
- *         <p>While the Spot Fleet request is being modified, it is in the <code>modifying</code>
- *             state.</p>
- *         <p>To scale up your Spot Fleet, increase its target capacity. The Spot Fleet launches the
- *             additional Spot Instances according to the allocation strategy for the Spot Fleet
- *             request. If the allocation strategy is <code>lowestPrice</code>, the Spot Fleet launches
- *             instances using the Spot Instance pool with the lowest price. If the allocation strategy
- *             is <code>diversified</code>, the Spot Fleet distributes the instances across the Spot
- *             Instance pools. If the allocation strategy is <code>capacityOptimized</code>, Spot Fleet
- *             launches instances from Spot Instance pools with optimal capacity for the number of instances
- *             that are launching.</p>
- *         <p>To scale down your Spot Fleet, decrease its target capacity. First, the Spot Fleet
- *             cancels any open requests that exceed the new target capacity. You can request that the
- *             Spot Fleet terminate Spot Instances until the size of the fleet no longer exceeds the
- *             new target capacity. If the allocation strategy is <code>lowestPrice</code>, the Spot
- *             Fleet terminates the instances with the highest price per unit. If the allocation
- *             strategy is <code>capacityOptimized</code>, the Spot Fleet terminates the instances in
- *             the Spot Instance pools that have the least available Spot Instance capacity. If the allocation
- *             strategy is <code>diversified</code>, the Spot Fleet terminates instances across the
- *             Spot Instance pools. Alternatively, you can request that the Spot Fleet keep the fleet
- *             at its current size, but not replace any Spot Instances that are interrupted or that you
- *             terminate manually.</p>
- *         <p>If you are finished with your Spot Fleet for now, but will use it again later, you can
- *             set the target capacity to 0.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifySpotFleetRequestCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifySpotFleetRequestCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifySpotFleetRequestCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifySpotFleetRequestCommandInput} for command's `input` shape.
- * @see {@link ModifySpotFleetRequestCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifySpotFleetRequestCommand extends $Command<ModifySpotFleetRequestCommandInput, ModifySpotFleetRequestCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifySpotFleetRequestCommandInput;
     constructor(input: ModifySpotFleetRequestCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifySpotFleetRequestCommandInput, ModifySpotFleetRequestCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,34 +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 { ModifySubnetAttributeRequest } from "../models/models_4";
+import { ModifySubnetAttributeRequest } from "../models/models_5";
 export interface ModifySubnetAttributeCommandInput extends ModifySubnetAttributeRequest {
 }
 export interface ModifySubnetAttributeCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Modifies a subnet attribute. You can only modify one attribute at a time.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifySubnetAttributeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifySubnetAttributeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifySubnetAttributeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifySubnetAttributeCommandInput} for command's `input` shape.
- * @see {@link ModifySubnetAttributeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifySubnetAttributeCommand extends $Command<ModifySubnetAttributeCommandInput, ModifySubnetAttributeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifySubnetAttributeCommandInput;
     constructor(input: ModifySubnetAttributeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifySubnetAttributeCommandInput, ModifySubnetAttributeCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ModifyTrafficMirrorFilterNetworkServicesCommand.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 { ModifyTrafficMirrorFilterNetworkServicesRequest, ModifyTrafficMirrorFilterNetworkServicesResult } from "../models/models_4";
+import { ModifyTrafficMirrorFilterNetworkServicesRequest, ModifyTrafficMirrorFilterNetworkServicesResult } from "../models/models_5";
 export interface ModifyTrafficMirrorFilterNetworkServicesCommandInput extends ModifyTrafficMirrorFilterNetworkServicesRequest {
 }
 export interface ModifyTrafficMirrorFilterNetworkServicesCommandOutput extends ModifyTrafficMirrorFilterNetworkServicesResult, __MetadataBearer {
 }
-/**
- * <p>Allows or restricts mirroring network services.</p>
- *          <p> By default, Amazon DNS network services are not eligible for Traffic Mirror. Use <code>AddNetworkServices</code> to add network services to a Traffic Mirror filter. When a network service is added to the Traffic Mirror filter, all traffic related to that network service will be mirrored.
- *          When you no longer want to mirror network services, use <code>RemoveNetworkServices</code> to remove the network services from the Traffic Mirror filter.
- *       </p>
- *          <p>For information about filter rule properties, see
- *          <a href="https://docs.aws.amazon.com/vpc/latest/mirroring/traffic-mirroring-considerations.html">Network Services</a> in the <i>Traffic Mirroring User Guide </i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyTrafficMirrorFilterNetworkServicesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyTrafficMirrorFilterNetworkServicesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyTrafficMirrorFilterNetworkServicesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyTrafficMirrorFilterNetworkServicesCommandInput} for command's `input` shape.
- * @see {@link ModifyTrafficMirrorFilterNetworkServicesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyTrafficMirrorFilterNetworkServicesCommand extends $Command<ModifyTrafficMirrorFilterNetworkServicesCommandInput, ModifyTrafficMirrorFilterNetworkServicesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyTrafficMirrorFilterNetworkServicesCommandInput;
     constructor(input: ModifyTrafficMirrorFilterNetworkServicesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyTrafficMirrorFilterNetworkServicesCommandInput, ModifyTrafficMirrorFilterNetworkServicesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,37 +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 { ModifyTrafficMirrorFilterRuleRequest, ModifyTrafficMirrorFilterRuleResult } from "../models/models_4";
+import { ModifyTrafficMirrorFilterRuleRequest, ModifyTrafficMirrorFilterRuleResult } from "../models/models_5";
 export interface ModifyTrafficMirrorFilterRuleCommandInput extends ModifyTrafficMirrorFilterRuleRequest {
 }
 export interface ModifyTrafficMirrorFilterRuleCommandOutput extends ModifyTrafficMirrorFilterRuleResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the specified Traffic Mirror rule.</p>
- *          <p>
- *             <code>DestinationCidrBlock</code> and <code>SourceCidrBlock</code> must both be an IPv4
- *          range or an IPv6 range.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyTrafficMirrorFilterRuleCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyTrafficMirrorFilterRuleCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyTrafficMirrorFilterRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyTrafficMirrorFilterRuleCommandInput} for command's `input` shape.
- * @see {@link ModifyTrafficMirrorFilterRuleCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyTrafficMirrorFilterRuleCommand extends $Command<ModifyTrafficMirrorFilterRuleCommandInput, ModifyTrafficMirrorFilterRuleCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyTrafficMirrorFilterRuleCommandInput;
     constructor(input: ModifyTrafficMirrorFilterRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyTrafficMirrorFilterRuleCommandInput, ModifyTrafficMirrorFilterRuleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,35 +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 { ModifyTrafficMirrorSessionRequest } from "../models/models_4";
-import { ModifyTrafficMirrorSessionResult } from "../models/models_5";
+import { ModifyTrafficMirrorSessionRequest, ModifyTrafficMirrorSessionResult } from "../models/models_5";
 export interface ModifyTrafficMirrorSessionCommandInput extends ModifyTrafficMirrorSessionRequest {
 }
 export interface ModifyTrafficMirrorSessionCommandOutput extends ModifyTrafficMirrorSessionResult, __MetadataBearer {
 }
-/**
- * <p>Modifies a Traffic Mirror session.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyTrafficMirrorSessionCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyTrafficMirrorSessionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyTrafficMirrorSessionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyTrafficMirrorSessionCommandInput} for command's `input` shape.
- * @see {@link ModifyTrafficMirrorSessionCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyTrafficMirrorSessionCommand extends $Command<ModifyTrafficMirrorSessionCommandInput, ModifyTrafficMirrorSessionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyTrafficMirrorSessionCommandInput;
     constructor(input: ModifyTrafficMirrorSessionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyTrafficMirrorSessionCommandInput, ModifyTrafficMirrorSessionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ModifyTransitGatewayCommandInput extends ModifyTransitGatewayRe
 }
 export interface ModifyTransitGatewayCommandOutput extends ModifyTransitGatewayResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the specified transit gateway. When you modify a transit gateway, the modified options are applied to new transit gateway attachments only. Your existing transit gateway attachments are not modified.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyTransitGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyTransitGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyTransitGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyTransitGatewayCommandInput} for command's `input` shape.
- * @see {@link ModifyTransitGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyTransitGatewayCommand extends $Command<ModifyTransitGatewayCommandInput, ModifyTransitGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyTransitGatewayCommandInput;
     constructor(input: ModifyTransitGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyTransitGatewayCommandInput, ModifyTransitGatewayCommandOutput>;
     private serialize;
     private deserialize;