@aws-sdk/client-swf 3.296.0 → 3.297.0

package/dist-types/commands/PollForActivityTaskCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ActivityTask, PollForActivityTaskInput } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SWFClientResolvedConfig } from "../SWFClient";
 /**
+ * @public
+ *
  * The input for {@link PollForActivityTaskCommand}.
  */
 export interface PollForActivityTaskCommandInput extends PollForActivityTaskInput {
 }
 /**
+ * @public
+ *
  * The output of {@link PollForActivityTaskCommand}.
  */
 export interface PollForActivityTaskCommandOutput extends ActivityTask, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Used by workers to get an <a>ActivityTask</a> from the specified activity
  *         <code>taskList</code>. This initiates a long poll, where the service holds the HTTP
  *       connection open and responds as soon as a task becomes available. The maximum time the service
@@ -60,6 +65,8 @@ export interface PollForActivityTaskCommandOutput extends ActivityTask, __Metada
  * const response = await client.send(command);
  * ```
  *
+ * @param PollForActivityTaskCommandInput - {@link PollForActivityTaskCommandInput}
+ * @returns {@link PollForActivityTaskCommandOutput}
  * @see {@link PollForActivityTaskCommandInput} for command's `input` shape.
  * @see {@link PollForActivityTaskCommandOutput} for command's `response` shape.
  * @see {@link SWFClientResolvedConfig | config} for SWFClient's `config` shape.
@@ -78,11 +85,20 @@ export interface PollForActivityTaskCommandOutput extends ActivityTask, __Metada
 export declare class PollForActivityTaskCommand extends $Command<PollForActivityTaskCommandInput, PollForActivityTaskCommandOutput, SWFClientResolvedConfig> {
     readonly input: PollForActivityTaskCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: PollForActivityTaskCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PollForActivityTaskCommandInput, PollForActivityTaskCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/PollForDecisionTaskCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DecisionTask, PollForDecisionTaskInput } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SWFClientResolvedConfig } from "../SWFClient";
 /**
+ * @public
+ *
  * The input for {@link PollForDecisionTaskCommand}.
  */
 export interface PollForDecisionTaskCommandInput extends PollForDecisionTaskInput {
 }
 /**
+ * @public
+ *
  * The output of {@link PollForDecisionTaskCommand}.
  */
 export interface PollForDecisionTaskCommandOutput extends DecisionTask, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Used by deciders to get a <a>DecisionTask</a> from the specified decision
  *         <code>taskList</code>. A decision task may be returned for any open workflow execution that
  *       is using the specified task list. The task includes a paginated view of the history of the
@@ -72,6 +77,8 @@ export interface PollForDecisionTaskCommandOutput extends DecisionTask, __Metada
  * const response = await client.send(command);
  * ```
  *
+ * @param PollForDecisionTaskCommandInput - {@link PollForDecisionTaskCommandInput}
+ * @returns {@link PollForDecisionTaskCommandOutput}
  * @see {@link PollForDecisionTaskCommandInput} for command's `input` shape.
  * @see {@link PollForDecisionTaskCommandOutput} for command's `response` shape.
  * @see {@link SWFClientResolvedConfig | config} for SWFClient's `config` shape.
@@ -90,11 +97,20 @@ export interface PollForDecisionTaskCommandOutput extends DecisionTask, __Metada
 export declare class PollForDecisionTaskCommand extends $Command<PollForDecisionTaskCommandInput, PollForDecisionTaskCommandOutput, SWFClientResolvedConfig> {
     readonly input: PollForDecisionTaskCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: PollForDecisionTaskCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PollForDecisionTaskCommandInput, PollForDecisionTaskCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/RecordActivityTaskHeartbeatCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ActivityTaskStatus, RecordActivityTaskHeartbeatInput } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SWFClientResolvedConfig } from "../SWFClient";
 /**
+ * @public
+ *
  * The input for {@link RecordActivityTaskHeartbeatCommand}.
  */
 export interface RecordActivityTaskHeartbeatCommandInput extends RecordActivityTaskHeartbeatInput {
 }
 /**
+ * @public
+ *
  * The output of {@link RecordActivityTaskHeartbeatCommand}.
  */
 export interface RecordActivityTaskHeartbeatCommandOutput extends ActivityTaskStatus, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Used by activity workers to report to the service that the <a>ActivityTask</a> represented by the specified <code>taskToken</code> is still making progress. The worker
  *       can also specify details of the progress, for example percent complete, using the
  *         <code>details</code> parameter. This action can also be used by the worker as a mechanism to
