@aws-sdk/client-athena 3.1068.0 → 3.1069.0

package/dist-cjs/index.js

@@ -1,18 +1,21 @@
-'use strict';
-
-var client$1 = require('@aws-sdk/core/client');
-var core = require('@smithy/core');
-var client = require('@smithy/core/client');
-var config = require('@smithy/core/config');
-var endpoints = require('@smithy/core/endpoints');
-var protocols = require('@smithy/core/protocols');
-var retry = require('@smithy/core/retry');
-var schema = require('@smithy/core/schema');
-var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
-var runtimeConfig = require('./runtimeConfig');
-var schemas_0 = require('./schemas/schemas_0');
-var errors = require('./models/errors');
-var AthenaServiceException = require('./models/AthenaServiceException');
+var __exportStar = (m, e) => { Object.assign(e, m); };
+const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
+const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
+exports.$Command = Command;
+exports.__Client = Client;
+const { resolveRegionConfig } = require("@smithy/core/config");
+const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveHttpAuthSchemeConfig, defaultAthenaHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { BatchGetNamedQuery$, BatchGetPreparedStatement$, BatchGetQueryExecution$, CancelCapacityReservation$, CreateCapacityReservation$, CreateDataCatalog$, CreateNamedQuery$, CreateNotebook$, CreatePreparedStatement$, CreatePresignedNotebookUrl$, CreateWorkGroup$, DeleteCapacityReservation$, DeleteDataCatalog$, DeleteNamedQuery$, DeleteNotebook$, DeletePreparedStatement$, DeleteWorkGroup$, ExportNotebook$, GetCalculationExecutionCode$, GetCalculationExecution$, GetCalculationExecutionStatus$, GetCapacityAssignmentConfiguration$, GetCapacityReservation$, GetDatabase$, GetDataCatalog$, GetNamedQuery$, GetNotebookMetadata$, GetPreparedStatement$, GetQueryExecution$, GetQueryResults$, GetQueryRuntimeStatistics$, GetResourceDashboard$, GetSession$, GetSessionEndpoint$, GetSessionStatus$, GetTableMetadata$, GetWorkGroup$, ImportNotebook$, ListApplicationDPUSizes$, ListCalculationExecutions$, ListCapacityReservations$, ListDatabases$, ListDataCatalogs$, ListEngineVersions$, ListExecutors$, ListNamedQueries$, ListNotebookMetadata$, ListNotebookSessions$, ListPreparedStatements$, ListQueryExecutions$, ListSessions$, ListTableMetadata$, ListTagsForResource$, ListWorkGroups$, PutCapacityAssignmentConfiguration$, StartCalculationExecution$, StartQueryExecution$, StartSession$, StopCalculationExecution$, StopQueryExecution$, TagResource$, TerminateSession$, UntagResource$, UpdateCapacityReservation$, UpdateDataCatalog$, UpdateNamedQuery$, UpdateNotebook$, UpdateNotebookMetadata$, UpdatePreparedStatement$, UpdateWorkGroup$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { AthenaServiceException } = require("./models/AthenaServiceException");
+exports.AthenaServiceException = AthenaServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -68,915 +71,915 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(client$1.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
     extensions.forEach((extension) => extension.configure(extensionConfiguration));
-    return Object.assign(runtimeConfig, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class AthenaClient extends client.Client {
+class AthenaClient extends Client {
     config;
     constructor(...[configuration]) {
-        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        const _config_0 = getRuntimeConfig(configuration || {});
         super(_config_0);
         this.initConfig = _config_0;
         const _config_1 = resolveClientEndpointParameters(_config_0);
-        const _config_2 = client$1.resolveUserAgentConfig(_config_1);
-        const _config_3 = retry.resolveRetryConfig(_config_2);
-        const _config_4 = config.resolveRegionConfig(_config_3);
-        const _config_5 = client$1.resolveHostHeaderConfig(_config_4);
-        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
-        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_2 = resolveUserAgentConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveRegionConfig(_config_3);
+        const _config_5 = resolveHostHeaderConfig(_config_4);
+        const _config_6 = resolveEndpointConfig(_config_5);
+        const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
-        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
-        this.middlewareStack.use(client$1.getUserAgentPlugin(this.config));
-        this.middlewareStack.use(retry.getRetryPlugin(this.config));
-        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
-        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));
-        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
-            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultAthenaHttpAuthSchemeParametersProvider,
-            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+        this.middlewareStack.use(getSchemaSerdePlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: defaultAthenaHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
                 "aws.auth#sigv4": config.credentials,
             }),
         }));
