@aws-sdk/client-sfn 3.52.0 → 3.53.0

package/dist-es/index.js

@@ -3,3 +3,4 @@ export * from "./SFNClient";
 export * from "./commands";
 export * from "./models";
 export * from "./pagination";
+export { SFNServiceException } from "./models/SFNServiceException";

package/dist-es/models/SFNServiceException.js

@@ -0,0 +1,12 @@
+import { __extends } from "tslib";
+import { ServiceException as __ServiceException, } from "@aws-sdk/smithy-client";
+var SFNServiceException = (function (_super) {
+    __extends(SFNServiceException, _super);
+    function SFNServiceException(options) {
+        var _this = _super.call(this, options) || this;
+        Object.setPrototypeOf(_this, SFNServiceException.prototype);
+        return _this;
+    }
+    return SFNServiceException;
+}(__ServiceException));
+export { SFNServiceException };

package/dist-es/models/models_0.js

@@ -1,9 +1,34 @@
-import { __assign } from "tslib";
+import { __assign, __extends } from "tslib";
 import { SENSITIVE_STRING } from "@aws-sdk/smithy-client";
+import { SFNServiceException as __BaseException } from "./SFNServiceException";
+var ActivityDoesNotExist = (function (_super) {
+    __extends(ActivityDoesNotExist, _super);
+    function ActivityDoesNotExist(opts) {
+        var _this = _super.call(this, __assign({ name: "ActivityDoesNotExist", $fault: "client" }, opts)) || this;
+        _this.name = "ActivityDoesNotExist";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ActivityDoesNotExist.prototype);
+        return _this;
+    }
+    return ActivityDoesNotExist;
+}(__BaseException));
+export { ActivityDoesNotExist };
 export var ActivityFailedEventDetails;
 (function (ActivityFailedEventDetails) {
     ActivityFailedEventDetails.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.error && { error: SENSITIVE_STRING })), (obj.cause && { cause: SENSITIVE_STRING }))); };
 })(ActivityFailedEventDetails || (ActivityFailedEventDetails = {}));
+var ActivityLimitExceeded = (function (_super) {
+    __extends(ActivityLimitExceeded, _super);
+    function ActivityLimitExceeded(opts) {
+        var _this = _super.call(this, __assign({ name: "ActivityLimitExceeded", $fault: "client" }, opts)) || this;
+        _this.name = "ActivityLimitExceeded";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ActivityLimitExceeded.prototype);
+        return _this;
+    }
+    return ActivityLimitExceeded;
+}(__BaseException));
+export { ActivityLimitExceeded };
 export var ActivityListItem;
 (function (ActivityListItem) {
     ActivityListItem.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -32,6 +57,18 @@ export var ActivityTimedOutEventDetails;
 (function (ActivityTimedOutEventDetails) {
     ActivityTimedOutEventDetails.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.error && { error: SENSITIVE_STRING })), (obj.cause && { cause: SENSITIVE_STRING }))); };
 })(ActivityTimedOutEventDetails || (ActivityTimedOutEventDetails = {}));