@@ -72,6 +77,8 @@ export interface RecordActivityTaskHeartbeatCommandOutput extends ActivityTaskSt
  * const response = await client.send(command);
  * ```
  *
+ * @param RecordActivityTaskHeartbeatCommandInput - {@link RecordActivityTaskHeartbeatCommandInput}
+ * @returns {@link RecordActivityTaskHeartbeatCommandOutput}
  * @see {@link RecordActivityTaskHeartbeatCommandInput} for command's `input` shape.
  * @see {@link RecordActivityTaskHeartbeatCommandOutput} for command's `response` shape.
  * @see {@link SWFClientResolvedConfig | config} for SWFClient's `config` shape.
@@ -87,11 +94,20 @@ export interface RecordActivityTaskHeartbeatCommandOutput extends ActivityTaskSt
 export declare class RecordActivityTaskHeartbeatCommand extends $Command<RecordActivityTaskHeartbeatCommandInput, RecordActivityTaskHeartbeatCommandOutput, SWFClientResolvedConfig> {
     readonly input: RecordActivityTaskHeartbeatCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RecordActivityTaskHeartbeatCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RecordActivityTaskHeartbeatCommandInput, RecordActivityTaskHeartbeatCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/RegisterActivityTypeCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { RegisterActivityTypeInput } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SWFClientResolvedConfig } from "../SWFClient";
 /**
+ * @public
+ *
  * The input for {@link RegisterActivityTypeCommand}.
  */
 export interface RegisterActivityTypeCommandInput extends RegisterActivityTypeInput {
 }
 /**
+ * @public
+ *
  * The output of {@link RegisterActivityTypeCommand}.
  */
 export interface RegisterActivityTypeCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Registers a new <i>activity type</i> along with its configuration
  *       settings in the specified domain.</p>
  *          <important>
@@ -71,6 +76,8 @@ export interface RegisterActivityTypeCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param RegisterActivityTypeCommandInput - {@link RegisterActivityTypeCommandInput}
+ * @returns {@link RegisterActivityTypeCommandOutput}
  * @see {@link RegisterActivityTypeCommandInput} for command's `input` shape.
  * @see {@link RegisterActivityTypeCommandOutput} for command's `response` shape.
  * @see {@link SWFClientResolvedConfig | config} for SWFClient's `config` shape.
@@ -92,11 +99,20 @@ export interface RegisterActivityTypeCommandOutput extends __MetadataBearer {
 export declare class RegisterActivityTypeCommand extends $Command<RegisterActivityTypeCommandInput, RegisterActivityTypeCommandOutput, SWFClientResolvedConfig> {
     readonly input: RegisterActivityTypeCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RegisterActivityTypeCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterActivityTypeCommandInput, RegisterActivityTypeCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/RegisterDomainCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { RegisterDomainInput } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SWFClientResolvedConfig } from "../SWFClient";
 /**
+ * @public
+ *
  * The input for {@link RegisterDomainCommand}.
  */
 export interface RegisterDomainCommandInput extends RegisterDomainInput {
 }
 /**
+ * @public
+ *
  * The output of {@link RegisterDomainCommand}.
  */
 export interface RegisterDomainCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Registers a new domain.</p>
  *          <p>
  *             <b>Access Control</b>
@@ -48,6 +53,8 @@ export interface RegisterDomainCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param RegisterDomainCommandInput - {@link RegisterDomainCommandInput}
+ * @returns {@link RegisterDomainCommandOutput}
  * @see {@link RegisterDomainCommandInput} for command's `input` shape.
  * @see {@link RegisterDomainCommandOutput} for command's `response` shape.
  * @see {@link SWFClientResolvedConfig | config} for SWFClient's `config` shape.
@@ -69,11 +76,20 @@ export interface RegisterDomainCommandOutput extends __MetadataBearer {
 export declare class RegisterDomainCommand extends $Command<RegisterDomainCommandInput, RegisterDomainCommandOutput, SWFClientResolvedConfig> {
     readonly input: RegisterDomainCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RegisterDomainCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterDomainCommandInput, RegisterDomainCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/RegisterWorkflowTypeCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { RegisterWorkflowTypeInput } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SWFClientResolvedConfig } from "../SWFClient";
 /**
+ * @public
+ *
  * The input for {@link RegisterWorkflowTypeCommand}.
  */
 export interface RegisterWorkflowTypeCommandInput extends RegisterWorkflowTypeInput {
 }
 /**
+ * @public
+ *
  * The output of {@link RegisterWorkflowTypeCommand}.
  */
 export interface RegisterWorkflowTypeCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Registers a new <i>workflow type</i> and its configuration settings in
  *       the specified domain.</p>
  *          <p>The retention period for the workflow history is set by the <a>RegisterDomain</a> action.</p>
@@ -72,6 +77,8 @@ export interface RegisterWorkflowTypeCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param RegisterWorkflowTypeCommandInput - {@link RegisterWorkflowTypeCommandInput}
+ * @returns {@link RegisterWorkflowTypeCommandOutput}
  * @see {@link RegisterWorkflowTypeCommandInput} for command's `input` shape.
  * @see {@link RegisterWorkflowTypeCommandOutput} for command's `response` shape.
  * @see {@link SWFClientResolvedConfig | config} for SWFClient's `config` shape.
@@ -93,11 +100,20 @@ export interface RegisterWorkflowTypeCommandOutput extends __MetadataBearer {
 export declare class RegisterWorkflowTypeCommand extends $Command<RegisterWorkflowTypeCommandInput, RegisterWorkflowTypeCommandOutput, SWFClientResolvedConfig> {
     readonly input: RegisterWorkflowTypeCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RegisterWorkflowTypeCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterWorkflowTypeCommandInput, RegisterWorkflowTypeCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/RequestCancelWorkflowExecutionCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { RequestCancelWorkflowExecutionInput } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SWFClientResolvedConfig } from "../SWFClient";
 /**
+ * @public
+ *
  * The input for {@link RequestCancelWorkflowExecutionCommand}.
  */
 export interface RequestCancelWorkflowExecutionCommandInput extends RequestCancelWorkflowExecutionInput {
 }
 /**
+ * @public
+ *
  * The output of {@link RequestCancelWorkflowExecutionCommand}.
  */
 export interface RequestCancelWorkflowExecutionCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Records a <code>WorkflowExecutionCancelRequested</code> event in the currently running
  *       workflow execution identified by the given domain, workflowId, and runId. This logically
  *       requests the cancellation of the workflow execution as a whole. It is up to the decider to
@@ -63,6 +68,8 @@ export interface RequestCancelWorkflowExecutionCommandOutput extends __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param RequestCancelWorkflowExecutionCommandInput - {@link RequestCancelWorkflowExecutionCommandInput}
+ * @returns {@link RequestCancelWorkflowExecutionCommandOutput}
  * @see {@link RequestCancelWorkflowExecutionCommandInput} for command's `input` shape.
  * @see {@link RequestCancelWorkflowExecutionCommandOutput} for command's `response` shape.
  * @see {@link SWFClientResolvedConfig | config} for SWFClient's `config` shape.
@@ -78,11 +85,20 @@ export interface RequestCancelWorkflowExecutionCommandOutput extends __MetadataB
 export declare class RequestCancelWorkflowExecutionCommand extends $Command<RequestCancelWorkflowExecutionCommandInput, RequestCancelWorkflowExecutionCommandOutput, SWFClientResolvedConfig> {
     readonly input: RequestCancelWorkflowExecutionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RequestCancelWorkflowExecutionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RequestCancelWorkflowExecutionCommandInput, RequestCancelWorkflowExecutionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/RespondActivityTaskCanceledCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { RespondActivityTaskCanceledInput } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SWFClientResolvedConfig } from "../SWFClient";
 /**
+ * @public
+ *
  * The input for {@link RespondActivityTaskCanceledCommand}.
  */
 export interface RespondActivityTaskCanceledCommandInput extends RespondActivityTaskCanceledInput {
 }
 /**
+ * @public
+ *
  * The output of {@link RespondActivityTaskCanceledCommand}.
  */
 export interface RespondActivityTaskCanceledCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Used by workers to tell the service that the <a>ActivityTask</a> identified
  *       by the <code>taskToken</code> was successfully canceled. Additional <code>details</code> can
  *       be provided using the <code>details</code> argument.</p>
@@ -66,6 +71,8 @@ export interface RespondActivityTaskCanceledCommandOutput extends __MetadataBear
  * const response = await client.send(command);
  * ```
  *