-        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+        this.middlewareStack.use(getHttpSigningPlugin(this.config));
     }
     destroy() {
         super.destroy();
     }
 }
 
-class BatchGetNamedQueryCommand extends client.Command
+class BatchGetNamedQueryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "BatchGetNamedQuery", {})
     .n("AthenaClient", "BatchGetNamedQueryCommand")
-    .sc(schemas_0.BatchGetNamedQuery$)
+    .sc(BatchGetNamedQuery$)
     .build() {
 }
 
-class BatchGetPreparedStatementCommand extends client.Command
+class BatchGetPreparedStatementCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "BatchGetPreparedStatement", {})
     .n("AthenaClient", "BatchGetPreparedStatementCommand")
-    .sc(schemas_0.BatchGetPreparedStatement$)
+    .sc(BatchGetPreparedStatement$)
     .build() {
 }
 
-class BatchGetQueryExecutionCommand extends client.Command
+class BatchGetQueryExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "BatchGetQueryExecution", {})
     .n("AthenaClient", "BatchGetQueryExecutionCommand")
-    .sc(schemas_0.BatchGetQueryExecution$)
+    .sc(BatchGetQueryExecution$)
     .build() {
 }
 
-class CancelCapacityReservationCommand extends client.Command
+class CancelCapacityReservationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "CancelCapacityReservation", {})
     .n("AthenaClient", "CancelCapacityReservationCommand")
-    .sc(schemas_0.CancelCapacityReservation$)
+    .sc(CancelCapacityReservation$)
     .build() {
 }
 
-class CreateCapacityReservationCommand extends client.Command
+class CreateCapacityReservationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "CreateCapacityReservation", {})
     .n("AthenaClient", "CreateCapacityReservationCommand")
-    .sc(schemas_0.CreateCapacityReservation$)
+    .sc(CreateCapacityReservation$)
     .build() {
 }
 
-class CreateDataCatalogCommand extends client.Command
+class CreateDataCatalogCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "CreateDataCatalog", {})
     .n("AthenaClient", "CreateDataCatalogCommand")
-    .sc(schemas_0.CreateDataCatalog$)
+    .sc(CreateDataCatalog$)
     .build() {
 }
 
-class CreateNamedQueryCommand extends client.Command
+class CreateNamedQueryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "CreateNamedQuery", {})
     .n("AthenaClient", "CreateNamedQueryCommand")
-    .sc(schemas_0.CreateNamedQuery$)
+    .sc(CreateNamedQuery$)
     .build() {
 }
 
-class CreateNotebookCommand extends client.Command
+class CreateNotebookCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "CreateNotebook", {})
     .n("AthenaClient", "CreateNotebookCommand")
-    .sc(schemas_0.CreateNotebook$)
+    .sc(CreateNotebook$)
     .build() {
 }
 
-class CreatePreparedStatementCommand extends client.Command
+class CreatePreparedStatementCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "CreatePreparedStatement", {})
     .n("AthenaClient", "CreatePreparedStatementCommand")
-    .sc(schemas_0.CreatePreparedStatement$)
+    .sc(CreatePreparedStatement$)
     .build() {
 }
 
-class CreatePresignedNotebookUrlCommand extends client.Command
+class CreatePresignedNotebookUrlCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "CreatePresignedNotebookUrl", {})
     .n("AthenaClient", "CreatePresignedNotebookUrlCommand")
-    .sc(schemas_0.CreatePresignedNotebookUrl$)
+    .sc(CreatePresignedNotebookUrl$)
     .build() {
 }
 
-class CreateWorkGroupCommand extends client.Command
+class CreateWorkGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "CreateWorkGroup", {})
     .n("AthenaClient", "CreateWorkGroupCommand")
-    .sc(schemas_0.CreateWorkGroup$)
+    .sc(CreateWorkGroup$)
     .build() {
 }
 
-class DeleteCapacityReservationCommand extends client.Command
+class DeleteCapacityReservationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "DeleteCapacityReservation", {})
     .n("AthenaClient", "DeleteCapacityReservationCommand")
-    .sc(schemas_0.DeleteCapacityReservation$)
+    .sc(DeleteCapacityReservation$)
     .build() {
 }
 
