@aws-sdk/client-ec2 3.43.0 → 3.47.0

package/dist-types/commands/ModifyImageAttributeCommand.d.ts

@@ -1,7 +1,7 @@
 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 { ModifyImageAttributeRequest } from "../models/models_4";
+import { ModifyImageAttributeRequest } from "../models/models_5";
 export interface ModifyImageAttributeCommandInput extends ModifyImageAttributeRequest {
 }
 export interface ModifyImageAttributeCommandOutput extends __MetadataBearer {

package/dist-types/commands/ModifyIpamCommand.d.ts

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

package/dist-types/commands/ModifyIpamPoolCommand.d.ts

@@ -0,0 +1,37 @@
+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 { ModifyIpamPoolRequest, ModifyIpamPoolResult } from "../models/models_5";
+export interface ModifyIpamPoolCommandInput extends ModifyIpamPoolRequest {
+}
+export interface ModifyIpamPoolCommandOutput extends ModifyIpamPoolResult, __MetadataBearer {
+}
+/**
+ * <p>Modify the configurations of an IPAM pool.</p>
+ *          <p>For more information, see <a href="/vpc/latest/ipam/mod-pool-ipam.html">Modify a pool</a> in the <i>Amazon VPC IPAM User Guide</i>.
+ *       </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, ModifyIpamPoolCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, ModifyIpamPoolCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const command = new ModifyIpamPoolCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ModifyIpamPoolCommandInput} for command's `input` shape.
+ * @see {@link ModifyIpamPoolCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ */
+export declare class ModifyIpamPoolCommand extends $Command<ModifyIpamPoolCommandInput, ModifyIpamPoolCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: ModifyIpamPoolCommandInput;
+    constructor(input: ModifyIpamPoolCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyIpamPoolCommandInput, ModifyIpamPoolCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ModifyIpamResourceCidrCommand.d.ts

@@ -0,0 +1,36 @@
+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 { ModifyIpamResourceCidrRequest, ModifyIpamResourceCidrResult } from "../models/models_5";
+export interface ModifyIpamResourceCidrCommandInput extends ModifyIpamResourceCidrRequest {
+}
+export interface ModifyIpamResourceCidrCommandOutput extends ModifyIpamResourceCidrResult, __MetadataBearer {
+}
+/**
+ * <p>Modify a resource CIDR. You can use this action to transfer resource CIDRs between scopes and ignore resource CIDRs that you do not want to manage. If set to false, the resource will not be tracked for overlap, it cannot be auto-imported into a pool, and it will be removed from any pool it has an allocation in.</p>
+ *          <p>For more information, see <a href="/vpc/latest/ipam/move-resource-ipam.html">Move resource CIDRs between scopes</a> and <a href="/vpc/latest/ipam/change-monitoring-state-ipam.html">Change the monitoring state of resource CIDRs</a> in the <i>Amazon VPC IPAM User Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, ModifyIpamResourceCidrCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, ModifyIpamResourceCidrCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const command = new ModifyIpamResourceCidrCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ModifyIpamResourceCidrCommandInput} for command's `input` shape.
+ * @see {@link ModifyIpamResourceCidrCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ */
+export declare class ModifyIpamResourceCidrCommand extends $Command<ModifyIpamResourceCidrCommandInput, ModifyIpamResourceCidrCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: ModifyIpamResourceCidrCommandInput;
+    constructor(input: ModifyIpamResourceCidrCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyIpamResourceCidrCommandInput, ModifyIpamResourceCidrCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ModifyIpamScopeCommand.d.ts

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

package/dist-types/commands/ModifySnapshotTierCommand.d.ts

@@ -0,0 +1,39 @@
+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 { ModifySnapshotTierRequest, ModifySnapshotTierResult } from "../models/models_5";
+export interface ModifySnapshotTierCommandInput extends ModifySnapshotTierRequest {
+}
+export interface ModifySnapshotTierCommandOutput extends ModifySnapshotTierResult, __MetadataBearer {
+}
+/**
+ * <p>Archives an Amazon EBS snapshot. When you archive a snapshot, it is converted to a full
+ *       snapshot that includes all of the blocks of data that were written to the volume at the
+ *       time the snapshot was created, and moved from the standard tier to the archive
+ *       tier. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/snapshot-archive.html">Archive Amazon EBS snapshots</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, ModifySnapshotTierCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, ModifySnapshotTierCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const command = new ModifySnapshotTierCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ModifySnapshotTierCommandInput} for command's `input` shape.
+ * @see {@link ModifySnapshotTierCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ */
+export declare class ModifySnapshotTierCommand extends $Command<ModifySnapshotTierCommandInput, ModifySnapshotTierCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: ModifySnapshotTierCommandInput;
+    constructor(input: ModifySnapshotTierCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifySnapshotTierCommandInput, ModifySnapshotTierCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -8,6 +8,36 @@ export interface ModifySubnetAttributeCommandOutput extends __MetadataBearer {
 }
 /**
  * <p>Modifies a subnet attribute. You can only modify one attribute at a time.</p>
+ *
+ * 	        <p>Use this action to modify subnets on Amazon Web Services Outposts.</p>
+ *         <ul>
+ *             <li>
+ *                 <p>To modify a subnet on an Outpost rack, set both
+ *                         <code>MapCustomerOwnedIpOnLaunch</code> and
+ *                         <code>CustomerOwnedIpv4Pool</code>. These two parameters act as a single
+ *                     attribute.</p>
+ *             </li>
+ *             <li>
+ *                 <p>To modify a subnet on an Outpost server, set either
+ *                         <code>EnableLniAtDeviceIndex</code> or
+ *                     <code>DisableLniAtDeviceIndex</code>.</p>
+ *             </li>
+ *          </ul>
+ *
+ * 	        <p>For more information about Amazon Web Services Outposts, see the following:</p>
+ *
+ * 	        <ul>
+ *             <li>
+ *                <p>
+ *                   <a href="https://docs.aws.amazon.com/outposts/latest/userguide/how-servers-work.html">Outpost servers</a>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <a href="https://docs.aws.amazon.com/outposts/latest/userguide/how-racks-work.html">Outpost racks</a>
+ *                </p>
+ *             </li>
+ *          </ul>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/ModifyVpcEndpointServicePayerResponsibilityCommand.d.ts

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

package/dist-types/commands/MoveByoipCidrToIpamCommand.d.ts

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

package/dist-types/commands/ProvisionIpamPoolCidrCommand.d.ts

@@ -0,0 +1,37 @@
+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 { ProvisionIpamPoolCidrRequest, ProvisionIpamPoolCidrResult } from "../models/models_5";
+export interface ProvisionIpamPoolCidrCommandInput extends ProvisionIpamPoolCidrRequest {
+}
+export interface ProvisionIpamPoolCidrCommandOutput extends ProvisionIpamPoolCidrResult, __MetadataBearer {
+}
+/**
+ * <p>Provision a CIDR to an IPAM pool. You can use thsi action to provision new CIDRs to a top-level pool or to transfer a CIDR from a top-level pool to a pool within it.</p>
+ *          <p>For more information, see <a href="/vpc/latest/ipam/prov-cidr-ipam.html">Provision CIDRs to pools</a> in the <i>Amazon VPC IPAM User Guide</i>.
+ *       </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, ProvisionIpamPoolCidrCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, ProvisionIpamPoolCidrCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const command = new ProvisionIpamPoolCidrCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ProvisionIpamPoolCidrCommandInput} for command's `input` shape.
+ * @see {@link ProvisionIpamPoolCidrCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ */
+export declare class ProvisionIpamPoolCidrCommand extends $Command<ProvisionIpamPoolCidrCommandInput, ProvisionIpamPoolCidrCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: ProvisionIpamPoolCidrCommandInput;
+    constructor(input: ProvisionIpamPoolCidrCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ProvisionIpamPoolCidrCommandInput, ProvisionIpamPoolCidrCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ProvisionPublicIpv4PoolCidrCommand.d.ts

@@ -0,0 +1,37 @@
+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 { ProvisionPublicIpv4PoolCidrRequest, ProvisionPublicIpv4PoolCidrResult } from "../models/models_5";
+export interface ProvisionPublicIpv4PoolCidrCommandInput extends ProvisionPublicIpv4PoolCidrRequest {
+}
+export interface ProvisionPublicIpv4PoolCidrCommandOutput extends ProvisionPublicIpv4PoolCidrResult, __MetadataBearer {
+}
+/**
+ * <p>Provision a CIDR to a public IPv4 pool.</p>
+ *          <p>For more information about IPAM, see <a href="/vpc/latest/ipam/what-is-it-ipam.html">What is IPAM?</a> in the <i>Amazon VPC IPAM User Guide</i>.
+ *       </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, ProvisionPublicIpv4PoolCidrCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, ProvisionPublicIpv4PoolCidrCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const command = new ProvisionPublicIpv4PoolCidrCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ProvisionPublicIpv4PoolCidrCommandInput} for command's `input` shape.
+ * @see {@link ProvisionPublicIpv4PoolCidrCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ */
+export declare class ProvisionPublicIpv4PoolCidrCommand extends $Command<ProvisionPublicIpv4PoolCidrCommandInput, ProvisionPublicIpv4PoolCidrCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: ProvisionPublicIpv4PoolCidrCommandInput;
+    constructor(input: ProvisionPublicIpv4PoolCidrCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ProvisionPublicIpv4PoolCidrCommandInput, ProvisionPublicIpv4PoolCidrCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ReleaseIpamPoolAllocationCommand.d.ts

@@ -0,0 +1,36 @@
+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 { ReleaseIpamPoolAllocationRequest, ReleaseIpamPoolAllocationResult } from "../models/models_5";
+export interface ReleaseIpamPoolAllocationCommandInput extends ReleaseIpamPoolAllocationRequest {
+}
+export interface ReleaseIpamPoolAllocationCommandOutput extends ReleaseIpamPoolAllocationResult, __MetadataBearer {
+}
+/**
+ * <p>Release an allocation within an IPAM pool. You can only use this action to release manual allocations. To remove an allocation for a resource without deleting the resource, set its monitored state to false using <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyIpamResourceCidr.html">ModifyIpamResourceCidr</a>. For more information, see <a href="/vpc/latest/ipam/release-pool-alloc-ipam.html">Release an allocation</a> in the <i>Amazon VPC IPAM User Guide</i>.
+ *       </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, ReleaseIpamPoolAllocationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, ReleaseIpamPoolAllocationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const command = new ReleaseIpamPoolAllocationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ReleaseIpamPoolAllocationCommandInput} for command's `input` shape.
+ * @see {@link ReleaseIpamPoolAllocationCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ */
+export declare class ReleaseIpamPoolAllocationCommand extends $Command<ReleaseIpamPoolAllocationCommandInput, ReleaseIpamPoolAllocationCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: ReleaseIpamPoolAllocationCommandInput;
+    constructor(input: ReleaseIpamPoolAllocationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ReleaseIpamPoolAllocationCommandInput, ReleaseIpamPoolAllocationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RestoreSnapshotFromRecycleBinCommand.d.ts

@@ -0,0 +1,36 @@
+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 { RestoreSnapshotFromRecycleBinRequest, RestoreSnapshotFromRecycleBinResult } from "../models/models_5";
+export interface RestoreSnapshotFromRecycleBinCommandInput extends RestoreSnapshotFromRecycleBinRequest {
+}
+export interface RestoreSnapshotFromRecycleBinCommandOutput extends RestoreSnapshotFromRecycleBinResult, __MetadataBearer {
+}
+/**
+ * <p>Restores a snapshot from the Recycle Bin. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/recycle-bin-working-with-snaps.html#recycle-bin-restore-snaps">Restore
+ *       snapshots from the Recycle Bin</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, RestoreSnapshotFromRecycleBinCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, RestoreSnapshotFromRecycleBinCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const command = new RestoreSnapshotFromRecycleBinCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RestoreSnapshotFromRecycleBinCommandInput} for command's `input` shape.
+ * @see {@link RestoreSnapshotFromRecycleBinCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ */
+export declare class RestoreSnapshotFromRecycleBinCommand extends $Command<RestoreSnapshotFromRecycleBinCommandInput, RestoreSnapshotFromRecycleBinCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: RestoreSnapshotFromRecycleBinCommandInput;
+    constructor(input: RestoreSnapshotFromRecycleBinCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RestoreSnapshotFromRecycleBinCommandInput, RestoreSnapshotFromRecycleBinCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RestoreSnapshotTierCommand.d.ts

@@ -0,0 +1,40 @@
+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 { RestoreSnapshotTierRequest, RestoreSnapshotTierResult } from "../models/models_5";
+export interface RestoreSnapshotTierCommandInput extends RestoreSnapshotTierRequest {
+}
+export interface RestoreSnapshotTierCommandOutput extends RestoreSnapshotTierResult, __MetadataBearer {
+}
+/**
+ * <p>Restores an archived Amazon EBS snapshot for use temporarily or permanently, or modifies the restore
+ *       period or restore type for a snapshot that was previously temporarily restored.</p>
+ *
+ *          <p>For more information see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-snapshot-archiving.html#restore-archived-snapshot">
+ *       Restore an archived snapshot</a> and <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-snapshot-archiving.html#modify-temp-restore-period">
+ *         modify the restore period or restore type for a temporarily restored 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, RestoreSnapshotTierCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, RestoreSnapshotTierCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const command = new RestoreSnapshotTierCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RestoreSnapshotTierCommandInput} for command's `input` shape.
+ * @see {@link RestoreSnapshotTierCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ */
+export declare class RestoreSnapshotTierCommand extends $Command<RestoreSnapshotTierCommandInput, RestoreSnapshotTierCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: RestoreSnapshotTierCommandInput;
+    constructor(input: RestoreSnapshotTierCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RestoreSnapshotTierCommandInput, RestoreSnapshotTierCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RunInstancesCommand.d.ts

@@ -2,7 +2,7 @@ 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 { Reservation } from "../models/models_3";
-import { RunInstancesRequest } from "../models/models_5";
+import { RunInstancesRequest } from "../models/models_6";
 export interface RunInstancesCommandInput extends RunInstancesRequest {
 }
 export interface RunInstancesCommandOutput extends Reservation, __MetadataBearer {

package/dist-types/commands/RunScheduledInstancesCommand.d.ts

@@ -1,7 +1,7 @@
 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 { RunScheduledInstancesRequest, RunScheduledInstancesResult } from "../models/models_5";
+import { RunScheduledInstancesRequest, RunScheduledInstancesResult } from "../models/models_6";
 export interface RunScheduledInstancesCommandInput extends RunScheduledInstancesRequest {
 }
 export interface RunScheduledInstancesCommandOutput extends RunScheduledInstancesResult, __MetadataBearer {

package/dist-types/commands/SearchLocalGatewayRoutesCommand.d.ts

@@ -1,7 +1,7 @@
 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 { SearchLocalGatewayRoutesRequest, SearchLocalGatewayRoutesResult } from "../models/models_5";
+import { SearchLocalGatewayRoutesRequest, SearchLocalGatewayRoutesResult } from "../models/models_6";
 export interface SearchLocalGatewayRoutesCommandInput extends SearchLocalGatewayRoutesRequest {
 }
 export interface SearchLocalGatewayRoutesCommandOutput extends SearchLocalGatewayRoutesResult, __MetadataBearer {

package/dist-types/commands/SearchTransitGatewayMulticastGroupsCommand.d.ts

@@ -1,7 +1,7 @@
 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 { SearchTransitGatewayMulticastGroupsRequest, SearchTransitGatewayMulticastGroupsResult } from "../models/models_5";
+import { SearchTransitGatewayMulticastGroupsRequest, SearchTransitGatewayMulticastGroupsResult } from "../models/models_6";
 export interface SearchTransitGatewayMulticastGroupsCommandInput extends SearchTransitGatewayMulticastGroupsRequest {
 }
 export interface SearchTransitGatewayMulticastGroupsCommandOutput extends SearchTransitGatewayMulticastGroupsResult, __MetadataBearer {

package/dist-types/commands/SearchTransitGatewayRoutesCommand.d.ts

@@ -1,7 +1,7 @@
 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 { SearchTransitGatewayRoutesRequest, SearchTransitGatewayRoutesResult } from "../models/models_5";
+import { SearchTransitGatewayRoutesRequest, SearchTransitGatewayRoutesResult } from "../models/models_6";
 export interface SearchTransitGatewayRoutesCommandInput extends SearchTransitGatewayRoutesRequest {
 }
 export interface SearchTransitGatewayRoutesCommandOutput extends SearchTransitGatewayRoutesResult, __MetadataBearer {

package/dist-types/commands/SendDiagnosticInterruptCommand.d.ts

@@ -1,7 +1,7 @@
 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 { SendDiagnosticInterruptRequest } from "../models/models_5";
+import { SendDiagnosticInterruptRequest } from "../models/models_6";
 export interface SendDiagnosticInterruptCommandInput extends SendDiagnosticInterruptRequest {
 }
 export interface SendDiagnosticInterruptCommandOutput extends __MetadataBearer {

package/dist-types/commands/StartInstancesCommand.d.ts

@@ -1,7 +1,7 @@
 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 { StartInstancesRequest, StartInstancesResult } from "../models/models_5";
+import { StartInstancesRequest, StartInstancesResult } from "../models/models_6";
 export interface StartInstancesCommandInput extends StartInstancesRequest {
 }
 export interface StartInstancesCommandOutput extends StartInstancesResult, __MetadataBearer {

package/dist-types/commands/StartNetworkInsightsAccessScopeAnalysisCommand.d.ts

@@ -0,0 +1,35 @@
+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 { StartNetworkInsightsAccessScopeAnalysisRequest, StartNetworkInsightsAccessScopeAnalysisResult } from "../models/models_6";
+export interface StartNetworkInsightsAccessScopeAnalysisCommandInput extends StartNetworkInsightsAccessScopeAnalysisRequest {
+}
+export interface StartNetworkInsightsAccessScopeAnalysisCommandOutput extends StartNetworkInsightsAccessScopeAnalysisResult, __MetadataBearer {
+}
+/**
+ * <p>Starts analyzing the specified Network Access Scope.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, StartNetworkInsightsAccessScopeAnalysisCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, StartNetworkInsightsAccessScopeAnalysisCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const command = new StartNetworkInsightsAccessScopeAnalysisCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartNetworkInsightsAccessScopeAnalysisCommandInput} for command's `input` shape.
+ * @see {@link StartNetworkInsightsAccessScopeAnalysisCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ */
+export declare class StartNetworkInsightsAccessScopeAnalysisCommand extends $Command<StartNetworkInsightsAccessScopeAnalysisCommandInput, StartNetworkInsightsAccessScopeAnalysisCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: StartNetworkInsightsAccessScopeAnalysisCommandInput;
+    constructor(input: StartNetworkInsightsAccessScopeAnalysisCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartNetworkInsightsAccessScopeAnalysisCommandInput, StartNetworkInsightsAccessScopeAnalysisCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/StartNetworkInsightsAnalysisCommand.d.ts

@@ -1,7 +1,7 @@
 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 { StartNetworkInsightsAnalysisRequest, StartNetworkInsightsAnalysisResult } from "../models/models_5";
+import { StartNetworkInsightsAnalysisRequest, StartNetworkInsightsAnalysisResult } from "../models/models_6";
 export interface StartNetworkInsightsAnalysisCommandInput extends StartNetworkInsightsAnalysisRequest {
 }
 export interface StartNetworkInsightsAnalysisCommandOutput extends StartNetworkInsightsAnalysisResult, __MetadataBearer {