@aws-sdk/client-athena 3.218.0 → 3.222.0

package/dist-es/Athena.js

@@ -4,36 +4,59 @@ import { BatchGetPreparedStatementCommand, } from "./commands/BatchGetPreparedSt
 import { BatchGetQueryExecutionCommand, } from "./commands/BatchGetQueryExecutionCommand";
 import { CreateDataCatalogCommand, } from "./commands/CreateDataCatalogCommand";
 import { CreateNamedQueryCommand, } from "./commands/CreateNamedQueryCommand";
+import { CreateNotebookCommand, } from "./commands/CreateNotebookCommand";
 import { CreatePreparedStatementCommand, } from "./commands/CreatePreparedStatementCommand";
+import { CreatePresignedNotebookUrlCommand, } from "./commands/CreatePresignedNotebookUrlCommand";
 import { CreateWorkGroupCommand, } from "./commands/CreateWorkGroupCommand";
 import { DeleteDataCatalogCommand, } from "./commands/DeleteDataCatalogCommand";
 import { DeleteNamedQueryCommand, } from "./commands/DeleteNamedQueryCommand";
+import { DeleteNotebookCommand, } from "./commands/DeleteNotebookCommand";
 import { DeletePreparedStatementCommand, } from "./commands/DeletePreparedStatementCommand";
 import { DeleteWorkGroupCommand, } from "./commands/DeleteWorkGroupCommand";
+import { ExportNotebookCommand, } from "./commands/ExportNotebookCommand";
+import { GetCalculationExecutionCodeCommand, } from "./commands/GetCalculationExecutionCodeCommand";
+import { GetCalculationExecutionCommand, } from "./commands/GetCalculationExecutionCommand";
+import { GetCalculationExecutionStatusCommand, } from "./commands/GetCalculationExecutionStatusCommand";
 import { GetDatabaseCommand } from "./commands/GetDatabaseCommand";
 import { GetDataCatalogCommand, } from "./commands/GetDataCatalogCommand";
 import { GetNamedQueryCommand, } from "./commands/GetNamedQueryCommand";
+import { GetNotebookMetadataCommand, } from "./commands/GetNotebookMetadataCommand";
 import { GetPreparedStatementCommand, } from "./commands/GetPreparedStatementCommand";
 import { GetQueryExecutionCommand, } from "./commands/GetQueryExecutionCommand";
 import { GetQueryResultsCommand, } from "./commands/GetQueryResultsCommand";
 import { GetQueryRuntimeStatisticsCommand, } from "./commands/GetQueryRuntimeStatisticsCommand";
+import { GetSessionCommand } from "./commands/GetSessionCommand";
+import { GetSessionStatusCommand, } from "./commands/GetSessionStatusCommand";
 import { GetTableMetadataCommand, } from "./commands/GetTableMetadataCommand";
 import { GetWorkGroupCommand, } from "./commands/GetWorkGroupCommand";
+import { ImportNotebookCommand, } from "./commands/ImportNotebookCommand";
+import { ListApplicationDPUSizesCommand, } from "./commands/ListApplicationDPUSizesCommand";
+import { ListCalculationExecutionsCommand, } from "./commands/ListCalculationExecutionsCommand";
 import { ListDatabasesCommand, } from "./commands/ListDatabasesCommand";
 import { ListDataCatalogsCommand, } from "./commands/ListDataCatalogsCommand";
 import { ListEngineVersionsCommand, } from "./commands/ListEngineVersionsCommand";
+import { ListExecutorsCommand, } from "./commands/ListExecutorsCommand";
 import { ListNamedQueriesCommand, } from "./commands/ListNamedQueriesCommand";
+import { ListNotebookMetadataCommand, } from "./commands/ListNotebookMetadataCommand";
+import { ListNotebookSessionsCommand, } from "./commands/ListNotebookSessionsCommand";
 import { ListPreparedStatementsCommand, } from "./commands/ListPreparedStatementsCommand";
 import { ListQueryExecutionsCommand, } from "./commands/ListQueryExecutionsCommand";
+import { ListSessionsCommand, } from "./commands/ListSessionsCommand";
 import { ListTableMetadataCommand, } from "./commands/ListTableMetadataCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
 import { ListWorkGroupsCommand, } from "./commands/ListWorkGroupsCommand";
