@aws-sdk/client-ec2 3.309.0 → 3.310.1

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

@@ -1,41 +1,75 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-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 {
-  AllocateIpamPoolCidrRequest,
-  AllocateIpamPoolCidrResult,
-} from "../models/models_0";
-export interface AllocateIpamPoolCidrCommandInput
-  extends AllocateIpamPoolCidrRequest {}
-export interface AllocateIpamPoolCidrCommandOutput
-  extends AllocateIpamPoolCidrResult,
-    __MetadataBearer {}
-export declare class AllocateIpamPoolCidrCommand extends $Command<
-  AllocateIpamPoolCidrCommandInput,
-  AllocateIpamPoolCidrCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: AllocateIpamPoolCidrCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: AllocateIpamPoolCidrCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
-    AllocateIpamPoolCidrCommandInput,
-    AllocateIpamPoolCidrCommandOutput
-  >;
-  private serialize;
-  private deserialize;
-}
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+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 { AllocateIpamPoolCidrRequest, AllocateIpamPoolCidrResult } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link AllocateIpamPoolCidrCommand}.
+ */
+export interface AllocateIpamPoolCidrCommandInput extends AllocateIpamPoolCidrRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AllocateIpamPoolCidrCommand}.
+ */
+export interface AllocateIpamPoolCidrCommandOutput extends AllocateIpamPoolCidrResult, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Allocate a CIDR from an IPAM pool. In IPAM, an allocation is a CIDR assignment from an IPAM pool to another IPAM pool or to a resource. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/allocate-cidrs-ipam.html">Allocate CIDRs</a> in the <i>Amazon VPC IPAM User Guide</i>.</p>
+ *          <note>
+ *             <p>This action creates an allocation with strong consistency. The returned CIDR will not overlap with any other allocations from the same pool.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, AllocateIpamPoolCidrCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, AllocateIpamPoolCidrCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // AllocateIpamPoolCidrRequest
+ *   DryRun: true || false,
+ *   IpamPoolId: "STRING_VALUE", // required
+ *   Cidr: "STRING_VALUE",
+ *   NetmaskLength: Number("int"),
+ *   ClientToken: "STRING_VALUE",
+ *   Description: "STRING_VALUE",
+ *   PreviewNextCidr: true || false,
+ *   DisallowedCidrs: [ // IpamPoolAllocationDisallowedCidrs
+ *     "STRING_VALUE",
+ *   ],
+ * };
+ * const command = new AllocateIpamPoolCidrCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param AllocateIpamPoolCidrCommandInput - {@link AllocateIpamPoolCidrCommandInput}
+ * @returns {@link AllocateIpamPoolCidrCommandOutput}
+ * @see {@link AllocateIpamPoolCidrCommandInput} for command's `input` shape.
+ * @see {@link AllocateIpamPoolCidrCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ */
+export declare class AllocateIpamPoolCidrCommand extends $Command<AllocateIpamPoolCidrCommandInput, AllocateIpamPoolCidrCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: AllocateIpamPoolCidrCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AllocateIpamPoolCidrCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocateIpamPoolCidrCommandInput, AllocateIpamPoolCidrCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -1,41 +1,69 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-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 {
-  ApplySecurityGroupsToClientVpnTargetNetworkRequest,
-  ApplySecurityGroupsToClientVpnTargetNetworkResult,
-} from "../models/models_0";
-export interface ApplySecurityGroupsToClientVpnTargetNetworkCommandInput
-  extends ApplySecurityGroupsToClientVpnTargetNetworkRequest {}
-export interface ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput
-  extends ApplySecurityGroupsToClientVpnTargetNetworkResult,
-    __MetadataBearer {}
-export declare class ApplySecurityGroupsToClientVpnTargetNetworkCommand extends $Command<
-  ApplySecurityGroupsToClientVpnTargetNetworkCommandInput,
-  ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: ApplySecurityGroupsToClientVpnTargetNetworkCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ApplySecurityGroupsToClientVpnTargetNetworkCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
-    ApplySecurityGroupsToClientVpnTargetNetworkCommandInput,
-    ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput
-  >;
-  private serialize;
-  private deserialize;
-}
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+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 { ApplySecurityGroupsToClientVpnTargetNetworkRequest, ApplySecurityGroupsToClientVpnTargetNetworkResult } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link ApplySecurityGroupsToClientVpnTargetNetworkCommand}.
+ */
+export interface ApplySecurityGroupsToClientVpnTargetNetworkCommandInput extends ApplySecurityGroupsToClientVpnTargetNetworkRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link ApplySecurityGroupsToClientVpnTargetNetworkCommand}.
+ */
+export interface ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput extends ApplySecurityGroupsToClientVpnTargetNetworkResult, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Applies a security group to the association between the target network and the Client VPN endpoint. This action replaces the existing
+ * 			security groups with the specified security groups.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, ApplySecurityGroupsToClientVpnTargetNetworkCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, ApplySecurityGroupsToClientVpnTargetNetworkCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // ApplySecurityGroupsToClientVpnTargetNetworkRequest
+ *   ClientVpnEndpointId: "STRING_VALUE", // required
+ *   VpcId: "STRING_VALUE", // required
+ *   SecurityGroupIds: [ // ClientVpnSecurityGroupIdSet // required
+ *     "STRING_VALUE",
+ *   ],
+ *   DryRun: true || false,
+ * };
+ * const command = new ApplySecurityGroupsToClientVpnTargetNetworkCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param ApplySecurityGroupsToClientVpnTargetNetworkCommandInput - {@link ApplySecurityGroupsToClientVpnTargetNetworkCommandInput}
+ * @returns {@link ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput}
+ * @see {@link ApplySecurityGroupsToClientVpnTargetNetworkCommandInput} for command's `input` shape.
+ * @see {@link ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ */
+export declare class ApplySecurityGroupsToClientVpnTargetNetworkCommand extends $Command<ApplySecurityGroupsToClientVpnTargetNetworkCommandInput, ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: ApplySecurityGroupsToClientVpnTargetNetworkCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: ApplySecurityGroupsToClientVpnTargetNetworkCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ApplySecurityGroupsToClientVpnTargetNetworkCommandInput, ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -1,38 +1,81 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-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 {
-  AssignIpv6AddressesRequest,
-  AssignIpv6AddressesResult,
-} from "../models/models_0";
-export interface AssignIpv6AddressesCommandInput
-  extends AssignIpv6AddressesRequest {}
-export interface AssignIpv6AddressesCommandOutput
-  extends AssignIpv6AddressesResult,
-    __MetadataBearer {}
-export declare class AssignIpv6AddressesCommand extends $Command<
-  AssignIpv6AddressesCommandInput,
-  AssignIpv6AddressesCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: AssignIpv6AddressesCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: AssignIpv6AddressesCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<AssignIpv6AddressesCommandInput, AssignIpv6AddressesCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+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 { AssignIpv6AddressesRequest, AssignIpv6AddressesResult } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link AssignIpv6AddressesCommand}.
+ */
+export interface AssignIpv6AddressesCommandInput extends AssignIpv6AddressesRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AssignIpv6AddressesCommand}.
+ */
+export interface AssignIpv6AddressesCommandOutput extends AssignIpv6AddressesResult, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Assigns one or more IPv6 addresses to the specified network interface. You can
+ *             specify one or more specific IPv6 addresses, or you can specify the number of IPv6
+ *             addresses to be automatically assigned from within the subnet's IPv6 CIDR block range.
+ *             You can assign as many IPv6 addresses to a network interface as you can assign private
+ *             IPv4 addresses, and the limit varies per instance type. For information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html#AvailableIpPerENI">IP Addresses Per Network Interface Per Instance Type</a>
+ *             in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
+ *          <p>You must specify either the IPv6 addresses or the IPv6 address count in the request. </p>
+ *          <p>You can optionally use Prefix Delegation on the network interface. You must specify
+ *             either the IPV6 Prefix Delegation prefixes, or the IPv6 Prefix Delegation count. For
+ *             information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-prefix-eni.html">
+ *                 Assigning prefixes to Amazon EC2 network interfaces</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, AssignIpv6AddressesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, AssignIpv6AddressesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // AssignIpv6AddressesRequest
+ *   Ipv6AddressCount: Number("int"),
+ *   Ipv6Addresses: [ // Ipv6AddressList
+ *     "STRING_VALUE",
+ *   ],
+ *   Ipv6PrefixCount: Number("int"),
+ *   Ipv6Prefixes: [ // IpPrefixList
+ *     "STRING_VALUE",
+ *   ],
+ *   NetworkInterfaceId: "STRING_VALUE", // required
+ * };
+ * const command = new AssignIpv6AddressesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param AssignIpv6AddressesCommandInput - {@link AssignIpv6AddressesCommandInput}
+ * @returns {@link AssignIpv6AddressesCommandOutput}
+ * @see {@link AssignIpv6AddressesCommandInput} for command's `input` shape.
+ * @see {@link AssignIpv6AddressesCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ */
+export declare class AssignIpv6AddressesCommand extends $Command<AssignIpv6AddressesCommandInput, AssignIpv6AddressesCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: AssignIpv6AddressesCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AssignIpv6AddressesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssignIpv6AddressesCommandInput, AssignIpv6AddressesCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -1,41 +1,113 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-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 {
-  AssignPrivateIpAddressesRequest,
-  AssignPrivateIpAddressesResult,
-} from "../models/models_0";
-export interface AssignPrivateIpAddressesCommandInput
-  extends AssignPrivateIpAddressesRequest {}
-export interface AssignPrivateIpAddressesCommandOutput
-  extends AssignPrivateIpAddressesResult,
-    __MetadataBearer {}
-export declare class AssignPrivateIpAddressesCommand extends $Command<
-  AssignPrivateIpAddressesCommandInput,
-  AssignPrivateIpAddressesCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: AssignPrivateIpAddressesCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: AssignPrivateIpAddressesCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
-    AssignPrivateIpAddressesCommandInput,
-    AssignPrivateIpAddressesCommandOutput
-  >;
-  private serialize;
-  private deserialize;
-}
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+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 { AssignPrivateIpAddressesRequest, AssignPrivateIpAddressesResult } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link AssignPrivateIpAddressesCommand}.
+ */
+export interface AssignPrivateIpAddressesCommandInput extends AssignPrivateIpAddressesRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AssignPrivateIpAddressesCommand}.
+ */
+export interface AssignPrivateIpAddressesCommandOutput extends AssignPrivateIpAddressesResult, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Assigns one or more secondary private IP addresses to the specified network interface.</p>
+ *          <p>You can specify one or more specific secondary IP addresses, or you can specify the number
+ *             of secondary IP addresses to be automatically assigned within the subnet's CIDR block range.
+ *             The number of secondary IP addresses that you can assign to an instance varies by instance type.
+ *             For information about instance types, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html">Instance Types</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>. For more information about
+ *             Elastic IP addresses, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html">Elastic IP Addresses</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
+ *          <p>When you move a secondary private IP address to another network interface, any Elastic IP address
+ *             that is associated with the IP address is also moved.</p>
+ *          <p>Remapping an IP address is an asynchronous operation. When you move an IP address from one network
+ *             interface to another, check <code>network/interfaces/macs/mac/local-ipv4s</code> in the instance
+ *             metadata to confirm that the remapping is complete.</p>
+ *          <p>You must specify either the IP addresses or the IP address count in the request.</p>
+ *          <p>You can optionally use Prefix Delegation on the network interface. You must specify
+ *             either the IPv4 Prefix Delegation prefixes, or the IPv4 Prefix Delegation count. For
+ *             information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-prefix-eni.html">
+ *                 Assigning prefixes to Amazon EC2 network interfaces</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, AssignPrivateIpAddressesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, AssignPrivateIpAddressesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // AssignPrivateIpAddressesRequest
+ *   AllowReassignment: true || false,
+ *   NetworkInterfaceId: "STRING_VALUE", // required
+ *   PrivateIpAddresses: [ // PrivateIpAddressStringList
+ *     "STRING_VALUE",
+ *   ],
+ *   SecondaryPrivateIpAddressCount: Number("int"),
+ *   Ipv4Prefixes: [ // IpPrefixList
+ *     "STRING_VALUE",
+ *   ],
+ *   Ipv4PrefixCount: Number("int"),
+ * };
+ * const command = new AssignPrivateIpAddressesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param AssignPrivateIpAddressesCommandInput - {@link AssignPrivateIpAddressesCommandInput}
+ * @returns {@link AssignPrivateIpAddressesCommandOutput}
+ * @see {@link AssignPrivateIpAddressesCommandInput} for command's `input` shape.
+ * @see {@link AssignPrivateIpAddressesCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ * @example To assign a specific secondary private IP address to an interface
+ * ```javascript
+ * // This example assigns the specified secondary private IP address to the specified network interface.
+ * const input = {
+ *   "NetworkInterfaceId": "eni-e5aa89a3",
+ *   "PrivateIpAddresses": [
+ *     "10.0.0.82"
+ *   ]
+ * };
+ * const command = new AssignPrivateIpAddressesCommand(input);
+ * await client.send(command);
+ * // example id: ec2-assign-private-ip-addresses-1
+ * ```
+ *
+ * @example To assign secondary private IP addresses that Amazon EC2 selects to an interface
+ * ```javascript
+ * // This example assigns two secondary private IP addresses to the specified network interface. Amazon EC2 automatically assigns these IP addresses from the available IP addresses in the CIDR block range of the subnet the network interface is associated with.
+ * const input = {
+ *   "NetworkInterfaceId": "eni-e5aa89a3",
+ *   "SecondaryPrivateIpAddressCount": 2
+ * };
+ * const command = new AssignPrivateIpAddressesCommand(input);
+ * await client.send(command);
+ * // example id: ec2-assign-private-ip-addresses-2
+ * ```
+ *
+ */
+export declare class AssignPrivateIpAddressesCommand extends $Command<AssignPrivateIpAddressesCommandInput, AssignPrivateIpAddressesCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: AssignPrivateIpAddressesCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AssignPrivateIpAddressesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssignPrivateIpAddressesCommandInput, AssignPrivateIpAddressesCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -1,41 +1,68 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-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 {
-  AssignPrivateNatGatewayAddressRequest,
-  AssignPrivateNatGatewayAddressResult,
-} from "../models/models_0";
-export interface AssignPrivateNatGatewayAddressCommandInput
-  extends AssignPrivateNatGatewayAddressRequest {}
-export interface AssignPrivateNatGatewayAddressCommandOutput
-  extends AssignPrivateNatGatewayAddressResult,
-    __MetadataBearer {}
-export declare class AssignPrivateNatGatewayAddressCommand extends $Command<
-  AssignPrivateNatGatewayAddressCommandInput,
-  AssignPrivateNatGatewayAddressCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: AssignPrivateNatGatewayAddressCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: AssignPrivateNatGatewayAddressCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
-    AssignPrivateNatGatewayAddressCommandInput,
-    AssignPrivateNatGatewayAddressCommandOutput
-  >;
-  private serialize;
-  private deserialize;
-}
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+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 { AssignPrivateNatGatewayAddressRequest, AssignPrivateNatGatewayAddressResult } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link AssignPrivateNatGatewayAddressCommand}.
+ */
+export interface AssignPrivateNatGatewayAddressCommandInput extends AssignPrivateNatGatewayAddressRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AssignPrivateNatGatewayAddressCommand}.
+ */
+export interface AssignPrivateNatGatewayAddressCommandOutput extends AssignPrivateNatGatewayAddressResult, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Assigns one or more private IPv4 addresses to a private NAT gateway. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-working-with">Work with NAT gateways</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, AssignPrivateNatGatewayAddressCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, AssignPrivateNatGatewayAddressCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // AssignPrivateNatGatewayAddressRequest
+ *   NatGatewayId: "STRING_VALUE", // required
+ *   PrivateIpAddresses: [ // IpList
+ *     "STRING_VALUE",
+ *   ],
+ *   PrivateIpAddressCount: Number("int"),
+ *   DryRun: true || false,
+ * };
+ * const command = new AssignPrivateNatGatewayAddressCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param AssignPrivateNatGatewayAddressCommandInput - {@link AssignPrivateNatGatewayAddressCommandInput}
+ * @returns {@link AssignPrivateNatGatewayAddressCommandOutput}
+ * @see {@link AssignPrivateNatGatewayAddressCommandInput} for command's `input` shape.
+ * @see {@link AssignPrivateNatGatewayAddressCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ */
+export declare class AssignPrivateNatGatewayAddressCommand extends $Command<AssignPrivateNatGatewayAddressCommandInput, AssignPrivateNatGatewayAddressCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: AssignPrivateNatGatewayAddressCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AssignPrivateNatGatewayAddressCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssignPrivateNatGatewayAddressCommandInput, AssignPrivateNatGatewayAddressCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}