-class DeleteDataCatalogCommand extends client.Command
+class DeleteDataCatalogCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "DeleteDataCatalog", {})
     .n("AthenaClient", "DeleteDataCatalogCommand")
-    .sc(schemas_0.DeleteDataCatalog$)
+    .sc(DeleteDataCatalog$)
     .build() {
 }
 
-class DeleteNamedQueryCommand extends client.Command
+class DeleteNamedQueryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "DeleteNamedQuery", {})
     .n("AthenaClient", "DeleteNamedQueryCommand")
-    .sc(schemas_0.DeleteNamedQuery$)
+    .sc(DeleteNamedQuery$)
     .build() {
 }
 
-class DeleteNotebookCommand extends client.Command
+class DeleteNotebookCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "DeleteNotebook", {})
     .n("AthenaClient", "DeleteNotebookCommand")
-    .sc(schemas_0.DeleteNotebook$)
+    .sc(DeleteNotebook$)
     .build() {
 }
 
-class DeletePreparedStatementCommand extends client.Command
+class DeletePreparedStatementCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "DeletePreparedStatement", {})
     .n("AthenaClient", "DeletePreparedStatementCommand")
-    .sc(schemas_0.DeletePreparedStatement$)
+    .sc(DeletePreparedStatement$)
     .build() {
 }
 
-class DeleteWorkGroupCommand extends client.Command
+class DeleteWorkGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "DeleteWorkGroup", {})
     .n("AthenaClient", "DeleteWorkGroupCommand")
-    .sc(schemas_0.DeleteWorkGroup$)
+    .sc(DeleteWorkGroup$)
     .build() {
 }
 
-class ExportNotebookCommand extends client.Command
+class ExportNotebookCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ExportNotebook", {})
     .n("AthenaClient", "ExportNotebookCommand")
-    .sc(schemas_0.ExportNotebook$)
+    .sc(ExportNotebook$)
     .build() {
 }
 
-class GetCalculationExecutionCodeCommand extends client.Command
+class GetCalculationExecutionCodeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetCalculationExecutionCode", {})
     .n("AthenaClient", "GetCalculationExecutionCodeCommand")
-    .sc(schemas_0.GetCalculationExecutionCode$)
+    .sc(GetCalculationExecutionCode$)
     .build() {
 }
 
-class GetCalculationExecutionCommand extends client.Command
+class GetCalculationExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetCalculationExecution", {})
     .n("AthenaClient", "GetCalculationExecutionCommand")
-    .sc(schemas_0.GetCalculationExecution$)
+    .sc(GetCalculationExecution$)
     .build() {
 }
 
-class GetCalculationExecutionStatusCommand extends client.Command
+class GetCalculationExecutionStatusCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetCalculationExecutionStatus", {})
     .n("AthenaClient", "GetCalculationExecutionStatusCommand")
-    .sc(schemas_0.GetCalculationExecutionStatus$)
+    .sc(GetCalculationExecutionStatus$)
     .build() {
 }
 
-class GetCapacityAssignmentConfigurationCommand extends client.Command
+class GetCapacityAssignmentConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetCapacityAssignmentConfiguration", {})
     .n("AthenaClient", "GetCapacityAssignmentConfigurationCommand")
-    .sc(schemas_0.GetCapacityAssignmentConfiguration$)
+    .sc(GetCapacityAssignmentConfiguration$)
     .build() {
 }
 
-class GetCapacityReservationCommand extends client.Command
+class GetCapacityReservationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetCapacityReservation", {})
     .n("AthenaClient", "GetCapacityReservationCommand")
-    .sc(schemas_0.GetCapacityReservation$)
+    .sc(GetCapacityReservation$)
     .build() {
 }
 
-class GetDatabaseCommand extends client.Command
+class GetDatabaseCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetDatabase", {})
     .n("AthenaClient", "GetDatabaseCommand")
-    .sc(schemas_0.GetDatabase$)
+    .sc(GetDatabase$)
     .build() {
 }
 
-class GetDataCatalogCommand extends client.Command
+class GetDataCatalogCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetDataCatalog", {})
     .n("AthenaClient", "GetDataCatalogCommand")
-    .sc(schemas_0.GetDataCatalog$)
+    .sc(GetDataCatalog$)
     .build() {
 }
 
-class GetNamedQueryCommand extends client.Command
+class GetNamedQueryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetNamedQuery", {})
     .n("AthenaClient", "GetNamedQueryCommand")
