@aws-sdk/client-swf 3.35.0 → 3.38.0

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

@@ -6,68 +6,11 @@ export interface RespondActivityTaskCompletedCommandInput extends RespondActivit
 }
 export interface RespondActivityTaskCompletedCommandOutput extends __MetadataBearer {
 }
-/**
- * <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
- *       workflow history.</p>
- *
- *          <important>
- *             <p>If the requested task doesn't complete successfully, use <a>RespondActivityTaskFailed</a> instead. If the worker finds that the task is
- *         canceled through the <code>canceled</code> flag returned by <a>RecordActivityTaskHeartbeat</a>, it should cancel the task, clean up and then call
- *           <a>RespondActivityTaskCanceled</a>.</p>
- *          </important>
- *
- *          <p>A task is considered open from the time that it is scheduled until it is closed.
- *       Therefore a task is reported as open while a worker is processing it. A task is closed after
- *       it has been specified in a call to RespondActivityTaskCompleted, <a>RespondActivityTaskCanceled</a>, <a>RespondActivityTaskFailed</a>, or the
- *       task has <a href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dg-basic.html#swf-dev-timeout-types">timed
- *         out</a>.</p>
- *
- *          <p>
- *             <b>Access Control</b>
- *          </p>
- *          <p>You can use IAM policies to control this action's access to Amazon SWF resources as
- *       follows:</p>
- *          <ul>
- *             <li>
- *                <p>Use a <code>Resource</code> element with the domain name to limit the action to
- *           only specified domains.</p>
- *             </li>
- *             <li>
- *                <p>Use an <code>Action</code> element to allow or deny permission to call this
- *           action.</p>
- *             </li>
- *             <li>
- *                <p>You cannot use an IAM policy to constrain this action's parameters.</p>
- *             </li>
- *          </ul>
- *          <p>If the caller doesn't have sufficient permissions to invoke the action, or the
- *       parameter values fall outside the specified constraints, the action fails. The associated
- *       event attribute's <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>.
- *       For details and example IAM policies, see <a href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using IAM to Manage Access to Amazon SWF
- *         Workflows</a> in the <i>Amazon SWF Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SWFClient, RespondActivityTaskCompletedCommand } from "@aws-sdk/client-swf"; // ES Modules import
- * // const { SWFClient, RespondActivityTaskCompletedCommand } = require("@aws-sdk/client-swf"); // CommonJS import
- * const client = new SWFClient(config);
- * const command = new RespondActivityTaskCompletedCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RespondActivityTaskCompletedCommandInput} for command's `input` shape.
- * @see {@link RespondActivityTaskCompletedCommandOutput} for command's `response` shape.
- * @see {@link SWFClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RespondActivityTaskCompletedCommand extends $Command<RespondActivityTaskCompletedCommandInput, RespondActivityTaskCompletedCommandOutput, SWFClientResolvedConfig> {
     readonly input: RespondActivityTaskCompletedCommandInput;
     constructor(input: RespondActivityTaskCompletedCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RespondActivityTaskCompletedCommandInput, RespondActivityTaskCompletedCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,61 +6,11 @@ export interface RespondActivityTaskFailedCommandInput extends RespondActivityTa
 }
 export interface RespondActivityTaskFailedCommandOutput extends __MetadataBearer {
 }
-/**
- * <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>
- *       event added to the workflow history.</p>
- *
- *          <p>A task is considered open from the time that it is scheduled until it is closed.
- *       Therefore a task is reported as open while a worker is processing it. A task is closed after
- *       it has been specified in a call to <a>RespondActivityTaskCompleted</a>, <a>RespondActivityTaskCanceled</a>, RespondActivityTaskFailed, or the task has <a href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dg-basic.html#swf-dev-timeout-types">timed
- *         out</a>.</p>
- *
- *          <p>
- *             <b>Access Control</b>
- *          </p>
- *          <p>You can use IAM policies to control this action's access to Amazon SWF resources as
- *       follows:</p>
- *          <ul>
- *             <li>
- *                <p>Use a <code>Resource</code> element with the domain name to limit the action to
- *           only specified domains.</p>
- *             </li>
- *             <li>
- *                <p>Use an <code>Action</code> element to allow or deny permission to call this
- *           action.</p>
- *             </li>
- *             <li>
- *                <p>You cannot use an IAM policy to constrain this action's parameters.</p>
- *             </li>
- *          </ul>
- *          <p>If the caller doesn't have sufficient permissions to invoke the action, or the
- *       parameter values fall outside the specified constraints, the action fails. The associated
- *       event attribute's <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>.
- *       For details and example IAM policies, see <a href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using IAM to Manage Access to Amazon SWF
- *         Workflows</a> in the <i>Amazon SWF Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SWFClient, RespondActivityTaskFailedCommand } from "@aws-sdk/client-swf"; // ES Modules import
- * // const { SWFClient, RespondActivityTaskFailedCommand } = require("@aws-sdk/client-swf"); // CommonJS import
- * const client = new SWFClient(config);
- * const command = new RespondActivityTaskFailedCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RespondActivityTaskFailedCommandInput} for command's `input` shape.
- * @see {@link RespondActivityTaskFailedCommandOutput} for command's `response` shape.
- * @see {@link SWFClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RespondActivityTaskFailedCommand extends $Command<RespondActivityTaskFailedCommandInput, RespondActivityTaskFailedCommandOutput, SWFClientResolvedConfig> {
     readonly input: RespondActivityTaskFailedCommandInput;
     constructor(input: RespondActivityTaskFailedCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RespondActivityTaskFailedCommandInput, RespondActivityTaskFailedCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,48 +6,11 @@ export interface RespondDecisionTaskCompletedCommandInput extends RespondDecisio
 }
 export interface RespondDecisionTaskCompletedCommandOutput extends __MetadataBearer {
 }
-/**
- * <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>
- *
- *          <p>A <code>DecisionTaskCompleted</code> event is added to the workflow history. The
- *         <code>executionContext</code> specified is attached to the event in the workflow execution
- *       history.</p>
- *
- *          <p>
- *             <b>Access Control</b>
- *          </p>
- *
- *          <p>If an IAM policy grants permission to use <code>RespondDecisionTaskCompleted</code>, it
- *       can express permissions for the list of decisions in the <code>decisions</code> parameter.
- *       Each of the decisions has one or more parameters, much like a regular API call. To allow for
- *       policies to be as readable as possible, you can express permissions on decisions as if they
- *       were actual API calls, including applying conditions to some parameters. For more information,
- *       see <a href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
- *         IAM to Manage Access to Amazon SWF Workflows</a> in the
- *       <i>Amazon SWF Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SWFClient, RespondDecisionTaskCompletedCommand } from "@aws-sdk/client-swf"; // ES Modules import
- * // const { SWFClient, RespondDecisionTaskCompletedCommand } = require("@aws-sdk/client-swf"); // CommonJS import
- * const client = new SWFClient(config);
- * const command = new RespondDecisionTaskCompletedCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RespondDecisionTaskCompletedCommandInput} for command's `input` shape.
- * @see {@link RespondDecisionTaskCompletedCommandOutput} for command's `response` shape.
- * @see {@link SWFClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RespondDecisionTaskCompletedCommand extends $Command<RespondDecisionTaskCompletedCommandInput, RespondDecisionTaskCompletedCommandOutput, SWFClientResolvedConfig> {
     readonly input: RespondDecisionTaskCompletedCommandInput;
     constructor(input: RespondDecisionTaskCompletedCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RespondDecisionTaskCompletedCommandInput, RespondDecisionTaskCompletedCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,67 +6,11 @@ export interface SignalWorkflowExecutionCommandInput extends SignalWorkflowExecu
 }
 export interface SignalWorkflowExecutionCommandOutput extends __MetadataBearer {
 }
-/**
- * <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
- *       input (if provided).</p>
- *
- *          <note>
- *             <p>If a runId isn't specified, then the <code>WorkflowExecutionSignaled</code> event is
- *         recorded in the history of the current open workflow with the matching workflowId in the
- *         domain.</p>
- *          </note>
- *
- *          <note>
- *             <p>If the specified workflow execution isn't open, this method fails with
- *           <code>UnknownResource</code>.</p>
- *          </note>
- *
- *          <p>
- *             <b>Access Control</b>
- *          </p>
- *          <p>You can use IAM policies to control this action's access to Amazon SWF resources as
- *       follows:</p>
- *          <ul>
- *             <li>
- *                <p>Use a <code>Resource</code> element with the domain name to limit the action to
- *           only specified domains.</p>
- *             </li>
- *             <li>
- *                <p>Use an <code>Action</code> element to allow or deny permission to call this
- *           action.</p>
- *             </li>
- *             <li>
- *                <p>You cannot use an IAM policy to constrain this action's parameters.</p>
- *             </li>
- *          </ul>
- *          <p>If the caller doesn't have sufficient permissions to invoke the action, or the
- *       parameter values fall outside the specified constraints, the action fails. The associated
- *       event attribute's <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>.
- *       For details and example IAM policies, see <a href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using IAM to Manage Access to Amazon SWF
- *         Workflows</a> in the <i>Amazon SWF Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SWFClient, SignalWorkflowExecutionCommand } from "@aws-sdk/client-swf"; // ES Modules import
- * // const { SWFClient, SignalWorkflowExecutionCommand } = require("@aws-sdk/client-swf"); // CommonJS import
- * const client = new SWFClient(config);
- * const command = new SignalWorkflowExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SignalWorkflowExecutionCommandInput} for command's `input` shape.
- * @see {@link SignalWorkflowExecutionCommandOutput} for command's `response` shape.
- * @see {@link SWFClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SignalWorkflowExecutionCommand extends $Command<SignalWorkflowExecutionCommandInput, SignalWorkflowExecutionCommandOutput, SWFClientResolvedConfig> {
     readonly input: SignalWorkflowExecutionCommandInput;
     constructor(input: SignalWorkflowExecutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SignalWorkflowExecutionCommandInput, SignalWorkflowExecutionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,94 +6,11 @@ export interface StartWorkflowExecutionCommandInput extends StartWorkflowExecuti
 }
 export interface StartWorkflowExecutionCommandOutput extends Run, __MetadataBearer {
 }
-/**
- * <p>Starts an execution of the workflow type in the specified domain using the provided
- *         <code>workflowId</code> and input data.</p>
- *
- *          <p>This action returns the newly started workflow execution.</p>
- *
- *          <p>
- *             <b>Access Control</b>
- *          </p>
- *          <p>You can use IAM policies to control this action's access to Amazon SWF resources as
- *       follows:</p>
- *          <ul>
- *             <li>
- *                <p>Use a <code>Resource</code> element with the domain name to limit the action to
- *           only specified domains.</p>
- *             </li>
- *             <li>
- *                <p>Use an <code>Action</code> element to allow or deny permission to call this
- *           action.</p>
- *             </li>
- *             <li>
- *                <p>Constrain the following parameters by using a <code>Condition</code> element with
- *           the appropriate keys.</p>
- *                <ul>
- *                   <li>
- *                      <p>
- *                         <code>tagList.member.0</code>: The key is <code>swf:tagList.member.0</code>.</p>
- *                   </li>
- *                   <li>
- *                      <p>
- *                         <code>tagList.member.1</code>: The key is <code>swf:tagList.member.1</code>.</p>
- *                   </li>
- *                   <li>
- *                      <p>
- *                         <code>tagList.member.2</code>: The key is <code>swf:tagList.member.2</code>.</p>
- *                   </li>
- *                   <li>
- *                      <p>
- *                         <code>tagList.member.3</code>: The key is <code>swf:tagList.member.3</code>.</p>
- *                   </li>
- *                   <li>
- *                      <p>
- *                         <code>tagList.member.4</code>: The key is <code>swf:tagList.member.4</code>.</p>
- *                   </li>
- *                   <li>
- *                      <p>
- *                         <code>taskList</code>: String constraint. The key is
- *               <code>swf:taskList.name</code>.</p>
- *                   </li>
- *                   <li>
- *                      <p>
- *                         <code>workflowType.name</code>: String constraint. The key is
- *                 <code>swf:workflowType.name</code>.</p>
- *                   </li>
- *                   <li>
- *                      <p>
- *                         <code>workflowType.version</code>: String constraint. The key is
- *                 <code>swf:workflowType.version</code>.</p>
- *                   </li>
- *                </ul>
- *             </li>
- *          </ul>
- *          <p>If the caller doesn't have sufficient permissions to invoke the action, or the
- *       parameter values fall outside the specified constraints, the action fails. The associated
- *       event attribute's <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>.
- *       For details and example IAM policies, see <a href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using IAM to Manage Access to Amazon SWF
- *         Workflows</a> in the <i>Amazon SWF Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SWFClient, StartWorkflowExecutionCommand } from "@aws-sdk/client-swf"; // ES Modules import
- * // const { SWFClient, StartWorkflowExecutionCommand } = require("@aws-sdk/client-swf"); // CommonJS import
- * const client = new SWFClient(config);
- * const command = new StartWorkflowExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartWorkflowExecutionCommandInput} for command's `input` shape.
- * @see {@link StartWorkflowExecutionCommandOutput} for command's `response` shape.
- * @see {@link SWFClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartWorkflowExecutionCommand extends $Command<StartWorkflowExecutionCommandInput, StartWorkflowExecutionCommandOutput, SWFClientResolvedConfig> {
     readonly input: StartWorkflowExecutionCommandInput;
     constructor(input: StartWorkflowExecutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartWorkflowExecutionCommandInput, StartWorkflowExecutionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface TagResourceCommandInput extends TagResourceInput {
 }
 export interface TagResourceCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Add a tag to a Amazon SWF domain.</p>
- *          <note>
- *             <p>Amazon SWF supports a maximum of 50 tags per resource.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SWFClient, TagResourceCommand } from "@aws-sdk/client-swf"; // ES Modules import
- * // const { SWFClient, TagResourceCommand } = require("@aws-sdk/client-swf"); // CommonJS import
- * const client = new SWFClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link SWFClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, SWFClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,72 +6,11 @@ export interface TerminateWorkflowExecutionCommandInput extends TerminateWorkflo
 }
 export interface TerminateWorkflowExecutionCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Records a <code>WorkflowExecutionTerminated</code> event and forces closure of the
- *       workflow execution identified by the given domain, runId, and workflowId. The child policy,
- *       registered with the workflow type or specified when starting this execution, is applied to any
- *       open child workflow executions of this workflow execution.</p>
- *
- *          <important>
- *             <p>If the identified workflow execution was in progress, it is terminated
- *         immediately.</p>
- *          </important>
- *
- *          <note>
- *             <p>If a runId isn't specified, then the <code>WorkflowExecutionTerminated</code> event
- *         is recorded in the history of the current open workflow with the matching workflowId in the
- *         domain.</p>
- *          </note>
- *
- *          <note>
- *             <p>You should consider using <a>RequestCancelWorkflowExecution</a> action
- *         instead because it allows the workflow to gracefully close while <a>TerminateWorkflowExecution</a> doesn't.</p>
- *          </note>
- *
- *          <p>
- *             <b>Access Control</b>
- *          </p>
- *          <p>You can use IAM policies to control this action's access to Amazon SWF resources as
- *       follows:</p>
- *          <ul>
- *             <li>
- *                <p>Use a <code>Resource</code> element with the domain name to limit the action to
- *           only specified domains.</p>
- *             </li>
- *             <li>
- *                <p>Use an <code>Action</code> element to allow or deny permission to call this
- *           action.</p>
- *             </li>
- *             <li>
- *                <p>You cannot use an IAM policy to constrain this action's parameters.</p>
- *             </li>
- *          </ul>
- *          <p>If the caller doesn't have sufficient permissions to invoke the action, or the
- *       parameter values fall outside the specified constraints, the action fails. The associated
- *       event attribute's <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>.
- *       For details and example IAM policies, see <a href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using IAM to Manage Access to Amazon SWF
- *         Workflows</a> in the <i>Amazon SWF Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SWFClient, TerminateWorkflowExecutionCommand } from "@aws-sdk/client-swf"; // ES Modules import
- * // const { SWFClient, TerminateWorkflowExecutionCommand } = require("@aws-sdk/client-swf"); // CommonJS import
- * const client = new SWFClient(config);
- * const command = new TerminateWorkflowExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TerminateWorkflowExecutionCommandInput} for command's `input` shape.
- * @see {@link TerminateWorkflowExecutionCommandOutput} for command's `response` shape.
- * @see {@link SWFClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TerminateWorkflowExecutionCommand extends $Command<TerminateWorkflowExecutionCommandInput, TerminateWorkflowExecutionCommandOutput, SWFClientResolvedConfig> {
     readonly input: TerminateWorkflowExecutionCommandInput;
     constructor(input: TerminateWorkflowExecutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TerminateWorkflowExecutionCommandInput, TerminateWorkflowExecutionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,70 +6,11 @@ export interface UndeprecateActivityTypeCommandInput extends UndeprecateActivity
 }
 export interface UndeprecateActivityTypeCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Undeprecates a previously deprecated <i>activity type</i>. After an activity type has
- *       been undeprecated, you can create new tasks of that activity type.</p>
- *          <note>
- *             <p>This operation is eventually consistent. The results are best effort and may not
- *         exactly reflect recent updates and changes.</p>
- *          </note>
- *          <p>
- *             <b>Access Control</b>
- *          </p>
- *          <p>You can use IAM policies to control this action's access to Amazon SWF resources as
- *       follows:</p>
- *          <ul>
- *             <li>
- *                <p>Use a <code>Resource</code> element with the domain name to limit the action to
- *           only specified domains.</p>
- *             </li>
- *             <li>
- *                <p>Use an <code>Action</code> element to allow or deny permission to call this
- *           action.</p>
- *             </li>
- *             <li>
- *                <p>Constrain the following parameters by using a <code>Condition</code> element with
- *           the appropriate keys.</p>
- *                <ul>
- *                   <li>
- *                      <p>
- *                         <code>activityType.name</code>: String constraint. The key is
- *               <code>swf:activityType.name</code>.</p>
- *                   </li>
- *                   <li>
- *                      <p>
- *                         <code>activityType.version</code>: String constraint. The key is
- *               <code>swf:activityType.version</code>.</p>
- *                   </li>
- *                </ul>
- *             </li>
- *          </ul>
- *          <p>If the caller doesn't have sufficient permissions to invoke the action, or the
- *       parameter values fall outside the specified constraints, the action fails. The associated
- *       event attribute's <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>.
- *       For details and example IAM policies, see <a href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using IAM to Manage Access to Amazon SWF
- *         Workflows</a> in the <i>Amazon SWF Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SWFClient, UndeprecateActivityTypeCommand } from "@aws-sdk/client-swf"; // ES Modules import
- * // const { SWFClient, UndeprecateActivityTypeCommand } = require("@aws-sdk/client-swf"); // CommonJS import
- * const client = new SWFClient(config);
- * const command = new UndeprecateActivityTypeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UndeprecateActivityTypeCommandInput} for command's `input` shape.
- * @see {@link UndeprecateActivityTypeCommandOutput} for command's `response` shape.
- * @see {@link SWFClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UndeprecateActivityTypeCommand extends $Command<UndeprecateActivityTypeCommandInput, UndeprecateActivityTypeCommandOutput, SWFClientResolvedConfig> {
     readonly input: UndeprecateActivityTypeCommandInput;
     constructor(input: UndeprecateActivityTypeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UndeprecateActivityTypeCommandInput, UndeprecateActivityTypeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,57 +6,11 @@ export interface UndeprecateDomainCommandInput extends UndeprecateDomainInput {
 }
 export interface UndeprecateDomainCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Undeprecates a previously deprecated domain. After a domain has been undeprecated it can be used
- *       to create new workflow executions or register new types.</p>
- *          <note>
- *             <p>This operation is eventually consistent. The results are best effort and may not
- *         exactly reflect recent updates and changes.</p>
- *          </note>
- *          <p>
- *             <b>Access Control</b>
- *          </p>
- *          <p>You can use IAM policies to control this action's access to Amazon SWF resources as
- *       follows:</p>
- *          <ul>
- *             <li>
- *                <p>Use a <code>Resource</code> element with the domain name to limit the action to
- *           only specified domains.</p>
- *             </li>
- *             <li>
- *                <p>Use an <code>Action</code> element to allow or deny permission to call this
- *           action.</p>
- *             </li>
- *             <li>
- *                <p>You cannot use an IAM policy to constrain this action's parameters.</p>
- *             </li>
- *          </ul>
- *          <p>If the caller doesn't have sufficient permissions to invoke the action, or the
- *       parameter values fall outside the specified constraints, the action fails. The associated
- *       event attribute's <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>.
- *       For details and example IAM policies, see <a href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using IAM to Manage Access to Amazon SWF
- *         Workflows</a> in the <i>Amazon SWF Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SWFClient, UndeprecateDomainCommand } from "@aws-sdk/client-swf"; // ES Modules import
- * // const { SWFClient, UndeprecateDomainCommand } = require("@aws-sdk/client-swf"); // CommonJS import
- * const client = new SWFClient(config);
- * const command = new UndeprecateDomainCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UndeprecateDomainCommandInput} for command's `input` shape.
- * @see {@link UndeprecateDomainCommandOutput} for command's `response` shape.
- * @see {@link SWFClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UndeprecateDomainCommand extends $Command<UndeprecateDomainCommandInput, UndeprecateDomainCommandOutput, SWFClientResolvedConfig> {
     readonly input: UndeprecateDomainCommandInput;
     constructor(input: UndeprecateDomainCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SWFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UndeprecateDomainCommandInput, UndeprecateDomainCommandOutput>;
     private serialize;
     private deserialize;