+var ActivityWorkerLimitExceeded = (function (_super) {
+    __extends(ActivityWorkerLimitExceeded, _super);
+    function ActivityWorkerLimitExceeded(opts) {
+        var _this = _super.call(this, __assign({ name: "ActivityWorkerLimitExceeded", $fault: "client" }, opts)) || this;
+        _this.name = "ActivityWorkerLimitExceeded";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ActivityWorkerLimitExceeded.prototype);
+        return _this;
+    }
+    return ActivityWorkerLimitExceeded;
+}(__BaseException));
+export { ActivityWorkerLimitExceeded };
 export var Tag;
 (function (Tag) {
     Tag.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -44,6 +81,31 @@ export var CreateActivityOutput;
 (function (CreateActivityOutput) {
     CreateActivityOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(CreateActivityOutput || (CreateActivityOutput = {}));
+var InvalidName = (function (_super) {
+    __extends(InvalidName, _super);
+    function InvalidName(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidName", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidName";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidName.prototype);
+        return _this;
+    }
+    return InvalidName;
+}(__BaseException));
+export { InvalidName };
+var TooManyTags = (function (_super) {
+    __extends(TooManyTags, _super);
+    function TooManyTags(opts) {
+        var _this = _super.call(this, __assign({ name: "TooManyTags", $fault: "client" }, opts)) || this;
+        _this.name = "TooManyTags";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, TooManyTags.prototype);
+        _this.resourceName = opts.resourceName;
+        return _this;
+    }
+    return TooManyTags;
+}(__BaseException));
+export { TooManyTags };
 export var CloudWatchLogsLogGroup;
 (function (CloudWatchLogsLogGroup) {
     CloudWatchLogsLogGroup.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -68,6 +130,102 @@ export var CreateStateMachineOutput;
 (function (CreateStateMachineOutput) {
     CreateStateMachineOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(CreateStateMachineOutput || (CreateStateMachineOutput = {}));
+var InvalidArn = (function (_super) {
+    __extends(InvalidArn, _super);
+    function InvalidArn(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidArn", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidArn";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidArn.prototype);
+        return _this;
+    }
+    return InvalidArn;
+}(__BaseException));
+export { InvalidArn };
+var InvalidDefinition = (function (_super) {
+    __extends(InvalidDefinition, _super);
+    function InvalidDefinition(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidDefinition", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidDefinition";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidDefinition.prototype);
+        return _this;
+    }
+    return InvalidDefinition;
+}(__BaseException));
+export { InvalidDefinition };
+var InvalidLoggingConfiguration = (function (_super) {
+    __extends(InvalidLoggingConfiguration, _super);
+    function InvalidLoggingConfiguration(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidLoggingConfiguration", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidLoggingConfiguration";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidLoggingConfiguration.prototype);
+        return _this;
+    }
+    return InvalidLoggingConfiguration;
+}(__BaseException));
+export { InvalidLoggingConfiguration };
+var InvalidTracingConfiguration = (function (_super) {
+    __extends(InvalidTracingConfiguration, _super);
+    function InvalidTracingConfiguration(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidTracingConfiguration", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidTracingConfiguration";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidTracingConfiguration.prototype);
+        return _this;
+    }
+    return InvalidTracingConfiguration;
+}(__BaseException));
+export { InvalidTracingConfiguration };
+var StateMachineAlreadyExists = (function (_super) {
+    __extends(StateMachineAlreadyExists, _super);
+    function StateMachineAlreadyExists(opts) {
+        var _this = _super.call(this, __assign({ name: "StateMachineAlreadyExists", $fault: "client" }, opts)) || this;
+        _this.name = "StateMachineAlreadyExists";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, StateMachineAlreadyExists.prototype);
+        return _this;
+    }
+    return StateMachineAlreadyExists;
+}(__BaseException));
+export { StateMachineAlreadyExists };
+var StateMachineDeleting = (function (_super) {
+    __extends(StateMachineDeleting, _super);
+    function StateMachineDeleting(opts) {
+        var _this = _super.call(this, __assign({ name: "StateMachineDeleting", $fault: "client" }, opts)) || this;
+        _this.name = "StateMachineDeleting";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, StateMachineDeleting.prototype);
+        return _this;
+    }
+    return StateMachineDeleting;
+}(__BaseException));
+export { StateMachineDeleting };
+var StateMachineLimitExceeded = (function (_super) {
+    __extends(StateMachineLimitExceeded, _super);
+    function StateMachineLimitExceeded(opts) {
+        var _this = _super.call(this, __assign({ name: "StateMachineLimitExceeded", $fault: "client" }, opts)) || this;
+        _this.name = "StateMachineLimitExceeded";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, StateMachineLimitExceeded.prototype);
+        return _this;
+    }
+    return StateMachineLimitExceeded;
+}(__BaseException));
+export { StateMachineLimitExceeded };
+var StateMachineTypeNotSupported = (function (_super) {
+    __extends(StateMachineTypeNotSupported, _super);
+    function StateMachineTypeNotSupported(opts) {
+        var _this = _super.call(this, __assign({ name: "StateMachineTypeNotSupported", $fault: "client" }, opts)) || this;
+        _this.name = "StateMachineTypeNotSupported";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, StateMachineTypeNotSupported.prototype);
+        return _this;
+    }
+    return StateMachineTypeNotSupported;
+}(__BaseException));
+export { StateMachineTypeNotSupported };
 export var DeleteActivityInput;
 (function (DeleteActivityInput) {
     DeleteActivityInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -104,6 +262,18 @@ export var DescribeExecutionOutput;
 (function (DescribeExecutionOutput) {
     DescribeExecutionOutput.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.input && { input: SENSITIVE_STRING })), (obj.output && { output: SENSITIVE_STRING }))); };
 })(DescribeExecutionOutput || (DescribeExecutionOutput = {}));
