@aws-sdk/client-swf 3.477.0 → 3.481.0

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

package/dist-types/ts3.4/commands/PollForActivityTaskCommand.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 { ActivityTask, PollForActivityTaskInput } from "../models/models_0";
 import {
   ServiceInputTypes,
@@ -18,19 +12,16 @@ export interface PollForActivityTaskCommandInput
 export interface PollForActivityTaskCommandOutput
   extends ActivityTask,
     __MetadataBearer {}
-export declare class PollForActivityTaskCommand extends $Command<
-  PollForActivityTaskCommandInput,
-  PollForActivityTaskCommandOutput,
-  SWFClientResolvedConfig
-> {
-  readonly input: PollForActivityTaskCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: PollForActivityTaskCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SWFClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PollForActivityTaskCommandInput, PollForActivityTaskCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const PollForActivityTaskCommand_base: {
+  new (
+    input: PollForActivityTaskCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    PollForActivityTaskCommandInput,
+    PollForActivityTaskCommandOutput,
+    SWFClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class PollForActivityTaskCommand extends PollForActivityTaskCommand_base {}

package/dist-types/ts3.4/commands/PollForDecisionTaskCommand.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 { DecisionTask, PollForDecisionTaskInput } from "../models/models_0";
 import {
   ServiceInputTypes,
@@ -18,19 +12,16 @@ export interface PollForDecisionTaskCommandInput
 export interface PollForDecisionTaskCommandOutput
   extends DecisionTask,
     __MetadataBearer {}
-export declare class PollForDecisionTaskCommand extends $Command<
-  PollForDecisionTaskCommandInput,
-  PollForDecisionTaskCommandOutput,
-  SWFClientResolvedConfig
-> {
-  readonly input: PollForDecisionTaskCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: PollForDecisionTaskCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SWFClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PollForDecisionTaskCommandInput, PollForDecisionTaskCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const PollForDecisionTaskCommand_base: {
+  new (
+    input: PollForDecisionTaskCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    PollForDecisionTaskCommandInput,
+    PollForDecisionTaskCommandOutput,
+    SWFClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class PollForDecisionTaskCommand extends PollForDecisionTaskCommand_base {}

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

package/dist-types/ts3.4/commands/RegisterActivityTypeCommand.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 { RegisterActivityTypeInput } from "../models/models_0";
 import {
   ServiceInputTypes,
@@ -16,22 +10,16 @@ export { __MetadataBearer, $Command };
 export interface RegisterActivityTypeCommandInput
   extends RegisterActivityTypeInput {}
 export interface RegisterActivityTypeCommandOutput extends __MetadataBearer {}
-export declare class RegisterActivityTypeCommand extends $Command<
-  RegisterActivityTypeCommandInput,
-  RegisterActivityTypeCommandOutput,
-  SWFClientResolvedConfig
-> {
-  readonly input: RegisterActivityTypeCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: RegisterActivityTypeCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SWFClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const RegisterActivityTypeCommand_base: {
+  new (
+    input: RegisterActivityTypeCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     RegisterActivityTypeCommandInput,
-    RegisterActivityTypeCommandOutput
+    RegisterActivityTypeCommandOutput,
+    SWFClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class RegisterActivityTypeCommand extends RegisterActivityTypeCommand_base {}

package/dist-types/ts3.4/commands/RegisterDomainCommand.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 { RegisterDomainInput } from "../models/models_0";
 import {
   ServiceInputTypes,
@@ -15,19 +9,16 @@ import {
 export { __MetadataBearer, $Command };
 export interface RegisterDomainCommandInput extends RegisterDomainInput {}
 export interface RegisterDomainCommandOutput extends __MetadataBearer {}
-export declare class RegisterDomainCommand extends $Command<
-  RegisterDomainCommandInput,
-  RegisterDomainCommandOutput,
-  SWFClientResolvedConfig
-> {
-  readonly input: RegisterDomainCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: RegisterDomainCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SWFClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<RegisterDomainCommandInput, RegisterDomainCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+declare const RegisterDomainCommand_base: {
+  new (
+    input: RegisterDomainCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
+    RegisterDomainCommandInput,
+    RegisterDomainCommandOutput,
+    SWFClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
+  >;
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class RegisterDomainCommand extends RegisterDomainCommand_base {}

package/dist-types/ts3.4/commands/RegisterWorkflowTypeCommand.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 { RegisterWorkflowTypeInput } from "../models/models_0";
 import {
   ServiceInputTypes,
@@ -16,22 +10,16 @@ export { __MetadataBearer, $Command };
 export interface RegisterWorkflowTypeCommandInput
   extends RegisterWorkflowTypeInput {}
 export interface RegisterWorkflowTypeCommandOutput extends __MetadataBearer {}
-export declare class RegisterWorkflowTypeCommand extends $Command<
-  RegisterWorkflowTypeCommandInput,
-  RegisterWorkflowTypeCommandOutput,
-  SWFClientResolvedConfig
-> {
-  readonly input: RegisterWorkflowTypeCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: RegisterWorkflowTypeCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SWFClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const RegisterWorkflowTypeCommand_base: {
+  new (
+    input: RegisterWorkflowTypeCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     RegisterWorkflowTypeCommandInput,
-    RegisterWorkflowTypeCommandOutput
+    RegisterWorkflowTypeCommandOutput,
+    SWFClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class RegisterWorkflowTypeCommand extends RegisterWorkflowTypeCommand_base {}

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

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

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

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

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

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

package/dist-types/ts3.4/commands/StartWorkflowExecutionCommand.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 { Run, StartWorkflowExecutionInput } from "../models/models_0";
 import {
   ServiceInputTypes,
@@ -18,22 +12,16 @@ export interface StartWorkflowExecutionCommandInput
 export interface StartWorkflowExecutionCommandOutput
   extends Run,
     __MetadataBearer {}
-export declare class StartWorkflowExecutionCommand extends $Command<
-  StartWorkflowExecutionCommandInput,
-  StartWorkflowExecutionCommandOutput,
-  SWFClientResolvedConfig
-> {
-  readonly input: StartWorkflowExecutionCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: StartWorkflowExecutionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SWFClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
+declare const StartWorkflowExecutionCommand_base: {
+  new (
+    input: StartWorkflowExecutionCommandInput
+  ): import("@smithy/smithy-client").CommandImpl<
     StartWorkflowExecutionCommandInput,
-    StartWorkflowExecutionCommandOutput
+    StartWorkflowExecutionCommandOutput,
+    SWFClientResolvedConfig,
+    ServiceInputTypes,
+    ServiceOutputTypes
   >;
-  private serialize;
-  private deserialize;
-}
+  getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+export declare class StartWorkflowExecutionCommand extends StartWorkflowExecutionCommand_base {}