-    .sc(schemas_0.GetNamedQuery$)
+    .sc(GetNamedQuery$)
     .build() {
 }
 
-class GetNotebookMetadataCommand extends client.Command
+class GetNotebookMetadataCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetNotebookMetadata", {})
     .n("AthenaClient", "GetNotebookMetadataCommand")
-    .sc(schemas_0.GetNotebookMetadata$)
+    .sc(GetNotebookMetadata$)
     .build() {
 }
 
-class GetPreparedStatementCommand extends client.Command
+class GetPreparedStatementCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetPreparedStatement", {})
     .n("AthenaClient", "GetPreparedStatementCommand")
-    .sc(schemas_0.GetPreparedStatement$)
+    .sc(GetPreparedStatement$)
     .build() {
 }
 
-class GetQueryExecutionCommand extends client.Command
+class GetQueryExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetQueryExecution", {})
     .n("AthenaClient", "GetQueryExecutionCommand")
-    .sc(schemas_0.GetQueryExecution$)
+    .sc(GetQueryExecution$)
     .build() {
 }
 
-class GetQueryResultsCommand extends client.Command
+class GetQueryResultsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetQueryResults", {})
     .n("AthenaClient", "GetQueryResultsCommand")
-    .sc(schemas_0.GetQueryResults$)
+    .sc(GetQueryResults$)
     .build() {
 }
 
-class GetQueryRuntimeStatisticsCommand extends client.Command
+class GetQueryRuntimeStatisticsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetQueryRuntimeStatistics", {})
     .n("AthenaClient", "GetQueryRuntimeStatisticsCommand")
-    .sc(schemas_0.GetQueryRuntimeStatistics$)
+    .sc(GetQueryRuntimeStatistics$)
     .build() {
 }
 
-class GetResourceDashboardCommand extends client.Command
+class GetResourceDashboardCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetResourceDashboard", {})
     .n("AthenaClient", "GetResourceDashboardCommand")
-    .sc(schemas_0.GetResourceDashboard$)
+    .sc(GetResourceDashboard$)
     .build() {
 }
 
-class GetSessionCommand extends client.Command
+class GetSessionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetSession", {})
     .n("AthenaClient", "GetSessionCommand")
-    .sc(schemas_0.GetSession$)
+    .sc(GetSession$)
     .build() {
 }
 
-class GetSessionEndpointCommand extends client.Command
+class GetSessionEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetSessionEndpoint", {})
     .n("AthenaClient", "GetSessionEndpointCommand")
-    .sc(schemas_0.GetSessionEndpoint$)
+    .sc(GetSessionEndpoint$)
     .build() {
 }
 
-class GetSessionStatusCommand extends client.Command
+class GetSessionStatusCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetSessionStatus", {})
     .n("AthenaClient", "GetSessionStatusCommand")
-    .sc(schemas_0.GetSessionStatus$)
+    .sc(GetSessionStatus$)
     .build() {
 }
 
-class GetTableMetadataCommand extends client.Command
+class GetTableMetadataCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetTableMetadata", {})
     .n("AthenaClient", "GetTableMetadataCommand")
-    .sc(schemas_0.GetTableMetadata$)
+    .sc(GetTableMetadata$)
     .build() {
 }
 
-class GetWorkGroupCommand extends client.Command
+class GetWorkGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "GetWorkGroup", {})
     .n("AthenaClient", "GetWorkGroupCommand")
-    .sc(schemas_0.GetWorkGroup$)
+    .sc(GetWorkGroup$)
     .build() {
 }
 
-class ImportNotebookCommand extends client.Command
+class ImportNotebookCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ImportNotebook", {})
     .n("AthenaClient", "ImportNotebookCommand")
-    .sc(schemas_0.ImportNotebook$)
+    .sc(ImportNotebook$)
     .build() {
 }
 
-class ListApplicationDPUSizesCommand extends client.Command
+class ListApplicationDPUSizesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListApplicationDPUSizes", {})
     .n("AthenaClient", "ListApplicationDPUSizesCommand")
-    .sc(schemas_0.ListApplicationDPUSizes$)
+    .sc(ListApplicationDPUSizes$)
     .build() {
 }
 
-class ListCalculationExecutionsCommand extends client.Command
+class ListCalculationExecutionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListCalculationExecutions", {})
     .n("AthenaClient", "ListCalculationExecutionsCommand")
