@aws-sdk/client-sfn 3.36.0 → 3.39.0

package/dist-types/ts3.4/commands/DeleteStateMachineCommand.d.ts

@@ -6,35 +6,11 @@ export interface DeleteStateMachineCommandInput extends DeleteStateMachineInput
 }
 export interface DeleteStateMachineCommandOutput extends DeleteStateMachineOutput, __MetadataBearer {
 }
-/**
- * <p>Deletes a state machine. This is an asynchronous operation: It sets the state machine's
- *       status to <code>DELETING</code> and begins the deletion process. </p>
- *          <note>
- *             <p>For <code>EXPRESS</code>state machines, the deletion will happen eventually (usually
- *         less than a minute). Running executions may emit logs after <code>DeleteStateMachine</code>
- *         API is called.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, DeleteStateMachineCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, DeleteStateMachineCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new DeleteStateMachineCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteStateMachineCommandInput} for command's `input` shape.
- * @see {@link DeleteStateMachineCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteStateMachineCommand extends $Command<DeleteStateMachineCommandInput, DeleteStateMachineCommandOutput, SFNClientResolvedConfig> {
     readonly input: DeleteStateMachineCommandInput;
     constructor(input: DeleteStateMachineCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteStateMachineCommandInput, DeleteStateMachineCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeActivityCommand.d.ts

@@ -6,32 +6,11 @@ export interface DescribeActivityCommandInput extends DescribeActivityInput {
 }
 export interface DescribeActivityCommandOutput extends DescribeActivityOutput, __MetadataBearer {
 }
-/**
- * <p>Describes an activity.</p>
- *          <note>
- *             <p>This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, DescribeActivityCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, DescribeActivityCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new DescribeActivityCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeActivityCommandInput} for command's `input` shape.
- * @see {@link DescribeActivityCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeActivityCommand extends $Command<DescribeActivityCommandInput, DescribeActivityCommandOutput, SFNClientResolvedConfig> {
     readonly input: DescribeActivityCommandInput;
     constructor(input: DescribeActivityCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeActivityCommandInput, DescribeActivityCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeExecutionCommand.d.ts

@@ -6,33 +6,11 @@ export interface DescribeExecutionCommandInput extends DescribeExecutionInput {
 }
 export interface DescribeExecutionCommandOutput extends DescribeExecutionOutput, __MetadataBearer {
 }
-/**
- * <p>Describes an execution.</p>
- *          <note>
- *             <p>This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.</p>
- *          </note>
- *          <p>This API action is not supported by <code>EXPRESS</code> state machines.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, DescribeExecutionCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, DescribeExecutionCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new DescribeExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeExecutionCommandInput} for command's `input` shape.
- * @see {@link DescribeExecutionCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeExecutionCommand extends $Command<DescribeExecutionCommandInput, DescribeExecutionCommandOutput, SFNClientResolvedConfig> {
     readonly input: DescribeExecutionCommandInput;
     constructor(input: DescribeExecutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeExecutionCommandInput, DescribeExecutionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeStateMachineCommand.d.ts

@@ -6,32 +6,11 @@ export interface DescribeStateMachineCommandInput extends DescribeStateMachineIn
 }
 export interface DescribeStateMachineCommandOutput extends DescribeStateMachineOutput, __MetadataBearer {
 }
-/**
- * <p>Describes a state machine.</p>
- *          <note>
- *             <p>This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, DescribeStateMachineCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, DescribeStateMachineCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new DescribeStateMachineCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeStateMachineCommandInput} for command's `input` shape.
- * @see {@link DescribeStateMachineCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeStateMachineCommand extends $Command<DescribeStateMachineCommandInput, DescribeStateMachineCommandOutput, SFNClientResolvedConfig> {
     readonly input: DescribeStateMachineCommandInput;
     constructor(input: DescribeStateMachineCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStateMachineCommandInput, DescribeStateMachineCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeStateMachineForExecutionCommand.d.ts

@@ -6,33 +6,11 @@ export interface DescribeStateMachineForExecutionCommandInput extends DescribeSt
 }
 export interface DescribeStateMachineForExecutionCommandOutput extends DescribeStateMachineForExecutionOutput, __MetadataBearer {
 }
-/**
- * <p>Describes the state machine associated with a specific execution.</p>
- *          <note>
- *             <p>This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.</p>
- *          </note>
- *          <p>This API action is not supported by <code>EXPRESS</code> state machines.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, DescribeStateMachineForExecutionCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, DescribeStateMachineForExecutionCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new DescribeStateMachineForExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeStateMachineForExecutionCommandInput} for command's `input` shape.
- * @see {@link DescribeStateMachineForExecutionCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeStateMachineForExecutionCommand extends $Command<DescribeStateMachineForExecutionCommandInput, DescribeStateMachineForExecutionCommandOutput, SFNClientResolvedConfig> {
     readonly input: DescribeStateMachineForExecutionCommandInput;
     constructor(input: DescribeStateMachineForExecutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStateMachineForExecutionCommandInput, DescribeStateMachineForExecutionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetActivityTaskCommand.d.ts

@@ -6,41 +6,11 @@ export interface GetActivityTaskCommandInput extends GetActivityTaskInput {
 }
 export interface GetActivityTaskCommandOutput extends GetActivityTaskOutput, __MetadataBearer {
 }
-/**
- * <p>Used by workers to retrieve a task (with the specified activity ARN) which has been
- *       scheduled for execution by a running state machine. This initiates a long poll, where the
- *       service holds the HTTP connection open and responds as soon as a task becomes available (i.e.
- *       an execution of a task of this type is needed.) The maximum time the service holds on to the
- *       request before responding is 60 seconds. If no task is available within 60 seconds, the poll
- *       returns a <code>taskToken</code> with a null string.</p>
- *          <important>
- *             <p>Workers should set their client side socket timeout to at least 65 seconds (5 seconds
- *         higher than the maximum time the service may hold the poll request).</p>
- *             <p>Polling with <code>GetActivityTask</code> can cause latency in some implementations. See
- *           <a href="https://docs.aws.amazon.com/step-functions/latest/dg/bp-activity-pollers.html">Avoid
- *           Latency When Polling for Activity Tasks</a> in the Step Functions Developer Guide.</p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, GetActivityTaskCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, GetActivityTaskCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new GetActivityTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetActivityTaskCommandInput} for command's `input` shape.
- * @see {@link GetActivityTaskCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetActivityTaskCommand extends $Command<GetActivityTaskCommandInput, GetActivityTaskCommandOutput, SFNClientResolvedConfig> {
     readonly input: GetActivityTaskCommandInput;
     constructor(input: GetActivityTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetActivityTaskCommandInput, GetActivityTaskCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetExecutionHistoryCommand.d.ts

@@ -6,34 +6,11 @@ export interface GetExecutionHistoryCommandInput extends GetExecutionHistoryInpu
 }
 export interface GetExecutionHistoryCommandOutput extends GetExecutionHistoryOutput, __MetadataBearer {
 }
-/**
- * <p>Returns the history of the specified execution as a list of events. By default, the
- *       results are returned in ascending order of the <code>timeStamp</code> of the events. Use the
- *         <code>reverseOrder</code> parameter to get the latest events first.</p>
- *          <p>If <code>nextToken</code> is returned, there are more results available. The value of <code>nextToken</code> is a unique pagination token for each page.
- *     Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an <i>HTTP 400 InvalidToken</i> error.</p>
- *          <p>This API action is not supported by <code>EXPRESS</code> state machines.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, GetExecutionHistoryCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, GetExecutionHistoryCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new GetExecutionHistoryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetExecutionHistoryCommandInput} for command's `input` shape.
- * @see {@link GetExecutionHistoryCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetExecutionHistoryCommand extends $Command<GetExecutionHistoryCommandInput, GetExecutionHistoryCommandOutput, SFNClientResolvedConfig> {
     readonly input: GetExecutionHistoryCommandInput;
     constructor(input: GetExecutionHistoryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetExecutionHistoryCommandInput, GetExecutionHistoryCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListActivitiesCommand.d.ts

@@ -6,34 +6,11 @@ export interface ListActivitiesCommandInput extends ListActivitiesInput {
 }
 export interface ListActivitiesCommandOutput extends ListActivitiesOutput, __MetadataBearer {
 }
-/**
- * <p>Lists the existing activities.</p>
- *          <p>If <code>nextToken</code> is returned, there are more results available. The value of <code>nextToken</code> is a unique pagination token for each page.
- *     Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an <i>HTTP 400 InvalidToken</i> error.</p>
- *          <note>
- *             <p>This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, ListActivitiesCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, ListActivitiesCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new ListActivitiesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListActivitiesCommandInput} for command's `input` shape.
- * @see {@link ListActivitiesCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListActivitiesCommand extends $Command<ListActivitiesCommandInput, ListActivitiesCommandOutput, SFNClientResolvedConfig> {
     readonly input: ListActivitiesCommandInput;
     constructor(input: ListActivitiesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListActivitiesCommandInput, ListActivitiesCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListExecutionsCommand.d.ts

@@ -6,36 +6,11 @@ export interface ListExecutionsCommandInput extends ListExecutionsInput {
 }
 export interface ListExecutionsCommandOutput extends ListExecutionsOutput, __MetadataBearer {
 }
-/**
- * <p>Lists the executions of a state machine that meet the filtering criteria. Results are
- *       sorted by time, with the most recent execution first.</p>
- *          <p>If <code>nextToken</code> is returned, there are more results available. The value of <code>nextToken</code> is a unique pagination token for each page.
- *     Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an <i>HTTP 400 InvalidToken</i> error.</p>
- *          <note>
- *             <p>This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.</p>
- *          </note>
- *          <p>This API action is not supported by <code>EXPRESS</code> state machines.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, ListExecutionsCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, ListExecutionsCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new ListExecutionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListExecutionsCommandInput} for command's `input` shape.
- * @see {@link ListExecutionsCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListExecutionsCommand extends $Command<ListExecutionsCommandInput, ListExecutionsCommandOutput, SFNClientResolvedConfig> {
     readonly input: ListExecutionsCommandInput;
     constructor(input: ListExecutionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListExecutionsCommandInput, ListExecutionsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListStateMachinesCommand.d.ts

@@ -6,34 +6,11 @@ export interface ListStateMachinesCommandInput extends ListStateMachinesInput {
 }
 export interface ListStateMachinesCommandOutput extends ListStateMachinesOutput, __MetadataBearer {
 }
-/**
- * <p>Lists the existing state machines.</p>
- *          <p>If <code>nextToken</code> is returned, there are more results available. The value of <code>nextToken</code> is a unique pagination token for each page.
- *     Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an <i>HTTP 400 InvalidToken</i> error.</p>
- *          <note>
- *             <p>This operation is eventually consistent. The results are best effort and may not reflect very recent updates and changes.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, ListStateMachinesCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, ListStateMachinesCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new ListStateMachinesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListStateMachinesCommandInput} for command's `input` shape.
- * @see {@link ListStateMachinesCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListStateMachinesCommand extends $Command<ListStateMachinesCommandInput, ListStateMachinesCommandOutput, SFNClientResolvedConfig> {
     readonly input: ListStateMachinesCommandInput;
     constructor(input: ListStateMachinesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListStateMachinesCommandInput, ListStateMachinesCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListTagsForResourceCommand.d.ts

@@ -6,30 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceInpu
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceOutput, __MetadataBearer {
 }
-/**
- * <p>List tags for a given resource.</p>
- *          <p>Tags may only contain Unicode letters, digits, white space, or these symbols: <code>_ . : / = + - @</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, ListTagsForResourceCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, ListTagsForResourceCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, SFNClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/SendTaskFailureCommand.d.ts

@@ -6,30 +6,11 @@ export interface SendTaskFailureCommandInput extends SendTaskFailureInput {
 }
 export interface SendTaskFailureCommandOutput extends SendTaskFailureOutput, __MetadataBearer {
 }
-/**
- * <p>Used by activity workers and task states using the <a href="https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token">callback</a>
- *       pattern to report that the task identified by the <code>taskToken</code> failed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, SendTaskFailureCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, SendTaskFailureCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new SendTaskFailureCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SendTaskFailureCommandInput} for command's `input` shape.
- * @see {@link SendTaskFailureCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SendTaskFailureCommand extends $Command<SendTaskFailureCommandInput, SendTaskFailureCommandOutput, SFNClientResolvedConfig> {
     readonly input: SendTaskFailureCommandInput;
     constructor(input: SendTaskFailureCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendTaskFailureCommandInput, SendTaskFailureCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/SendTaskHeartbeatCommand.d.ts

@@ -6,43 +6,11 @@ export interface SendTaskHeartbeatCommandInput extends SendTaskHeartbeatInput {
 }
 export interface SendTaskHeartbeatCommandOutput extends SendTaskHeartbeatOutput, __MetadataBearer {
 }
-/**
- * <p>Used by activity workers and task states using the <a href="https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token">callback</a>
- *       pattern to report to Step Functions that the task represented by the specified
- *         <code>taskToken</code> is still making progress. This action resets the
- *         <code>Heartbeat</code> clock. The <code>Heartbeat</code> threshold is specified in the state
- *       machine's Amazon States Language definition (<code>HeartbeatSeconds</code>). This action does not in itself
- *       create an event in the execution history. However, if the task times out, the execution
- *       history contains an <code>ActivityTimedOut</code> entry for activities, or a
- *         <code>TaskTimedOut</code> entry for for tasks using the <a href="https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync">job run</a> or
- *         <a href="https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token">callback</a>
- *       pattern.</p>
- *          <note>
- *             <p>The <code>Timeout</code> of a task, defined in the state machine's Amazon States Language definition, is
- *         its maximum allowed duration, regardless of the number of <a>SendTaskHeartbeat</a> requests received. Use <code>HeartbeatSeconds</code> to configure the timeout interval
- *         for heartbeats.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, SendTaskHeartbeatCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, SendTaskHeartbeatCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new SendTaskHeartbeatCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SendTaskHeartbeatCommandInput} for command's `input` shape.
- * @see {@link SendTaskHeartbeatCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SendTaskHeartbeatCommand extends $Command<SendTaskHeartbeatCommandInput, SendTaskHeartbeatCommandOutput, SFNClientResolvedConfig> {
     readonly input: SendTaskHeartbeatCommandInput;
     constructor(input: SendTaskHeartbeatCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendTaskHeartbeatCommandInput, SendTaskHeartbeatCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/SendTaskSuccessCommand.d.ts

@@ -6,31 +6,11 @@ export interface SendTaskSuccessCommandInput extends SendTaskSuccessInput {
 }
 export interface SendTaskSuccessCommandOutput extends SendTaskSuccessOutput, __MetadataBearer {
 }
-/**
- * <p>Used by activity workers and task states using the <a href="https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token">callback</a>
- *       pattern to report that the task identified by the <code>taskToken</code> completed
- *       successfully.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, SendTaskSuccessCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, SendTaskSuccessCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new SendTaskSuccessCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SendTaskSuccessCommandInput} for command's `input` shape.
- * @see {@link SendTaskSuccessCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SendTaskSuccessCommand extends $Command<SendTaskSuccessCommandInput, SendTaskSuccessCommandOutput, SFNClientResolvedConfig> {
     readonly input: SendTaskSuccessCommandInput;
     constructor(input: SendTaskSuccessCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendTaskSuccessCommandInput, SendTaskSuccessCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/StartExecutionCommand.d.ts

@@ -6,37 +6,11 @@ export interface StartExecutionCommandInput extends StartExecutionInput {
 }
 export interface StartExecutionCommandOutput extends StartExecutionOutput, __MetadataBearer {
 }
-/**
- * <p>Starts a state machine execution.</p>
- *          <note>
- *             <p>
- *                <code>StartExecution</code> is idempotent. If <code>StartExecution</code> is called with
- *         the same name and input as a running execution, the call will succeed and return the same
- *         response as the original request. If the execution is closed or if the input is different,
- *         it will return a 400 <code>ExecutionAlreadyExists</code> error. Names can be reused after 90
- *         days. </p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, StartExecutionCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, StartExecutionCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new StartExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartExecutionCommandInput} for command's `input` shape.
- * @see {@link StartExecutionCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartExecutionCommand extends $Command<StartExecutionCommandInput, StartExecutionCommandOutput, SFNClientResolvedConfig> {
     readonly input: StartExecutionCommandInput;
     constructor(input: StartExecutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartExecutionCommandInput, StartExecutionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/StartSyncExecutionCommand.d.ts

@@ -6,29 +6,11 @@ export interface StartSyncExecutionCommandInput extends StartSyncExecutionInput
 }
 export interface StartSyncExecutionCommandOutput extends StartSyncExecutionOutput, __MetadataBearer {
 }
-/**
- * <p>Starts a Synchronous Express state machine execution.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, StartSyncExecutionCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, StartSyncExecutionCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new StartSyncExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartSyncExecutionCommandInput} for command's `input` shape.
- * @see {@link StartSyncExecutionCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartSyncExecutionCommand extends $Command<StartSyncExecutionCommandInput, StartSyncExecutionCommandOutput, SFNClientResolvedConfig> {
     readonly input: StartSyncExecutionCommandInput;
     constructor(input: StartSyncExecutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartSyncExecutionCommandInput, StartSyncExecutionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/StopExecutionCommand.d.ts

@@ -6,30 +6,11 @@ export interface StopExecutionCommandInput extends StopExecutionInput {
 }
 export interface StopExecutionCommandOutput extends StopExecutionOutput, __MetadataBearer {
 }
-/**
- * <p>Stops an execution.</p>
- *          <p>This API action is not supported by <code>EXPRESS</code> state machines.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SFNClient, StopExecutionCommand } from "@aws-sdk/client-sfn"; // ES Modules import
- * // const { SFNClient, StopExecutionCommand } = require("@aws-sdk/client-sfn"); // CommonJS import
- * const client = new SFNClient(config);
- * const command = new StopExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopExecutionCommandInput} for command's `input` shape.
- * @see {@link StopExecutionCommandOutput} for command's `response` shape.
- * @see {@link SFNClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopExecutionCommand extends $Command<StopExecutionCommandInput, StopExecutionCommandOutput, SFNClientResolvedConfig> {
     readonly input: StopExecutionCommandInput;
     constructor(input: StopExecutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SFNClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopExecutionCommandInput, StopExecutionCommandOutput>;
     private serialize;
     private deserialize;