+var ExecutionDoesNotExist = (function (_super) {
+    __extends(ExecutionDoesNotExist, _super);
+    function ExecutionDoesNotExist(opts) {
+        var _this = _super.call(this, __assign({ name: "ExecutionDoesNotExist", $fault: "client" }, opts)) || this;
+        _this.name = "ExecutionDoesNotExist";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ExecutionDoesNotExist.prototype);
+        return _this;
+    }
+    return ExecutionDoesNotExist;
+}(__BaseException));
+export { ExecutionDoesNotExist };
 export var DescribeStateMachineInput;
 (function (DescribeStateMachineInput) {
     DescribeStateMachineInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -112,6 +282,18 @@ export var DescribeStateMachineOutput;
 (function (DescribeStateMachineOutput) {
     DescribeStateMachineOutput.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.definition && { definition: SENSITIVE_STRING }))); };
 })(DescribeStateMachineOutput || (DescribeStateMachineOutput = {}));
+var StateMachineDoesNotExist = (function (_super) {
+    __extends(StateMachineDoesNotExist, _super);
+    function StateMachineDoesNotExist(opts) {
+        var _this = _super.call(this, __assign({ name: "StateMachineDoesNotExist", $fault: "client" }, opts)) || this;
+        _this.name = "StateMachineDoesNotExist";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, StateMachineDoesNotExist.prototype);
+        return _this;
+    }
+    return StateMachineDoesNotExist;
+}(__BaseException));
+export { StateMachineDoesNotExist };
 export var DescribeStateMachineForExecutionInput;
 (function (DescribeStateMachineForExecutionInput) {
     DescribeStateMachineForExecutionInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -282,6 +464,18 @@ export var GetExecutionHistoryOutput;
 (function (GetExecutionHistoryOutput) {
     GetExecutionHistoryOutput.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.events && { events: obj.events.map(function (item) { return HistoryEvent.filterSensitiveLog(item); }) }))); };
 })(GetExecutionHistoryOutput || (GetExecutionHistoryOutput = {}));
+var InvalidToken = (function (_super) {
+    __extends(InvalidToken, _super);
+    function InvalidToken(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidToken", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidToken";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidToken.prototype);
+        return _this;
+    }
+    return InvalidToken;
+}(__BaseException));
+export { InvalidToken };
 export var ListActivitiesInput;
 (function (ListActivitiesInput) {
     ListActivitiesInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -322,6 +516,19 @@ export var ListTagsForResourceOutput;
 (function (ListTagsForResourceOutput) {
     ListTagsForResourceOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(ListTagsForResourceOutput || (ListTagsForResourceOutput = {}));
+var ResourceNotFound = (function (_super) {
+    __extends(ResourceNotFound, _super);
+    function ResourceNotFound(opts) {
+        var _this = _super.call(this, __assign({ name: "ResourceNotFound", $fault: "client" }, opts)) || this;
+        _this.name = "ResourceNotFound";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ResourceNotFound.prototype);
+        _this.resourceName = opts.resourceName;
+        return _this;
+    }
+    return ResourceNotFound;
+}(__BaseException));
+export { ResourceNotFound };
 export var SendTaskFailureInput;
 (function (SendTaskFailureInput) {
     SendTaskFailureInput.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.error && { error: SENSITIVE_STRING })), (obj.cause && { cause: SENSITIVE_STRING }))); };
