@aws-sdk/client-sfn 3.478.0 → 3.484.0

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

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

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

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

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

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

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

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

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