-    .sc(schemas_0.ListCalculationExecutions$)
+    .sc(ListCalculationExecutions$)
     .build() {
 }
 
-class ListCapacityReservationsCommand extends client.Command
+class ListCapacityReservationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListCapacityReservations", {})
     .n("AthenaClient", "ListCapacityReservationsCommand")
-    .sc(schemas_0.ListCapacityReservations$)
+    .sc(ListCapacityReservations$)
     .build() {
 }
 
-class ListDatabasesCommand extends client.Command
+class ListDatabasesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListDatabases", {})
     .n("AthenaClient", "ListDatabasesCommand")
-    .sc(schemas_0.ListDatabases$)
+    .sc(ListDatabases$)
     .build() {
 }
 
-class ListDataCatalogsCommand extends client.Command
+class ListDataCatalogsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListDataCatalogs", {})
     .n("AthenaClient", "ListDataCatalogsCommand")
-    .sc(schemas_0.ListDataCatalogs$)
+    .sc(ListDataCatalogs$)
     .build() {
 }
 
-class ListEngineVersionsCommand extends client.Command
+class ListEngineVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListEngineVersions", {})
     .n("AthenaClient", "ListEngineVersionsCommand")
-    .sc(schemas_0.ListEngineVersions$)
+    .sc(ListEngineVersions$)
     .build() {
 }
 
-class ListExecutorsCommand extends client.Command
+class ListExecutorsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListExecutors", {})
     .n("AthenaClient", "ListExecutorsCommand")
-    .sc(schemas_0.ListExecutors$)
+    .sc(ListExecutors$)
     .build() {
 }
 
-class ListNamedQueriesCommand extends client.Command
+class ListNamedQueriesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListNamedQueries", {})
     .n("AthenaClient", "ListNamedQueriesCommand")
-    .sc(schemas_0.ListNamedQueries$)
+    .sc(ListNamedQueries$)
     .build() {
 }
 
-class ListNotebookMetadataCommand extends client.Command
+class ListNotebookMetadataCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListNotebookMetadata", {})
     .n("AthenaClient", "ListNotebookMetadataCommand")
-    .sc(schemas_0.ListNotebookMetadata$)
+    .sc(ListNotebookMetadata$)
     .build() {
 }
 
-class ListNotebookSessionsCommand extends client.Command
+class ListNotebookSessionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListNotebookSessions", {})
     .n("AthenaClient", "ListNotebookSessionsCommand")
-    .sc(schemas_0.ListNotebookSessions$)
+    .sc(ListNotebookSessions$)
     .build() {
 }
 
-class ListPreparedStatementsCommand extends client.Command
+class ListPreparedStatementsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListPreparedStatements", {})
     .n("AthenaClient", "ListPreparedStatementsCommand")
-    .sc(schemas_0.ListPreparedStatements$)
+    .sc(ListPreparedStatements$)
     .build() {
 }
 
-class ListQueryExecutionsCommand extends client.Command
+class ListQueryExecutionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListQueryExecutions", {})
     .n("AthenaClient", "ListQueryExecutionsCommand")
-    .sc(schemas_0.ListQueryExecutions$)
+    .sc(ListQueryExecutions$)
     .build() {
 }
 
-class ListSessionsCommand extends client.Command
+class ListSessionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListSessions", {})
     .n("AthenaClient", "ListSessionsCommand")
-    .sc(schemas_0.ListSessions$)
+    .sc(ListSessions$)
     .build() {
 }
 
-class ListTableMetadataCommand extends client.Command
+class ListTableMetadataCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListTableMetadata", {})
     .n("AthenaClient", "ListTableMetadataCommand")
-    .sc(schemas_0.ListTableMetadata$)
+    .sc(ListTableMetadata$)
     .build() {
 }
 
-class ListTagsForResourceCommand extends client.Command
+class ListTagsForResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListTagsForResource", {})
     .n("AthenaClient", "ListTagsForResourceCommand")
-    .sc(schemas_0.ListTagsForResource$)
+    .sc(ListTagsForResource$)
     .build() {
 }
 
-class ListWorkGroupsCommand extends client.Command
+class ListWorkGroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "ListWorkGroups", {})
     .n("AthenaClient", "ListWorkGroupsCommand")
-    .sc(schemas_0.ListWorkGroups$)
+    .sc(ListWorkGroups$)
     .build() {
 }
 
