@aws-sdk/client-swf 3.934.0 → 3.935.0

package/dist-types/models/enums.d.ts

@@ -0,0 +1,409 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const ActivityTaskTimeoutType: {
+    readonly HEARTBEAT: "HEARTBEAT";
+    readonly SCHEDULE_TO_CLOSE: "SCHEDULE_TO_CLOSE";
+    readonly SCHEDULE_TO_START: "SCHEDULE_TO_START";
+    readonly START_TO_CLOSE: "START_TO_CLOSE";
+};
+/**
+ * @public
+ */
+export type ActivityTaskTimeoutType = (typeof ActivityTaskTimeoutType)[keyof typeof ActivityTaskTimeoutType];
+/**
+ * @public
+ * @enum
+ */
+export declare const RegistrationStatus: {
+    readonly DEPRECATED: "DEPRECATED";
+    readonly REGISTERED: "REGISTERED";
+};
+/**
+ * @public
+ */
+export type RegistrationStatus = (typeof RegistrationStatus)[keyof typeof RegistrationStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const CancelTimerFailedCause: {
+    readonly OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED";
+    readonly TIMER_ID_UNKNOWN: "TIMER_ID_UNKNOWN";
+};
+/**
+ * @public
+ */
+export type CancelTimerFailedCause = (typeof CancelTimerFailedCause)[keyof typeof CancelTimerFailedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const CancelWorkflowExecutionFailedCause: {
+    readonly OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED";
+    readonly UNHANDLED_DECISION: "UNHANDLED_DECISION";
+};
+/**
+ * @public
+ */
+export type CancelWorkflowExecutionFailedCause = (typeof CancelWorkflowExecutionFailedCause)[keyof typeof CancelWorkflowExecutionFailedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChildPolicy: {
+    readonly ABANDON: "ABANDON";
+    readonly REQUEST_CANCEL: "REQUEST_CANCEL";
+    readonly TERMINATE: "TERMINATE";
+};
+/**
+ * @public
+ */
+export type ChildPolicy = (typeof ChildPolicy)[keyof typeof ChildPolicy];
+/**
+ * @public
+ * @enum
+ */
+export declare const WorkflowExecutionTimeoutType: {
+    readonly START_TO_CLOSE: "START_TO_CLOSE";
+};
+/**
+ * @public
+ */
+export type WorkflowExecutionTimeoutType = (typeof WorkflowExecutionTimeoutType)[keyof typeof WorkflowExecutionTimeoutType];
+/**
+ * @public
+ * @enum
+ */
+export declare const CloseStatus: {
+    readonly CANCELED: "CANCELED";
+    readonly COMPLETED: "COMPLETED";
+    readonly CONTINUED_AS_NEW: "CONTINUED_AS_NEW";
+    readonly FAILED: "FAILED";
+    readonly TERMINATED: "TERMINATED";
+    readonly TIMED_OUT: "TIMED_OUT";
+};
+/**
+ * @public
+ */
+export type CloseStatus = (typeof CloseStatus)[keyof typeof CloseStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const CompleteWorkflowExecutionFailedCause: {
+    readonly OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED";
+    readonly UNHANDLED_DECISION: "UNHANDLED_DECISION";
+};
+/**
+ * @public
+ */
+export type CompleteWorkflowExecutionFailedCause = (typeof CompleteWorkflowExecutionFailedCause)[keyof typeof CompleteWorkflowExecutionFailedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const ContinueAsNewWorkflowExecutionFailedCause: {
+    readonly CONTINUE_AS_NEW_WORKFLOW_EXECUTION_RATE_EXCEEDED: "CONTINUE_AS_NEW_WORKFLOW_EXECUTION_RATE_EXCEEDED";
+    readonly DEFAULT_CHILD_POLICY_UNDEFINED: "DEFAULT_CHILD_POLICY_UNDEFINED";
+    readonly DEFAULT_EXECUTION_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_EXECUTION_START_TO_CLOSE_TIMEOUT_UNDEFINED";
+    readonly DEFAULT_TASK_LIST_UNDEFINED: "DEFAULT_TASK_LIST_UNDEFINED";
+    readonly DEFAULT_TASK_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_TASK_START_TO_CLOSE_TIMEOUT_UNDEFINED";
+    readonly OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED";
+    readonly UNHANDLED_DECISION: "UNHANDLED_DECISION";
+    readonly WORKFLOW_TYPE_DEPRECATED: "WORKFLOW_TYPE_DEPRECATED";
+    readonly WORKFLOW_TYPE_DOES_NOT_EXIST: "WORKFLOW_TYPE_DOES_NOT_EXIST";
+};
+/**
+ * @public
+ */
+export type ContinueAsNewWorkflowExecutionFailedCause = (typeof ContinueAsNewWorkflowExecutionFailedCause)[keyof typeof ContinueAsNewWorkflowExecutionFailedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const DecisionType: {
+    readonly CancelTimer: "CancelTimer";
+    readonly CancelWorkflowExecution: "CancelWorkflowExecution";
+    readonly CompleteWorkflowExecution: "CompleteWorkflowExecution";
+    readonly ContinueAsNewWorkflowExecution: "ContinueAsNewWorkflowExecution";
+    readonly FailWorkflowExecution: "FailWorkflowExecution";
+    readonly RecordMarker: "RecordMarker";
+    readonly RequestCancelActivityTask: "RequestCancelActivityTask";
+    readonly RequestCancelExternalWorkflowExecution: "RequestCancelExternalWorkflowExecution";
+    readonly ScheduleActivityTask: "ScheduleActivityTask";
+    readonly ScheduleLambdaFunction: "ScheduleLambdaFunction";
+    readonly SignalExternalWorkflowExecution: "SignalExternalWorkflowExecution";
+    readonly StartChildWorkflowExecution: "StartChildWorkflowExecution";
+    readonly StartTimer: "StartTimer";
+};
+/**
+ * @public
+ */
+export type DecisionType = (typeof DecisionType)[keyof typeof DecisionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const DecisionTaskTimeoutType: {
+    readonly SCHEDULE_TO_START: "SCHEDULE_TO_START";
+    readonly START_TO_CLOSE: "START_TO_CLOSE";
+};
+/**
+ * @public
+ */
+export type DecisionTaskTimeoutType = (typeof DecisionTaskTimeoutType)[keyof typeof DecisionTaskTimeoutType];
+/**
+ * @public
+ * @enum
+ */
+export declare const EventType: {
+    readonly ActivityTaskCancelRequested: "ActivityTaskCancelRequested";
+    readonly ActivityTaskCanceled: "ActivityTaskCanceled";
+    readonly ActivityTaskCompleted: "ActivityTaskCompleted";
+    readonly ActivityTaskFailed: "ActivityTaskFailed";
+    readonly ActivityTaskScheduled: "ActivityTaskScheduled";
+    readonly ActivityTaskStarted: "ActivityTaskStarted";
+    readonly ActivityTaskTimedOut: "ActivityTaskTimedOut";
+    readonly CancelTimerFailed: "CancelTimerFailed";
+    readonly CancelWorkflowExecutionFailed: "CancelWorkflowExecutionFailed";
+    readonly ChildWorkflowExecutionCanceled: "ChildWorkflowExecutionCanceled";
+    readonly ChildWorkflowExecutionCompleted: "ChildWorkflowExecutionCompleted";
+    readonly ChildWorkflowExecutionFailed: "ChildWorkflowExecutionFailed";
+    readonly ChildWorkflowExecutionStarted: "ChildWorkflowExecutionStarted";
+    readonly ChildWorkflowExecutionTerminated: "ChildWorkflowExecutionTerminated";
+    readonly ChildWorkflowExecutionTimedOut: "ChildWorkflowExecutionTimedOut";
+    readonly CompleteWorkflowExecutionFailed: "CompleteWorkflowExecutionFailed";
+    readonly ContinueAsNewWorkflowExecutionFailed: "ContinueAsNewWorkflowExecutionFailed";
+    readonly DecisionTaskCompleted: "DecisionTaskCompleted";
+    readonly DecisionTaskScheduled: "DecisionTaskScheduled";
+    readonly DecisionTaskStarted: "DecisionTaskStarted";
+    readonly DecisionTaskTimedOut: "DecisionTaskTimedOut";
+    readonly ExternalWorkflowExecutionCancelRequested: "ExternalWorkflowExecutionCancelRequested";
+    readonly ExternalWorkflowExecutionSignaled: "ExternalWorkflowExecutionSignaled";
+    readonly FailWorkflowExecutionFailed: "FailWorkflowExecutionFailed";
+    readonly LambdaFunctionCompleted: "LambdaFunctionCompleted";
+    readonly LambdaFunctionFailed: "LambdaFunctionFailed";
+    readonly LambdaFunctionScheduled: "LambdaFunctionScheduled";
+    readonly LambdaFunctionStarted: "LambdaFunctionStarted";
+    readonly LambdaFunctionTimedOut: "LambdaFunctionTimedOut";
+    readonly MarkerRecorded: "MarkerRecorded";
+    readonly RecordMarkerFailed: "RecordMarkerFailed";
+    readonly RequestCancelActivityTaskFailed: "RequestCancelActivityTaskFailed";
+    readonly RequestCancelExternalWorkflowExecutionFailed: "RequestCancelExternalWorkflowExecutionFailed";
+    readonly RequestCancelExternalWorkflowExecutionInitiated: "RequestCancelExternalWorkflowExecutionInitiated";
+    readonly ScheduleActivityTaskFailed: "ScheduleActivityTaskFailed";
+    readonly ScheduleLambdaFunctionFailed: "ScheduleLambdaFunctionFailed";
+    readonly SignalExternalWorkflowExecutionFailed: "SignalExternalWorkflowExecutionFailed";
+    readonly SignalExternalWorkflowExecutionInitiated: "SignalExternalWorkflowExecutionInitiated";
+    readonly StartChildWorkflowExecutionFailed: "StartChildWorkflowExecutionFailed";
+    readonly StartChildWorkflowExecutionInitiated: "StartChildWorkflowExecutionInitiated";
+    readonly StartLambdaFunctionFailed: "StartLambdaFunctionFailed";
+    readonly StartTimerFailed: "StartTimerFailed";
+    readonly TimerCanceled: "TimerCanceled";
+    readonly TimerFired: "TimerFired";
+    readonly TimerStarted: "TimerStarted";
+    readonly WorkflowExecutionCancelRequested: "WorkflowExecutionCancelRequested";
+    readonly WorkflowExecutionCanceled: "WorkflowExecutionCanceled";
+    readonly WorkflowExecutionCompleted: "WorkflowExecutionCompleted";
+    readonly WorkflowExecutionContinuedAsNew: "WorkflowExecutionContinuedAsNew";
+    readonly WorkflowExecutionFailed: "WorkflowExecutionFailed";
+    readonly WorkflowExecutionSignaled: "WorkflowExecutionSignaled";
+    readonly WorkflowExecutionStarted: "WorkflowExecutionStarted";
+    readonly WorkflowExecutionTerminated: "WorkflowExecutionTerminated";
+    readonly WorkflowExecutionTimedOut: "WorkflowExecutionTimedOut";
+};
+/**
+ * @public
+ */
+export type EventType = (typeof EventType)[keyof typeof EventType];
+/**
+ * @public
+ * @enum
+ */
+export declare const FailWorkflowExecutionFailedCause: {
+    readonly OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED";
+    readonly UNHANDLED_DECISION: "UNHANDLED_DECISION";
+};
+/**
+ * @public
+ */
+export type FailWorkflowExecutionFailedCause = (typeof FailWorkflowExecutionFailedCause)[keyof typeof FailWorkflowExecutionFailedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const LambdaFunctionTimeoutType: {
+    readonly START_TO_CLOSE: "START_TO_CLOSE";
+};
+/**
+ * @public
+ */
+export type LambdaFunctionTimeoutType = (typeof LambdaFunctionTimeoutType)[keyof typeof LambdaFunctionTimeoutType];
+/**
+ * @public
+ * @enum
+ */
+export declare const RecordMarkerFailedCause: {
+    readonly OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED";
+};
+/**
+ * @public
+ */
+export type RecordMarkerFailedCause = (typeof RecordMarkerFailedCause)[keyof typeof RecordMarkerFailedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const RequestCancelActivityTaskFailedCause: {
+    readonly ACTIVITY_ID_UNKNOWN: "ACTIVITY_ID_UNKNOWN";
+    readonly OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED";
+};
+/**
+ * @public
+ */
+export type RequestCancelActivityTaskFailedCause = (typeof RequestCancelActivityTaskFailedCause)[keyof typeof RequestCancelActivityTaskFailedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const RequestCancelExternalWorkflowExecutionFailedCause: {
+    readonly OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED";
+    readonly REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_RATE_EXCEEDED: "REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_RATE_EXCEEDED";
+    readonly UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION: "UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION";
+};
+/**
+ * @public
+ */
+export type RequestCancelExternalWorkflowExecutionFailedCause = (typeof RequestCancelExternalWorkflowExecutionFailedCause)[keyof typeof RequestCancelExternalWorkflowExecutionFailedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const ScheduleActivityTaskFailedCause: {
+    readonly ACTIVITY_CREATION_RATE_EXCEEDED: "ACTIVITY_CREATION_RATE_EXCEEDED";
+    readonly ACTIVITY_ID_ALREADY_IN_USE: "ACTIVITY_ID_ALREADY_IN_USE";
+    readonly ACTIVITY_TYPE_DEPRECATED: "ACTIVITY_TYPE_DEPRECATED";
+    readonly ACTIVITY_TYPE_DOES_NOT_EXIST: "ACTIVITY_TYPE_DOES_NOT_EXIST";
+    readonly DEFAULT_HEARTBEAT_TIMEOUT_UNDEFINED: "DEFAULT_HEARTBEAT_TIMEOUT_UNDEFINED";
+    readonly DEFAULT_SCHEDULE_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_SCHEDULE_TO_CLOSE_TIMEOUT_UNDEFINED";
+    readonly DEFAULT_SCHEDULE_TO_START_TIMEOUT_UNDEFINED: "DEFAULT_SCHEDULE_TO_START_TIMEOUT_UNDEFINED";
+    readonly DEFAULT_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_START_TO_CLOSE_TIMEOUT_UNDEFINED";
+    readonly DEFAULT_TASK_LIST_UNDEFINED: "DEFAULT_TASK_LIST_UNDEFINED";
+    readonly OPEN_ACTIVITIES_LIMIT_EXCEEDED: "OPEN_ACTIVITIES_LIMIT_EXCEEDED";
+    readonly OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED";
+};
+/**
+ * @public
+ */
+export type ScheduleActivityTaskFailedCause = (typeof ScheduleActivityTaskFailedCause)[keyof typeof ScheduleActivityTaskFailedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const ScheduleLambdaFunctionFailedCause: {
+    readonly ID_ALREADY_IN_USE: "ID_ALREADY_IN_USE";
+    readonly LAMBDA_FUNCTION_CREATION_RATE_EXCEEDED: "LAMBDA_FUNCTION_CREATION_RATE_EXCEEDED";
+    readonly LAMBDA_SERVICE_NOT_AVAILABLE_IN_REGION: "LAMBDA_SERVICE_NOT_AVAILABLE_IN_REGION";
+    readonly OPEN_LAMBDA_FUNCTIONS_LIMIT_EXCEEDED: "OPEN_LAMBDA_FUNCTIONS_LIMIT_EXCEEDED";
+};
+/**
+ * @public
+ */
+export type ScheduleLambdaFunctionFailedCause = (typeof ScheduleLambdaFunctionFailedCause)[keyof typeof ScheduleLambdaFunctionFailedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const SignalExternalWorkflowExecutionFailedCause: {
+    readonly OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED";
+    readonly SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_RATE_EXCEEDED: "SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_RATE_EXCEEDED";
+    readonly UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION: "UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION";
+};
+/**
+ * @public
+ */
+export type SignalExternalWorkflowExecutionFailedCause = (typeof SignalExternalWorkflowExecutionFailedCause)[keyof typeof SignalExternalWorkflowExecutionFailedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const StartChildWorkflowExecutionFailedCause: {
+    readonly CHILD_CREATION_RATE_EXCEEDED: "CHILD_CREATION_RATE_EXCEEDED";
+    readonly DEFAULT_CHILD_POLICY_UNDEFINED: "DEFAULT_CHILD_POLICY_UNDEFINED";
+    readonly DEFAULT_EXECUTION_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_EXECUTION_START_TO_CLOSE_TIMEOUT_UNDEFINED";
+    readonly DEFAULT_TASK_LIST_UNDEFINED: "DEFAULT_TASK_LIST_UNDEFINED";
+    readonly DEFAULT_TASK_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_TASK_START_TO_CLOSE_TIMEOUT_UNDEFINED";
+    readonly OPEN_CHILDREN_LIMIT_EXCEEDED: "OPEN_CHILDREN_LIMIT_EXCEEDED";
+    readonly OPEN_WORKFLOWS_LIMIT_EXCEEDED: "OPEN_WORKFLOWS_LIMIT_EXCEEDED";
+    readonly OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED";
+    readonly WORKFLOW_ALREADY_RUNNING: "WORKFLOW_ALREADY_RUNNING";
+    readonly WORKFLOW_TYPE_DEPRECATED: "WORKFLOW_TYPE_DEPRECATED";
+    readonly WORKFLOW_TYPE_DOES_NOT_EXIST: "WORKFLOW_TYPE_DOES_NOT_EXIST";
+};
+/**
+ * @public
+ */
+export type StartChildWorkflowExecutionFailedCause = (typeof StartChildWorkflowExecutionFailedCause)[keyof typeof StartChildWorkflowExecutionFailedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const StartLambdaFunctionFailedCause: {
+    readonly ASSUME_ROLE_FAILED: "ASSUME_ROLE_FAILED";
+};
+/**
+ * @public
+ */
+export type StartLambdaFunctionFailedCause = (typeof StartLambdaFunctionFailedCause)[keyof typeof StartLambdaFunctionFailedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const StartTimerFailedCause: {
+    readonly OPEN_TIMERS_LIMIT_EXCEEDED: "OPEN_TIMERS_LIMIT_EXCEEDED";
+    readonly OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED";
+    readonly TIMER_CREATION_RATE_EXCEEDED: "TIMER_CREATION_RATE_EXCEEDED";
+    readonly TIMER_ID_ALREADY_IN_USE: "TIMER_ID_ALREADY_IN_USE";
+};
+/**
+ * @public
+ */
+export type StartTimerFailedCause = (typeof StartTimerFailedCause)[keyof typeof StartTimerFailedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const WorkflowExecutionCancelRequestedCause: {
+    readonly CHILD_POLICY_APPLIED: "CHILD_POLICY_APPLIED";
+};
+/**
+ * @public
+ */
+export type WorkflowExecutionCancelRequestedCause = (typeof WorkflowExecutionCancelRequestedCause)[keyof typeof WorkflowExecutionCancelRequestedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const WorkflowExecutionTerminatedCause: {
+    readonly CHILD_POLICY_APPLIED: "CHILD_POLICY_APPLIED";
+    readonly EVENT_LIMIT_EXCEEDED: "EVENT_LIMIT_EXCEEDED";
+    readonly OPERATOR_INITIATED: "OPERATOR_INITIATED";
+};
+/**
+ * @public
+ */
+export type WorkflowExecutionTerminatedCause = (typeof WorkflowExecutionTerminatedCause)[keyof typeof WorkflowExecutionTerminatedCause];
+/**
+ * @public
+ * @enum
+ */
+export declare const ExecutionStatus: {
+    readonly CLOSED: "CLOSED";
+    readonly OPEN: "OPEN";
+};
+/**
+ * @public
+ */
+export type ExecutionStatus = (typeof ExecutionStatus)[keyof typeof ExecutionStatus];

package/dist-types/models/errors.d.ts

@@ -0,0 +1,145 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { SWFServiceException as __BaseException } from "./SWFServiceException";
+/**
+ * <p>Returned when the caller doesn't have sufficient permissions to invoke the action.</p>
+ * @public
+ */
+export declare class OperationNotPermittedFault extends __BaseException {
+    readonly name: "OperationNotPermittedFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<OperationNotPermittedFault, __BaseException>);
+}
+/**
+ * <p>Returned when the named resource cannot be found with in the scope of this operation (region or domain). This could happen if the named resource was never created or is no longer available for this operation.</p>
+ * @public
+ */
+export declare class UnknownResourceFault extends __BaseException {
+    readonly name: "UnknownResourceFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<UnknownResourceFault, __BaseException>);
+}
+/**
+ * <p>The <code>StartWorkflowExecution</code> API action was called without the required
+ *       parameters set.</p>
+ *          <p>Some workflow execution parameters, such as the decision <code>taskList</code>, must be
+ *       set to start the execution. However, these parameters might have been set as defaults when the
+ *       workflow type was registered. In this case, you can omit these parameters from the
+ *         <code>StartWorkflowExecution</code> call and Amazon SWF uses the values defined in the workflow
+ *       type.</p>
+ *          <note>
+ *             <p>If these parameters aren't set and no default parameters were defined in the workflow
+ *         type, this error is displayed.</p>
+ *          </note>
+ * @public
+ */
+export declare class DefaultUndefinedFault extends __BaseException {
+    readonly name: "DefaultUndefinedFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<DefaultUndefinedFault, __BaseException>);
+}
+/**
+ * <p>Returned when the resource type has not been deprecated.</p>
+ * @public
+ */
+export declare class TypeNotDeprecatedFault extends __BaseException {
+    readonly name: "TypeNotDeprecatedFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TypeNotDeprecatedFault, __BaseException>);
+}
+/**
+ * <p>Returned when the specified activity or workflow type was already deprecated.</p>
+ * @public
+ */
+export declare class TypeDeprecatedFault extends __BaseException {
+    readonly name: "TypeDeprecatedFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TypeDeprecatedFault, __BaseException>);
+}
+/**
+ * <p>Returned when the specified domain has been deprecated.</p>
+ * @public
+ */
+export declare class DomainDeprecatedFault extends __BaseException {
+    readonly name: "DomainDeprecatedFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<DomainDeprecatedFault, __BaseException>);
+}
+/**
+ * <p>Returned if the domain already exists. You may get this fault if you are registering a domain that is either already registered or deprecated, or if you undeprecate a domain that is currently registered.</p>
+ * @public
+ */
+export declare class DomainAlreadyExistsFault extends __BaseException {
+    readonly name: "DomainAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<DomainAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>Returned by any operation if a system imposed limitation has been reached. To address this fault you should either clean up unused resources or increase the limit by contacting AWS.</p>
+ * @public
+ */
+export declare class LimitExceededFault extends __BaseException {
+    readonly name: "LimitExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<LimitExceededFault, __BaseException>);
+}
+/**
+ * <p>Returned if the type already exists in the specified domain. You may get this fault if you are registering a type that is either already registered or deprecated, or if you undeprecate a type that is currently registered.</p>
+ * @public
+ */
+export declare class TypeAlreadyExistsFault extends __BaseException {
+    readonly name: "TypeAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TypeAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>You've exceeded the number of tags allowed for a domain.</p>
+ * @public
+ */
+export declare class TooManyTagsFault extends __BaseException {
+    readonly name: "TooManyTagsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TooManyTagsFault, __BaseException>);
+}
+/**
+ * <p>Returned by <a>StartWorkflowExecution</a> when an open execution with the same workflowId is already running in
+ *       the specified domain.</p>
+ * @public
+ */
+export declare class WorkflowExecutionAlreadyStartedFault extends __BaseException {
+    readonly name: "WorkflowExecutionAlreadyStartedFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<WorkflowExecutionAlreadyStartedFault, __BaseException>);
+}