+ * @param RespondActivityTaskCanceledCommandInput - {@link RespondActivityTaskCanceledCommandInput}
+ * @returns {@link RespondActivityTaskCanceledCommandOutput}
  * @see {@link RespondActivityTaskCanceledCommandInput} for command's `input` shape.
  * @see {@link RespondActivityTaskCanceledCommandOutput} for command's `response` shape.
  * @see {@link SWFClientResolvedConfig | config} for SWFClient's `config` shape.
@@ -81,11 +88,20 @@ export interface RespondActivityTaskCanceledCommandOutput extends __MetadataBear
 export declare class RespondActivityTaskCanceledCommand extends $Command<RespondActivityTaskCanceledCommandInput, RespondActivityTaskCanceledCommandOutput, SWFClientResolvedConfig> {
     readonly input: RespondActivityTaskCanceledCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RespondActivityTaskCanceledCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RespondActivityTaskCanceledCommandInput, RespondActivityTaskCanceledCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/RespondActivityTaskCompletedCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { RespondActivityTaskCompletedInput } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SWFClientResolvedConfig } from "../SWFClient";
 /**
+ * @public
+ *
  * The input for {@link RespondActivityTaskCompletedCommand}.
  */
 export interface RespondActivityTaskCompletedCommandInput extends RespondActivityTaskCompletedInput {
 }
 /**
+ * @public
+ *
  * The output of {@link RespondActivityTaskCompletedCommand}.
  */
 export interface RespondActivityTaskCompletedCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Used by workers to tell the service that the <a>ActivityTask</a> identified
  *       by the <code>taskToken</code> completed successfully with a <code>result</code> (if provided).
  *       The <code>result</code> appears in the <code>ActivityTaskCompleted</code> event in the
