@aws-sdk/client-ec2 3.438.0 → 3.441.0

package/dist-es/commands/PurchaseCapacityBlockCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_PurchaseCapacityBlockCommand, se_PurchaseCapacityBlockCommand } from "../protocols/Aws_ec2";
+export { $Command };
+export class PurchaseCapacityBlockCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, PurchaseCapacityBlockCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "EC2Client";
+        const commandName = "PurchaseCapacityBlockCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AmazonEC2",
+                operation: "PurchaseCapacityBlock",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_PurchaseCapacityBlockCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_PurchaseCapacityBlockCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -224,6 +224,7 @@ export * from "./DescribeAvailabilityZonesCommand";
 export * from "./DescribeAwsNetworkPerformanceMetricSubscriptionsCommand";
 export * from "./DescribeBundleTasksCommand";
 export * from "./DescribeByoipCidrsCommand";
+export * from "./DescribeCapacityBlockOfferingsCommand";
 export * from "./DescribeCapacityReservationFleetsCommand";
 export * from "./DescribeCapacityReservationsCommand";
 export * from "./DescribeCarrierGatewaysCommand";
@@ -537,6 +538,7 @@ export * from "./MoveByoipCidrToIpamCommand";
 export * from "./ProvisionByoipCidrCommand";
 export * from "./ProvisionIpamPoolCidrCommand";
 export * from "./ProvisionPublicIpv4PoolCidrCommand";
+export * from "./PurchaseCapacityBlockCommand";
 export * from "./PurchaseHostReservationCommand";
 export * from "./PurchaseReservedInstancesOfferingCommand";
 export * from "./PurchaseScheduledInstancesCommand";

package/dist-es/models/models_0.js

@@ -468,12 +468,19 @@ export const CapacityReservationTenancy = {
     dedicated: "dedicated",
     default: "default",
 };