@@ -330,6 +537,30 @@ export var SendTaskFailureOutput;
 (function (SendTaskFailureOutput) {
     SendTaskFailureOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(SendTaskFailureOutput || (SendTaskFailureOutput = {}));
+var TaskDoesNotExist = (function (_super) {
+    __extends(TaskDoesNotExist, _super);
+    function TaskDoesNotExist(opts) {
+        var _this = _super.call(this, __assign({ name: "TaskDoesNotExist", $fault: "client" }, opts)) || this;
+        _this.name = "TaskDoesNotExist";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, TaskDoesNotExist.prototype);
+        return _this;
+    }
+    return TaskDoesNotExist;
+}(__BaseException));
+export { TaskDoesNotExist };
+var TaskTimedOut = (function (_super) {
+    __extends(TaskTimedOut, _super);
+    function TaskTimedOut(opts) {
+        var _this = _super.call(this, __assign({ name: "TaskTimedOut", $fault: "client" }, opts)) || this;
+        _this.name = "TaskTimedOut";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, TaskTimedOut.prototype);
+        return _this;
+    }
+    return TaskTimedOut;
+}(__BaseException));
+export { TaskTimedOut };
 export var SendTaskHeartbeatInput;
 (function (SendTaskHeartbeatInput) {
     SendTaskHeartbeatInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -338,6 +569,18 @@ export var SendTaskHeartbeatOutput;
 (function (SendTaskHeartbeatOutput) {
     SendTaskHeartbeatOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(SendTaskHeartbeatOutput || (SendTaskHeartbeatOutput = {}));
+var InvalidOutput = (function (_super) {
+    __extends(InvalidOutput, _super);
+    function InvalidOutput(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidOutput", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidOutput";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidOutput.prototype);
+        return _this;
+    }
+    return InvalidOutput;
+}(__BaseException));
+export { InvalidOutput };
 export var SendTaskSuccessInput;
 (function (SendTaskSuccessInput) {
     SendTaskSuccessInput.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.output && { output: SENSITIVE_STRING }))); };
@@ -346,6 +589,42 @@ export var SendTaskSuccessOutput;
 (function (SendTaskSuccessOutput) {
     SendTaskSuccessOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(SendTaskSuccessOutput || (SendTaskSuccessOutput = {}));
+var ExecutionAlreadyExists = (function (_super) {
+    __extends(ExecutionAlreadyExists, _super);
+    function ExecutionAlreadyExists(opts) {
+        var _this = _super.call(this, __assign({ name: "ExecutionAlreadyExists", $fault: "client" }, opts)) || this;
+        _this.name = "ExecutionAlreadyExists";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ExecutionAlreadyExists.prototype);
+        return _this;
+    }
+    return ExecutionAlreadyExists;
+}(__BaseException));
+export { ExecutionAlreadyExists };
+var ExecutionLimitExceeded = (function (_super) {
+    __extends(ExecutionLimitExceeded, _super);
+    function ExecutionLimitExceeded(opts) {
+        var _this = _super.call(this, __assign({ name: "ExecutionLimitExceeded", $fault: "client" }, opts)) || this;
+        _this.name = "ExecutionLimitExceeded";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ExecutionLimitExceeded.prototype);
+        return _this;
+    }
+    return ExecutionLimitExceeded;
+}(__BaseException));
+export { ExecutionLimitExceeded };
+var InvalidExecutionInput = (function (_super) {
+    __extends(InvalidExecutionInput, _super);
+    function InvalidExecutionInput(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidExecutionInput", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidExecutionInput";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidExecutionInput.prototype);
+        return _this;
+    }
+    return InvalidExecutionInput;
+}(__BaseException));
+export { InvalidExecutionInput };
 export var StartExecutionInput;
 (function (StartExecutionInput) {
     StartExecutionInput.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.input && { input: SENSITIVE_STRING }))); };
@@ -390,6 +669,18 @@ export var UntagResourceOutput;
 (function (UntagResourceOutput) {
     UntagResourceOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(UntagResourceOutput || (UntagResourceOutput = {}));
+var MissingRequiredParameter = (function (_super) {
+    __extends(MissingRequiredParameter, _super);
+    function MissingRequiredParameter(opts) {
+        var _this = _super.call(this, __assign({ name: "MissingRequiredParameter", $fault: "client" }, opts)) || this;
+        _this.name = "MissingRequiredParameter";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, MissingRequiredParameter.prototype);
+        return _this;
+    }
+    return MissingRequiredParameter;
+}(__BaseException));
+export { MissingRequiredParameter };
 export var UpdateStateMachineInput;
 (function (UpdateStateMachineInput) {
     UpdateStateMachineInput.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.definition && { definition: SENSITIVE_STRING }))); };