@@ -64,6 +69,8 @@ export interface RespondActivityTaskCompletedCommandOutput extends __MetadataBea
  * const response = await client.send(command);
  * ```
  *
+ * @param RespondActivityTaskCompletedCommandInput - {@link RespondActivityTaskCompletedCommandInput}
+ * @returns {@link RespondActivityTaskCompletedCommandOutput}
  * @see {@link RespondActivityTaskCompletedCommandInput} for command's `input` shape.
  * @see {@link RespondActivityTaskCompletedCommandOutput} for command's `response` shape.
  * @see {@link SWFClientResolvedConfig | config} for SWFClient's `config` shape.
@@ -79,11 +86,20 @@ export interface RespondActivityTaskCompletedCommandOutput extends __MetadataBea
 export declare class RespondActivityTaskCompletedCommand extends $Command<RespondActivityTaskCompletedCommandInput, RespondActivityTaskCompletedCommandOutput, SWFClientResolvedConfig> {
     readonly input: RespondActivityTaskCompletedCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RespondActivityTaskCompletedCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RespondActivityTaskCompletedCommandInput, RespondActivityTaskCompletedCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/RespondActivityTaskFailedCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { RespondActivityTaskFailedInput } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SWFClientResolvedConfig } from "../SWFClient";
 /**
+ * @public
+ *
  * The input for {@link RespondActivityTaskFailedCommand}.
  */
 export interface RespondActivityTaskFailedCommandInput extends RespondActivityTaskFailedInput {
 }
 /**
+ * @public
+ *
  * The output of {@link RespondActivityTaskFailedCommand}.
  */
 export interface RespondActivityTaskFailedCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Used by workers to tell the service that the <a>ActivityTask</a> identified
  *       by the <code>taskToken</code> has failed with <code>reason</code> (if specified). The
  *         <code>reason</code> and <code>details</code> appear in the <code>ActivityTaskFailed</code>
@@ -57,6 +62,8 @@ export interface RespondActivityTaskFailedCommandOutput extends __MetadataBearer
  * const response = await client.send(command);
  * ```
  *
+ * @param RespondActivityTaskFailedCommandInput - {@link RespondActivityTaskFailedCommandInput}
+ * @returns {@link RespondActivityTaskFailedCommandOutput}
  * @see {@link RespondActivityTaskFailedCommandInput} for command's `input` shape.
  * @see {@link RespondActivityTaskFailedCommandOutput} for command's `response` shape.
  * @see {@link SWFClientResolvedConfig | config} for SWFClient's `config` shape.
