@aws-sdk/client-athena 3.186.0 → 3.190.0

package/dist-es/Athena.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { AthenaClient } from "./AthenaClient";
 import { BatchGetNamedQueryCommand, } from "./commands/BatchGetNamedQueryCommand";
 import { BatchGetPreparedStatementCommand, } from "./commands/BatchGetPreparedStatementCommand";
@@ -37,529 +36,523 @@ import { UpdateDataCatalogCommand, } from "./commands/UpdateDataCatalogCommand";
 import { UpdateNamedQueryCommand, } from "./commands/UpdateNamedQueryCommand";
 import { UpdatePreparedStatementCommand, } from "./commands/UpdatePreparedStatementCommand";
 import { UpdateWorkGroupCommand, } from "./commands/UpdateWorkGroupCommand";
-var Athena = (function (_super) {
-    __extends(Athena, _super);
-    function Athena() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Athena.prototype.batchGetNamedQuery = function (args, optionsOrCb, cb) {
-        var command = new BatchGetNamedQueryCommand(args);
+export class Athena extends AthenaClient {
+    batchGetNamedQuery(args, optionsOrCb, cb) {
+        const command = new BatchGetNamedQueryCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.batchGetPreparedStatement = function (args, optionsOrCb, cb) {
-        var command = new BatchGetPreparedStatementCommand(args);
+    }
+    batchGetPreparedStatement(args, optionsOrCb, cb) {
+        const command = new BatchGetPreparedStatementCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.batchGetQueryExecution = function (args, optionsOrCb, cb) {
-        var command = new BatchGetQueryExecutionCommand(args);
+    }
+    batchGetQueryExecution(args, optionsOrCb, cb) {
+        const command = new BatchGetQueryExecutionCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.createDataCatalog = function (args, optionsOrCb, cb) {
-        var command = new CreateDataCatalogCommand(args);
+    }
+    createDataCatalog(args, optionsOrCb, cb) {
+        const command = new CreateDataCatalogCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.createNamedQuery = function (args, optionsOrCb, cb) {
-        var command = new CreateNamedQueryCommand(args);
+    }
+    createNamedQuery(args, optionsOrCb, cb) {
+        const command = new CreateNamedQueryCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.createPreparedStatement = function (args, optionsOrCb, cb) {
-        var command = new CreatePreparedStatementCommand(args);
+    }
+    createPreparedStatement(args, optionsOrCb, cb) {
+        const command = new CreatePreparedStatementCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.createWorkGroup = function (args, optionsOrCb, cb) {
-        var command = new CreateWorkGroupCommand(args);
+    }
+    createWorkGroup(args, optionsOrCb, cb) {
+        const command = new CreateWorkGroupCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.deleteDataCatalog = function (args, optionsOrCb, cb) {
-        var command = new DeleteDataCatalogCommand(args);
+    }
+    deleteDataCatalog(args, optionsOrCb, cb) {
+        const command = new DeleteDataCatalogCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.deleteNamedQuery = function (args, optionsOrCb, cb) {
-        var command = new DeleteNamedQueryCommand(args);
+    }
+    deleteNamedQuery(args, optionsOrCb, cb) {
+        const command = new DeleteNamedQueryCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.deletePreparedStatement = function (args, optionsOrCb, cb) {
-        var command = new DeletePreparedStatementCommand(args);
+    }
+    deletePreparedStatement(args, optionsOrCb, cb) {
+        const command = new DeletePreparedStatementCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.deleteWorkGroup = function (args, optionsOrCb, cb) {
-        var command = new DeleteWorkGroupCommand(args);
+    }
+    deleteWorkGroup(args, optionsOrCb, cb) {
+        const command = new DeleteWorkGroupCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.getDatabase = function (args, optionsOrCb, cb) {
-        var command = new GetDatabaseCommand(args);
+    }
+    getDatabase(args, optionsOrCb, cb) {
+        const command = new GetDatabaseCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.getDataCatalog = function (args, optionsOrCb, cb) {
-        var command = new GetDataCatalogCommand(args);
+    }
+    getDataCatalog(args, optionsOrCb, cb) {
+        const command = new GetDataCatalogCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.getNamedQuery = function (args, optionsOrCb, cb) {
-        var command = new GetNamedQueryCommand(args);
+    }
+    getNamedQuery(args, optionsOrCb, cb) {
+        const command = new GetNamedQueryCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.getPreparedStatement = function (args, optionsOrCb, cb) {
-        var command = new GetPreparedStatementCommand(args);
+    }
+    getPreparedStatement(args, optionsOrCb, cb) {
+        const command = new GetPreparedStatementCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.getQueryExecution = function (args, optionsOrCb, cb) {
-        var command = new GetQueryExecutionCommand(args);
+    }
+    getQueryExecution(args, optionsOrCb, cb) {
+        const command = new GetQueryExecutionCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.getQueryResults = function (args, optionsOrCb, cb) {
-        var command = new GetQueryResultsCommand(args);
+    }
+    getQueryResults(args, optionsOrCb, cb) {
+        const command = new GetQueryResultsCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.getQueryRuntimeStatistics = function (args, optionsOrCb, cb) {
-        var command = new GetQueryRuntimeStatisticsCommand(args);
+    }
+    getQueryRuntimeStatistics(args, optionsOrCb, cb) {
+        const command = new GetQueryRuntimeStatisticsCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.getTableMetadata = function (args, optionsOrCb, cb) {
-        var command = new GetTableMetadataCommand(args);
+    }
+    getTableMetadata(args, optionsOrCb, cb) {
+        const command = new GetTableMetadataCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.getWorkGroup = function (args, optionsOrCb, cb) {
-        var command = new GetWorkGroupCommand(args);
+    }
+    getWorkGroup(args, optionsOrCb, cb) {
+        const command = new GetWorkGroupCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.listDatabases = function (args, optionsOrCb, cb) {
-        var command = new ListDatabasesCommand(args);
+    }
+    listDatabases(args, optionsOrCb, cb) {
+        const command = new ListDatabasesCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.listDataCatalogs = function (args, optionsOrCb, cb) {
-        var command = new ListDataCatalogsCommand(args);
+    }
+    listDataCatalogs(args, optionsOrCb, cb) {
+        const command = new ListDataCatalogsCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.listEngineVersions = function (args, optionsOrCb, cb) {
-        var command = new ListEngineVersionsCommand(args);
+    }
+    listEngineVersions(args, optionsOrCb, cb) {
+        const command = new ListEngineVersionsCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.listNamedQueries = function (args, optionsOrCb, cb) {
-        var command = new ListNamedQueriesCommand(args);
+    }
+    listNamedQueries(args, optionsOrCb, cb) {
+        const command = new ListNamedQueriesCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.listPreparedStatements = function (args, optionsOrCb, cb) {
-        var command = new ListPreparedStatementsCommand(args);
+    }
+    listPreparedStatements(args, optionsOrCb, cb) {
+        const command = new ListPreparedStatementsCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.listQueryExecutions = function (args, optionsOrCb, cb) {
-        var command = new ListQueryExecutionsCommand(args);
+    }
+    listQueryExecutions(args, optionsOrCb, cb) {
+        const command = new ListQueryExecutionsCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.listTableMetadata = function (args, optionsOrCb, cb) {
-        var command = new ListTableMetadataCommand(args);
+    }
+    listTableMetadata(args, optionsOrCb, cb) {
+        const command = new ListTableMetadataCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
-        var command = new ListTagsForResourceCommand(args);
+    }
+    listTagsForResource(args, optionsOrCb, cb) {
+        const command = new ListTagsForResourceCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.listWorkGroups = function (args, optionsOrCb, cb) {
-        var command = new ListWorkGroupsCommand(args);
+    }
+    listWorkGroups(args, optionsOrCb, cb) {
+        const command = new ListWorkGroupsCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.startQueryExecution = function (args, optionsOrCb, cb) {
-        var command = new StartQueryExecutionCommand(args);
+    }
+    startQueryExecution(args, optionsOrCb, cb) {
+        const command = new StartQueryExecutionCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.stopQueryExecution = function (args, optionsOrCb, cb) {
-        var command = new StopQueryExecutionCommand(args);
+    }
+    stopQueryExecution(args, optionsOrCb, cb) {
+        const command = new StopQueryExecutionCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.tagResource = function (args, optionsOrCb, cb) {
-        var command = new TagResourceCommand(args);
+    }
+    tagResource(args, optionsOrCb, cb) {
+        const command = new TagResourceCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.untagResource = function (args, optionsOrCb, cb) {
-        var command = new UntagResourceCommand(args);
+    }
+    untagResource(args, optionsOrCb, cb) {
+        const command = new UntagResourceCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.updateDataCatalog = function (args, optionsOrCb, cb) {
-        var command = new UpdateDataCatalogCommand(args);
+    }
+    updateDataCatalog(args, optionsOrCb, cb) {
+        const command = new UpdateDataCatalogCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.updateNamedQuery = function (args, optionsOrCb, cb) {
-        var command = new UpdateNamedQueryCommand(args);
+    }
+    updateNamedQuery(args, optionsOrCb, cb) {
+        const command = new UpdateNamedQueryCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.updatePreparedStatement = function (args, optionsOrCb, cb) {
-        var command = new UpdatePreparedStatementCommand(args);
+    }
+    updatePreparedStatement(args, optionsOrCb, cb) {
+        const command = new UpdatePreparedStatementCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    Athena.prototype.updateWorkGroup = function (args, optionsOrCb, cb) {
-        var command = new UpdateWorkGroupCommand(args);
+    }
+    updateWorkGroup(args, optionsOrCb, cb) {
+        const command = new UpdateWorkGroupCommand(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 ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    return Athena;
-}(AthenaClient));
-export { Athena };
+    }
+}