@aws-sdk/client-ec2 3.310.0 → 3.310.1

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

@@ -1,41 +1,67 @@
-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 {
-  AcceptVpcEndpointConnectionsRequest,
-  AcceptVpcEndpointConnectionsResult,
-} from "../models/models_0";
-export interface AcceptVpcEndpointConnectionsCommandInput
-  extends AcceptVpcEndpointConnectionsRequest {}
-export interface AcceptVpcEndpointConnectionsCommandOutput
-  extends AcceptVpcEndpointConnectionsResult,
-    __MetadataBearer {}
-export declare class AcceptVpcEndpointConnectionsCommand extends $Command<
-  AcceptVpcEndpointConnectionsCommandInput,
-  AcceptVpcEndpointConnectionsCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: AcceptVpcEndpointConnectionsCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: AcceptVpcEndpointConnectionsCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
-    AcceptVpcEndpointConnectionsCommandInput,
-    AcceptVpcEndpointConnectionsCommandOutput
-  >;
-  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 { AcceptVpcEndpointConnectionsRequest, AcceptVpcEndpointConnectionsResult } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link AcceptVpcEndpointConnectionsCommand}.
+ */
+export interface AcceptVpcEndpointConnectionsCommandInput extends AcceptVpcEndpointConnectionsRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AcceptVpcEndpointConnectionsCommand}.
+ */
+export interface AcceptVpcEndpointConnectionsCommandOutput extends AcceptVpcEndpointConnectionsResult, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Accepts connection requests to your VPC endpoint service.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, AcceptVpcEndpointConnectionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, AcceptVpcEndpointConnectionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // AcceptVpcEndpointConnectionsRequest
+ *   DryRun: true || false,
+ *   ServiceId: "STRING_VALUE", // required
+ *   VpcEndpointIds: [ // VpcEndpointIdList // required
+ *     "STRING_VALUE",
+ *   ],
+ * };
+ * const command = new AcceptVpcEndpointConnectionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param AcceptVpcEndpointConnectionsCommandInput - {@link AcceptVpcEndpointConnectionsCommandInput}
+ * @returns {@link AcceptVpcEndpointConnectionsCommandOutput}
+ * @see {@link AcceptVpcEndpointConnectionsCommandInput} for command's `input` shape.
+ * @see {@link AcceptVpcEndpointConnectionsCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ */
+export declare class AcceptVpcEndpointConnectionsCommand extends $Command<AcceptVpcEndpointConnectionsCommandInput, AcceptVpcEndpointConnectionsCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: AcceptVpcEndpointConnectionsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AcceptVpcEndpointConnectionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AcceptVpcEndpointConnectionsCommandInput, AcceptVpcEndpointConnectionsCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/ts3.4/commands/AcceptVpcPeeringConnectionCommand.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 {
-  AcceptVpcPeeringConnectionRequest,
-  AcceptVpcPeeringConnectionResult,
-} from "../models/models_0";
-export interface AcceptVpcPeeringConnectionCommandInput
-  extends AcceptVpcPeeringConnectionRequest {}
-export interface AcceptVpcPeeringConnectionCommandOutput
-  extends AcceptVpcPeeringConnectionResult,
-    __MetadataBearer {}
-export declare class AcceptVpcPeeringConnectionCommand extends $Command<
-  AcceptVpcPeeringConnectionCommandInput,
-  AcceptVpcPeeringConnectionCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: AcceptVpcPeeringConnectionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: AcceptVpcPeeringConnectionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
-    AcceptVpcPeeringConnectionCommandInput,
-    AcceptVpcPeeringConnectionCommandOutput
-  >;
-  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 { AcceptVpcPeeringConnectionRequest, AcceptVpcPeeringConnectionResult } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link AcceptVpcPeeringConnectionCommand}.
+ */
+export interface AcceptVpcPeeringConnectionCommandInput extends AcceptVpcPeeringConnectionRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AcceptVpcPeeringConnectionCommand}.
+ */
+export interface AcceptVpcPeeringConnectionCommandOutput extends AcceptVpcPeeringConnectionResult, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Accept a VPC peering connection request. To accept a request, the VPC peering connection must
+ *       be in the <code>pending-acceptance</code> state, and you must be the owner of the peer VPC.
+ *       Use <a>DescribeVpcPeeringConnections</a> to view your outstanding VPC
+ *       peering connection requests.</p>
+ *          <p>For an inter-Region VPC peering connection request, you must accept the VPC peering
+ *       connection in the Region of the accepter VPC.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, AcceptVpcPeeringConnectionCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, AcceptVpcPeeringConnectionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // AcceptVpcPeeringConnectionRequest
+ *   DryRun: true || false,
+ *   VpcPeeringConnectionId: "STRING_VALUE", // required
+ * };
+ * const command = new AcceptVpcPeeringConnectionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param AcceptVpcPeeringConnectionCommandInput - {@link AcceptVpcPeeringConnectionCommandInput}
+ * @returns {@link AcceptVpcPeeringConnectionCommandOutput}
+ * @see {@link AcceptVpcPeeringConnectionCommandInput} for command's `input` shape.
+ * @see {@link AcceptVpcPeeringConnectionCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ */
+export declare class AcceptVpcPeeringConnectionCommand extends $Command<AcceptVpcPeeringConnectionCommandInput, AcceptVpcPeeringConnectionCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: AcceptVpcPeeringConnectionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AcceptVpcPeeringConnectionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AcceptVpcPeeringConnectionCommandInput, AcceptVpcPeeringConnectionCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -1,38 +1,74 @@
-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 {
-  AdvertiseByoipCidrRequest,
-  AdvertiseByoipCidrResult,
-} from "../models/models_0";
-export interface AdvertiseByoipCidrCommandInput
-  extends AdvertiseByoipCidrRequest {}
-export interface AdvertiseByoipCidrCommandOutput
-  extends AdvertiseByoipCidrResult,
-    __MetadataBearer {}
-export declare class AdvertiseByoipCidrCommand extends $Command<
-  AdvertiseByoipCidrCommandInput,
-  AdvertiseByoipCidrCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: AdvertiseByoipCidrCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: AdvertiseByoipCidrCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<AdvertiseByoipCidrCommandInput, AdvertiseByoipCidrCommandOutput>;
-  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 { AdvertiseByoipCidrRequest, AdvertiseByoipCidrResult } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link AdvertiseByoipCidrCommand}.
+ */
+export interface AdvertiseByoipCidrCommandInput extends AdvertiseByoipCidrRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AdvertiseByoipCidrCommand}.
+ */
+export interface AdvertiseByoipCidrCommandOutput extends AdvertiseByoipCidrResult, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Advertises an IPv4 or IPv6 address range that is provisioned for use with your Amazon Web Services resources through
+ *          bring your own IP addresses (BYOIP).</p>
+ *          <p>You can perform this operation at most once every 10 seconds, even if you specify different
+ *          address ranges each time.</p>
+ *          <p>We recommend that you stop advertising the BYOIP CIDR from other locations when you advertise
+ *           it from Amazon Web Services. To minimize down time, you can configure your Amazon Web Services resources to use an address from a
+ *          BYOIP CIDR before it is advertised, and then simultaneously stop advertising it from the current
+ *          location and start advertising it through Amazon Web Services.</p>
+ *          <p>It can take a few minutes before traffic to the specified addresses starts routing to Amazon Web Services
+ *          because of BGP propagation delays.</p>
+ *          <p>To stop advertising the BYOIP CIDR, use <a>WithdrawByoipCidr</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, AdvertiseByoipCidrCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, AdvertiseByoipCidrCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // AdvertiseByoipCidrRequest
+ *   Cidr: "STRING_VALUE", // required
+ *   DryRun: true || false,
+ * };
+ * const command = new AdvertiseByoipCidrCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param AdvertiseByoipCidrCommandInput - {@link AdvertiseByoipCidrCommandInput}
+ * @returns {@link AdvertiseByoipCidrCommandOutput}
+ * @see {@link AdvertiseByoipCidrCommandInput} for command's `input` shape.
+ * @see {@link AdvertiseByoipCidrCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ */
+export declare class AdvertiseByoipCidrCommand extends $Command<AdvertiseByoipCidrCommandInput, AdvertiseByoipCidrCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: AdvertiseByoipCidrCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AdvertiseByoipCidrCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AdvertiseByoipCidrCommandInput, AdvertiseByoipCidrCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -1,37 +1,127 @@
-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 {
-  AllocateAddressRequest,
-  AllocateAddressResult,
-} from "../models/models_0";
-export interface AllocateAddressCommandInput extends AllocateAddressRequest {}
-export interface AllocateAddressCommandOutput
-  extends AllocateAddressResult,
-    __MetadataBearer {}
-export declare class AllocateAddressCommand extends $Command<
-  AllocateAddressCommandInput,
-  AllocateAddressCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: AllocateAddressCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: AllocateAddressCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<AllocateAddressCommandInput, AllocateAddressCommandOutput>;
-  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 { AllocateAddressRequest, AllocateAddressResult } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link AllocateAddressCommand}.
+ */
+export interface AllocateAddressCommandInput extends AllocateAddressRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AllocateAddressCommand}.
+ */
+export interface AllocateAddressCommandOutput extends AllocateAddressResult, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Allocates an Elastic IP address to your Amazon Web Services account. After you allocate the Elastic IP address you can associate
+ *          it with an instance or network interface. After you release an Elastic IP address, it is released to the IP address
+ *          pool and can be allocated to a different Amazon Web Services account.</p>
+ *          <p>You can allocate an Elastic IP address from an address pool owned by Amazon Web Services or from an address pool created
+ *        from a public IPv4 address range that you have brought to Amazon Web Services for use with your Amazon Web Services resources using bring your own
+ *          IP addresses (BYOIP). For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">Bring Your Own IP Addresses (BYOIP)</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
+ *          <p>[EC2-VPC] If you release an Elastic IP address, you might be able to recover it. You cannot recover an
+ *        Elastic IP address that you released after it is allocated to another Amazon Web Services account. You cannot recover an Elastic IP
+ *          address for EC2-Classic. To attempt to recover an Elastic IP address that you released, specify it in this operation.</p>
+ *          <p>An Elastic IP address is for use either in the EC2-Classic platform or in a VPC. By default, you can allocate
+ *          5 Elastic IP addresses for EC2-Classic per Region and 5 Elastic IP addresses for EC2-VPC per Region.</p>
+ *          <p>For more information, 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>You can allocate a carrier IP address which is a public IP address from a telecommunication carrier, to a network interface which resides in a subnet in a Wavelength Zone (for example an EC2 instance). </p>
+ *          <note>
+ *             <p>We are retiring EC2-Classic. We recommend that you migrate from EC2-Classic to a VPC. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/vpc-migrate.html">Migrate from EC2-Classic to a VPC</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, AllocateAddressCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, AllocateAddressCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // AllocateAddressRequest
+ *   Domain: "vpc" || "standard",
+ *   Address: "STRING_VALUE",
+ *   PublicIpv4Pool: "STRING_VALUE",
+ *   NetworkBorderGroup: "STRING_VALUE",
+ *   CustomerOwnedIpv4Pool: "STRING_VALUE",
+ *   DryRun: true || false,
+ *   TagSpecifications: [ // TagSpecificationList
+ *     { // TagSpecification
+ *       ResourceType: "capacity-reservation" || "client-vpn-endpoint" || "customer-gateway" || "carrier-gateway" || "coip-pool" || "dedicated-host" || "dhcp-options" || "egress-only-internet-gateway" || "elastic-ip" || "elastic-gpu" || "export-image-task" || "export-instance-task" || "fleet" || "fpga-image" || "host-reservation" || "image" || "import-image-task" || "import-snapshot-task" || "instance" || "instance-event-window" || "internet-gateway" || "ipam" || "ipam-pool" || "ipam-scope" || "ipv4pool-ec2" || "ipv6pool-ec2" || "key-pair" || "launch-template" || "local-gateway" || "local-gateway-route-table" || "local-gateway-virtual-interface" || "local-gateway-virtual-interface-group" || "local-gateway-route-table-vpc-association" || "local-gateway-route-table-virtual-interface-group-association" || "natgateway" || "network-acl" || "network-interface" || "network-insights-analysis" || "network-insights-path" || "network-insights-access-scope" || "network-insights-access-scope-analysis" || "placement-group" || "prefix-list" || "replace-root-volume-task" || "reserved-instances" || "route-table" || "security-group" || "security-group-rule" || "snapshot" || "spot-fleet-request" || "spot-instances-request" || "subnet" || "subnet-cidr-reservation" || "traffic-mirror-filter" || "traffic-mirror-session" || "traffic-mirror-target" || "transit-gateway" || "transit-gateway-attachment" || "transit-gateway-connect-peer" || "transit-gateway-multicast-domain" || "transit-gateway-policy-table" || "transit-gateway-route-table" || "transit-gateway-route-table-announcement" || "volume" || "vpc" || "vpc-endpoint" || "vpc-endpoint-connection" || "vpc-endpoint-service" || "vpc-endpoint-service-permission" || "vpc-peering-connection" || "vpn-connection" || "vpn-gateway" || "vpc-flow-log" || "capacity-reservation-fleet" || "traffic-mirror-filter-rule" || "vpc-endpoint-connection-device-type" || "verified-access-instance" || "verified-access-group" || "verified-access-endpoint" || "verified-access-policy" || "verified-access-trust-provider" || "vpn-connection-device-type" || "vpc-block-public-access-exclusion" || "ipam-resource-discovery" || "ipam-resource-discovery-association",
+ *       Tags: [ // TagList
+ *         { // Tag
+ *           Key: "STRING_VALUE",
+ *           Value: "STRING_VALUE",
+ *         },
+ *       ],
+ *     },
+ *   ],
+ * };
+ * const command = new AllocateAddressCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param AllocateAddressCommandInput - {@link AllocateAddressCommandInput}
+ * @returns {@link AllocateAddressCommandOutput}
+ * @see {@link AllocateAddressCommandInput} for command's `input` shape.
+ * @see {@link AllocateAddressCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ * @example To allocate an Elastic IP address for EC2-VPC
+ * ```javascript
+ * // This example allocates an Elastic IP address to use with an instance in a VPC.
+ * const input = {
+ *   "Domain": "vpc"
+ * };
+ * const command = new AllocateAddressCommand(input);
+ * const response = await client.send(command);
+ * /* response ==
+ * {
+ *   "AllocationId": "eipalloc-64d5890a",
+ *   "Domain": "vpc",
+ *   "PublicIp": "203.0.113.0"
+ * }
+ * *\/
+ * // example id: ec2-allocate-address-1
+ * ```
+ *
+ * @example To allocate an Elastic IP address for EC2-Classic
+ * ```javascript
+ * // This example allocates an Elastic IP address to use with an instance in EC2-Classic.
+ * const input = undefined;
+ * const command = new AllocateAddressCommand(input);
+ * const response = await client.send(command);
+ * /* response ==
+ * {
+ *   "Domain": "standard",
+ *   "PublicIp": "198.51.100.0"
+ * }
+ * *\/
+ * // example id: ec2-allocate-address-2
+ * ```
+ *
+ */
+export declare class AllocateAddressCommand extends $Command<AllocateAddressCommandInput, AllocateAddressCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: AllocateAddressCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AllocateAddressCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocateAddressCommandInput, AllocateAddressCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -1,34 +1,84 @@
-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 { AllocateHostsRequest, AllocateHostsResult } from "../models/models_0";
-export interface AllocateHostsCommandInput extends AllocateHostsRequest {}
-export interface AllocateHostsCommandOutput
-  extends AllocateHostsResult,
-    __MetadataBearer {}
-export declare class AllocateHostsCommand extends $Command<
-  AllocateHostsCommandInput,
-  AllocateHostsCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: AllocateHostsCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: AllocateHostsCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<AllocateHostsCommandInput, AllocateHostsCommandOutput>;
-  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 { AllocateHostsRequest, AllocateHostsResult } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link AllocateHostsCommand}.
+ */
+export interface AllocateHostsCommandInput extends AllocateHostsRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AllocateHostsCommand}.
+ */
+export interface AllocateHostsCommandOutput extends AllocateHostsResult, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Allocates a Dedicated Host to your account. At a minimum, specify the supported
+ *             instance type or instance family, the Availability Zone in which to allocate the host,
+ *             and the number of hosts to allocate.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, AllocateHostsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, AllocateHostsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // AllocateHostsRequest
+ *   AutoPlacement: "on" || "off",
+ *   AvailabilityZone: "STRING_VALUE", // required
+ *   ClientToken: "STRING_VALUE",
+ *   InstanceType: "STRING_VALUE",
+ *   InstanceFamily: "STRING_VALUE",
+ *   Quantity: Number("int"), // required
+ *   TagSpecifications: [ // TagSpecificationList
+ *     { // TagSpecification
+ *       ResourceType: "capacity-reservation" || "client-vpn-endpoint" || "customer-gateway" || "carrier-gateway" || "coip-pool" || "dedicated-host" || "dhcp-options" || "egress-only-internet-gateway" || "elastic-ip" || "elastic-gpu" || "export-image-task" || "export-instance-task" || "fleet" || "fpga-image" || "host-reservation" || "image" || "import-image-task" || "import-snapshot-task" || "instance" || "instance-event-window" || "internet-gateway" || "ipam" || "ipam-pool" || "ipam-scope" || "ipv4pool-ec2" || "ipv6pool-ec2" || "key-pair" || "launch-template" || "local-gateway" || "local-gateway-route-table" || "local-gateway-virtual-interface" || "local-gateway-virtual-interface-group" || "local-gateway-route-table-vpc-association" || "local-gateway-route-table-virtual-interface-group-association" || "natgateway" || "network-acl" || "network-interface" || "network-insights-analysis" || "network-insights-path" || "network-insights-access-scope" || "network-insights-access-scope-analysis" || "placement-group" || "prefix-list" || "replace-root-volume-task" || "reserved-instances" || "route-table" || "security-group" || "security-group-rule" || "snapshot" || "spot-fleet-request" || "spot-instances-request" || "subnet" || "subnet-cidr-reservation" || "traffic-mirror-filter" || "traffic-mirror-session" || "traffic-mirror-target" || "transit-gateway" || "transit-gateway-attachment" || "transit-gateway-connect-peer" || "transit-gateway-multicast-domain" || "transit-gateway-policy-table" || "transit-gateway-route-table" || "transit-gateway-route-table-announcement" || "volume" || "vpc" || "vpc-endpoint" || "vpc-endpoint-connection" || "vpc-endpoint-service" || "vpc-endpoint-service-permission" || "vpc-peering-connection" || "vpn-connection" || "vpn-gateway" || "vpc-flow-log" || "capacity-reservation-fleet" || "traffic-mirror-filter-rule" || "vpc-endpoint-connection-device-type" || "verified-access-instance" || "verified-access-group" || "verified-access-endpoint" || "verified-access-policy" || "verified-access-trust-provider" || "vpn-connection-device-type" || "vpc-block-public-access-exclusion" || "ipam-resource-discovery" || "ipam-resource-discovery-association",
+ *       Tags: [ // TagList
+ *         { // Tag
+ *           Key: "STRING_VALUE",
+ *           Value: "STRING_VALUE",
+ *         },
+ *       ],
+ *     },
+ *   ],
+ *   HostRecovery: "on" || "off",
+ *   OutpostArn: "STRING_VALUE",
+ *   HostMaintenance: "on" || "off",
+ * };
+ * const command = new AllocateHostsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param AllocateHostsCommandInput - {@link AllocateHostsCommandInput}
+ * @returns {@link AllocateHostsCommandOutput}
+ * @see {@link AllocateHostsCommandInput} for command's `input` shape.
+ * @see {@link AllocateHostsCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ */
+export declare class AllocateHostsCommand extends $Command<AllocateHostsCommandInput, AllocateHostsCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: AllocateHostsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AllocateHostsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocateHostsCommandInput, AllocateHostsCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}