@aws-sdk/client-athena 3.218.0 → 3.221.0

package/dist-es/commands/GetCalculationExecutionCodeCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetCalculationExecutionCodeRequestFilterSensitiveLog, GetCalculationExecutionCodeResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1GetCalculationExecutionCodeCommand, serializeAws_json1_1GetCalculationExecutionCodeCommand, } from "../protocols/Aws_json1_1";
+export class GetCalculationExecutionCodeCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetCalculationExecutionCodeCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "GetCalculationExecutionCodeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetCalculationExecutionCodeRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetCalculationExecutionCodeResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1GetCalculationExecutionCodeCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1GetCalculationExecutionCodeCommand(output, context);
+    }
+}

package/dist-es/commands/GetCalculationExecutionCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetCalculationExecutionRequestFilterSensitiveLog, GetCalculationExecutionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1GetCalculationExecutionCommand, serializeAws_json1_1GetCalculationExecutionCommand, } from "../protocols/Aws_json1_1";
+export class GetCalculationExecutionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetCalculationExecutionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "GetCalculationExecutionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetCalculationExecutionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetCalculationExecutionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1GetCalculationExecutionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1GetCalculationExecutionCommand(output, context);
+    }
+}

package/dist-es/commands/GetCalculationExecutionStatusCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetCalculationExecutionStatusRequestFilterSensitiveLog, GetCalculationExecutionStatusResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1GetCalculationExecutionStatusCommand, serializeAws_json1_1GetCalculationExecutionStatusCommand, } from "../protocols/Aws_json1_1";
+export class GetCalculationExecutionStatusCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetCalculationExecutionStatusCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "GetCalculationExecutionStatusCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetCalculationExecutionStatusRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetCalculationExecutionStatusResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1GetCalculationExecutionStatusCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1GetCalculationExecutionStatusCommand(output, context);
+    }
+}

package/dist-es/commands/GetNotebookMetadataCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetNotebookMetadataInputFilterSensitiveLog, GetNotebookMetadataOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1GetNotebookMetadataCommand, serializeAws_json1_1GetNotebookMetadataCommand, } from "../protocols/Aws_json1_1";
+export class GetNotebookMetadataCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetNotebookMetadataCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "GetNotebookMetadataCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetNotebookMetadataInputFilterSensitiveLog,
+            outputFilterSensitiveLog: GetNotebookMetadataOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1GetNotebookMetadataCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1GetNotebookMetadataCommand(output, context);
+    }
+}

package/dist-es/commands/GetSessionCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetSessionRequestFilterSensitiveLog, GetSessionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1GetSessionCommand, serializeAws_json1_1GetSessionCommand, } from "../protocols/Aws_json1_1";
+export class GetSessionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetSessionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "GetSessionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetSessionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetSessionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1GetSessionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1GetSessionCommand(output, context);
+    }
+}

package/dist-es/commands/GetSessionStatusCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetSessionStatusRequestFilterSensitiveLog, GetSessionStatusResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1GetSessionStatusCommand, serializeAws_json1_1GetSessionStatusCommand, } from "../protocols/Aws_json1_1";
+export class GetSessionStatusCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetSessionStatusCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "GetSessionStatusCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetSessionStatusRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetSessionStatusResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1GetSessionStatusCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1GetSessionStatusCommand(output, context);
+    }
+}

package/dist-es/commands/ImportNotebookCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ImportNotebookInputFilterSensitiveLog, ImportNotebookOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1ImportNotebookCommand, serializeAws_json1_1ImportNotebookCommand, } from "../protocols/Aws_json1_1";
+export class ImportNotebookCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ImportNotebookCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "ImportNotebookCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ImportNotebookInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ImportNotebookOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1ImportNotebookCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1ImportNotebookCommand(output, context);
+    }
+}

package/dist-es/commands/ListApplicationDPUSizesCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListApplicationDPUSizesInputFilterSensitiveLog, ListApplicationDPUSizesOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1ListApplicationDPUSizesCommand, serializeAws_json1_1ListApplicationDPUSizesCommand, } from "../protocols/Aws_json1_1";
+export class ListApplicationDPUSizesCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListApplicationDPUSizesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "ListApplicationDPUSizesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListApplicationDPUSizesInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListApplicationDPUSizesOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1ListApplicationDPUSizesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1ListApplicationDPUSizesCommand(output, context);
+    }
+}

package/dist-es/commands/ListCalculationExecutionsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListCalculationExecutionsRequestFilterSensitiveLog, ListCalculationExecutionsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1ListCalculationExecutionsCommand, serializeAws_json1_1ListCalculationExecutionsCommand, } from "../protocols/Aws_json1_1";
+export class ListCalculationExecutionsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListCalculationExecutionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "ListCalculationExecutionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListCalculationExecutionsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListCalculationExecutionsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1ListCalculationExecutionsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1ListCalculationExecutionsCommand(output, context);
+    }
+}

package/dist-es/commands/ListExecutorsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListExecutorsRequestFilterSensitiveLog, ListExecutorsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1ListExecutorsCommand, serializeAws_json1_1ListExecutorsCommand, } from "../protocols/Aws_json1_1";
+export class ListExecutorsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListExecutorsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "ListExecutorsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListExecutorsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListExecutorsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1ListExecutorsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1ListExecutorsCommand(output, context);
+    }
+}

package/dist-es/commands/ListNotebookMetadataCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListNotebookMetadataInputFilterSensitiveLog, ListNotebookMetadataOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1ListNotebookMetadataCommand, serializeAws_json1_1ListNotebookMetadataCommand, } from "../protocols/Aws_json1_1";
+export class ListNotebookMetadataCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListNotebookMetadataCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "ListNotebookMetadataCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListNotebookMetadataInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListNotebookMetadataOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1ListNotebookMetadataCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1ListNotebookMetadataCommand(output, context);
+    }
+}

package/dist-es/commands/ListNotebookSessionsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListNotebookSessionsRequestFilterSensitiveLog, ListNotebookSessionsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1ListNotebookSessionsCommand, serializeAws_json1_1ListNotebookSessionsCommand, } from "../protocols/Aws_json1_1";
+export class ListNotebookSessionsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListNotebookSessionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "ListNotebookSessionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListNotebookSessionsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListNotebookSessionsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1ListNotebookSessionsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1ListNotebookSessionsCommand(output, context);
+    }
+}

package/dist-es/commands/ListSessionsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListSessionsRequestFilterSensitiveLog, ListSessionsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1ListSessionsCommand, serializeAws_json1_1ListSessionsCommand, } from "../protocols/Aws_json1_1";
+export class ListSessionsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListSessionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "ListSessionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListSessionsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListSessionsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1ListSessionsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1ListSessionsCommand(output, context);
+    }
+}

package/dist-es/commands/StartCalculationExecutionCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StartCalculationExecutionRequestFilterSensitiveLog, StartCalculationExecutionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1StartCalculationExecutionCommand, serializeAws_json1_1StartCalculationExecutionCommand, } from "../protocols/Aws_json1_1";
+export class StartCalculationExecutionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, StartCalculationExecutionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "StartCalculationExecutionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartCalculationExecutionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: StartCalculationExecutionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1StartCalculationExecutionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1StartCalculationExecutionCommand(output, context);
+    }
+}

package/dist-es/commands/StartSessionCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StartSessionRequestFilterSensitiveLog, StartSessionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1StartSessionCommand, serializeAws_json1_1StartSessionCommand, } from "../protocols/Aws_json1_1";
+export class StartSessionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, StartSessionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "StartSessionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartSessionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: StartSessionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1StartSessionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1StartSessionCommand(output, context);
+    }
+}