@aws-sdk/client-athena 3.321.1 → 3.323.0

package/dist-es/commands/GetCapacityReservationCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_GetCapacityReservationCommand, se_GetCapacityReservationCommand } from "../protocols/Aws_json1_1";
+export class GetCapacityReservationCommand 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, GetCapacityReservationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "GetCapacityReservationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetCapacityReservationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetCapacityReservationCommand(output, context);
+    }
+}

package/dist-es/commands/ListCapacityReservationsCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_ListCapacityReservationsCommand, se_ListCapacityReservationsCommand } from "../protocols/Aws_json1_1";
+export class ListCapacityReservationsCommand 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, ListCapacityReservationsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "ListCapacityReservationsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListCapacityReservationsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListCapacityReservationsCommand(output, context);
+    }
+}

package/dist-es/commands/PutCapacityAssignmentConfigurationCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_PutCapacityAssignmentConfigurationCommand, se_PutCapacityAssignmentConfigurationCommand, } from "../protocols/Aws_json1_1";
+export class PutCapacityAssignmentConfigurationCommand 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, PutCapacityAssignmentConfigurationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "PutCapacityAssignmentConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_PutCapacityAssignmentConfigurationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_PutCapacityAssignmentConfigurationCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateCapacityReservationCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_UpdateCapacityReservationCommand, se_UpdateCapacityReservationCommand } from "../protocols/Aws_json1_1";
+export class UpdateCapacityReservationCommand 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, UpdateCapacityReservationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "UpdateCapacityReservationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateCapacityReservationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateCapacityReservationCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -1,6 +1,8 @@
 export * from "./BatchGetNamedQueryCommand";
 export * from "./BatchGetPreparedStatementCommand";
 export * from "./BatchGetQueryExecutionCommand";
+export * from "./CancelCapacityReservationCommand";
+export * from "./CreateCapacityReservationCommand";
 export * from "./CreateDataCatalogCommand";
 export * from "./CreateNamedQueryCommand";
 export * from "./CreateNotebookCommand";
@@ -16,6 +18,8 @@ export * from "./ExportNotebookCommand";
 export * from "./GetCalculationExecutionCodeCommand";
 export * from "./GetCalculationExecutionCommand";
 export * from "./GetCalculationExecutionStatusCommand";
+export * from "./GetCapacityAssignmentConfigurationCommand";
+export * from "./GetCapacityReservationCommand";
 export * from "./GetDataCatalogCommand";
 export * from "./GetDatabaseCommand";
 export * from "./GetNamedQueryCommand";
@@ -31,6 +35,7 @@ export * from "./GetWorkGroupCommand";
 export * from "./ImportNotebookCommand";
 export * from "./ListApplicationDPUSizesCommand";
 export * from "./ListCalculationExecutionsCommand";
+export * from "./ListCapacityReservationsCommand";
 export * from "./ListDataCatalogsCommand";
 export * from "./ListDatabasesCommand";
 export * from "./ListEngineVersionsCommand";
@@ -44,6 +49,7 @@ export * from "./ListSessionsCommand";
 export * from "./ListTableMetadataCommand";
 export * from "./ListTagsForResourceCommand";
 export * from "./ListWorkGroupsCommand";
+export * from "./PutCapacityAssignmentConfigurationCommand";
 export * from "./StartCalculationExecutionCommand";
 export * from "./StartQueryExecutionCommand";
 export * from "./StartSessionCommand";
@@ -52,6 +58,7 @@ export * from "./StopQueryExecutionCommand";
 export * from "./TagResourceCommand";
 export * from "./TerminateSessionCommand";
 export * from "./UntagResourceCommand";
+export * from "./UpdateCapacityReservationCommand";
 export * from "./UpdateDataCatalogCommand";
 export * from "./UpdateNamedQueryCommand";
 export * from "./UpdateNotebookCommand";

package/dist-es/models/models_0.js

@@ -95,6 +95,19 @@ export const CalculationExecutionState = {
     QUEUED: "QUEUED",
     RUNNING: "RUNNING",
 };