-class PutCapacityAssignmentConfigurationCommand extends client.Command
+class PutCapacityAssignmentConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "PutCapacityAssignmentConfiguration", {})
     .n("AthenaClient", "PutCapacityAssignmentConfigurationCommand")
-    .sc(schemas_0.PutCapacityAssignmentConfiguration$)
+    .sc(PutCapacityAssignmentConfiguration$)
     .build() {
 }
 
-class StartCalculationExecutionCommand extends client.Command
+class StartCalculationExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "StartCalculationExecution", {})
     .n("AthenaClient", "StartCalculationExecutionCommand")
-    .sc(schemas_0.StartCalculationExecution$)
+    .sc(StartCalculationExecution$)
     .build() {
 }
 
-class StartQueryExecutionCommand extends client.Command
+class StartQueryExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "StartQueryExecution", {})
     .n("AthenaClient", "StartQueryExecutionCommand")
-    .sc(schemas_0.StartQueryExecution$)
+    .sc(StartQueryExecution$)
     .build() {
 }
 
-class StartSessionCommand extends client.Command
+class StartSessionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "StartSession", {})
     .n("AthenaClient", "StartSessionCommand")
-    .sc(schemas_0.StartSession$)
+    .sc(StartSession$)
     .build() {
 }
 
-class StopCalculationExecutionCommand extends client.Command
+class StopCalculationExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "StopCalculationExecution", {})
     .n("AthenaClient", "StopCalculationExecutionCommand")
-    .sc(schemas_0.StopCalculationExecution$)
+    .sc(StopCalculationExecution$)
     .build() {
 }
 
-class StopQueryExecutionCommand extends client.Command
+class StopQueryExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "StopQueryExecution", {})
     .n("AthenaClient", "StopQueryExecutionCommand")
-    .sc(schemas_0.StopQueryExecution$)
+    .sc(StopQueryExecution$)
     .build() {
 }
 
-class TagResourceCommand extends client.Command
+class TagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "TagResource", {})
     .n("AthenaClient", "TagResourceCommand")
-    .sc(schemas_0.TagResource$)
+    .sc(TagResource$)
     .build() {
 }
 
-class TerminateSessionCommand extends client.Command
+class TerminateSessionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "TerminateSession", {})
     .n("AthenaClient", "TerminateSessionCommand")
-    .sc(schemas_0.TerminateSession$)
+    .sc(TerminateSession$)
     .build() {
 }
 
-class UntagResourceCommand extends client.Command
+class UntagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "UntagResource", {})
     .n("AthenaClient", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
+    .sc(UntagResource$)
     .build() {
 }
 
-class UpdateCapacityReservationCommand extends client.Command
+class UpdateCapacityReservationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "UpdateCapacityReservation", {})
     .n("AthenaClient", "UpdateCapacityReservationCommand")
-    .sc(schemas_0.UpdateCapacityReservation$)
+    .sc(UpdateCapacityReservation$)
     .build() {
 }
 
-class UpdateDataCatalogCommand extends client.Command
+class UpdateDataCatalogCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "UpdateDataCatalog", {})
     .n("AthenaClient", "UpdateDataCatalogCommand")
-    .sc(schemas_0.UpdateDataCatalog$)
+    .sc(UpdateDataCatalog$)
     .build() {
 }
 
-class UpdateNamedQueryCommand extends client.Command
+class UpdateNamedQueryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "UpdateNamedQuery", {})
     .n("AthenaClient", "UpdateNamedQueryCommand")
-    .sc(schemas_0.UpdateNamedQuery$)
+    .sc(UpdateNamedQuery$)
     .build() {
 }
 
-class UpdateNotebookCommand extends client.Command
+class UpdateNotebookCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "UpdateNotebook", {})
     .n("AthenaClient", "UpdateNotebookCommand")
-    .sc(schemas_0.UpdateNotebook$)
+    .sc(UpdateNotebook$)
     .build() {
 }
 
-class UpdateNotebookMetadataCommand extends client.Command
+class UpdateNotebookMetadataCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "UpdateNotebookMetadata", {})
     .n("AthenaClient", "UpdateNotebookMetadataCommand")
-    .sc(schemas_0.UpdateNotebookMetadata$)
+    .sc(UpdateNotebookMetadata$)
     .build() {
 }
 