+export const CapacityReservationType = {
+    CAPACITY_BLOCK: "capacity-block",
+    DEFAULT: "default",
+};
 export const CapacityReservationState = {
     active: "active",
     cancelled: "cancelled",
     expired: "expired",
     failed: "failed",
+    payment_failed: "payment-failed",
+    payment_pending: "payment-pending",
     pending: "pending",
+    scheduled: "scheduled",
 };
 export const FleetInstanceMatchCriteria = {
     open: "open",

package/dist-es/models/models_1.js

@@ -100,6 +100,7 @@ export const FleetReplacementStrategy = {
     LAUNCH_BEFORE_TERMINATE: "launch-before-terminate",
 };
 export const DefaultTargetCapacityType = {
+    CAPACITY_BLOCK: "capacity-block",
     ON_DEMAND: "on-demand",
     SPOT: "spot",
 };
@@ -265,6 +266,7 @@ export const ShutdownBehavior = {
     terminate: "terminate",
 };
 export const MarketType = {
+    capacity_block: "capacity-block",
     spot: "spot",
 };
 export const InstanceInterruptionBehavior = {

package/dist-es/models/models_3.js

@@ -209,10 +209,6 @@ export const InstanceAttributeName = {
     sriovNetSupport: "sriovNetSupport",
     userData: "userData",
 };
-export const InstanceBootModeValues = {
-    legacy_bios: "legacy-bios",
-    uefi: "uefi",
-};
 export const DeleteVerifiedAccessTrustProviderResultFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.VerifiedAccessTrustProvider && {

package/dist-es/models/models_4.js

@@ -1,6 +1,11 @@
 import { SENSITIVE_STRING } from "@smithy/smithy-client";
 import { LaunchTemplateVersionFilterSensitiveLog, } from "./models_1";
+export const InstanceBootModeValues = {
+    legacy_bios: "legacy-bios",
+    uefi: "uefi",
+};
 export const InstanceLifecycleType = {
+    capacity_block: "capacity-block",
     scheduled: "scheduled",
     spot: "spot",
 };
@@ -139,6 +144,7 @@ export const RootDeviceType = {
     instance_store: "instance-store",
 };
 export const UsageClassType = {
+    capacity_block: "capacity-block",
     on_demand: "on-demand",
     spot: "spot",
 };

package/dist-es/pagination/DescribeCapacityBlockOfferingsPaginator.js

@@ -0,0 +1,25 @@
+import { DescribeCapacityBlockOfferingsCommand, } from "../commands/DescribeCapacityBlockOfferingsCommand";
+import { EC2Client } from "../EC2Client";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeCapacityBlockOfferingsCommand(input), ...args);
+};
+export async function* paginateDescribeCapacityBlockOfferings(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof EC2Client) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected EC2 | EC2Client");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -2,13 +2,14 @@ export * from "./DescribeAddressTransfersPaginator";
 export * from "./DescribeAddressesAttributePaginator";
 export * from "./DescribeAwsNetworkPerformanceMetricSubscriptionsPaginator";
 export * from "./DescribeByoipCidrsPaginator";
+export * from "./DescribeCapacityBlockOfferingsPaginator";
 export * from "./DescribeCapacityReservationFleetsPaginator";
 export * from "./DescribeCapacityReservationsPaginator";
 export * from "./DescribeCarrierGatewaysPaginator";
 export * from "./DescribeClassicLinkInstancesPaginator";
 export * from "./DescribeClientVpnAuthorizationRulesPaginator";
-export * from "./DescribeClientVpnConnectionsPaginator";
 export * from "./Interfaces";
+export * from "./DescribeClientVpnConnectionsPaginator";
 export * from "./DescribeClientVpnEndpointsPaginator";
 export * from "./DescribeClientVpnRoutesPaginator";
 export * from "./DescribeClientVpnTargetNetworksPaginator";

package/dist-es/protocols/Aws_ec2.js

@@ -2263,6 +2263,16 @@ export const se_DescribeByoipCidrsCommand = async (input, context) => {
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const se_DescribeCapacityBlockOfferingsCommand = async (input, context) => {
+    const headers = SHARED_HEADERS;
+    let body;
+    body = buildFormUrlencodedString({
+        ...se_DescribeCapacityBlockOfferingsRequest(input, context),
+        Action: "DescribeCapacityBlockOfferings",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const se_DescribeCapacityReservationFleetsCommand = async (input, context) => {
     const headers = SHARED_HEADERS;
     let body;
@@ -5393,6 +5403,16 @@ export const se_ProvisionPublicIpv4PoolCidrCommand = async (input, context) => {
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const se_PurchaseCapacityBlockCommand = async (input, context) => {
+    const headers = SHARED_HEADERS;
+    let body;
+    body = buildFormUrlencodedString({
+        ...se_PurchaseCapacityBlockRequest(input, context),
+        Action: "PurchaseCapacityBlock",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const se_PurchaseHostReservationCommand = async (input, context) => {
     const headers = SHARED_HEADERS;
     let body;
@@ -11798,6 +11818,32 @@ const de_DescribeByoipCidrsCommandError = async (output, context) => {
         errorCode,
     });
 };
+export const de_DescribeCapacityBlockOfferingsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_DescribeCapacityBlockOfferingsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeCapacityBlockOfferingsResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DescribeCapacityBlockOfferingsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        errorCode,
+    });
+};
 export const de_DescribeCapacityReservationFleetsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return de_DescribeCapacityReservationFleetsCommandError(output, context);
@@ -19885,6 +19931,32 @@ const de_ProvisionPublicIpv4PoolCidrCommandError = async (output, context) => {
         errorCode,
     });
 };
+export const de_PurchaseCapacityBlockCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_PurchaseCapacityBlockCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_PurchaseCapacityBlockResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_PurchaseCapacityBlockCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        errorCode,
+    });
+};
 export const de_PurchaseHostReservationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return de_PurchaseHostReservationCommandError(output, context);
@@ -27704,6 +27776,34 @@ const se_DescribeByoipCidrsRequest = (input, context) => {
     }
     return entries;
 };