@@ -72,11 +79,20 @@ export interface RespondActivityTaskFailedCommandOutput extends __MetadataBearer
 export declare class RespondActivityTaskFailedCommand extends $Command<RespondActivityTaskFailedCommandInput, RespondActivityTaskFailedCommandOutput, SWFClientResolvedConfig> {
     readonly input: RespondActivityTaskFailedCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RespondActivityTaskFailedCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RespondActivityTaskFailedCommandInput, RespondActivityTaskFailedCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/RespondDecisionTaskCompletedCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { RespondDecisionTaskCompletedInput } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SWFClientResolvedConfig } from "../SWFClient";
 /**
+ * @public
+ *
  * The input for {@link RespondDecisionTaskCompletedCommand}.
  */
 export interface RespondDecisionTaskCompletedCommandInput extends RespondDecisionTaskCompletedInput {
 }
 /**
+ * @public
+ *
  * The output of {@link RespondDecisionTaskCompletedCommand}.
  */
 export interface RespondDecisionTaskCompletedCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Used by deciders to tell the service that the <a>DecisionTask</a> identified
  *       by the <code>taskToken</code> has successfully completed. The <code>decisions</code> argument
  *       specifies the list of decisions made while processing the task.</p>
@@ -44,6 +49,8 @@ export interface RespondDecisionTaskCompletedCommandOutput extends __MetadataBea
  * const response = await client.send(command);
  * ```
  *
+ * @param RespondDecisionTaskCompletedCommandInput - {@link RespondDecisionTaskCompletedCommandInput}
+ * @returns {@link RespondDecisionTaskCompletedCommandOutput}
  * @see {@link RespondDecisionTaskCompletedCommandInput} for command's `input` shape.
  * @see {@link RespondDecisionTaskCompletedCommandOutput} for command's `response` shape.
  * @see {@link SWFClientResolvedConfig | config} for SWFClient's `config` shape.
@@ -59,11 +66,20 @@ export interface RespondDecisionTaskCompletedCommandOutput extends __MetadataBea
 export declare class RespondDecisionTaskCompletedCommand extends $Command<RespondDecisionTaskCompletedCommandInput, RespondDecisionTaskCompletedCommandOutput, SWFClientResolvedConfig> {
     readonly input: RespondDecisionTaskCompletedCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RespondDecisionTaskCompletedCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RespondDecisionTaskCompletedCommandInput, RespondDecisionTaskCompletedCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/SignalWorkflowExecutionCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { SignalWorkflowExecutionInput } from "../models/models_0";
 import { ServiceInputTypes, ServiceOutputTypes, SWFClientResolvedConfig } from "../SWFClient";
 /**
+ * @public
+ *
  * The input for {@link SignalWorkflowExecutionCommand}.
  */
 export interface SignalWorkflowExecutionCommandInput extends SignalWorkflowExecutionInput {
 }
 /**
+ * @public
+ *
  * The output of {@link SignalWorkflowExecutionCommand}.
  */
 export interface SignalWorkflowExecutionCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Records a <code>WorkflowExecutionSignaled</code> event in the workflow execution
  *       history and creates a decision task for the workflow execution identified by the given domain,
  *       workflowId and runId. The event is recorded with the specified user defined signalName and
@@ -63,6 +68,8 @@ export interface SignalWorkflowExecutionCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param SignalWorkflowExecutionCommandInput - {@link SignalWorkflowExecutionCommandInput}
+ * @returns {@link SignalWorkflowExecutionCommandOutput}
  * @see {@link SignalWorkflowExecutionCommandInput} for command's `input` shape.
  * @see {@link SignalWorkflowExecutionCommandOutput} for command's `response` shape.
  * @see {@link SWFClientResolvedConfig | config} for SWFClient's `config` shape.
@@ -78,11 +85,20 @@ export interface SignalWorkflowExecutionCommandOutput extends __MetadataBearer {
 export declare class SignalWorkflowExecutionCommand extends $Command<SignalWorkflowExecutionCommandInput, SignalWorkflowExecutionCommandOutput, SWFClientResolvedConfig> {
     readonly input: SignalWorkflowExecutionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: SignalWorkflowExecutionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SignalWorkflowExecutionCommandInput, SignalWorkflowExecutionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }