@aws-sdk/client-athena 3.477.0 → 3.481.0

package/dist-types/ts3.4/commands/ListSessionsCommand.d.ts

@@ -1,11 +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,
@@ -17,19 +11,16 @@ export interface ListSessionsCommandInput extends ListSessionsRequest {}
 export interface ListSessionsCommandOutput
   extends ListSessionsResponse,
     __MetadataBearer {}
-export declare class ListSessionsCommand extends $Command<
-  ListSessionsCommandInput,
-  ListSessionsCommandOutput,
-  AthenaClientResolvedConfig
-> {
-  readonly input: ListSessionsCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ListSessionsCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AthenaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListSessionsCommandInput, ListSessionsCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const ListSessionsCommand_base: {
+  new (
+    input: ListSessionsCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ListSessionsCommandInput,
+    ListSessionsCommandOutput,
+    AthenaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListSessionsCommand extends ListSessionsCommand_base {}

package/dist-types/ts3.4/commands/ListTableMetadataCommand.d.ts

@@ -1,11 +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,
@@ -20,19 +14,16 @@ export interface ListTableMetadataCommandInput extends ListTableMetadataInput {}
 export interface ListTableMetadataCommandOutput
   extends ListTableMetadataOutput,
     __MetadataBearer {}
-export declare class ListTableMetadataCommand extends $Command<
-  ListTableMetadataCommandInput,
-  ListTableMetadataCommandOutput,
-  AthenaClientResolvedConfig
-> {
-  readonly input: ListTableMetadataCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ListTableMetadataCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AthenaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListTableMetadataCommandInput, ListTableMetadataCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const ListTableMetadataCommand_base: {
+  new (
+    input: ListTableMetadataCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ListTableMetadataCommandInput,
+    ListTableMetadataCommandOutput,
+    AthenaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListTableMetadataCommand extends ListTableMetadataCommand_base {}

package/dist-types/ts3.4/commands/ListTagsForResourceCommand.d.ts

@@ -1,11 +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,
@@ -21,19 +15,16 @@ export interface ListTagsForResourceCommandInput
 export interface ListTagsForResourceCommandOutput
   extends ListTagsForResourceOutput,
     __MetadataBearer {}
-export declare class ListTagsForResourceCommand extends $Command<
-  ListTagsForResourceCommandInput,
-  ListTagsForResourceCommandOutput,
-  AthenaClientResolvedConfig
-> {
-  readonly input: ListTagsForResourceCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ListTagsForResourceCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AthenaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const ListTagsForResourceCommand_base: {
+  new (
+    input: ListTagsForResourceCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ListTagsForResourceCommandInput,
+    ListTagsForResourceCommandOutput,
+    AthenaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListTagsForResourceCommand extends ListTagsForResourceCommand_base {}

package/dist-types/ts3.4/commands/ListWorkGroupsCommand.d.ts

@@ -1,11 +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,
@@ -17,19 +11,16 @@ export interface ListWorkGroupsCommandInput extends ListWorkGroupsInput {}
 export interface ListWorkGroupsCommandOutput
   extends ListWorkGroupsOutput,
     __MetadataBearer {}
-export declare class ListWorkGroupsCommand extends $Command<
-  ListWorkGroupsCommandInput,
-  ListWorkGroupsCommandOutput,
-  AthenaClientResolvedConfig
-> {
-  readonly input: ListWorkGroupsCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ListWorkGroupsCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AthenaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListWorkGroupsCommandInput, ListWorkGroupsCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const ListWorkGroupsCommand_base: {
+  new (
+    input: ListWorkGroupsCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ListWorkGroupsCommandInput,
+    ListWorkGroupsCommandOutput,
+    AthenaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListWorkGroupsCommand extends ListWorkGroupsCommand_base {}

package/dist-types/ts3.4/commands/PutCapacityAssignmentConfigurationCommand.d.ts

@@ -1,11 +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,
@@ -21,22 +15,16 @@ export interface PutCapacityAssignmentConfigurationCommandInput
 export interface PutCapacityAssignmentConfigurationCommandOutput
   extends PutCapacityAssignmentConfigurationOutput,
     __MetadataBearer {}
-export declare class PutCapacityAssignmentConfigurationCommand extends $Command<
-  PutCapacityAssignmentConfigurationCommandInput,
-  PutCapacityAssignmentConfigurationCommandOutput,
-  AthenaClientResolvedConfig
-> {
-  readonly input: PutCapacityAssignmentConfigurationCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: PutCapacityAssignmentConfigurationCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AthenaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const PutCapacityAssignmentConfigurationCommand_base: {
+  new (
+    input: PutCapacityAssignmentConfigurationCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     PutCapacityAssignmentConfigurationCommandInput,
-    PutCapacityAssignmentConfigurationCommandOutput
+    PutCapacityAssignmentConfigurationCommandOutput,
+    AthenaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class PutCapacityAssignmentConfigurationCommand extends PutCapacityAssignmentConfigurationCommand_base {}

package/dist-types/ts3.4/commands/StartCalculationExecutionCommand.d.ts

@@ -1,11 +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,
@@ -21,22 +15,16 @@ export interface StartCalculationExecutionCommandInput
 export interface StartCalculationExecutionCommandOutput
   extends StartCalculationExecutionResponse,
     __MetadataBearer {}
-export declare class StartCalculationExecutionCommand extends $Command<
-  StartCalculationExecutionCommandInput,
-  StartCalculationExecutionCommandOutput,
-  AthenaClientResolvedConfig
-> {
-  readonly input: StartCalculationExecutionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: StartCalculationExecutionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AthenaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const StartCalculationExecutionCommand_base: {
+  new (
+    input: StartCalculationExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     StartCalculationExecutionCommandInput,
-    StartCalculationExecutionCommandOutput
+    StartCalculationExecutionCommandOutput,
+    AthenaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class StartCalculationExecutionCommand extends StartCalculationExecutionCommand_base {}

package/dist-types/ts3.4/commands/StartQueryExecutionCommand.d.ts

@@ -1,11 +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,
@@ -21,19 +15,16 @@ export interface StartQueryExecutionCommandInput
 export interface StartQueryExecutionCommandOutput
   extends StartQueryExecutionOutput,
     __MetadataBearer {}
-export declare class StartQueryExecutionCommand extends $Command<
-  StartQueryExecutionCommandInput,
-  StartQueryExecutionCommandOutput,
-  AthenaClientResolvedConfig
-> {
-  readonly input: StartQueryExecutionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: StartQueryExecutionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AthenaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<StartQueryExecutionCommandInput, StartQueryExecutionCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const StartQueryExecutionCommand_base: {
+  new (
+    input: StartQueryExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    StartQueryExecutionCommandInput,
+    StartQueryExecutionCommandOutput,
+    AthenaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class StartQueryExecutionCommand extends StartQueryExecutionCommand_base {}

package/dist-types/ts3.4/commands/StartSessionCommand.d.ts

@@ -1,11 +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,
@@ -17,19 +11,16 @@ export interface StartSessionCommandInput extends StartSessionRequest {}
 export interface StartSessionCommandOutput
   extends StartSessionResponse,
     __MetadataBearer {}
-export declare class StartSessionCommand extends $Command<
-  StartSessionCommandInput,
-  StartSessionCommandOutput,
-  AthenaClientResolvedConfig
-> {
-  readonly input: StartSessionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: StartSessionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AthenaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<StartSessionCommandInput, StartSessionCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const StartSessionCommand_base: {
+  new (
+    input: StartSessionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    StartSessionCommandInput,
+    StartSessionCommandOutput,
+    AthenaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class StartSessionCommand extends StartSessionCommand_base {}

package/dist-types/ts3.4/commands/StopCalculationExecutionCommand.d.ts

@@ -1,11 +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,
@@ -21,22 +15,16 @@ export interface StopCalculationExecutionCommandInput
 export interface StopCalculationExecutionCommandOutput
   extends StopCalculationExecutionResponse,
     __MetadataBearer {}
-export declare class StopCalculationExecutionCommand extends $Command<
-  StopCalculationExecutionCommandInput,
-  StopCalculationExecutionCommandOutput,
-  AthenaClientResolvedConfig
-> {
-  readonly input: StopCalculationExecutionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: StopCalculationExecutionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AthenaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const StopCalculationExecutionCommand_base: {
+  new (
+    input: StopCalculationExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     StopCalculationExecutionCommandInput,
-    StopCalculationExecutionCommandOutput
+    StopCalculationExecutionCommandOutput,
+    AthenaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class StopCalculationExecutionCommand extends StopCalculationExecutionCommand_base {}

package/dist-types/ts3.4/commands/StopQueryExecutionCommand.d.ts

@@ -1,11 +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,
@@ -21,19 +15,16 @@ export interface StopQueryExecutionCommandInput
 export interface StopQueryExecutionCommandOutput
   extends StopQueryExecutionOutput,
     __MetadataBearer {}
-export declare class StopQueryExecutionCommand extends $Command<
-  StopQueryExecutionCommandInput,
-  StopQueryExecutionCommandOutput,
-  AthenaClientResolvedConfig
-> {
-  readonly input: StopQueryExecutionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: StopQueryExecutionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AthenaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<StopQueryExecutionCommandInput, StopQueryExecutionCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const StopQueryExecutionCommand_base: {
+  new (
+    input: StopQueryExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    StopQueryExecutionCommandInput,
+    StopQueryExecutionCommandOutput,
+    AthenaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class StopQueryExecutionCommand extends StopQueryExecutionCommand_base {}

package/dist-types/ts3.4/commands/TagResourceCommand.d.ts

@@ -1,11 +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,
@@ -17,19 +11,16 @@ export interface TagResourceCommandInput extends TagResourceInput {}
 export interface TagResourceCommandOutput
   extends TagResourceOutput,
     __MetadataBearer {}
-export declare class TagResourceCommand extends $Command<
-  TagResourceCommandInput,
-  TagResourceCommandOutput,
-  AthenaClientResolvedConfig
-> {
-  readonly input: TagResourceCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: TagResourceCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AthenaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const TagResourceCommand_base: {
+  new (
+    input: TagResourceCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    TagResourceCommandInput,
+    TagResourceCommandOutput,
+    AthenaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class TagResourceCommand extends TagResourceCommand_base {}

package/dist-types/ts3.4/commands/TerminateSessionCommand.d.ts

@@ -1,11 +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,
@@ -20,19 +14,16 @@ export interface TerminateSessionCommandInput extends TerminateSessionRequest {}
 export interface TerminateSessionCommandOutput
   extends TerminateSessionResponse,
     __MetadataBearer {}
-export declare class TerminateSessionCommand extends $Command<
-  TerminateSessionCommandInput,
-  TerminateSessionCommandOutput,
-  AthenaClientResolvedConfig
-> {
-  readonly input: TerminateSessionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: TerminateSessionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AthenaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<TerminateSessionCommandInput, TerminateSessionCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const TerminateSessionCommand_base: {
+  new (
+    input: TerminateSessionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    TerminateSessionCommandInput,
+    TerminateSessionCommandOutput,
+    AthenaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class TerminateSessionCommand extends TerminateSessionCommand_base {}

package/dist-types/ts3.4/commands/UntagResourceCommand.d.ts

@@ -1,11 +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,
@@ -17,19 +11,16 @@ export interface UntagResourceCommandInput extends UntagResourceInput {}
 export interface UntagResourceCommandOutput
   extends UntagResourceOutput,
     __MetadataBearer {}
-export declare class UntagResourceCommand extends $Command<
-  UntagResourceCommandInput,
-  UntagResourceCommandOutput,
-  AthenaClientResolvedConfig
-> {
-  readonly input: UntagResourceCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: UntagResourceCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AthenaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const UntagResourceCommand_base: {
+  new (
+    input: UntagResourceCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    UntagResourceCommandInput,
+    UntagResourceCommandOutput,
+    AthenaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class UntagResourceCommand extends UntagResourceCommand_base {}

package/dist-types/ts3.4/commands/UpdateCapacityReservationCommand.d.ts

@@ -1,11 +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,
@@ -21,22 +15,16 @@ export interface UpdateCapacityReservationCommandInput
 export interface UpdateCapacityReservationCommandOutput
   extends UpdateCapacityReservationOutput,
     __MetadataBearer {}
-export declare class UpdateCapacityReservationCommand extends $Command<
-  UpdateCapacityReservationCommandInput,
-  UpdateCapacityReservationCommandOutput,
-  AthenaClientResolvedConfig
-> {
-  readonly input: UpdateCapacityReservationCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: UpdateCapacityReservationCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AthenaClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const UpdateCapacityReservationCommand_base: {
+  new (
+    input: UpdateCapacityReservationCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     UpdateCapacityReservationCommandInput,
-    UpdateCapacityReservationCommandOutput
+    UpdateCapacityReservationCommandOutput,
+    AthenaClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class UpdateCapacityReservationCommand extends UpdateCapacityReservationCommand_base {}