@aws-sdk/client-sfn 3.477.0 → 3.481.0

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

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

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

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

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

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

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 {}