+export const CapacityAllocationStatus = {
+    FAILED: "FAILED",
+    PENDING: "PENDING",
+    SUCCEEDED: "SUCCEEDED",
+};
+export const CapacityReservationStatus = {
+    ACTIVE: "ACTIVE",
+    CANCELLED: "CANCELLED",
+    CANCELLING: "CANCELLING",
+    FAILED: "FAILED",
+    PENDING: "PENDING",
+    UPDATE_PENDING: "UPDATE_PENDING",
+};
 export class MetadataException extends __BaseException {
     constructor(opts) {
         super({

package/dist-es/pagination/ListCapacityReservationsPaginator.js

@@ -0,0 +1,25 @@
+import { AthenaClient } from "../AthenaClient";
+import { ListCapacityReservationsCommand, } from "../commands/ListCapacityReservationsCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListCapacityReservationsCommand(input), ...args);
+};
+export async function* paginateListCapacityReservations(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 AthenaClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Athena | AthenaClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -2,6 +2,7 @@ export * from "./GetQueryResultsPaginator";
 export * from "./Interfaces";
 export * from "./ListApplicationDPUSizesPaginator";
 export * from "./ListCalculationExecutionsPaginator";
+export * from "./ListCapacityReservationsPaginator";
 export * from "./ListDataCatalogsPaginator";
 export * from "./ListDatabasesPaginator";
 export * from "./ListEngineVersionsPaginator";

package/dist-es/protocols/Aws_json1_1.js

@@ -1,5 +1,5 @@
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
-import { _json, decorateServiceException as __decorateServiceException, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@aws-sdk/smithy-client";
+import { _json, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@aws-sdk/smithy-client";
 import { v4 as generateIdempotencyToken } from "uuid";
 import { AthenaServiceException as __BaseException } from "../models/AthenaServiceException";
 import { InternalServerException, InvalidRequestException, MetadataException, ResourceNotFoundException, SessionAlreadyExistsException, TooManyRequestsException, } from "../models/models_0";
@@ -21,6 +21,18 @@ export const se_BatchGetQueryExecutionCommand = async (input, context) => {
     body = JSON.stringify(_json(input));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const se_CancelCapacityReservationCommand = async (input, context) => {
+    const headers = sharedHeaders("CancelCapacityReservation");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_CreateCapacityReservationCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateCapacityReservation");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const se_CreateDataCatalogCommand = async (input, context) => {
     const headers = sharedHeaders("CreateDataCatalog");
     let body;
@@ -111,6 +123,18 @@ export const se_GetCalculationExecutionStatusCommand = async (input, context) =>
     body = JSON.stringify(_json(input));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const se_GetCapacityAssignmentConfigurationCommand = async (input, context) => {
+    const headers = sharedHeaders("GetCapacityAssignmentConfiguration");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_GetCapacityReservationCommand = async (input, context) => {
+    const headers = sharedHeaders("GetCapacityReservation");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const se_GetDatabaseCommand = async (input, context) => {
     const headers = sharedHeaders("GetDatabase");
     let body;
@@ -201,6 +225,12 @@ export const se_ListCalculationExecutionsCommand = async (input, context) => {
     body = JSON.stringify(_json(input));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const se_ListCapacityReservationsCommand = async (input, context) => {
+    const headers = sharedHeaders("ListCapacityReservations");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const se_ListDatabasesCommand = async (input, context) => {
     const headers = sharedHeaders("ListDatabases");
     let body;
@@ -279,6 +309,12 @@ export const se_ListWorkGroupsCommand = async (input, context) => {
     body = JSON.stringify(_json(input));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const se_PutCapacityAssignmentConfigurationCommand = async (input, context) => {
+    const headers = sharedHeaders("PutCapacityAssignmentConfiguration");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const se_StartCalculationExecutionCommand = async (input, context) => {
     const headers = sharedHeaders("StartCalculationExecution");
     let body;
@@ -327,6 +363,12 @@ export const se_UntagResourceCommand = async (input, context) => {
     body = JSON.stringify(_json(input));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const se_UpdateCapacityReservationCommand = async (input, context) => {
+    const headers = sharedHeaders("UpdateCapacityReservation");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const se_UpdateDataCatalogCommand = async (input, context) => {
     const headers = sharedHeaders("UpdateDataCatalog");
     let body;
@@ -468,6 +510,76 @@ const de_BatchGetQueryExecutionCommandError = async (output, context) => {
             });
     }
 };
+export const de_CancelCapacityReservationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CancelCapacityReservationCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CancelCapacityReservationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.athena#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "InvalidRequestException":
+        case "com.amazonaws.athena#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_CreateCapacityReservationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CreateCapacityReservationCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CreateCapacityReservationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.athena#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "InvalidRequestException":
+        case "com.amazonaws.athena#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_CreateDataCatalogCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return de_CreateDataCatalogCommandError(output, context);
@@ -1017,6 +1129,76 @@ const de_GetCalculationExecutionStatusCommandError = async (output, context) =>
             });
     }
 };
+export const de_GetCapacityAssignmentConfigurationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_GetCapacityAssignmentConfigurationCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetCapacityAssignmentConfigurationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.athena#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "InvalidRequestException":
+        case "com.amazonaws.athena#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetCapacityReservationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_GetCapacityReservationCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_GetCapacityReservationOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetCapacityReservationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.athena#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "InvalidRequestException":
+        case "com.amazonaws.athena#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_GetDatabaseCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return de_GetDatabaseCommandError(output, context);
@@ -1572,6 +1754,41 @@ const de_ListCalculationExecutionsCommandError = async (output, context) => {
             });
     }
 };
+export const de_ListCapacityReservationsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_ListCapacityReservationsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ListCapacityReservationsOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListCapacityReservationsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.athena#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "InvalidRequestException":
+        case "com.amazonaws.athena#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListDatabasesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return de_ListDatabasesCommandError(output, context);
@@ -2048,6 +2265,41 @@ const de_ListWorkGroupsCommandError = async (output, context) => {
             });
     }
 };
+export const de_PutCapacityAssignmentConfigurationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_PutCapacityAssignmentConfigurationCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_PutCapacityAssignmentConfigurationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.athena#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "InvalidRequestException":
+        case "com.amazonaws.athena#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_StartCalculationExecutionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return de_StartCalculationExecutionCommandError(output, context);
@@ -2355,6 +2607,41 @@ const de_UntagResourceCommandError = async (output, context) => {
             });
     }
 };
+export const de_UpdateCapacityReservationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_UpdateCapacityReservationCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_UpdateCapacityReservationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.athena#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "InvalidRequestException":
+        case "com.amazonaws.athena#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_UpdateDataCatalogCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return de_UpdateDataCatalogCommandError(output, context);
@@ -2694,6 +2981,33 @@ const de_CalculationSummary = (output, context) => {
         Status: (_) => de_CalculationStatus(_, context),
     });
 };
+const de_CapacityAllocation = (output, context) => {
+    return take(output, {
+        RequestCompletionTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        RequestTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        Status: __expectString,
+        StatusMessage: __expectString,
+    });
+};
+const de_CapacityReservation = (output, context) => {
+    return take(output, {
+        AllocatedDpus: __expectInt32,
+        CreationTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        LastAllocation: (_) => de_CapacityAllocation(_, context),
+        LastSuccessfulAllocationTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        Name: __expectString,
+        Status: __expectString,
+        TargetDpus: __expectInt32,
+    });
+};
+const de_CapacityReservationsList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_CapacityReservation(entry, context);
+    });
+    return retVal;
+};
 const de_ExportNotebookOutput = (output, context) => {
     return take(output, {
         NotebookMetadata: (_) => de_NotebookMetadata(_, context),
@@ -2717,6 +3031,11 @@ const de_GetCalculationExecutionStatusResponse = (output, context) => {
         Status: (_) => de_CalculationStatus(_, context),
     });
 };
+const de_GetCapacityReservationOutput = (output, context) => {
+    return take(output, {
+        CapacityReservation: (_) => de_CapacityReservation(_, context),
+    });
+};
 const de_GetNotebookMetadataOutput = (output, context) => {
     return take(output, {
         NotebookMetadata: (_) => de_NotebookMetadata(_, context),
@@ -2772,6 +3091,12 @@ const de_ListCalculationExecutionsResponse = (output, context) => {
         NextToken: __expectString,
     });
 };
+const de_ListCapacityReservationsOutput = (output, context) => {
+    return take(output, {
+        CapacityReservations: (_) => de_CapacityReservationsList(_, context),
+        NextToken: __expectString,
+    });
+};
 const de_ListNotebookMetadataOutput = (output, context) => {
     return take(output, {
         NextToken: __expectString,