@aws-sdk/client-athena 3.477.0 → 3.481.0

package/dist-es/pagination/ListCapacityReservationsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { AthenaClient } from "../AthenaClient";
 import { ListCapacityReservationsCommand, } from "../commands/ListCapacityReservationsCommand";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListCapacityReservationsCommand(input), ...args);
-};
-export async function* paginateListCapacityReservations(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof AthenaClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Athena | AthenaClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListCapacityReservations = createPaginator(AthenaClient, ListCapacityReservationsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListDataCatalogsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { AthenaClient } from "../AthenaClient";
 import { ListDataCatalogsCommand, } from "../commands/ListDataCatalogsCommand";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListDataCatalogsCommand(input), ...args);
-};
-export async function* paginateListDataCatalogs(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof AthenaClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Athena | AthenaClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListDataCatalogs = createPaginator(AthenaClient, ListDataCatalogsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListDatabasesPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { AthenaClient } from "../AthenaClient";
 import { ListDatabasesCommand, } from "../commands/ListDatabasesCommand";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListDatabasesCommand(input), ...args);
-};
-export async function* paginateListDatabases(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof AthenaClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Athena | AthenaClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListDatabases = createPaginator(AthenaClient, ListDatabasesCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListEngineVersionsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { AthenaClient } from "../AthenaClient";
 import { ListEngineVersionsCommand, } from "../commands/ListEngineVersionsCommand";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListEngineVersionsCommand(input), ...args);
-};
-export async function* paginateListEngineVersions(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof AthenaClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Athena | AthenaClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListEngineVersions = createPaginator(AthenaClient, ListEngineVersionsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListExecutorsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { AthenaClient } from "../AthenaClient";
 import { ListExecutorsCommand, } from "../commands/ListExecutorsCommand";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListExecutorsCommand(input), ...args);
-};
-export async function* paginateListExecutors(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof AthenaClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Athena | AthenaClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListExecutors = createPaginator(AthenaClient, ListExecutorsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListNamedQueriesPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { AthenaClient } from "../AthenaClient";
 import { ListNamedQueriesCommand, } from "../commands/ListNamedQueriesCommand";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListNamedQueriesCommand(input), ...args);
-};
-export async function* paginateListNamedQueries(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof AthenaClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Athena | AthenaClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListNamedQueries = createPaginator(AthenaClient, ListNamedQueriesCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListPreparedStatementsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { AthenaClient } from "../AthenaClient";
 import { ListPreparedStatementsCommand, } from "../commands/ListPreparedStatementsCommand";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListPreparedStatementsCommand(input), ...args);
-};
-export async function* paginateListPreparedStatements(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof AthenaClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Athena | AthenaClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListPreparedStatements = createPaginator(AthenaClient, ListPreparedStatementsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListQueryExecutionsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { AthenaClient } from "../AthenaClient";
 import { ListQueryExecutionsCommand, } from "../commands/ListQueryExecutionsCommand";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListQueryExecutionsCommand(input), ...args);
-};
-export async function* paginateListQueryExecutions(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof AthenaClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Athena | AthenaClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListQueryExecutions = createPaginator(AthenaClient, ListQueryExecutionsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListSessionsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { AthenaClient } from "../AthenaClient";
 import { ListSessionsCommand, } from "../commands/ListSessionsCommand";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListSessionsCommand(input), ...args);
-};
-export async function* paginateListSessions(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof AthenaClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Athena | AthenaClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListSessions = createPaginator(AthenaClient, ListSessionsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListTableMetadataPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { AthenaClient } from "../AthenaClient";
 import { ListTableMetadataCommand, } from "../commands/ListTableMetadataCommand";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListTableMetadataCommand(input), ...args);
-};
-export async function* paginateListTableMetadata(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof AthenaClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Athena | AthenaClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListTableMetadata = createPaginator(AthenaClient, ListTableMetadataCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListTagsForResourcePaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { AthenaClient } from "../AthenaClient";
 import { ListTagsForResourceCommand, } from "../commands/ListTagsForResourceCommand";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListTagsForResourceCommand(input), ...args);
-};
-export async function* paginateListTagsForResource(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof AthenaClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Athena | AthenaClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListTagsForResource = createPaginator(AthenaClient, ListTagsForResourceCommand, "NextToken", "NextToken", "MaxResults");

package/dist-es/pagination/ListWorkGroupsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { AthenaClient } from "../AthenaClient";
 import { ListWorkGroupsCommand, } from "../commands/ListWorkGroupsCommand";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListWorkGroupsCommand(input), ...args);