-class UpdatePreparedStatementCommand extends client.Command
+class UpdatePreparedStatementCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "UpdatePreparedStatement", {})
     .n("AthenaClient", "UpdatePreparedStatementCommand")
-    .sc(schemas_0.UpdatePreparedStatement$)
+    .sc(UpdatePreparedStatement$)
     .build() {
 }
 
-class UpdateWorkGroupCommand extends client.Command
+class UpdateWorkGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonAthena", "UpdateWorkGroup", {})
     .n("AthenaClient", "UpdateWorkGroupCommand")
-    .sc(schemas_0.UpdateWorkGroup$)
+    .sc(UpdateWorkGroup$)
     .build() {
 }
 
-const paginateGetQueryResults = core.createPaginator(AthenaClient, GetQueryResultsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateGetQueryResults = createPaginator(AthenaClient, GetQueryResultsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListApplicationDPUSizes = core.createPaginator(AthenaClient, ListApplicationDPUSizesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListApplicationDPUSizes = createPaginator(AthenaClient, ListApplicationDPUSizesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListCalculationExecutions = core.createPaginator(AthenaClient, ListCalculationExecutionsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListCalculationExecutions = createPaginator(AthenaClient, ListCalculationExecutionsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListCapacityReservations = core.createPaginator(AthenaClient, ListCapacityReservationsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListCapacityReservations = createPaginator(AthenaClient, ListCapacityReservationsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListDatabases = core.createPaginator(AthenaClient, ListDatabasesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListDatabases = createPaginator(AthenaClient, ListDatabasesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListDataCatalogs = core.createPaginator(AthenaClient, ListDataCatalogsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListDataCatalogs = createPaginator(AthenaClient, ListDataCatalogsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListEngineVersions = core.createPaginator(AthenaClient, ListEngineVersionsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListEngineVersions = createPaginator(AthenaClient, ListEngineVersionsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListExecutors = core.createPaginator(AthenaClient, ListExecutorsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListExecutors = createPaginator(AthenaClient, ListExecutorsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListNamedQueries = core.createPaginator(AthenaClient, ListNamedQueriesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListNamedQueries = createPaginator(AthenaClient, ListNamedQueriesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListPreparedStatements = core.createPaginator(AthenaClient, ListPreparedStatementsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListPreparedStatements = createPaginator(AthenaClient, ListPreparedStatementsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListQueryExecutions = core.createPaginator(AthenaClient, ListQueryExecutionsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListQueryExecutions = createPaginator(AthenaClient, ListQueryExecutionsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListSessions = core.createPaginator(AthenaClient, ListSessionsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListSessions = createPaginator(AthenaClient, ListSessionsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListTableMetadata = core.createPaginator(AthenaClient, ListTableMetadataCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListTableMetadata = createPaginator(AthenaClient, ListTableMetadataCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListTagsForResource = core.createPaginator(AthenaClient, ListTagsForResourceCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListTagsForResource = createPaginator(AthenaClient, ListTagsForResourceCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListWorkGroups = core.createPaginator(AthenaClient, ListWorkGroupsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListWorkGroups = createPaginator(AthenaClient, ListWorkGroupsCommand, "NextToken", "NextToken", "MaxResults");
 
 const commands = {
     BatchGetNamedQueryCommand,
@@ -1069,7 +1072,7 @@ const paginators = {
 };
 class Athena extends AthenaClient {
 }
-client.createAggregatedClient(commands, Athena, { paginators });
+createAggregatedClient(commands, Athena, { paginators });
 
 const S3AclOption = {
     BUCKET_OWNER_FULL_CONTROL: "BUCKET_OWNER_FULL_CONTROL",
@@ -1199,9 +1202,6 @@ const ExecutorType = {
     WORKER: "WORKER",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.AthenaServiceException = AthenaServiceException.AthenaServiceException;
 exports.Athena = Athena;
 exports.AthenaClient = AthenaClient;
 exports.AuthenticationType = AuthenticationType;
@@ -1308,23 +1308,3 @@ exports.paginateListSessions = paginateListSessions;
 exports.paginateListTableMetadata = paginateListTableMetadata;
 exports.paginateListTagsForResource = paginateListTagsForResource;
 exports.paginateListWorkGroups = paginateListWorkGroups;
-Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: schemas_0['__proto__']
-    });
-
-Object.keys(schemas_0).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
-});
-Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: errors['__proto__']
-    });
-
-Object.keys(errors).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
-});