@aws-sdk/client-sfn 3.478.0 → 3.481.0

package/dist-types/ts3.4/commands/ListStateMachineVersionsCommand.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 {
   ListStateMachineVersionsInput,
   ListStateMachineVersionsOutput,
@@ -21,22 +15,16 @@ export interface ListStateMachineVersionsCommandInput
 export interface ListStateMachineVersionsCommandOutput
   extends ListStateMachineVersionsOutput,
     __MetadataBearer {}
-export declare class ListStateMachineVersionsCommand extends $Command<
-  ListStateMachineVersionsCommandInput,
-  ListStateMachineVersionsCommandOutput,
-  SFNClientResolvedConfig
-> {
-  readonly input: ListStateMachineVersionsCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ListStateMachineVersionsCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SFNClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const ListStateMachineVersionsCommand_base: {
+  new (
+    input: ListStateMachineVersionsCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     ListStateMachineVersionsCommandInput,
-    ListStateMachineVersionsCommandOutput
+    ListStateMachineVersionsCommandOutput,
+    SFNClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListStateMachineVersionsCommand extends ListStateMachineVersionsCommand_base {}

package/dist-types/ts3.4/commands/ListStateMachinesCommand.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 {
   ListStateMachinesInput,
   ListStateMachinesOutput,
@@ -20,19 +14,16 @@ export interface ListStateMachinesCommandInput extends ListStateMachinesInput {}
 export interface ListStateMachinesCommandOutput
   extends ListStateMachinesOutput,
     __MetadataBearer {}
-export declare class ListStateMachinesCommand extends $Command<
-  ListStateMachinesCommandInput,
-  ListStateMachinesCommandOutput,
-  SFNClientResolvedConfig
-> {
-  readonly input: ListStateMachinesCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ListStateMachinesCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SFNClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListStateMachinesCommandInput, ListStateMachinesCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const ListStateMachinesCommand_base: {
+  new (
+    input: ListStateMachinesCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ListStateMachinesCommandInput,
+    ListStateMachinesCommandOutput,
+    SFNClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListStateMachinesCommand extends ListStateMachinesCommand_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 {
   ListTagsForResourceInput,
   ListTagsForResourceOutput,
@@ -21,19 +15,16 @@ export interface ListTagsForResourceCommandInput
 export interface ListTagsForResourceCommandOutput
   extends ListTagsForResourceOutput,
     __MetadataBearer {}
-export declare class ListTagsForResourceCommand extends $Command<
-  ListTagsForResourceCommandInput,
-  ListTagsForResourceCommandOutput,
-  SFNClientResolvedConfig
-> {
-  readonly input: ListTagsForResourceCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: ListTagsForResourceCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SFNClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const ListTagsForResourceCommand_base: {
+  new (
+    input: ListTagsForResourceCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    ListTagsForResourceCommandInput,
+    ListTagsForResourceCommandOutput,
+    SFNClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class ListTagsForResourceCommand extends ListTagsForResourceCommand_base {}

package/dist-types/ts3.4/commands/PublishStateMachineVersionCommand.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 {
   PublishStateMachineVersionInput,
   PublishStateMachineVersionOutput,
@@ -21,22 +15,16 @@ export interface PublishStateMachineVersionCommandInput
 export interface PublishStateMachineVersionCommandOutput
   extends PublishStateMachineVersionOutput,
     __MetadataBearer {}
-export declare class PublishStateMachineVersionCommand extends $Command<
-  PublishStateMachineVersionCommandInput,
-  PublishStateMachineVersionCommandOutput,
-  SFNClientResolvedConfig
-> {
-  readonly input: PublishStateMachineVersionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: PublishStateMachineVersionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SFNClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const PublishStateMachineVersionCommand_base: {
+  new (
+    input: PublishStateMachineVersionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     PublishStateMachineVersionCommandInput,
-    PublishStateMachineVersionCommandOutput
+    PublishStateMachineVersionCommandOutput,
+    SFNClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class PublishStateMachineVersionCommand extends PublishStateMachineVersionCommand_base {}

package/dist-types/ts3.4/commands/RedriveExecutionCommand.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 {
   RedriveExecutionInput,
   RedriveExecutionOutput,
@@ -20,19 +14,16 @@ export interface RedriveExecutionCommandInput extends RedriveExecutionInput {}
 export interface RedriveExecutionCommandOutput
   extends RedriveExecutionOutput,
     __MetadataBearer {}
-export declare class RedriveExecutionCommand extends $Command<
-  RedriveExecutionCommandInput,
-  RedriveExecutionCommandOutput,
-  SFNClientResolvedConfig
-> {
-  readonly input: RedriveExecutionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: RedriveExecutionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SFNClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<RedriveExecutionCommandInput, RedriveExecutionCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const RedriveExecutionCommand_base: {
+  new (
+    input: RedriveExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    RedriveExecutionCommandInput,
+    RedriveExecutionCommandOutput,
+    SFNClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class RedriveExecutionCommand extends RedriveExecutionCommand_base {}

package/dist-types/ts3.4/commands/SendTaskFailureCommand.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 {
   SendTaskFailureInput,
   SendTaskFailureOutput,
@@ -20,19 +14,16 @@ export interface SendTaskFailureCommandInput extends SendTaskFailureInput {}
 export interface SendTaskFailureCommandOutput
   extends SendTaskFailureOutput,
     __MetadataBearer {}
-export declare class SendTaskFailureCommand extends $Command<
-  SendTaskFailureCommandInput,
-  SendTaskFailureCommandOutput,
-  SFNClientResolvedConfig
-> {
-  readonly input: SendTaskFailureCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: SendTaskFailureCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SFNClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SendTaskFailureCommandInput, SendTaskFailureCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const SendTaskFailureCommand_base: {
+  new (
+    input: SendTaskFailureCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    SendTaskFailureCommandInput,
+    SendTaskFailureCommandOutput,
+    SFNClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class SendTaskFailureCommand extends SendTaskFailureCommand_base {}

package/dist-types/ts3.4/commands/SendTaskHeartbeatCommand.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 {
   SendTaskHeartbeatInput,
   SendTaskHeartbeatOutput,
@@ -20,19 +14,16 @@ export interface SendTaskHeartbeatCommandInput extends SendTaskHeartbeatInput {}
 export interface SendTaskHeartbeatCommandOutput
   extends SendTaskHeartbeatOutput,
     __MetadataBearer {}
-export declare class SendTaskHeartbeatCommand extends $Command<
-  SendTaskHeartbeatCommandInput,
-  SendTaskHeartbeatCommandOutput,
-  SFNClientResolvedConfig
-> {
-  readonly input: SendTaskHeartbeatCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: SendTaskHeartbeatCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SFNClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SendTaskHeartbeatCommandInput, SendTaskHeartbeatCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const SendTaskHeartbeatCommand_base: {
+  new (
+    input: SendTaskHeartbeatCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    SendTaskHeartbeatCommandInput,
+    SendTaskHeartbeatCommandOutput,
+    SFNClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class SendTaskHeartbeatCommand extends SendTaskHeartbeatCommand_base {}

package/dist-types/ts3.4/commands/SendTaskSuccessCommand.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 {
   SendTaskSuccessInput,
   SendTaskSuccessOutput,
@@ -20,19 +14,16 @@ export interface SendTaskSuccessCommandInput extends SendTaskSuccessInput {}
 export interface SendTaskSuccessCommandOutput
   extends SendTaskSuccessOutput,
     __MetadataBearer {}
-export declare class SendTaskSuccessCommand extends $Command<
-  SendTaskSuccessCommandInput,
-  SendTaskSuccessCommandOutput,
-  SFNClientResolvedConfig
-> {
-  readonly input: SendTaskSuccessCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: SendTaskSuccessCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SFNClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SendTaskSuccessCommandInput, SendTaskSuccessCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const SendTaskSuccessCommand_base: {
+  new (
+    input: SendTaskSuccessCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    SendTaskSuccessCommandInput,
+    SendTaskSuccessCommandOutput,
+    SFNClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class SendTaskSuccessCommand extends SendTaskSuccessCommand_base {}

package/dist-types/ts3.4/commands/StartExecutionCommand.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 { StartExecutionInput, StartExecutionOutput } from "../models/models_0";
 import {
   ServiceInputTypes,
@@ -17,19 +11,16 @@ export interface StartExecutionCommandInput extends StartExecutionInput {}
 export interface StartExecutionCommandOutput
   extends StartExecutionOutput,
     __MetadataBearer {}
-export declare class StartExecutionCommand extends $Command<
-  StartExecutionCommandInput,
-  StartExecutionCommandOutput,
-  SFNClientResolvedConfig
-> {
-  readonly input: StartExecutionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: StartExecutionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SFNClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<StartExecutionCommandInput, StartExecutionCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const StartExecutionCommand_base: {
+  new (
+    input: StartExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    StartExecutionCommandInput,
+    StartExecutionCommandOutput,
+    SFNClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class StartExecutionCommand extends StartExecutionCommand_base {}

package/dist-types/ts3.4/commands/StartSyncExecutionCommand.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 {
   StartSyncExecutionInput,
   StartSyncExecutionOutput,
@@ -21,19 +15,16 @@ export interface StartSyncExecutionCommandInput
 export interface StartSyncExecutionCommandOutput
   extends StartSyncExecutionOutput,
     __MetadataBearer {}
-export declare class StartSyncExecutionCommand extends $Command<
-  StartSyncExecutionCommandInput,
-  StartSyncExecutionCommandOutput,
-  SFNClientResolvedConfig
-> {
-  readonly input: StartSyncExecutionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: StartSyncExecutionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SFNClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<StartSyncExecutionCommandInput, StartSyncExecutionCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const StartSyncExecutionCommand_base: {
+  new (
+    input: StartSyncExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    StartSyncExecutionCommandInput,
+    StartSyncExecutionCommandOutput,
+    SFNClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class StartSyncExecutionCommand extends StartSyncExecutionCommand_base {}

package/dist-types/ts3.4/commands/StopExecutionCommand.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 { StopExecutionInput, StopExecutionOutput } from "../models/models_0";
 import {
   ServiceInputTypes,
@@ -17,19 +11,16 @@ export interface StopExecutionCommandInput extends StopExecutionInput {}
 export interface StopExecutionCommandOutput
   extends StopExecutionOutput,
     __MetadataBearer {}
-export declare class StopExecutionCommand extends $Command<
-  StopExecutionCommandInput,
-  StopExecutionCommandOutput,
-  SFNClientResolvedConfig
-> {
-  readonly input: StopExecutionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: StopExecutionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SFNClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<StopExecutionCommandInput, StopExecutionCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const StopExecutionCommand_base: {
+  new (
+    input: StopExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    StopExecutionCommandInput,
+    StopExecutionCommandOutput,
+    SFNClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class StopExecutionCommand extends StopExecutionCommand_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 { TagResourceInput, TagResourceOutput } from "../models/models_0";
 import {
   ServiceInputTypes,
@@ -17,19 +11,16 @@ export interface TagResourceCommandInput extends TagResourceInput {}
 export interface TagResourceCommandOutput
   extends TagResourceOutput,
     __MetadataBearer {}
-export declare class TagResourceCommand extends $Command<
-  TagResourceCommandInput,
-  TagResourceCommandOutput,
-  SFNClientResolvedConfig
-> {
-  readonly input: TagResourceCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: TagResourceCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SFNClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const TagResourceCommand_base: {
+  new (
+    input: TagResourceCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    TagResourceCommandInput,
+    TagResourceCommandOutput,
+    SFNClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class TagResourceCommand extends TagResourceCommand_base {}

package/dist-types/ts3.4/commands/TestStateCommand.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 { TestStateInput, TestStateOutput } from "../models/models_0";
 import {
   ServiceInputTypes,
@@ -17,19 +11,16 @@ export interface TestStateCommandInput extends TestStateInput {}
 export interface TestStateCommandOutput
   extends TestStateOutput,
     __MetadataBearer {}
-export declare class TestStateCommand extends $Command<
-  TestStateCommandInput,
-  TestStateCommandOutput,
-  SFNClientResolvedConfig
-> {
-  readonly input: TestStateCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: TestStateCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SFNClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<TestStateCommandInput, TestStateCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const TestStateCommand_base: {
+  new (
+    input: TestStateCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    TestStateCommandInput,
+    TestStateCommandOutput,
+    SFNClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class TestStateCommand extends TestStateCommand_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 { UntagResourceInput, UntagResourceOutput } from "../models/models_0";
 import {
   ServiceInputTypes,
@@ -17,19 +11,16 @@ export interface UntagResourceCommandInput extends UntagResourceInput {}
 export interface UntagResourceCommandOutput
   extends UntagResourceOutput,
     __MetadataBearer {}
-export declare class UntagResourceCommand extends $Command<
-  UntagResourceCommandInput,
-  UntagResourceCommandOutput,
-  SFNClientResolvedConfig
-> {
-  readonly input: UntagResourceCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: UntagResourceCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SFNClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const UntagResourceCommand_base: {
+  new (
+    input: UntagResourceCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    UntagResourceCommandInput,
+    UntagResourceCommandOutput,
+    SFNClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class UntagResourceCommand extends UntagResourceCommand_base {}