-};
-export async function* paginateListWorkGroups(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof AthenaClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Athena | AthenaClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListWorkGroups = createPaginator(AthenaClient, ListWorkGroupsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-types/commands/BatchGetNamedQueryCommand.d.ts

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { BatchGetNamedQueryInput, BatchGetNamedQueryOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface BatchGetNamedQueryCommandInput extends BatchGetNamedQueryInput
  */
 export interface BatchGetNamedQueryCommandOutput extends BatchGetNamedQueryOutput, __MetadataBearer {
 }
+declare const BatchGetNamedQueryCommand_base: {
+    new (input: BatchGetNamedQueryCommandInput): import("@smithy/smithy-client").CommandImpl<BatchGetNamedQueryCommandInput, BatchGetNamedQueryCommandOutput, AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Returns the details of a single named query or a list of up to 50 queries, which you
@@ -85,23 +88,5 @@ export interface BatchGetNamedQueryCommandOutput extends BatchGetNamedQueryOutpu
  * <p>Base exception class for all service exceptions from Athena service.</p>
  *
  */
-export declare class BatchGetNamedQueryCommand extends $Command<BatchGetNamedQueryCommandInput, BatchGetNamedQueryCommandOutput, AthenaClientResolvedConfig> {
-    readonly input: BatchGetNamedQueryCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: BatchGetNamedQueryCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchGetNamedQueryCommandInput, BatchGetNamedQueryCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class BatchGetNamedQueryCommand extends BatchGetNamedQueryCommand_base {
 }

package/dist-types/commands/BatchGetPreparedStatementCommand.d.ts

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { BatchGetPreparedStatementInput, BatchGetPreparedStatementOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface BatchGetPreparedStatementCommandInput extends BatchGetPreparedS
  */
 export interface BatchGetPreparedStatementCommandOutput extends BatchGetPreparedStatementOutput, __MetadataBearer {
 }
+declare const BatchGetPreparedStatementCommand_base: {
+    new (input: BatchGetPreparedStatementCommandInput): import("@smithy/smithy-client").CommandImpl<BatchGetPreparedStatementCommandInput, BatchGetPreparedStatementCommandOutput, AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Returns the details of a single prepared statement or a list of up to 256 prepared
@@ -81,23 +84,5 @@ export interface BatchGetPreparedStatementCommandOutput extends BatchGetPrepared
  * <p>Base exception class for all service exceptions from Athena service.</p>
  *
  */
-export declare class BatchGetPreparedStatementCommand extends $Command<BatchGetPreparedStatementCommandInput, BatchGetPreparedStatementCommandOutput, AthenaClientResolvedConfig> {
-    readonly input: BatchGetPreparedStatementCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: BatchGetPreparedStatementCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchGetPreparedStatementCommandInput, BatchGetPreparedStatementCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class BatchGetPreparedStatementCommand extends BatchGetPreparedStatementCommand_base {
 }

package/dist-types/commands/BatchGetQueryExecutionCommand.d.ts

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { BatchGetQueryExecutionInput, BatchGetQueryExecutionOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface BatchGetQueryExecutionCommandInput extends BatchGetQueryExecuti
  */
 export interface BatchGetQueryExecutionCommandOutput extends BatchGetQueryExecutionOutput, __MetadataBearer {
 }
+declare const BatchGetQueryExecutionCommand_base: {
+    new (input: BatchGetQueryExecutionCommandInput): import("@smithy/smithy-client").CommandImpl<BatchGetQueryExecutionCommandInput, BatchGetQueryExecutionCommandOutput, AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Returns the details of a single query execution or a list of up to 50 query
@@ -139,23 +142,5 @@ export interface BatchGetQueryExecutionCommandOutput extends BatchGetQueryExecut
  * <p>Base exception class for all service exceptions from Athena service.</p>
  *
  */
-export declare class BatchGetQueryExecutionCommand extends $Command<BatchGetQueryExecutionCommandInput, BatchGetQueryExecutionCommandOutput, AthenaClientResolvedConfig> {
-    readonly input: BatchGetQueryExecutionCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: BatchGetQueryExecutionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchGetQueryExecutionCommandInput, BatchGetQueryExecutionCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class BatchGetQueryExecutionCommand extends BatchGetQueryExecutionCommand_base {
 }

package/dist-types/commands/CancelCapacityReservationCommand.d.ts

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { CancelCapacityReservationInput, CancelCapacityReservationOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface CancelCapacityReservationCommandInput extends CancelCapacityRes
  */
 export interface CancelCapacityReservationCommandOutput extends CancelCapacityReservationOutput, __MetadataBearer {
 }
+declare const CancelCapacityReservationCommand_base: {
+    new (input: CancelCapacityReservationCommandInput): import("@smithy/smithy-client").CommandImpl<CancelCapacityReservationCommandInput, CancelCapacityReservationCommandOutput, AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Cancels the capacity reservation with the specified name. Cancelled reservations
@@ -60,23 +63,5 @@ export interface CancelCapacityReservationCommandOutput extends CancelCapacityRe
  * <p>Base exception class for all service exceptions from Athena service.</p>
  *
  */
-export declare class CancelCapacityReservationCommand extends $Command<CancelCapacityReservationCommandInput, CancelCapacityReservationCommandOutput, AthenaClientResolvedConfig> {
-    readonly input: CancelCapacityReservationCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CancelCapacityReservationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelCapacityReservationCommandInput, CancelCapacityReservationCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class CancelCapacityReservationCommand extends CancelCapacityReservationCommand_base {
 }

package/dist-types/commands/CreateCapacityReservationCommand.d.ts

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { CreateCapacityReservationInput, CreateCapacityReservationOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface CreateCapacityReservationCommandInput extends CreateCapacityRes
  */
 export interface CreateCapacityReservationCommandOutput extends CreateCapacityReservationOutput, __MetadataBearer {
 }
+declare const CreateCapacityReservationCommand_base: {
+    new (input: CreateCapacityReservationCommandInput): import("@smithy/smithy-client").CommandImpl<CreateCapacityReservationCommandInput, CreateCapacityReservationCommandOutput, AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Creates a capacity reservation with the specified name and number of requested data
@@ -65,23 +68,5 @@ export interface CreateCapacityReservationCommandOutput extends CreateCapacityRe
  * <p>Base exception class for all service exceptions from Athena service.</p>
  *
  */
-export declare class CreateCapacityReservationCommand extends $Command<CreateCapacityReservationCommandInput, CreateCapacityReservationCommandOutput, AthenaClientResolvedConfig> {
-    readonly input: CreateCapacityReservationCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateCapacityReservationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCapacityReservationCommandInput, CreateCapacityReservationCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class CreateCapacityReservationCommand extends CreateCapacityReservationCommand_base {
 }

package/dist-types/commands/CreateDataCatalogCommand.d.ts

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { CreateDataCatalogInput, CreateDataCatalogOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface CreateDataCatalogCommandInput extends CreateDataCatalogInput {
  */
 export interface CreateDataCatalogCommandOutput extends CreateDataCatalogOutput, __MetadataBearer {
 }
+declare const CreateDataCatalogCommand_base: {
+    new (input: CreateDataCatalogCommandInput): import("@smithy/smithy-client").CommandImpl<CreateDataCatalogCommandInput, CreateDataCatalogCommandOutput, AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Creates (registers) a data catalog with the specified name and properties. Catalogs
@@ -69,23 +72,5 @@ export interface CreateDataCatalogCommandOutput extends CreateDataCatalogOutput,
  * <p>Base exception class for all service exceptions from Athena service.</p>
  *
  */
-export declare class CreateDataCatalogCommand extends $Command<CreateDataCatalogCommandInput, CreateDataCatalogCommandOutput, AthenaClientResolvedConfig> {
-    readonly input: CreateDataCatalogCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateDataCatalogCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDataCatalogCommandInput, CreateDataCatalogCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class CreateDataCatalogCommand extends CreateDataCatalogCommand_base {
 }

package/dist-types/commands/CreateNamedQueryCommand.d.ts

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { CreateNamedQueryInput, CreateNamedQueryOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface CreateNamedQueryCommandInput extends CreateNamedQueryInput {
  */
 export interface CreateNamedQueryCommandOutput extends CreateNamedQueryOutput, __MetadataBearer {
 }
+declare const CreateNamedQueryCommand_base: {
+    new (input: CreateNamedQueryCommandInput): import("@smithy/smithy-client").CommandImpl<CreateNamedQueryCommandInput, CreateNamedQueryCommandOutput, AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Creates a named query in the specified workgroup. Requires that you have access to the
@@ -65,23 +68,5 @@ export interface CreateNamedQueryCommandOutput extends CreateNamedQueryOutput, _
  * <p>Base exception class for all service exceptions from Athena service.</p>
  *
  */
-export declare class CreateNamedQueryCommand extends $Command<CreateNamedQueryCommandInput, CreateNamedQueryCommandOutput, AthenaClientResolvedConfig> {
-    readonly input: CreateNamedQueryCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateNamedQueryCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNamedQueryCommandInput, CreateNamedQueryCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class CreateNamedQueryCommand extends CreateNamedQueryCommand_base {
 }