+import { StartCalculationExecutionCommand, } from "./commands/StartCalculationExecutionCommand";
 import { StartQueryExecutionCommand, } from "./commands/StartQueryExecutionCommand";
+import { StartSessionCommand, } from "./commands/StartSessionCommand";
+import { StopCalculationExecutionCommand, } from "./commands/StopCalculationExecutionCommand";
 import { StopQueryExecutionCommand, } from "./commands/StopQueryExecutionCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
+import { TerminateSessionCommand, } from "./commands/TerminateSessionCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateDataCatalogCommand, } from "./commands/UpdateDataCatalogCommand";
 import { UpdateNamedQueryCommand, } from "./commands/UpdateNamedQueryCommand";
+import { UpdateNotebookCommand, } from "./commands/UpdateNotebookCommand";
+import { UpdateNotebookMetadataCommand, } from "./commands/UpdateNotebookMetadataCommand";
 import { UpdatePreparedStatementCommand, } from "./commands/UpdatePreparedStatementCommand";
 import { UpdateWorkGroupCommand, } from "./commands/UpdateWorkGroupCommand";
 export class Athena extends AthenaClient {
@@ -107,6 +130,20 @@ export class Athena extends AthenaClient {
             return this.send(command, optionsOrCb);
         }
     }
+    createNotebook(args, optionsOrCb, cb) {
+        const command = new CreateNotebookCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     createPreparedStatement(args, optionsOrCb, cb) {
         const command = new CreatePreparedStatementCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -121,6 +158,20 @@ export class Athena extends AthenaClient {
             return this.send(command, optionsOrCb);
         }
     }
+    createPresignedNotebookUrl(args, optionsOrCb, cb) {
+        const command = new CreatePresignedNotebookUrlCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     createWorkGroup(args, optionsOrCb, cb) {
         const command = new CreateWorkGroupCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -163,6 +214,20 @@ export class Athena extends AthenaClient {
             return this.send(command, optionsOrCb);
         }
     }
+    deleteNotebook(args, optionsOrCb, cb) {
+        const command = new DeleteNotebookCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     deletePreparedStatement(args, optionsOrCb, cb) {
         const command = new DeletePreparedStatementCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -191,6 +256,62 @@ export class Athena extends AthenaClient {
             return this.send(command, optionsOrCb);
         }
     }
+    exportNotebook(args, optionsOrCb, cb) {
+        const command = new ExportNotebookCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    getCalculationExecution(args, optionsOrCb, cb) {
+        const command = new GetCalculationExecutionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    getCalculationExecutionCode(args, optionsOrCb, cb) {
+        const command = new GetCalculationExecutionCodeCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    getCalculationExecutionStatus(args, optionsOrCb, cb) {
+        const command = new GetCalculationExecutionStatusCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     getDatabase(args, optionsOrCb, cb) {
         const command = new GetDatabaseCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -233,6 +354,20 @@ export class Athena extends AthenaClient {
             return this.send(command, optionsOrCb);
         }
     }
+    getNotebookMetadata(args, optionsOrCb, cb) {
+        const command = new GetNotebookMetadataCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     getPreparedStatement(args, optionsOrCb, cb) {
         const command = new GetPreparedStatementCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -289,6 +424,34 @@ export class Athena extends AthenaClient {
             return this.send(command, optionsOrCb);
         }
     }
+    getSession(args, optionsOrCb, cb) {
+        const command = new GetSessionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    getSessionStatus(args, optionsOrCb, cb) {
+        const command = new GetSessionStatusCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     getTableMetadata(args, optionsOrCb, cb) {
         const command = new GetTableMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -317,6 +480,48 @@ export class Athena extends AthenaClient {
             return this.send(command, optionsOrCb);
         }
     }
+    importNotebook(args, optionsOrCb, cb) {
+        const command = new ImportNotebookCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    listApplicationDPUSizes(args, optionsOrCb, cb) {
+        const command = new ListApplicationDPUSizesCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    listCalculationExecutions(args, optionsOrCb, cb) {
+        const command = new ListCalculationExecutionsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     listDatabases(args, optionsOrCb, cb) {
         const command = new ListDatabasesCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -359,6 +564,20 @@ export class Athena extends AthenaClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listExecutors(args, optionsOrCb, cb) {
+        const command = new ListExecutorsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     listNamedQueries(args, optionsOrCb, cb) {
         const command = new ListNamedQueriesCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -373,6 +592,34 @@ export class Athena extends AthenaClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listNotebookMetadata(args, optionsOrCb, cb) {
+        const command = new ListNotebookMetadataCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    listNotebookSessions(args, optionsOrCb, cb) {
+        const command = new ListNotebookSessionsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     listPreparedStatements(args, optionsOrCb, cb) {
         const command = new ListPreparedStatementsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -401,6 +648,20 @@ export class Athena extends AthenaClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listSessions(args, optionsOrCb, cb) {
+        const command = new ListSessionsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     listTableMetadata(args, optionsOrCb, cb) {
         const command = new ListTableMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -443,6 +704,20 @@ export class Athena extends AthenaClient {
             return this.send(command, optionsOrCb);
         }
     }
+    startCalculationExecution(args, optionsOrCb, cb) {
+        const command = new StartCalculationExecutionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     startQueryExecution(args, optionsOrCb, cb) {
         const command = new StartQueryExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -457,6 +732,34 @@ export class Athena extends AthenaClient {
             return this.send(command, optionsOrCb);
         }
     }
+    startSession(args, optionsOrCb, cb) {
+        const command = new StartSessionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    stopCalculationExecution(args, optionsOrCb, cb) {
+        const command = new StopCalculationExecutionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     stopQueryExecution(args, optionsOrCb, cb) {
         const command = new StopQueryExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -485,6 +788,20 @@ export class Athena extends AthenaClient {
             return this.send(command, optionsOrCb);
         }
     }
+    terminateSession(args, optionsOrCb, cb) {
+        const command = new TerminateSessionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     untagResource(args, optionsOrCb, cb) {
         const command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -527,6 +844,34 @@ export class Athena extends AthenaClient {
             return this.send(command, optionsOrCb);
         }
     }
+    updateNotebook(args, optionsOrCb, cb) {
+        const command = new UpdateNotebookCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    updateNotebookMetadata(args, optionsOrCb, cb) {
+        const command = new UpdateNotebookMetadataCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     updatePreparedStatement(args, optionsOrCb, cb) {
         const command = new UpdatePreparedStatementCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/CreateNotebookCommand.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 { CreateNotebookInputFilterSensitiveLog, CreateNotebookOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1CreateNotebookCommand, serializeAws_json1_1CreateNotebookCommand, } from "../protocols/Aws_json1_1";
+export class CreateNotebookCommand 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, CreateNotebookCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "CreateNotebookCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateNotebookInputFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateNotebookOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1CreateNotebookCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1CreateNotebookCommand(output, context);
+    }
+}

package/dist-es/commands/CreatePresignedNotebookUrlCommand.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 { CreatePresignedNotebookUrlRequestFilterSensitiveLog, CreatePresignedNotebookUrlResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1CreatePresignedNotebookUrlCommand, serializeAws_json1_1CreatePresignedNotebookUrlCommand, } from "../protocols/Aws_json1_1";
+export class CreatePresignedNotebookUrlCommand 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, CreatePresignedNotebookUrlCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "CreatePresignedNotebookUrlCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreatePresignedNotebookUrlRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreatePresignedNotebookUrlResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1CreatePresignedNotebookUrlCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1CreatePresignedNotebookUrlCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteNotebookCommand.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 { DeleteNotebookInputFilterSensitiveLog, DeleteNotebookOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1DeleteNotebookCommand, serializeAws_json1_1DeleteNotebookCommand, } from "../protocols/Aws_json1_1";
+export class DeleteNotebookCommand 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, DeleteNotebookCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "DeleteNotebookCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteNotebookInputFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteNotebookOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1DeleteNotebookCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1DeleteNotebookCommand(output, context);
+    }
+}

package/dist-es/commands/ExportNotebookCommand.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 { ExportNotebookInputFilterSensitiveLog, ExportNotebookOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1ExportNotebookCommand, serializeAws_json1_1ExportNotebookCommand, } from "../protocols/Aws_json1_1";
+export class ExportNotebookCommand 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, ExportNotebookCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AthenaClient";
+        const commandName = "ExportNotebookCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ExportNotebookInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ExportNotebookOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1ExportNotebookCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1ExportNotebookCommand(output, context);
+    }
+}