+const se_DescribeCapacityBlockOfferingsRequest = (input, context) => {
+    const entries = {};
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.InstanceType != null) {
+        entries["InstanceType"] = input.InstanceType;
+    }
+    if (input.InstanceCount != null) {
+        entries["InstanceCount"] = input.InstanceCount;
+    }
+    if (input.StartDateRange != null) {
+        entries["StartDateRange"] = input.StartDateRange.toISOString().split(".")[0] + "Z";
+    }
+    if (input.EndDateRange != null) {
+        entries["EndDateRange"] = input.EndDateRange.toISOString().split(".")[0] + "Z";
+    }
+    if (input.CapacityDurationHours != null) {
+        entries["CapacityDurationHours"] = input.CapacityDurationHours;
+    }
+    if (input.NextToken != null) {
+        entries["NextToken"] = input.NextToken;
+    }
+    if (input.MaxResults != null) {
+        entries["MaxResults"] = input.MaxResults;
+    }
+    return entries;
+};
 const se_DescribeCapacityReservationFleetsRequest = (input, context) => {
     const entries = {};
     if (input.CapacityReservationFleetIds != null) {
@@ -39712,6 +39812,29 @@ const se_PublicIpv4PoolIdStringList = (input, context) => {
     }
     return entries;
 };
+const se_PurchaseCapacityBlockRequest = (input, context) => {
+    const entries = {};
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.TagSpecifications != null) {
+        const memberEntries = se_TagSpecificationList(input.TagSpecifications, context);
+        if (input.TagSpecifications?.length === 0) {
+            entries.TagSpecification = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TagSpecification.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.CapacityBlockOfferingId != null) {
+        entries["CapacityBlockOfferingId"] = input.CapacityBlockOfferingId;
+    }
+    if (input.InstancePlatform != null) {
+        entries["InstancePlatform"] = input.InstancePlatform;
+    }
+    return entries;
+};
 const se_PurchaseHostReservationRequest = (input, context) => {
     const entries = {};
     if (input.ClientToken != null) {
@@ -45481,6 +45604,47 @@ const de_CapacityAllocations = (output, context) => {
         return de_CapacityAllocation(entry, context);
     });
 };
+const de_CapacityBlockOffering = (output, context) => {
+    const contents = {};
+    if (output["capacityBlockOfferingId"] !== undefined) {
+        contents.CapacityBlockOfferingId = __expectString(output["capacityBlockOfferingId"]);
+    }
+    if (output["instanceType"] !== undefined) {
+        contents.InstanceType = __expectString(output["instanceType"]);
+    }
+    if (output["availabilityZone"] !== undefined) {
+        contents.AvailabilityZone = __expectString(output["availabilityZone"]);
+    }
+    if (output["instanceCount"] !== undefined) {
+        contents.InstanceCount = __strictParseInt32(output["instanceCount"]);
+    }
+    if (output["startDate"] !== undefined) {
+        contents.StartDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(output["startDate"]));
+    }
+    if (output["endDate"] !== undefined) {
+        contents.EndDate = __expectNonNull(__parseRfc3339DateTimeWithOffset(output["endDate"]));
+    }
+    if (output["capacityBlockDurationHours"] !== undefined) {
+        contents.CapacityBlockDurationHours = __strictParseInt32(output["capacityBlockDurationHours"]);
+    }
+    if (output["upfrontFee"] !== undefined) {
+        contents.UpfrontFee = __expectString(output["upfrontFee"]);
+    }
+    if (output["currencyCode"] !== undefined) {
+        contents.CurrencyCode = __expectString(output["currencyCode"]);
+    }
+    if (output["tenancy"] !== undefined) {
+        contents.Tenancy = __expectString(output["tenancy"]);
+    }
+    return contents;
+};
+const de_CapacityBlockOfferingSet = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_CapacityBlockOffering(entry, context);
+    });
+};
 const de_CapacityReservation = (output, context) => {
     const contents = {};
     if (output["capacityReservationId"] !== undefined) {
@@ -45558,6 +45722,9 @@ const de_CapacityReservation = (output, context) => {
     else if (output["capacityAllocationSet"] !== undefined && output["capacityAllocationSet"]["item"] !== undefined) {
         contents.CapacityAllocations = de_CapacityAllocations(__getArrayIfSingleItem(output["capacityAllocationSet"]["item"]), context);
     }
+    if (output["reservationType"] !== undefined) {
+        contents.ReservationType = __expectString(output["reservationType"]);
+    }
     return contents;
 };
 const de_CapacityReservationFleet = (output, context) => {
@@ -47826,6 +47993,20 @@ const de_DescribeByoipCidrsResult = (output, context) => {
     }
     return contents;
 };
+const de_DescribeCapacityBlockOfferingsResult = (output, context) => {
+    const contents = {};
+    if (output.capacityBlockOfferingSet === "") {
+        contents.CapacityBlockOfferings = [];
+    }
+    else if (output["capacityBlockOfferingSet"] !== undefined &&
+        output["capacityBlockOfferingSet"]["item"] !== undefined) {
+        contents.CapacityBlockOfferings = de_CapacityBlockOfferingSet(__getArrayIfSingleItem(output["capacityBlockOfferingSet"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
 const de_DescribeCapacityReservationFleetsResult = (output, context) => {
     const contents = {};
     if (output.capacityReservationFleetSet === "") {
@@ -58615,6 +58796,13 @@ const de_Purchase = (output, context) => {
     }
     return contents;
 };
+const de_PurchaseCapacityBlockResult = (output, context) => {
+    const contents = {};
+    if (output["capacityReservation"] !== undefined) {
+        contents.CapacityReservation = de_CapacityReservation(output["capacityReservation"], context);
+    }
+    return contents;
+};
 const de_PurchasedScheduledInstanceSet = (output, context) => {
     return (output || [])
         .filter((e) => e != null)

package/dist-types/EC2.d.ts

@@ -225,6 +225,7 @@ import { DescribeAvailabilityZonesCommandInput, DescribeAvailabilityZonesCommand
 import { DescribeAwsNetworkPerformanceMetricSubscriptionsCommandInput, DescribeAwsNetworkPerformanceMetricSubscriptionsCommandOutput } from "./commands/DescribeAwsNetworkPerformanceMetricSubscriptionsCommand";
 import { DescribeBundleTasksCommandInput, DescribeBundleTasksCommandOutput } from "./commands/DescribeBundleTasksCommand";
 import { DescribeByoipCidrsCommandInput, DescribeByoipCidrsCommandOutput } from "./commands/DescribeByoipCidrsCommand";
+import { DescribeCapacityBlockOfferingsCommandInput, DescribeCapacityBlockOfferingsCommandOutput } from "./commands/DescribeCapacityBlockOfferingsCommand";
 import { DescribeCapacityReservationFleetsCommandInput, DescribeCapacityReservationFleetsCommandOutput } from "./commands/DescribeCapacityReservationFleetsCommand";
 import { DescribeCapacityReservationsCommandInput, DescribeCapacityReservationsCommandOutput } from "./commands/DescribeCapacityReservationsCommand";
 import { DescribeCarrierGatewaysCommandInput, DescribeCarrierGatewaysCommandOutput } from "./commands/DescribeCarrierGatewaysCommand";
@@ -538,6 +539,7 @@ import { MoveByoipCidrToIpamCommandInput, MoveByoipCidrToIpamCommandOutput } fro
 import { ProvisionByoipCidrCommandInput, ProvisionByoipCidrCommandOutput } from "./commands/ProvisionByoipCidrCommand";
 import { ProvisionIpamPoolCidrCommandInput, ProvisionIpamPoolCidrCommandOutput } from "./commands/ProvisionIpamPoolCidrCommand";
 import { ProvisionPublicIpv4PoolCidrCommandInput, ProvisionPublicIpv4PoolCidrCommandOutput } from "./commands/ProvisionPublicIpv4PoolCidrCommand";
+import { PurchaseCapacityBlockCommandInput, PurchaseCapacityBlockCommandOutput } from "./commands/PurchaseCapacityBlockCommand";
 import { PurchaseHostReservationCommandInput, PurchaseHostReservationCommandOutput } from "./commands/PurchaseHostReservationCommand";
 import { PurchaseReservedInstancesOfferingCommandInput, PurchaseReservedInstancesOfferingCommandOutput } from "./commands/PurchaseReservedInstancesOfferingCommand";
 import { PurchaseScheduledInstancesCommandInput, PurchaseScheduledInstancesCommandOutput } from "./commands/PurchaseScheduledInstancesCommand";
@@ -1957,6 +1959,12 @@ export interface EC2 {
     describeByoipCidrs(args: DescribeByoipCidrsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeByoipCidrsCommandOutput>;
     describeByoipCidrs(args: DescribeByoipCidrsCommandInput, cb: (err: any, data?: DescribeByoipCidrsCommandOutput) => void): void;
     describeByoipCidrs(args: DescribeByoipCidrsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeByoipCidrsCommandOutput) => void): void;
+    /**
+     * @see {@link DescribeCapacityBlockOfferingsCommand}
+     */
+    describeCapacityBlockOfferings(args: DescribeCapacityBlockOfferingsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeCapacityBlockOfferingsCommandOutput>;
+    describeCapacityBlockOfferings(args: DescribeCapacityBlockOfferingsCommandInput, cb: (err: any, data?: DescribeCapacityBlockOfferingsCommandOutput) => void): void;
+    describeCapacityBlockOfferings(args: DescribeCapacityBlockOfferingsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeCapacityBlockOfferingsCommandOutput) => void): void;
     /**
      * @see {@link DescribeCapacityReservationFleetsCommand}
      */
@@ -3835,6 +3843,12 @@ export interface EC2 {
     provisionPublicIpv4PoolCidr(args: ProvisionPublicIpv4PoolCidrCommandInput, options?: __HttpHandlerOptions): Promise<ProvisionPublicIpv4PoolCidrCommandOutput>;
     provisionPublicIpv4PoolCidr(args: ProvisionPublicIpv4PoolCidrCommandInput, cb: (err: any, data?: ProvisionPublicIpv4PoolCidrCommandOutput) => void): void;
     provisionPublicIpv4PoolCidr(args: ProvisionPublicIpv4PoolCidrCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ProvisionPublicIpv4PoolCidrCommandOutput) => void): void;
+    /**
+     * @see {@link PurchaseCapacityBlockCommand}
+     */
+    purchaseCapacityBlock(args: PurchaseCapacityBlockCommandInput, options?: __HttpHandlerOptions): Promise<PurchaseCapacityBlockCommandOutput>;
+    purchaseCapacityBlock(args: PurchaseCapacityBlockCommandInput, cb: (err: any, data?: PurchaseCapacityBlockCommandOutput) => void): void;
+    purchaseCapacityBlock(args: PurchaseCapacityBlockCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PurchaseCapacityBlockCommandOutput) => void): void;
     /**
      * @see {@link PurchaseHostReservationCommand}
      */