@effect-aws/client-sfn 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @effect-aws/client-sfn
 
+## 0.2.0
+
+### Minor Changes
+
+- [`9058353`](https://github.com/floydspace/effect-aws/commit/9058353c86eef256221e4b6bd137aa55b312ecd9) Thanks [@floydspace](https://github.com/floydspace)! - return tagged errors in the failure channel
+
 ## 0.1.0
 
 ### Minor Changes

package/lib/Errors.d.ts

@@ -0,0 +1,39 @@
+import type { ActivityDoesNotExist, ActivityLimitExceeded, ActivityWorkerLimitExceeded, InvalidName, TooManyTags, ConflictException, InvalidArn, InvalidDefinition, InvalidLoggingConfiguration, InvalidTracingConfiguration, StateMachineAlreadyExists, StateMachineDeleting, StateMachineLimitExceeded, StateMachineTypeNotSupported, ValidationException, ResourceNotFound, ServiceQuotaExceededException, ExecutionDoesNotExist, StateMachineDoesNotExist, InvalidToken, ExecutionLimitExceeded, ExecutionNotRedrivable, TaskDoesNotExist, TaskTimedOut, InvalidOutput, ExecutionAlreadyExists, InvalidExecutionInput, MissingRequiredParameter } from "@aws-sdk/client-sfn";
+import * as Data from "effect/Data";
+export type TaggedException<T extends {
+    name: string;
+}> = Data.Case & T & {
+    readonly _tag: T["name"];
+};
+export type ActivityDoesNotExistError = TaggedException<ActivityDoesNotExist>;
+export type ActivityLimitExceededError = TaggedException<ActivityLimitExceeded>;
+export type ActivityWorkerLimitExceededError = TaggedException<ActivityWorkerLimitExceeded>;
+export type InvalidNameError = TaggedException<InvalidName>;
+export type TooManyTagsError = TaggedException<TooManyTags>;
+export type ConflictError = TaggedException<ConflictException>;
+export type InvalidArnError = TaggedException<InvalidArn>;
+export type InvalidDefinitionError = TaggedException<InvalidDefinition>;
+export type InvalidLoggingConfigurationError = TaggedException<InvalidLoggingConfiguration>;
+export type InvalidTracingConfigurationError = TaggedException<InvalidTracingConfiguration>;
+export type StateMachineAlreadyExistsError = TaggedException<StateMachineAlreadyExists>;
+export type StateMachineDeletingError = TaggedException<StateMachineDeleting>;
+export type StateMachineLimitExceededError = TaggedException<StateMachineLimitExceeded>;
+export type StateMachineTypeNotSupportedError = TaggedException<StateMachineTypeNotSupported>;
+export type ValidationError = TaggedException<ValidationException>;
+export type ResourceNotFoundError = TaggedException<ResourceNotFound>;
+export type ServiceQuotaExceededError = TaggedException<ServiceQuotaExceededException>;
+export type ExecutionDoesNotExistError = TaggedException<ExecutionDoesNotExist>;
+export type StateMachineDoesNotExistError = TaggedException<StateMachineDoesNotExist>;
+export type InvalidTokenError = TaggedException<InvalidToken>;
+export type ExecutionLimitExceededError = TaggedException<ExecutionLimitExceeded>;
+export type ExecutionNotRedrivableError = TaggedException<ExecutionNotRedrivable>;
+export type TaskDoesNotExistError = TaggedException<TaskDoesNotExist>;
+export type TaskTimedOutError = TaggedException<TaskTimedOut>;
+export type InvalidOutputError = TaggedException<InvalidOutput>;
+export type ExecutionAlreadyExistsError = TaggedException<ExecutionAlreadyExists>;
+export type InvalidExecutionInputError = TaggedException<InvalidExecutionInput>;
+export type MissingRequiredParameterError = TaggedException<MissingRequiredParameter>;
+export type SdkError = TaggedException<Error & {
+    name: "SdkError";
+}>;
+export declare const SdkError: Data.Case.Constructor<SdkError, "_tag">;

package/lib/Errors.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SdkError = void 0;
+const Data = __importStar(require("effect/Data"));
+exports.SdkError = Data.tagged("SdkError");
+//# sourceMappingURL=data:application/json;base64,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

package/lib/SFN.d.ts

@@ -1,152 +1,152 @@
 import { CreateActivityCommandInput, CreateActivityCommandOutput, CreateStateMachineAliasCommandInput, CreateStateMachineAliasCommandOutput, CreateStateMachineCommandInput, CreateStateMachineCommandOutput, DeleteActivityCommandInput, DeleteActivityCommandOutput, DeleteStateMachineAliasCommandInput, DeleteStateMachineAliasCommandOutput, DeleteStateMachineCommandInput, DeleteStateMachineCommandOutput, DeleteStateMachineVersionCommandInput, DeleteStateMachineVersionCommandOutput, DescribeActivityCommandInput, DescribeActivityCommandOutput, DescribeExecutionCommandInput, DescribeExecutionCommandOutput, DescribeMapRunCommandInput, DescribeMapRunCommandOutput, DescribeStateMachineAliasCommandInput, DescribeStateMachineAliasCommandOutput, DescribeStateMachineCommandInput, DescribeStateMachineCommandOutput, DescribeStateMachineForExecutionCommandInput, DescribeStateMachineForExecutionCommandOutput, GetActivityTaskCommandInput, GetActivityTaskCommandOutput, GetExecutionHistoryCommandInput, GetExecutionHistoryCommandOutput, ListActivitiesCommandInput, ListActivitiesCommandOutput, ListExecutionsCommandInput, ListExecutionsCommandOutput, ListMapRunsCommandInput, ListMapRunsCommandOutput, ListStateMachineAliasesCommandInput, ListStateMachineAliasesCommandOutput, ListStateMachineVersionsCommandInput, ListStateMachineVersionsCommandOutput, ListStateMachinesCommandInput, ListStateMachinesCommandOutput, ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, PublishStateMachineVersionCommandInput, PublishStateMachineVersionCommandOutput, RedriveExecutionCommandInput, RedriveExecutionCommandOutput, SendTaskFailureCommandInput, SendTaskFailureCommandOutput, SendTaskHeartbeatCommandInput, SendTaskHeartbeatCommandOutput, SendTaskSuccessCommandInput, SendTaskSuccessCommandOutput, StartExecutionCommandInput, StartExecutionCommandOutput, StartSyncExecutionCommandInput, StartSyncExecutionCommandOutput, StopExecutionCommandInput, StopExecutionCommandOutput, TagResourceCommandInput, TagResourceCommandOutput, TestStateCommandInput, TestStateCommandOutput, UntagResourceCommandInput, UntagResourceCommandOutput, UpdateMapRunCommandInput, UpdateMapRunCommandOutput, UpdateStateMachineAliasCommandInput, UpdateStateMachineAliasCommandOutput, UpdateStateMachineCommandInput, UpdateStateMachineCommandOutput } from "@aws-sdk/client-sfn";
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
-import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
+import { ActivityDoesNotExistError, ActivityLimitExceededError, ActivityWorkerLimitExceededError, ConflictError, ExecutionAlreadyExistsError, ExecutionDoesNotExistError, ExecutionLimitExceededError, ExecutionNotRedrivableError, InvalidArnError, InvalidDefinitionError, InvalidExecutionInputError, InvalidLoggingConfigurationError, InvalidNameError, InvalidOutputError, InvalidTokenError, InvalidTracingConfigurationError, MissingRequiredParameterError, ResourceNotFoundError, SdkError, ServiceQuotaExceededError, StateMachineAlreadyExistsError, StateMachineDeletingError, StateMachineDoesNotExistError, StateMachineLimitExceededError, StateMachineTypeNotSupportedError, TaskDoesNotExistError, TaskTimedOutError, TooManyTagsError, ValidationError } from "./Errors";
 export interface SFNService {
     /**
      * @see {@link CreateActivityCommand}
      */
-    createActivity(args: CreateActivityCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, CreateActivityCommandOutput>;
+    createActivity(args: CreateActivityCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ActivityLimitExceededError | InvalidNameError | TooManyTagsError, CreateActivityCommandOutput>;
     /**
      * @see {@link CreateStateMachineCommand}
      */
-    createStateMachine(args: CreateStateMachineCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, CreateStateMachineCommandOutput>;
+    createStateMachine(args: CreateStateMachineCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ConflictError | InvalidArnError | InvalidDefinitionError | InvalidLoggingConfigurationError | InvalidNameError | InvalidTracingConfigurationError | StateMachineAlreadyExistsError | StateMachineDeletingError | StateMachineLimitExceededError | StateMachineTypeNotSupportedError | TooManyTagsError | ValidationError, CreateStateMachineCommandOutput>;
     /**
      * @see {@link CreateStateMachineAliasCommand}
      */
-    createStateMachineAlias(args: CreateStateMachineAliasCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, CreateStateMachineAliasCommandOutput>;
+    createStateMachineAlias(args: CreateStateMachineAliasCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ConflictError | InvalidArnError | InvalidNameError | ResourceNotFoundError | ServiceQuotaExceededError | StateMachineDeletingError | ValidationError, CreateStateMachineAliasCommandOutput>;
     /**
      * @see {@link DeleteActivityCommand}
      */
-    deleteActivity(args: DeleteActivityCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, DeleteActivityCommandOutput>;
+    deleteActivity(args: DeleteActivityCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidArnError, DeleteActivityCommandOutput>;
     /**
      * @see {@link DeleteStateMachineCommand}
      */
-    deleteStateMachine(args: DeleteStateMachineCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, DeleteStateMachineCommandOutput>;
+    deleteStateMachine(args: DeleteStateMachineCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidArnError | ValidationError, DeleteStateMachineCommandOutput>;
     /**
      * @see {@link DeleteStateMachineAliasCommand}
      */
-    deleteStateMachineAlias(args: DeleteStateMachineAliasCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, DeleteStateMachineAliasCommandOutput>;
+    deleteStateMachineAlias(args: DeleteStateMachineAliasCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ConflictError | InvalidArnError | ResourceNotFoundError | ValidationError, DeleteStateMachineAliasCommandOutput>;
     /**
      * @see {@link DeleteStateMachineVersionCommand}
      */
-    deleteStateMachineVersion(args: DeleteStateMachineVersionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, DeleteStateMachineVersionCommandOutput>;
+    deleteStateMachineVersion(args: DeleteStateMachineVersionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ConflictError | InvalidArnError | ValidationError, DeleteStateMachineVersionCommandOutput>;
     /**
      * @see {@link DescribeActivityCommand}
      */
-    describeActivity(args: DescribeActivityCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, DescribeActivityCommandOutput>;
+    describeActivity(args: DescribeActivityCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ActivityDoesNotExistError | InvalidArnError, DescribeActivityCommandOutput>;
     /**
      * @see {@link DescribeExecutionCommand}
      */
-    describeExecution(args: DescribeExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, DescribeExecutionCommandOutput>;
+    describeExecution(args: DescribeExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ExecutionDoesNotExistError | InvalidArnError, DescribeExecutionCommandOutput>;
     /**
      * @see {@link DescribeMapRunCommand}
      */
-    describeMapRun(args: DescribeMapRunCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, DescribeMapRunCommandOutput>;
+    describeMapRun(args: DescribeMapRunCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidArnError | ResourceNotFoundError, DescribeMapRunCommandOutput>;
     /**
      * @see {@link DescribeStateMachineCommand}
      */
-    describeStateMachine(args: DescribeStateMachineCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, DescribeStateMachineCommandOutput>;
+    describeStateMachine(args: DescribeStateMachineCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidArnError | StateMachineDoesNotExistError, DescribeStateMachineCommandOutput>;
     /**
      * @see {@link DescribeStateMachineAliasCommand}
      */
-    describeStateMachineAlias(args: DescribeStateMachineAliasCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, DescribeStateMachineAliasCommandOutput>;
+    describeStateMachineAlias(args: DescribeStateMachineAliasCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidArnError | ResourceNotFoundError | ValidationError, DescribeStateMachineAliasCommandOutput>;
     /**
      * @see {@link DescribeStateMachineForExecutionCommand}
      */
-    describeStateMachineForExecution(args: DescribeStateMachineForExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, DescribeStateMachineForExecutionCommandOutput>;
+    describeStateMachineForExecution(args: DescribeStateMachineForExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ExecutionDoesNotExistError | InvalidArnError, DescribeStateMachineForExecutionCommandOutput>;
     /**
      * @see {@link GetActivityTaskCommand}
      */
-    getActivityTask(args: GetActivityTaskCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, GetActivityTaskCommandOutput>;
+    getActivityTask(args: GetActivityTaskCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ActivityDoesNotExistError | ActivityWorkerLimitExceededError | InvalidArnError, GetActivityTaskCommandOutput>;
     /**
      * @see {@link GetExecutionHistoryCommand}
      */
-    getExecutionHistory(args: GetExecutionHistoryCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, GetExecutionHistoryCommandOutput>;
+    getExecutionHistory(args: GetExecutionHistoryCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError, GetExecutionHistoryCommandOutput>;
     /**
      * @see {@link ListActivitiesCommand}
      */
-    listActivities(args: ListActivitiesCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, ListActivitiesCommandOutput>;
+    listActivities(args: ListActivitiesCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidTokenError, ListActivitiesCommandOutput>;
     /**
      * @see {@link ListExecutionsCommand}
      */
-    listExecutions(args: ListExecutionsCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, ListExecutionsCommandOutput>;
+    listExecutions(args: ListExecutionsCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidArnError | InvalidTokenError | ResourceNotFoundError | StateMachineDoesNotExistError | StateMachineTypeNotSupportedError | ValidationError, ListExecutionsCommandOutput>;
     /**
      * @see {@link ListMapRunsCommand}
      */
-    listMapRuns(args: ListMapRunsCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, ListMapRunsCommandOutput>;
+    listMapRuns(args: ListMapRunsCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError, ListMapRunsCommandOutput>;
     /**
      * @see {@link ListStateMachineAliasesCommand}
      */
-    listStateMachineAliases(args: ListStateMachineAliasesCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, ListStateMachineAliasesCommandOutput>;
+    listStateMachineAliases(args: ListStateMachineAliasesCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidArnError | InvalidTokenError | ResourceNotFoundError | StateMachineDeletingError | StateMachineDoesNotExistError, ListStateMachineAliasesCommandOutput>;
     /**
      * @see {@link ListStateMachinesCommand}
      */
-    listStateMachines(args: ListStateMachinesCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, ListStateMachinesCommandOutput>;
+    listStateMachines(args: ListStateMachinesCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidTokenError, ListStateMachinesCommandOutput>;
     /**
      * @see {@link ListStateMachineVersionsCommand}
      */
-    listStateMachineVersions(args: ListStateMachineVersionsCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, ListStateMachineVersionsCommandOutput>;
+    listStateMachineVersions(args: ListStateMachineVersionsCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidArnError | InvalidTokenError | ValidationError, ListStateMachineVersionsCommandOutput>;
     /**
      * @see {@link ListTagsForResourceCommand}
      */
-    listTagsForResource(args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, ListTagsForResourceCommandOutput>;
+    listTagsForResource(args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidArnError | ResourceNotFoundError, ListTagsForResourceCommandOutput>;
     /**
      * @see {@link PublishStateMachineVersionCommand}
      */
-    publishStateMachineVersion(args: PublishStateMachineVersionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, PublishStateMachineVersionCommandOutput>;
+    publishStateMachineVersion(args: PublishStateMachineVersionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ConflictError | InvalidArnError | ServiceQuotaExceededError | StateMachineDeletingError | StateMachineDoesNotExistError | ValidationError, PublishStateMachineVersionCommandOutput>;
     /**
      * @see {@link RedriveExecutionCommand}
      */
-    redriveExecution(args: RedriveExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, RedriveExecutionCommandOutput>;
+    redriveExecution(args: RedriveExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ExecutionDoesNotExistError | ExecutionLimitExceededError | ExecutionNotRedrivableError | InvalidArnError, RedriveExecutionCommandOutput>;
     /**
      * @see {@link SendTaskFailureCommand}
      */
-    sendTaskFailure(args: SendTaskFailureCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, SendTaskFailureCommandOutput>;
+    sendTaskFailure(args: SendTaskFailureCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError, SendTaskFailureCommandOutput>;
     /**
      * @see {@link SendTaskHeartbeatCommand}
      */
-    sendTaskHeartbeat(args: SendTaskHeartbeatCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, SendTaskHeartbeatCommandOutput>;
+    sendTaskHeartbeat(args: SendTaskHeartbeatCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError, SendTaskHeartbeatCommandOutput>;
     /**
      * @see {@link SendTaskSuccessCommand}
      */
-    sendTaskSuccess(args: SendTaskSuccessCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, SendTaskSuccessCommandOutput>;
+    sendTaskSuccess(args: SendTaskSuccessCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidOutputError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError, SendTaskSuccessCommandOutput>;
     /**
      * @see {@link StartExecutionCommand}
      */
-    startExecution(args: StartExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, StartExecutionCommandOutput>;
+    startExecution(args: StartExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ExecutionAlreadyExistsError | ExecutionLimitExceededError | InvalidArnError | InvalidExecutionInputError | InvalidNameError | StateMachineDeletingError | StateMachineDoesNotExistError | ValidationError, StartExecutionCommandOutput>;
     /**
      * @see {@link StartSyncExecutionCommand}
      */
-    startSyncExecution(args: StartSyncExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, StartSyncExecutionCommandOutput>;
+    startSyncExecution(args: StartSyncExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidArnError | InvalidExecutionInputError | InvalidNameError | StateMachineDeletingError | StateMachineDoesNotExistError | StateMachineTypeNotSupportedError, StartSyncExecutionCommandOutput>;
     /**
      * @see {@link StopExecutionCommand}
      */
-    stopExecution(args: StopExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, StopExecutionCommandOutput>;
+    stopExecution(args: StopExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ExecutionDoesNotExistError | InvalidArnError | ValidationError, StopExecutionCommandOutput>;
     /**
      * @see {@link TagResourceCommand}
      */
-    tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, TagResourceCommandOutput>;
+    tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidArnError | ResourceNotFoundError | TooManyTagsError, TagResourceCommandOutput>;
     /**
      * @see {@link TestStateCommand}
      */
-    testState(args: TestStateCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, TestStateCommandOutput>;
+    testState(args: TestStateCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidArnError | InvalidDefinitionError | InvalidExecutionInputError | ValidationError, TestStateCommandOutput>;
     /**
      * @see {@link UntagResourceCommand}
      */
-    untagResource(args: UntagResourceCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, UntagResourceCommandOutput>;
+    untagResource(args: UntagResourceCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidArnError | ResourceNotFoundError, UntagResourceCommandOutput>;
     /**
      * @see {@link UpdateMapRunCommand}
      */
-    updateMapRun(args: UpdateMapRunCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, UpdateMapRunCommandOutput>;
+    updateMapRun(args: UpdateMapRunCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | InvalidArnError | ResourceNotFoundError | ValidationError, UpdateMapRunCommandOutput>;
     /**
      * @see {@link UpdateStateMachineCommand}
      */
-    updateStateMachine(args: UpdateStateMachineCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, UpdateStateMachineCommandOutput>;
+    updateStateMachine(args: UpdateStateMachineCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ConflictError | InvalidArnError | InvalidDefinitionError | InvalidLoggingConfigurationError | InvalidTracingConfigurationError | MissingRequiredParameterError | ServiceQuotaExceededError | StateMachineDeletingError | StateMachineDoesNotExistError | ValidationError, UpdateStateMachineCommandOutput>;
     /**
      * @see {@link UpdateStateMachineAliasCommand}
      */
-    updateStateMachineAlias(args: UpdateStateMachineAliasCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, Cause.UnknownException, UpdateStateMachineAliasCommandOutput>;
+    updateStateMachineAlias(args: UpdateStateMachineAliasCommandInput, options?: __HttpHandlerOptions): Effect.Effect<never, SdkError | ConflictError | InvalidArnError | ResourceNotFoundError | StateMachineDeletingError | ValidationError, UpdateStateMachineAliasCommandOutput>;
 }
 export declare const BaseSFNServiceEffect: Effect.Effect<import("@aws-sdk/client-sfn").SFNClient, never, SFNService>;
 export declare const SFNServiceEffect: Effect.Effect<import("./Context").SFNClientOptions, never, SFNService>;

package/lib/SFN.js

@@ -25,9 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultSFNServiceEffect = exports.SFNServiceEffect = exports.BaseSFNServiceEffect = void 0;
 const client_sfn_1 = require("@aws-sdk/client-sfn");
+const Data = __importStar(require("effect/Data"));
 const Effect = __importStar(require("effect/Effect"));
 const RR = __importStar(require("effect/ReadonlyRecord"));
 const Context_1 = require("./Context");
+const Errors_1 = require("./Errors");
 const commands = {
     CreateActivityCommand: client_sfn_1.CreateActivityCommand,
     CreateStateMachineCommand: client_sfn_1.CreateStateMachineCommand,
@@ -70,11 +72,32 @@ exports.BaseSFNServiceEffect = Effect.gen(function* (_) {
     const client = yield* _(Context_1.SFNClientInstanceTag);
     return RR.toEntries(commands).reduce((acc, [command]) => {
         const CommandCtor = commands[command];
-        const methodImpl = (args, options) => Effect.tryPromise(() => client.send(new CommandCtor(args), options !== null && options !== void 0 ? options : {}));
+        const methodImpl = (args, options) => Effect.tryPromise({
+            try: () => client.send(new CommandCtor(args), options !== null && options !== void 0 ? options : {}),
+            catch: (e) => {
+                if (e instanceof client_sfn_1.SFNServiceException) {
+                    const ServiceException = Data.tagged(e.name);
+                    return ServiceException({
+                        ...e,
+                        message: e.message,
+                        stack: e.stack,
+                    });
+                }
+                if (e instanceof Error) {
+                    return (0, Errors_1.SdkError)({
+                        ...e,
+                        name: "SdkError",
+                        message: e.message,
+                        stack: e.stack,
+                    });
+                }
+                throw e;
+            },
+        });
         const methodName = (command[0].toLowerCase() + command.slice(1)).replace(/Command$/, "");
         return { ...acc, [methodName]: methodImpl };
     }, {});
 });
 exports.SFNServiceEffect = exports.BaseSFNServiceEffect.pipe(Effect.provide(Context_1.SFNClientInstanceLayer));
 exports.DefaultSFNServiceEffect = exports.BaseSFNServiceEffect.pipe(Effect.provide(Context_1.DefaultSFNClientInstanceLayer));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SFN.js","sourceRoot":"","sources":["../src/SFN.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,oDA6G6B;AAG7B,sDAAwC;AACxC,0DAA4C;AAC5C,uCAImB;AAEnB,MAAM,QAAQ,GAAG;IACf,qBAAqB,EAArB,kCAAqB;IACrB,yBAAyB,EAAzB,sCAAyB;IACzB,8BAA8B,EAA9B,2CAA8B;IAC9B,qBAAqB,EAArB,kCAAqB;IACrB,yBAAyB,EAAzB,sCAAyB;IACzB,8BAA8B,EAA9B,2CAA8B;IAC9B,gCAAgC,EAAhC,6CAAgC;IAChC,uBAAuB,EAAvB,oCAAuB;IACvB,wBAAwB,EAAxB,qCAAwB;IACxB,qBAAqB,EAArB,kCAAqB;IACrB,2BAA2B,EAA3B,wCAA2B;IAC3B,gCAAgC,EAAhC,6CAAgC;IAChC,uCAAuC,EAAvC,oDAAuC;IACvC,sBAAsB,EAAtB,mCAAsB;IACtB,0BAA0B,EAA1B,uCAA0B;IAC1B,qBAAqB,EAArB,kCAAqB;IACrB,qBAAqB,EAArB,kCAAqB;IACrB,kBAAkB,EAAlB,+BAAkB;IAClB,8BAA8B,EAA9B,2CAA8B;IAC9B,wBAAwB,EAAxB,qCAAwB;IACxB,+BAA+B,EAA/B,4CAA+B;IAC/B,0BAA0B,EAA1B,uCAA0B;IAC1B,iCAAiC,EAAjC,8CAAiC;IACjC,uBAAuB,EAAvB,oCAAuB;IACvB,sBAAsB,EAAtB,mCAAsB;IACtB,wBAAwB,EAAxB,qCAAwB;IACxB,sBAAsB,EAAtB,mCAAsB;IACtB,qBAAqB,EAArB,kCAAqB;IACrB,yBAAyB,EAAzB,sCAAyB;IACzB,oBAAoB,EAApB,iCAAoB;IACpB,kBAAkB,EAAlB,+BAAkB;IAClB,gBAAgB,EAAhB,6BAAgB;IAChB,oBAAoB,EAApB,iCAAoB;IACpB,mBAAmB,EAAnB,gCAAmB;IACnB,yBAAyB,EAAzB,sCAAyB;IACzB,8BAA8B,EAA9B,2CAA8B;CAC/B,CAAC;AAqVW,QAAA,oBAAoB,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;IACzD,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,8BAAoB,CAAC,CAAC;IAE9C,OAAO,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,EAAE,EAAE;QACtD,MAAM,WAAW,GAAG,QAAQ,CAAC,OAAO,CAAQ,CAAC;QAC7C,MAAM,UAAU,GAAG,CAAC,IAAS,EAAE,OAAY,EAAE,EAAE,CAC7C,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,CACrB,MAAM,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,EAAE,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,EAAE,CAAC,CAClD,CAAC;QACJ,MAAM,UAAU,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CACtE,UAAU,EACV,EAAE,CACH,CAAC;QACF,OAAO,EAAE,GAAG,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,UAAU,EAAE,CAAC;IAC9C,CAAC,EAAE,EAAE,CAAe,CAAC;AACvB,CAAC,CAAC,CAAC;AAEU,QAAA,gBAAgB,GAAG,4BAAoB,CAAC,IAAI,CACvD,MAAM,CAAC,OAAO,CAAC,gCAAsB,CAAC,CACvC,CAAC;AAEW,QAAA,uBAAuB,GAAG,4BAAoB,CAAC,IAAI,CAC9D,MAAM,CAAC,OAAO,CAAC,uCAA6B,CAAC,CAC9C,CAAC","sourcesContent":["import {\n  CreateActivityCommand,\n  CreateActivityCommandInput,\n  CreateActivityCommandOutput,\n  CreateStateMachineAliasCommand,\n  CreateStateMachineAliasCommandInput,\n  CreateStateMachineAliasCommandOutput,\n  CreateStateMachineCommand,\n  CreateStateMachineCommandInput,\n  CreateStateMachineCommandOutput,\n  DeleteActivityCommand,\n  DeleteActivityCommandInput,\n  DeleteActivityCommandOutput,\n  DeleteStateMachineAliasCommand,\n  DeleteStateMachineAliasCommandInput,\n  DeleteStateMachineAliasCommandOutput,\n  DeleteStateMachineCommand,\n  DeleteStateMachineCommandInput,\n  DeleteStateMachineCommandOutput,\n  DeleteStateMachineVersionCommand,\n  DeleteStateMachineVersionCommandInput,\n  DeleteStateMachineVersionCommandOutput,\n  DescribeActivityCommand,\n  DescribeActivityCommandInput,\n  DescribeActivityCommandOutput,\n  DescribeExecutionCommand,\n  DescribeExecutionCommandInput,\n  DescribeExecutionCommandOutput,\n  DescribeMapRunCommand,\n  DescribeMapRunCommandInput,\n  DescribeMapRunCommandOutput,\n  DescribeStateMachineAliasCommand,\n  DescribeStateMachineAliasCommandInput,\n  DescribeStateMachineAliasCommandOutput,\n  DescribeStateMachineCommand,\n  DescribeStateMachineCommandInput,\n  DescribeStateMachineCommandOutput,\n  DescribeStateMachineForExecutionCommand,\n  DescribeStateMachineForExecutionCommandInput,\n  DescribeStateMachineForExecutionCommandOutput,\n  GetActivityTaskCommand,\n  GetActivityTaskCommandInput,\n  GetActivityTaskCommandOutput,\n  GetExecutionHistoryCommand,\n  GetExecutionHistoryCommandInput,\n  GetExecutionHistoryCommandOutput,\n  ListActivitiesCommand,\n  ListActivitiesCommandInput,\n  ListActivitiesCommandOutput,\n  ListExecutionsCommand,\n  ListExecutionsCommandInput,\n  ListExecutionsCommandOutput,\n  ListMapRunsCommand,\n  ListMapRunsCommandInput,\n  ListMapRunsCommandOutput,\n  ListStateMachineAliasesCommand,\n  ListStateMachineAliasesCommandInput,\n  ListStateMachineAliasesCommandOutput,\n  ListStateMachineVersionsCommand,\n  ListStateMachineVersionsCommandInput,\n  ListStateMachineVersionsCommandOutput,\n  ListStateMachinesCommand,\n  ListStateMachinesCommandInput,\n  ListStateMachinesCommandOutput,\n  ListTagsForResourceCommand,\n  ListTagsForResourceCommandInput,\n  ListTagsForResourceCommandOutput,\n  PublishStateMachineVersionCommand,\n  PublishStateMachineVersionCommandInput,\n  PublishStateMachineVersionCommandOutput,\n  RedriveExecutionCommand,\n  RedriveExecutionCommandInput,\n  RedriveExecutionCommandOutput,\n  SendTaskFailureCommand,\n  SendTaskFailureCommandInput,\n  SendTaskFailureCommandOutput,\n  SendTaskHeartbeatCommand,\n  SendTaskHeartbeatCommandInput,\n  SendTaskHeartbeatCommandOutput,\n  SendTaskSuccessCommand,\n  SendTaskSuccessCommandInput,\n  SendTaskSuccessCommandOutput,\n  StartExecutionCommand,\n  StartExecutionCommandInput,\n  StartExecutionCommandOutput,\n  StartSyncExecutionCommand,\n  StartSyncExecutionCommandInput,\n  StartSyncExecutionCommandOutput,\n  StopExecutionCommand,\n  StopExecutionCommandInput,\n  StopExecutionCommandOutput,\n  TagResourceCommand,\n  TagResourceCommandInput,\n  TagResourceCommandOutput,\n  TestStateCommand,\n  TestStateCommandInput,\n  TestStateCommandOutput,\n  UntagResourceCommand,\n  UntagResourceCommandInput,\n  UntagResourceCommandOutput,\n  UpdateMapRunCommand,\n  UpdateMapRunCommandInput,\n  UpdateMapRunCommandOutput,\n  UpdateStateMachineAliasCommand,\n  UpdateStateMachineAliasCommandInput,\n  UpdateStateMachineAliasCommandOutput,\n  UpdateStateMachineCommand,\n  UpdateStateMachineCommandInput,\n  UpdateStateMachineCommandOutput,\n} from \"@aws-sdk/client-sfn\";\nimport { HttpHandlerOptions as __HttpHandlerOptions } from \"@aws-sdk/types\";\nimport * as Cause from \"effect/Cause\";\nimport * as Effect from \"effect/Effect\";\nimport * as RR from \"effect/ReadonlyRecord\";\nimport {\n  DefaultSFNClientInstanceLayer,\n  SFNClientInstanceLayer,\n  SFNClientInstanceTag,\n} from \"./Context\";\n\nconst commands = {\n  CreateActivityCommand,\n  CreateStateMachineCommand,\n  CreateStateMachineAliasCommand,\n  DeleteActivityCommand,\n  DeleteStateMachineCommand,\n  DeleteStateMachineAliasCommand,\n  DeleteStateMachineVersionCommand,\n  DescribeActivityCommand,\n  DescribeExecutionCommand,\n  DescribeMapRunCommand,\n  DescribeStateMachineCommand,\n  DescribeStateMachineAliasCommand,\n  DescribeStateMachineForExecutionCommand,\n  GetActivityTaskCommand,\n  GetExecutionHistoryCommand,\n  ListActivitiesCommand,\n  ListExecutionsCommand,\n  ListMapRunsCommand,\n  ListStateMachineAliasesCommand,\n  ListStateMachinesCommand,\n  ListStateMachineVersionsCommand,\n  ListTagsForResourceCommand,\n  PublishStateMachineVersionCommand,\n  RedriveExecutionCommand,\n  SendTaskFailureCommand,\n  SendTaskHeartbeatCommand,\n  SendTaskSuccessCommand,\n  StartExecutionCommand,\n  StartSyncExecutionCommand,\n  StopExecutionCommand,\n  TagResourceCommand,\n  TestStateCommand,\n  UntagResourceCommand,\n  UpdateMapRunCommand,\n  UpdateStateMachineCommand,\n  UpdateStateMachineAliasCommand,\n};\n\nexport interface SFNService {\n  /**\n   * @see {@link CreateActivityCommand}\n   */\n  createActivity(\n    args: CreateActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, CreateActivityCommandOutput>;\n  /**\n   * @see {@link CreateStateMachineCommand}\n   */\n  createStateMachine(\n    args: CreateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    CreateStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link CreateStateMachineAliasCommand}\n   */\n  createStateMachineAlias(\n    args: CreateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    CreateStateMachineAliasCommandOutput\n  >;\n  /**\n   * @see {@link DeleteActivityCommand}\n   */\n  deleteActivity(\n    args: DeleteActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, DeleteActivityCommandOutput>;\n  /**\n   * @see {@link DeleteStateMachineCommand}\n   */\n  deleteStateMachine(\n    args: DeleteStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DeleteStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link DeleteStateMachineAliasCommand}\n   */\n  deleteStateMachineAlias(\n    args: DeleteStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DeleteStateMachineAliasCommandOutput\n  >;\n  /**\n   * @see {@link DeleteStateMachineVersionCommand}\n   */\n  deleteStateMachineVersion(\n    args: DeleteStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DeleteStateMachineVersionCommandOutput\n  >;\n  /**\n   * @see {@link DescribeActivityCommand}\n   */\n  describeActivity(\n    args: DescribeActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DescribeActivityCommandOutput\n  >;\n  /**\n   * @see {@link DescribeExecutionCommand}\n   */\n  describeExecution(\n    args: DescribeExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DescribeExecutionCommandOutput\n  >;\n  /**\n   * @see {@link DescribeMapRunCommand}\n   */\n  describeMapRun(\n    args: DescribeMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, DescribeMapRunCommandOutput>;\n  /**\n   * @see {@link DescribeStateMachineCommand}\n   */\n  describeStateMachine(\n    args: DescribeStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DescribeStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link DescribeStateMachineAliasCommand}\n   */\n  describeStateMachineAlias(\n    args: DescribeStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DescribeStateMachineAliasCommandOutput\n  >;\n  /**\n   * @see {@link DescribeStateMachineForExecutionCommand}\n   */\n  describeStateMachineForExecution(\n    args: DescribeStateMachineForExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DescribeStateMachineForExecutionCommandOutput\n  >;\n  /**\n   * @see {@link GetActivityTaskCommand}\n   */\n  getActivityTask(\n    args: GetActivityTaskCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, GetActivityTaskCommandOutput>;\n  /**\n   * @see {@link GetExecutionHistoryCommand}\n   */\n  getExecutionHistory(\n    args: GetExecutionHistoryCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    GetExecutionHistoryCommandOutput\n  >;\n  /**\n   * @see {@link ListActivitiesCommand}\n   */\n  listActivities(\n    args: ListActivitiesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, ListActivitiesCommandOutput>;\n  /**\n   * @see {@link ListExecutionsCommand}\n   */\n  listExecutions(\n    args: ListExecutionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, ListExecutionsCommandOutput>;\n  /**\n   * @see {@link ListMapRunsCommand}\n   */\n  listMapRuns(\n    args: ListMapRunsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, ListMapRunsCommandOutput>;\n  /**\n   * @see {@link ListStateMachineAliasesCommand}\n   */\n  listStateMachineAliases(\n    args: ListStateMachineAliasesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    ListStateMachineAliasesCommandOutput\n  >;\n  /**\n   * @see {@link ListStateMachinesCommand}\n   */\n  listStateMachines(\n    args: ListStateMachinesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    ListStateMachinesCommandOutput\n  >;\n  /**\n   * @see {@link ListStateMachineVersionsCommand}\n   */\n  listStateMachineVersions(\n    args: ListStateMachineVersionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    ListStateMachineVersionsCommandOutput\n  >;\n  /**\n   * @see {@link ListTagsForResourceCommand}\n   */\n  listTagsForResource(\n    args: ListTagsForResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    ListTagsForResourceCommandOutput\n  >;\n  /**\n   * @see {@link PublishStateMachineVersionCommand}\n   */\n  publishStateMachineVersion(\n    args: PublishStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    PublishStateMachineVersionCommandOutput\n  >;\n  /**\n   * @see {@link RedriveExecutionCommand}\n   */\n  redriveExecution(\n    args: RedriveExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    RedriveExecutionCommandOutput\n  >;\n  /**\n   * @see {@link SendTaskFailureCommand}\n   */\n  sendTaskFailure(\n    args: SendTaskFailureCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, SendTaskFailureCommandOutput>;\n  /**\n   * @see {@link SendTaskHeartbeatCommand}\n   */\n  sendTaskHeartbeat(\n    args: SendTaskHeartbeatCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    SendTaskHeartbeatCommandOutput\n  >;\n  /**\n   * @see {@link SendTaskSuccessCommand}\n   */\n  sendTaskSuccess(\n    args: SendTaskSuccessCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, SendTaskSuccessCommandOutput>;\n  /**\n   * @see {@link StartExecutionCommand}\n   */\n  startExecution(\n    args: StartExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, StartExecutionCommandOutput>;\n  /**\n   * @see {@link StartSyncExecutionCommand}\n   */\n  startSyncExecution(\n    args: StartSyncExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    StartSyncExecutionCommandOutput\n  >;\n  /**\n   * @see {@link StopExecutionCommand}\n   */\n  stopExecution(\n    args: StopExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, StopExecutionCommandOutput>;\n  /**\n   * @see {@link TagResourceCommand}\n   */\n  tagResource(\n    args: TagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, TagResourceCommandOutput>;\n  /**\n   * @see {@link TestStateCommand}\n   */\n  testState(\n    args: TestStateCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, TestStateCommandOutput>;\n  /**\n   * @see {@link UntagResourceCommand}\n   */\n  untagResource(\n    args: UntagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, UntagResourceCommandOutput>;\n  /**\n   * @see {@link UpdateMapRunCommand}\n   */\n  updateMapRun(\n    args: UpdateMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, UpdateMapRunCommandOutput>;\n  /**\n   * @see {@link UpdateStateMachineCommand}\n   */\n  updateStateMachine(\n    args: UpdateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    UpdateStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link UpdateStateMachineAliasCommand}\n   */\n  updateStateMachineAlias(\n    args: UpdateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    UpdateStateMachineAliasCommandOutput\n  >;\n}\n\nexport const BaseSFNServiceEffect = Effect.gen(function* (_) {\n  const client = yield* _(SFNClientInstanceTag);\n\n  return RR.toEntries(commands).reduce((acc, [command]) => {\n    const CommandCtor = commands[command] as any;\n    const methodImpl = (args: any, options: any) =>\n      Effect.tryPromise(() =>\n        client.send(new CommandCtor(args), options ?? {}),\n      );\n    const methodName = (command[0].toLowerCase() + command.slice(1)).replace(\n      /Command$/,\n      \"\",\n    );\n    return { ...acc, [methodName]: methodImpl };\n  }, {}) as SFNService;\n});\n\nexport const SFNServiceEffect = BaseSFNServiceEffect.pipe(\n  Effect.provide(SFNClientInstanceLayer),\n);\n\nexport const DefaultSFNServiceEffect = BaseSFNServiceEffect.pipe(\n  Effect.provide(DefaultSFNClientInstanceLayer),\n);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SFN.js","sourceRoot":"","sources":["../src/SFN.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CreateActivityCommand,\n  CreateActivityCommandInput,\n  CreateActivityCommandOutput,\n  CreateStateMachineAliasCommand,\n  CreateStateMachineAliasCommandInput,\n  CreateStateMachineAliasCommandOutput,\n  CreateStateMachineCommand,\n  CreateStateMachineCommandInput,\n  CreateStateMachineCommandOutput,\n  DeleteActivityCommand,\n  DeleteActivityCommandInput,\n  DeleteActivityCommandOutput,\n  DeleteStateMachineAliasCommand,\n  DeleteStateMachineAliasCommandInput,\n  DeleteStateMachineAliasCommandOutput,\n  DeleteStateMachineCommand,\n  DeleteStateMachineCommandInput,\n  DeleteStateMachineCommandOutput,\n  DeleteStateMachineVersionCommand,\n  DeleteStateMachineVersionCommandInput,\n  DeleteStateMachineVersionCommandOutput,\n  DescribeActivityCommand,\n  DescribeActivityCommandInput,\n  DescribeActivityCommandOutput,\n  DescribeExecutionCommand,\n  DescribeExecutionCommandInput,\n  DescribeExecutionCommandOutput,\n  DescribeMapRunCommand,\n  DescribeMapRunCommandInput,\n  DescribeMapRunCommandOutput,\n  DescribeStateMachineAliasCommand,\n  DescribeStateMachineAliasCommandInput,\n  DescribeStateMachineAliasCommandOutput,\n  DescribeStateMachineCommand,\n  DescribeStateMachineCommandInput,\n  DescribeStateMachineCommandOutput,\n  DescribeStateMachineForExecutionCommand,\n  DescribeStateMachineForExecutionCommandInput,\n  DescribeStateMachineForExecutionCommandOutput,\n  GetActivityTaskCommand,\n  GetActivityTaskCommandInput,\n  GetActivityTaskCommandOutput,\n  GetExecutionHistoryCommand,\n  GetExecutionHistoryCommandInput,\n  GetExecutionHistoryCommandOutput,\n  ListActivitiesCommand,\n  ListActivitiesCommandInput,\n  ListActivitiesCommandOutput,\n  ListExecutionsCommand,\n  ListExecutionsCommandInput,\n  ListExecutionsCommandOutput,\n  ListMapRunsCommand,\n  ListMapRunsCommandInput,\n  ListMapRunsCommandOutput,\n  ListStateMachineAliasesCommand,\n  ListStateMachineAliasesCommandInput,\n  ListStateMachineAliasesCommandOutput,\n  ListStateMachineVersionsCommand,\n  ListStateMachineVersionsCommandInput,\n  ListStateMachineVersionsCommandOutput,\n  ListStateMachinesCommand,\n  ListStateMachinesCommandInput,\n  ListStateMachinesCommandOutput,\n  ListTagsForResourceCommand,\n  ListTagsForResourceCommandInput,\n  ListTagsForResourceCommandOutput,\n  PublishStateMachineVersionCommand,\n  PublishStateMachineVersionCommandInput,\n  PublishStateMachineVersionCommandOutput,\n  RedriveExecutionCommand,\n  RedriveExecutionCommandInput,\n  RedriveExecutionCommandOutput,\n  SFNServiceException,\n  SendTaskFailureCommand,\n  SendTaskFailureCommandInput,\n  SendTaskFailureCommandOutput,\n  SendTaskHeartbeatCommand,\n  SendTaskHeartbeatCommandInput,\n  SendTaskHeartbeatCommandOutput,\n  SendTaskSuccessCommand,\n  SendTaskSuccessCommandInput,\n  SendTaskSuccessCommandOutput,\n  StartExecutionCommand,\n  StartExecutionCommandInput,\n  StartExecutionCommandOutput,\n  StartSyncExecutionCommand,\n  StartSyncExecutionCommandInput,\n  StartSyncExecutionCommandOutput,\n  StopExecutionCommand,\n  StopExecutionCommandInput,\n  StopExecutionCommandOutput,\n  TagResourceCommand,\n  TagResourceCommandInput,\n  TagResourceCommandOutput,\n  TestStateCommand,\n  TestStateCommandInput,\n  TestStateCommandOutput,\n  UntagResourceCommand,\n  UntagResourceCommandInput,\n  UntagResourceCommandOutput,\n  UpdateMapRunCommand,\n  UpdateMapRunCommandInput,\n  UpdateMapRunCommandOutput,\n  UpdateStateMachineAliasCommand,\n  UpdateStateMachineAliasCommandInput,\n  UpdateStateMachineAliasCommandOutput,\n  UpdateStateMachineCommand,\n  UpdateStateMachineCommandInput,\n  UpdateStateMachineCommandOutput,\n} from \"@aws-sdk/client-sfn\";\nimport { HttpHandlerOptions as __HttpHandlerOptions } from \"@aws-sdk/types\";\nimport * as Data from \"effect/Data\";\nimport * as Effect from \"effect/Effect\";\nimport * as RR from \"effect/ReadonlyRecord\";\nimport {\n  DefaultSFNClientInstanceLayer,\n  SFNClientInstanceLayer,\n  SFNClientInstanceTag,\n} from \"./Context\";\nimport {\n  ActivityDoesNotExistError,\n  ActivityLimitExceededError,\n  ActivityWorkerLimitExceededError,\n  ConflictError,\n  ExecutionAlreadyExistsError,\n  ExecutionDoesNotExistError,\n  ExecutionLimitExceededError,\n  ExecutionNotRedrivableError,\n  InvalidArnError,\n  InvalidDefinitionError,\n  InvalidExecutionInputError,\n  InvalidLoggingConfigurationError,\n  InvalidNameError,\n  InvalidOutputError,\n  InvalidTokenError,\n  InvalidTracingConfigurationError,\n  MissingRequiredParameterError,\n  ResourceNotFoundError,\n  SdkError,\n  ServiceQuotaExceededError,\n  StateMachineAlreadyExistsError,\n  StateMachineDeletingError,\n  StateMachineDoesNotExistError,\n  StateMachineLimitExceededError,\n  StateMachineTypeNotSupportedError,\n  TaggedException,\n  TaskDoesNotExistError,\n  TaskTimedOutError,\n  TooManyTagsError,\n  ValidationError,\n} from \"./Errors\";\n\nconst commands = {\n  CreateActivityCommand,\n  CreateStateMachineCommand,\n  CreateStateMachineAliasCommand,\n  DeleteActivityCommand,\n  DeleteStateMachineCommand,\n  DeleteStateMachineAliasCommand,\n  DeleteStateMachineVersionCommand,\n  DescribeActivityCommand,\n  DescribeExecutionCommand,\n  DescribeMapRunCommand,\n  DescribeStateMachineCommand,\n  DescribeStateMachineAliasCommand,\n  DescribeStateMachineForExecutionCommand,\n  GetActivityTaskCommand,\n  GetExecutionHistoryCommand,\n  ListActivitiesCommand,\n  ListExecutionsCommand,\n  ListMapRunsCommand,\n  ListStateMachineAliasesCommand,\n  ListStateMachinesCommand,\n  ListStateMachineVersionsCommand,\n  ListTagsForResourceCommand,\n  PublishStateMachineVersionCommand,\n  RedriveExecutionCommand,\n  SendTaskFailureCommand,\n  SendTaskHeartbeatCommand,\n  SendTaskSuccessCommand,\n  StartExecutionCommand,\n  StartSyncExecutionCommand,\n  StopExecutionCommand,\n  TagResourceCommand,\n  TestStateCommand,\n  UntagResourceCommand,\n  UpdateMapRunCommand,\n  UpdateStateMachineCommand,\n  UpdateStateMachineAliasCommand,\n};\n\nexport interface SFNService {\n  /**\n   * @see {@link CreateActivityCommand}\n   */\n  createActivity(\n    args: CreateActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ActivityLimitExceededError | InvalidNameError | TooManyTagsError,\n    CreateActivityCommandOutput\n  >;\n  /**\n   * @see {@link CreateStateMachineCommand}\n   */\n  createStateMachine(\n    args: CreateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidLoggingConfigurationError\n    | InvalidNameError\n    | InvalidTracingConfigurationError\n    | StateMachineAlreadyExistsError\n    | StateMachineDeletingError\n    | StateMachineLimitExceededError\n    | StateMachineTypeNotSupportedError\n    | TooManyTagsError\n    | ValidationError,\n    CreateStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link CreateStateMachineAliasCommand}\n   */\n  createStateMachineAlias(\n    args: CreateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidNameError\n    | ResourceNotFoundError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | ValidationError,\n    CreateStateMachineAliasCommandOutput\n  >;\n  /**\n   * @see {@link DeleteActivityCommand}\n   */\n  deleteActivity(\n    args: DeleteActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError,\n    DeleteActivityCommandOutput\n  >;\n  /**\n   * @see {@link DeleteStateMachineCommand}\n   */\n  deleteStateMachine(\n    args: DeleteStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | ValidationError,\n    DeleteStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link DeleteStateMachineAliasCommand}\n   */\n  deleteStateMachineAlias(\n    args: DeleteStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ResourceNotFoundError\n    | ValidationError,\n    DeleteStateMachineAliasCommandOutput\n  >;\n  /**\n   * @see {@link DeleteStateMachineVersionCommand}\n   */\n  deleteStateMachineVersion(\n    args: DeleteStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ConflictError | InvalidArnError | ValidationError,\n    DeleteStateMachineVersionCommandOutput\n  >;\n  /**\n   * @see {@link DescribeActivityCommand}\n   */\n  describeActivity(\n    args: DescribeActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ActivityDoesNotExistError | InvalidArnError,\n    DescribeActivityCommandOutput\n  >;\n  /**\n   * @see {@link DescribeExecutionCommand}\n   */\n  describeExecution(\n    args: DescribeExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError,\n    DescribeExecutionCommandOutput\n  >;\n  /**\n   * @see {@link DescribeMapRunCommand}\n   */\n  describeMapRun(\n    args: DescribeMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | ResourceNotFoundError,\n    DescribeMapRunCommandOutput\n  >;\n  /**\n   * @see {@link DescribeStateMachineCommand}\n   */\n  describeStateMachine(\n    args: DescribeStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | StateMachineDoesNotExistError,\n    DescribeStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link DescribeStateMachineAliasCommand}\n   */\n  describeStateMachineAlias(\n    args: DescribeStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | ResourceNotFoundError | ValidationError,\n    DescribeStateMachineAliasCommandOutput\n  >;\n  /**\n   * @see {@link DescribeStateMachineForExecutionCommand}\n   */\n  describeStateMachineForExecution(\n    args: DescribeStateMachineForExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError,\n    DescribeStateMachineForExecutionCommandOutput\n  >;\n  /**\n   * @see {@link GetActivityTaskCommand}\n   */\n  getActivityTask(\n    args: GetActivityTaskCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ActivityDoesNotExistError\n    | ActivityWorkerLimitExceededError\n    | InvalidArnError,\n    GetActivityTaskCommandOutput\n  >;\n  /**\n   * @see {@link GetExecutionHistoryCommand}\n   */\n  getExecutionHistory(\n    args: GetExecutionHistoryCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError,\n    GetExecutionHistoryCommandOutput\n  >;\n  /**\n   * @see {@link ListActivitiesCommand}\n   */\n  listActivities(\n    args: ListActivitiesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidTokenError,\n    ListActivitiesCommandOutput\n  >;\n  /**\n   * @see {@link ListExecutionsCommand}\n   */\n  listExecutions(\n    args: ListExecutionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | InvalidArnError\n    | InvalidTokenError\n    | ResourceNotFoundError\n    | StateMachineDoesNotExistError\n    | StateMachineTypeNotSupportedError\n    | ValidationError,\n    ListExecutionsCommandOutput\n  >;\n  /**\n   * @see {@link ListMapRunsCommand}\n   */\n  listMapRuns(\n    args: ListMapRunsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError,\n    ListMapRunsCommandOutput\n  >;\n  /**\n   * @see {@link ListStateMachineAliasesCommand}\n   */\n  listStateMachineAliases(\n    args: ListStateMachineAliasesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | InvalidArnError\n    | InvalidTokenError\n    | ResourceNotFoundError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError,\n    ListStateMachineAliasesCommandOutput\n  >;\n  /**\n   * @see {@link ListStateMachinesCommand}\n   */\n  listStateMachines(\n    args: ListStateMachinesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidTokenError,\n    ListStateMachinesCommandOutput\n  >;\n  /**\n   * @see {@link ListStateMachineVersionsCommand}\n   */\n  listStateMachineVersions(\n    args: ListStateMachineVersionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | InvalidTokenError | ValidationError,\n    ListStateMachineVersionsCommandOutput\n  >;\n  /**\n   * @see {@link ListTagsForResourceCommand}\n   */\n  listTagsForResource(\n    args: ListTagsForResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | ResourceNotFoundError,\n    ListTagsForResourceCommandOutput\n  >;\n  /**\n   * @see {@link PublishStateMachineVersionCommand}\n   */\n  publishStateMachineVersion(\n    args: PublishStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError,\n    PublishStateMachineVersionCommandOutput\n  >;\n  /**\n   * @see {@link RedriveExecutionCommand}\n   */\n  redriveExecution(\n    args: RedriveExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ExecutionDoesNotExistError\n    | ExecutionLimitExceededError\n    | ExecutionNotRedrivableError\n    | InvalidArnError,\n    RedriveExecutionCommandOutput\n  >;\n  /**\n   * @see {@link SendTaskFailureCommand}\n   */\n  sendTaskFailure(\n    args: SendTaskFailureCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError,\n    SendTaskFailureCommandOutput\n  >;\n  /**\n   * @see {@link SendTaskHeartbeatCommand}\n   */\n  sendTaskHeartbeat(\n    args: SendTaskHeartbeatCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError,\n    SendTaskHeartbeatCommandOutput\n  >;\n  /**\n   * @see {@link SendTaskSuccessCommand}\n   */\n  sendTaskSuccess(\n    args: SendTaskSuccessCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | InvalidOutputError\n    | InvalidTokenError\n    | TaskDoesNotExistError\n    | TaskTimedOutError,\n    SendTaskSuccessCommandOutput\n  >;\n  /**\n   * @see {@link StartExecutionCommand}\n   */\n  startExecution(\n    args: StartExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ExecutionAlreadyExistsError\n    | ExecutionLimitExceededError\n    | InvalidArnError\n    | InvalidExecutionInputError\n    | InvalidNameError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError,\n    StartExecutionCommandOutput\n  >;\n  /**\n   * @see {@link StartSyncExecutionCommand}\n   */\n  startSyncExecution(\n    args: StartSyncExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | InvalidArnError\n    | InvalidExecutionInputError\n    | InvalidNameError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | StateMachineTypeNotSupportedError,\n    StartSyncExecutionCommandOutput\n  >;\n  /**\n   * @see {@link StopExecutionCommand}\n   */\n  stopExecution(\n    args: StopExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError | ValidationError,\n    StopExecutionCommandOutput\n  >;\n  /**\n   * @see {@link TagResourceCommand}\n   */\n  tagResource(\n    args: TagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | ResourceNotFoundError | TooManyTagsError,\n    TagResourceCommandOutput\n  >;\n  /**\n   * @see {@link TestStateCommand}\n   */\n  testState(\n    args: TestStateCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidExecutionInputError\n    | ValidationError,\n    TestStateCommandOutput\n  >;\n  /**\n   * @see {@link UntagResourceCommand}\n   */\n  untagResource(\n    args: UntagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | ResourceNotFoundError,\n    UntagResourceCommandOutput\n  >;\n  /**\n   * @see {@link UpdateMapRunCommand}\n   */\n  updateMapRun(\n    args: UpdateMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | ResourceNotFoundError | ValidationError,\n    UpdateMapRunCommandOutput\n  >;\n  /**\n   * @see {@link UpdateStateMachineCommand}\n   */\n  updateStateMachine(\n    args: UpdateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidLoggingConfigurationError\n    | InvalidTracingConfigurationError\n    | MissingRequiredParameterError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError,\n    UpdateStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link UpdateStateMachineAliasCommand}\n   */\n  updateStateMachineAlias(\n    args: UpdateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ResourceNotFoundError\n    | StateMachineDeletingError\n    | ValidationError,\n    UpdateStateMachineAliasCommandOutput\n  >;\n}\n\nexport const BaseSFNServiceEffect = Effect.gen(function* (_) {\n  const client = yield* _(SFNClientInstanceTag);\n\n  return RR.toEntries(commands).reduce((acc, [command]) => {\n    const CommandCtor = commands[command] as any;\n    const methodImpl = (args: any, options: any) =>\n      Effect.tryPromise({\n        try: () => client.send(new CommandCtor(args), options ?? {}),\n        catch: (e) => {\n          if (e instanceof SFNServiceException) {\n            const ServiceException = Data.tagged<\n              TaggedException<SFNServiceException>\n            >(e.name);\n\n            return ServiceException({\n              ...e,\n              message: e.message,\n              stack: e.stack,\n            });\n          }\n          if (e instanceof Error) {\n            return SdkError({\n              ...e,\n              name: \"SdkError\",\n              message: e.message,\n              stack: e.stack,\n            });\n          }\n          throw e;\n        },\n      });\n    const methodName = (command[0].toLowerCase() + command.slice(1)).replace(\n      /Command$/,\n      \"\",\n    );\n    return { ...acc, [methodName]: methodImpl };\n  }, {}) as SFNService;\n});\n\nexport const SFNServiceEffect = BaseSFNServiceEffect.pipe(\n  Effect.provide(SFNClientInstanceLayer),\n);\n\nexport const DefaultSFNServiceEffect = BaseSFNServiceEffect.pipe(\n  Effect.provide(DefaultSFNClientInstanceLayer),\n);\n"]}

package/lib/esm/Errors.js

@@ -0,0 +1,3 @@
+import * as Data from "effect/Data";
+export const SdkError = Data.tagged("SdkError");
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/SFN.js

@@ -1,7 +1,9 @@
-import { CreateActivityCommand, CreateStateMachineAliasCommand, CreateStateMachineCommand, DeleteActivityCommand, DeleteStateMachineAliasCommand, DeleteStateMachineCommand, DeleteStateMachineVersionCommand, DescribeActivityCommand, DescribeExecutionCommand, DescribeMapRunCommand, DescribeStateMachineAliasCommand, DescribeStateMachineCommand, DescribeStateMachineForExecutionCommand, GetActivityTaskCommand, GetExecutionHistoryCommand, ListActivitiesCommand, ListExecutionsCommand, ListMapRunsCommand, ListStateMachineAliasesCommand, ListStateMachineVersionsCommand, ListStateMachinesCommand, ListTagsForResourceCommand, PublishStateMachineVersionCommand, RedriveExecutionCommand, SendTaskFailureCommand, SendTaskHeartbeatCommand, SendTaskSuccessCommand, StartExecutionCommand, StartSyncExecutionCommand, StopExecutionCommand, TagResourceCommand, TestStateCommand, UntagResourceCommand, UpdateMapRunCommand, UpdateStateMachineAliasCommand, UpdateStateMachineCommand, } from "@aws-sdk/client-sfn";
+import { CreateActivityCommand, CreateStateMachineAliasCommand, CreateStateMachineCommand, DeleteActivityCommand, DeleteStateMachineAliasCommand, DeleteStateMachineCommand, DeleteStateMachineVersionCommand, DescribeActivityCommand, DescribeExecutionCommand, DescribeMapRunCommand, DescribeStateMachineAliasCommand, DescribeStateMachineCommand, DescribeStateMachineForExecutionCommand, GetActivityTaskCommand, GetExecutionHistoryCommand, ListActivitiesCommand, ListExecutionsCommand, ListMapRunsCommand, ListStateMachineAliasesCommand, ListStateMachineVersionsCommand, ListStateMachinesCommand, ListTagsForResourceCommand, PublishStateMachineVersionCommand, RedriveExecutionCommand, SFNServiceException, SendTaskFailureCommand, SendTaskHeartbeatCommand, SendTaskSuccessCommand, StartExecutionCommand, StartSyncExecutionCommand, StopExecutionCommand, TagResourceCommand, TestStateCommand, UntagResourceCommand, UpdateMapRunCommand, UpdateStateMachineAliasCommand, UpdateStateMachineCommand, } from "@aws-sdk/client-sfn";
+import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as RR from "effect/ReadonlyRecord";
 import { DefaultSFNClientInstanceLayer, SFNClientInstanceLayer, SFNClientInstanceTag, } from "./Context";
+import { SdkError, } from "./Errors";
 const commands = {
     CreateActivityCommand,
     CreateStateMachineCommand,
@@ -44,11 +46,32 @@ export const BaseSFNServiceEffect = Effect.gen(function* (_) {
     const client = yield* _(SFNClientInstanceTag);
     return RR.toEntries(commands).reduce((acc, [command]) => {
         const CommandCtor = commands[command];
-        const methodImpl = (args, options) => Effect.tryPromise(() => client.send(new CommandCtor(args), options !== null && options !== void 0 ? options : {}));
+        const methodImpl = (args, options) => Effect.tryPromise({
+            try: () => client.send(new CommandCtor(args), options !== null && options !== void 0 ? options : {}),
+            catch: (e) => {
+                if (e instanceof SFNServiceException) {
+                    const ServiceException = Data.tagged(e.name);
+                    return ServiceException({
+                        ...e,
+                        message: e.message,
+                        stack: e.stack,
+                    });
+                }
+                if (e instanceof Error) {
+                    return SdkError({
+                        ...e,
+                        name: "SdkError",
+                        message: e.message,
+                        stack: e.stack,
+                    });
+                }
+                throw e;
+            },
+        });
         const methodName = (command[0].toLowerCase() + command.slice(1)).replace(/Command$/, "");
         return { ...acc, [methodName]: methodImpl };
     }, {});
 });
 export const SFNServiceEffect = BaseSFNServiceEffect.pipe(Effect.provide(SFNClientInstanceLayer));
 export const DefaultSFNServiceEffect = BaseSFNServiceEffect.pipe(Effect.provide(DefaultSFNClientInstanceLayer));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SFN.js","sourceRoot":"","sources":["../../src/SFN.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CreateActivityCommand,\n  CreateActivityCommandInput,\n  CreateActivityCommandOutput,\n  CreateStateMachineAliasCommand,\n  CreateStateMachineAliasCommandInput,\n  CreateStateMachineAliasCommandOutput,\n  CreateStateMachineCommand,\n  CreateStateMachineCommandInput,\n  CreateStateMachineCommandOutput,\n  DeleteActivityCommand,\n  DeleteActivityCommandInput,\n  DeleteActivityCommandOutput,\n  DeleteStateMachineAliasCommand,\n  DeleteStateMachineAliasCommandInput,\n  DeleteStateMachineAliasCommandOutput,\n  DeleteStateMachineCommand,\n  DeleteStateMachineCommandInput,\n  DeleteStateMachineCommandOutput,\n  DeleteStateMachineVersionCommand,\n  DeleteStateMachineVersionCommandInput,\n  DeleteStateMachineVersionCommandOutput,\n  DescribeActivityCommand,\n  DescribeActivityCommandInput,\n  DescribeActivityCommandOutput,\n  DescribeExecutionCommand,\n  DescribeExecutionCommandInput,\n  DescribeExecutionCommandOutput,\n  DescribeMapRunCommand,\n  DescribeMapRunCommandInput,\n  DescribeMapRunCommandOutput,\n  DescribeStateMachineAliasCommand,\n  DescribeStateMachineAliasCommandInput,\n  DescribeStateMachineAliasCommandOutput,\n  DescribeStateMachineCommand,\n  DescribeStateMachineCommandInput,\n  DescribeStateMachineCommandOutput,\n  DescribeStateMachineForExecutionCommand,\n  DescribeStateMachineForExecutionCommandInput,\n  DescribeStateMachineForExecutionCommandOutput,\n  GetActivityTaskCommand,\n  GetActivityTaskCommandInput,\n  GetActivityTaskCommandOutput,\n  GetExecutionHistoryCommand,\n  GetExecutionHistoryCommandInput,\n  GetExecutionHistoryCommandOutput,\n  ListActivitiesCommand,\n  ListActivitiesCommandInput,\n  ListActivitiesCommandOutput,\n  ListExecutionsCommand,\n  ListExecutionsCommandInput,\n  ListExecutionsCommandOutput,\n  ListMapRunsCommand,\n  ListMapRunsCommandInput,\n  ListMapRunsCommandOutput,\n  ListStateMachineAliasesCommand,\n  ListStateMachineAliasesCommandInput,\n  ListStateMachineAliasesCommandOutput,\n  ListStateMachineVersionsCommand,\n  ListStateMachineVersionsCommandInput,\n  ListStateMachineVersionsCommandOutput,\n  ListStateMachinesCommand,\n  ListStateMachinesCommandInput,\n  ListStateMachinesCommandOutput,\n  ListTagsForResourceCommand,\n  ListTagsForResourceCommandInput,\n  ListTagsForResourceCommandOutput,\n  PublishStateMachineVersionCommand,\n  PublishStateMachineVersionCommandInput,\n  PublishStateMachineVersionCommandOutput,\n  RedriveExecutionCommand,\n  RedriveExecutionCommandInput,\n  RedriveExecutionCommandOutput,\n  SendTaskFailureCommand,\n  SendTaskFailureCommandInput,\n  SendTaskFailureCommandOutput,\n  SendTaskHeartbeatCommand,\n  SendTaskHeartbeatCommandInput,\n  SendTaskHeartbeatCommandOutput,\n  SendTaskSuccessCommand,\n  SendTaskSuccessCommandInput,\n  SendTaskSuccessCommandOutput,\n  StartExecutionCommand,\n  StartExecutionCommandInput,\n  StartExecutionCommandOutput,\n  StartSyncExecutionCommand,\n  StartSyncExecutionCommandInput,\n  StartSyncExecutionCommandOutput,\n  StopExecutionCommand,\n  StopExecutionCommandInput,\n  StopExecutionCommandOutput,\n  TagResourceCommand,\n  TagResourceCommandInput,\n  TagResourceCommandOutput,\n  TestStateCommand,\n  TestStateCommandInput,\n  TestStateCommandOutput,\n  UntagResourceCommand,\n  UntagResourceCommandInput,\n  UntagResourceCommandOutput,\n  UpdateMapRunCommand,\n  UpdateMapRunCommandInput,\n  UpdateMapRunCommandOutput,\n  UpdateStateMachineAliasCommand,\n  UpdateStateMachineAliasCommandInput,\n  UpdateStateMachineAliasCommandOutput,\n  UpdateStateMachineCommand,\n  UpdateStateMachineCommandInput,\n  UpdateStateMachineCommandOutput,\n} from \"@aws-sdk/client-sfn\";\nimport { HttpHandlerOptions as __HttpHandlerOptions } from \"@aws-sdk/types\";\nimport * as Cause from \"effect/Cause\";\nimport * as Effect from \"effect/Effect\";\nimport * as RR from \"effect/ReadonlyRecord\";\nimport {\n  DefaultSFNClientInstanceLayer,\n  SFNClientInstanceLayer,\n  SFNClientInstanceTag,\n} from \"./Context\";\n\nconst commands = {\n  CreateActivityCommand,\n  CreateStateMachineCommand,\n  CreateStateMachineAliasCommand,\n  DeleteActivityCommand,\n  DeleteStateMachineCommand,\n  DeleteStateMachineAliasCommand,\n  DeleteStateMachineVersionCommand,\n  DescribeActivityCommand,\n  DescribeExecutionCommand,\n  DescribeMapRunCommand,\n  DescribeStateMachineCommand,\n  DescribeStateMachineAliasCommand,\n  DescribeStateMachineForExecutionCommand,\n  GetActivityTaskCommand,\n  GetExecutionHistoryCommand,\n  ListActivitiesCommand,\n  ListExecutionsCommand,\n  ListMapRunsCommand,\n  ListStateMachineAliasesCommand,\n  ListStateMachinesCommand,\n  ListStateMachineVersionsCommand,\n  ListTagsForResourceCommand,\n  PublishStateMachineVersionCommand,\n  RedriveExecutionCommand,\n  SendTaskFailureCommand,\n  SendTaskHeartbeatCommand,\n  SendTaskSuccessCommand,\n  StartExecutionCommand,\n  StartSyncExecutionCommand,\n  StopExecutionCommand,\n  TagResourceCommand,\n  TestStateCommand,\n  UntagResourceCommand,\n  UpdateMapRunCommand,\n  UpdateStateMachineCommand,\n  UpdateStateMachineAliasCommand,\n};\n\nexport interface SFNService {\n  /**\n   * @see {@link CreateActivityCommand}\n   */\n  createActivity(\n    args: CreateActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, CreateActivityCommandOutput>;\n  /**\n   * @see {@link CreateStateMachineCommand}\n   */\n  createStateMachine(\n    args: CreateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    CreateStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link CreateStateMachineAliasCommand}\n   */\n  createStateMachineAlias(\n    args: CreateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    CreateStateMachineAliasCommandOutput\n  >;\n  /**\n   * @see {@link DeleteActivityCommand}\n   */\n  deleteActivity(\n    args: DeleteActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, DeleteActivityCommandOutput>;\n  /**\n   * @see {@link DeleteStateMachineCommand}\n   */\n  deleteStateMachine(\n    args: DeleteStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DeleteStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link DeleteStateMachineAliasCommand}\n   */\n  deleteStateMachineAlias(\n    args: DeleteStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DeleteStateMachineAliasCommandOutput\n  >;\n  /**\n   * @see {@link DeleteStateMachineVersionCommand}\n   */\n  deleteStateMachineVersion(\n    args: DeleteStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DeleteStateMachineVersionCommandOutput\n  >;\n  /**\n   * @see {@link DescribeActivityCommand}\n   */\n  describeActivity(\n    args: DescribeActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DescribeActivityCommandOutput\n  >;\n  /**\n   * @see {@link DescribeExecutionCommand}\n   */\n  describeExecution(\n    args: DescribeExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DescribeExecutionCommandOutput\n  >;\n  /**\n   * @see {@link DescribeMapRunCommand}\n   */\n  describeMapRun(\n    args: DescribeMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, DescribeMapRunCommandOutput>;\n  /**\n   * @see {@link DescribeStateMachineCommand}\n   */\n  describeStateMachine(\n    args: DescribeStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DescribeStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link DescribeStateMachineAliasCommand}\n   */\n  describeStateMachineAlias(\n    args: DescribeStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DescribeStateMachineAliasCommandOutput\n  >;\n  /**\n   * @see {@link DescribeStateMachineForExecutionCommand}\n   */\n  describeStateMachineForExecution(\n    args: DescribeStateMachineForExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    DescribeStateMachineForExecutionCommandOutput\n  >;\n  /**\n   * @see {@link GetActivityTaskCommand}\n   */\n  getActivityTask(\n    args: GetActivityTaskCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, GetActivityTaskCommandOutput>;\n  /**\n   * @see {@link GetExecutionHistoryCommand}\n   */\n  getExecutionHistory(\n    args: GetExecutionHistoryCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    GetExecutionHistoryCommandOutput\n  >;\n  /**\n   * @see {@link ListActivitiesCommand}\n   */\n  listActivities(\n    args: ListActivitiesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, ListActivitiesCommandOutput>;\n  /**\n   * @see {@link ListExecutionsCommand}\n   */\n  listExecutions(\n    args: ListExecutionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, ListExecutionsCommandOutput>;\n  /**\n   * @see {@link ListMapRunsCommand}\n   */\n  listMapRuns(\n    args: ListMapRunsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, ListMapRunsCommandOutput>;\n  /**\n   * @see {@link ListStateMachineAliasesCommand}\n   */\n  listStateMachineAliases(\n    args: ListStateMachineAliasesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    ListStateMachineAliasesCommandOutput\n  >;\n  /**\n   * @see {@link ListStateMachinesCommand}\n   */\n  listStateMachines(\n    args: ListStateMachinesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    ListStateMachinesCommandOutput\n  >;\n  /**\n   * @see {@link ListStateMachineVersionsCommand}\n   */\n  listStateMachineVersions(\n    args: ListStateMachineVersionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    ListStateMachineVersionsCommandOutput\n  >;\n  /**\n   * @see {@link ListTagsForResourceCommand}\n   */\n  listTagsForResource(\n    args: ListTagsForResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    ListTagsForResourceCommandOutput\n  >;\n  /**\n   * @see {@link PublishStateMachineVersionCommand}\n   */\n  publishStateMachineVersion(\n    args: PublishStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    PublishStateMachineVersionCommandOutput\n  >;\n  /**\n   * @see {@link RedriveExecutionCommand}\n   */\n  redriveExecution(\n    args: RedriveExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    RedriveExecutionCommandOutput\n  >;\n  /**\n   * @see {@link SendTaskFailureCommand}\n   */\n  sendTaskFailure(\n    args: SendTaskFailureCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, SendTaskFailureCommandOutput>;\n  /**\n   * @see {@link SendTaskHeartbeatCommand}\n   */\n  sendTaskHeartbeat(\n    args: SendTaskHeartbeatCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    SendTaskHeartbeatCommandOutput\n  >;\n  /**\n   * @see {@link SendTaskSuccessCommand}\n   */\n  sendTaskSuccess(\n    args: SendTaskSuccessCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, SendTaskSuccessCommandOutput>;\n  /**\n   * @see {@link StartExecutionCommand}\n   */\n  startExecution(\n    args: StartExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, StartExecutionCommandOutput>;\n  /**\n   * @see {@link StartSyncExecutionCommand}\n   */\n  startSyncExecution(\n    args: StartSyncExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    StartSyncExecutionCommandOutput\n  >;\n  /**\n   * @see {@link StopExecutionCommand}\n   */\n  stopExecution(\n    args: StopExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, StopExecutionCommandOutput>;\n  /**\n   * @see {@link TagResourceCommand}\n   */\n  tagResource(\n    args: TagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, TagResourceCommandOutput>;\n  /**\n   * @see {@link TestStateCommand}\n   */\n  testState(\n    args: TestStateCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, TestStateCommandOutput>;\n  /**\n   * @see {@link UntagResourceCommand}\n   */\n  untagResource(\n    args: UntagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, UntagResourceCommandOutput>;\n  /**\n   * @see {@link UpdateMapRunCommand}\n   */\n  updateMapRun(\n    args: UpdateMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<never, Cause.UnknownException, UpdateMapRunCommandOutput>;\n  /**\n   * @see {@link UpdateStateMachineCommand}\n   */\n  updateStateMachine(\n    args: UpdateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    UpdateStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link UpdateStateMachineAliasCommand}\n   */\n  updateStateMachineAlias(\n    args: UpdateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    Cause.UnknownException,\n    UpdateStateMachineAliasCommandOutput\n  >;\n}\n\nexport const BaseSFNServiceEffect = Effect.gen(function* (_) {\n  const client = yield* _(SFNClientInstanceTag);\n\n  return RR.toEntries(commands).reduce((acc, [command]) => {\n    const CommandCtor = commands[command] as any;\n    const methodImpl = (args: any, options: any) =>\n      Effect.tryPromise(() =>\n        client.send(new CommandCtor(args), options ?? {}),\n      );\n    const methodName = (command[0].toLowerCase() + command.slice(1)).replace(\n      /Command$/,\n      \"\",\n    );\n    return { ...acc, [methodName]: methodImpl };\n  }, {}) as SFNService;\n});\n\nexport const SFNServiceEffect = BaseSFNServiceEffect.pipe(\n  Effect.provide(SFNClientInstanceLayer),\n);\n\nexport const DefaultSFNServiceEffect = BaseSFNServiceEffect.pipe(\n  Effect.provide(DefaultSFNClientInstanceLayer),\n);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SFN.js","sourceRoot":"","sources":["../../src/SFN.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CreateActivityCommand,\n  CreateActivityCommandInput,\n  CreateActivityCommandOutput,\n  CreateStateMachineAliasCommand,\n  CreateStateMachineAliasCommandInput,\n  CreateStateMachineAliasCommandOutput,\n  CreateStateMachineCommand,\n  CreateStateMachineCommandInput,\n  CreateStateMachineCommandOutput,\n  DeleteActivityCommand,\n  DeleteActivityCommandInput,\n  DeleteActivityCommandOutput,\n  DeleteStateMachineAliasCommand,\n  DeleteStateMachineAliasCommandInput,\n  DeleteStateMachineAliasCommandOutput,\n  DeleteStateMachineCommand,\n  DeleteStateMachineCommandInput,\n  DeleteStateMachineCommandOutput,\n  DeleteStateMachineVersionCommand,\n  DeleteStateMachineVersionCommandInput,\n  DeleteStateMachineVersionCommandOutput,\n  DescribeActivityCommand,\n  DescribeActivityCommandInput,\n  DescribeActivityCommandOutput,\n  DescribeExecutionCommand,\n  DescribeExecutionCommandInput,\n  DescribeExecutionCommandOutput,\n  DescribeMapRunCommand,\n  DescribeMapRunCommandInput,\n  DescribeMapRunCommandOutput,\n  DescribeStateMachineAliasCommand,\n  DescribeStateMachineAliasCommandInput,\n  DescribeStateMachineAliasCommandOutput,\n  DescribeStateMachineCommand,\n  DescribeStateMachineCommandInput,\n  DescribeStateMachineCommandOutput,\n  DescribeStateMachineForExecutionCommand,\n  DescribeStateMachineForExecutionCommandInput,\n  DescribeStateMachineForExecutionCommandOutput,\n  GetActivityTaskCommand,\n  GetActivityTaskCommandInput,\n  GetActivityTaskCommandOutput,\n  GetExecutionHistoryCommand,\n  GetExecutionHistoryCommandInput,\n  GetExecutionHistoryCommandOutput,\n  ListActivitiesCommand,\n  ListActivitiesCommandInput,\n  ListActivitiesCommandOutput,\n  ListExecutionsCommand,\n  ListExecutionsCommandInput,\n  ListExecutionsCommandOutput,\n  ListMapRunsCommand,\n  ListMapRunsCommandInput,\n  ListMapRunsCommandOutput,\n  ListStateMachineAliasesCommand,\n  ListStateMachineAliasesCommandInput,\n  ListStateMachineAliasesCommandOutput,\n  ListStateMachineVersionsCommand,\n  ListStateMachineVersionsCommandInput,\n  ListStateMachineVersionsCommandOutput,\n  ListStateMachinesCommand,\n  ListStateMachinesCommandInput,\n  ListStateMachinesCommandOutput,\n  ListTagsForResourceCommand,\n  ListTagsForResourceCommandInput,\n  ListTagsForResourceCommandOutput,\n  PublishStateMachineVersionCommand,\n  PublishStateMachineVersionCommandInput,\n  PublishStateMachineVersionCommandOutput,\n  RedriveExecutionCommand,\n  RedriveExecutionCommandInput,\n  RedriveExecutionCommandOutput,\n  SFNServiceException,\n  SendTaskFailureCommand,\n  SendTaskFailureCommandInput,\n  SendTaskFailureCommandOutput,\n  SendTaskHeartbeatCommand,\n  SendTaskHeartbeatCommandInput,\n  SendTaskHeartbeatCommandOutput,\n  SendTaskSuccessCommand,\n  SendTaskSuccessCommandInput,\n  SendTaskSuccessCommandOutput,\n  StartExecutionCommand,\n  StartExecutionCommandInput,\n  StartExecutionCommandOutput,\n  StartSyncExecutionCommand,\n  StartSyncExecutionCommandInput,\n  StartSyncExecutionCommandOutput,\n  StopExecutionCommand,\n  StopExecutionCommandInput,\n  StopExecutionCommandOutput,\n  TagResourceCommand,\n  TagResourceCommandInput,\n  TagResourceCommandOutput,\n  TestStateCommand,\n  TestStateCommandInput,\n  TestStateCommandOutput,\n  UntagResourceCommand,\n  UntagResourceCommandInput,\n  UntagResourceCommandOutput,\n  UpdateMapRunCommand,\n  UpdateMapRunCommandInput,\n  UpdateMapRunCommandOutput,\n  UpdateStateMachineAliasCommand,\n  UpdateStateMachineAliasCommandInput,\n  UpdateStateMachineAliasCommandOutput,\n  UpdateStateMachineCommand,\n  UpdateStateMachineCommandInput,\n  UpdateStateMachineCommandOutput,\n} from \"@aws-sdk/client-sfn\";\nimport { HttpHandlerOptions as __HttpHandlerOptions } from \"@aws-sdk/types\";\nimport * as Data from \"effect/Data\";\nimport * as Effect from \"effect/Effect\";\nimport * as RR from \"effect/ReadonlyRecord\";\nimport {\n  DefaultSFNClientInstanceLayer,\n  SFNClientInstanceLayer,\n  SFNClientInstanceTag,\n} from \"./Context\";\nimport {\n  ActivityDoesNotExistError,\n  ActivityLimitExceededError,\n  ActivityWorkerLimitExceededError,\n  ConflictError,\n  ExecutionAlreadyExistsError,\n  ExecutionDoesNotExistError,\n  ExecutionLimitExceededError,\n  ExecutionNotRedrivableError,\n  InvalidArnError,\n  InvalidDefinitionError,\n  InvalidExecutionInputError,\n  InvalidLoggingConfigurationError,\n  InvalidNameError,\n  InvalidOutputError,\n  InvalidTokenError,\n  InvalidTracingConfigurationError,\n  MissingRequiredParameterError,\n  ResourceNotFoundError,\n  SdkError,\n  ServiceQuotaExceededError,\n  StateMachineAlreadyExistsError,\n  StateMachineDeletingError,\n  StateMachineDoesNotExistError,\n  StateMachineLimitExceededError,\n  StateMachineTypeNotSupportedError,\n  TaggedException,\n  TaskDoesNotExistError,\n  TaskTimedOutError,\n  TooManyTagsError,\n  ValidationError,\n} from \"./Errors\";\n\nconst commands = {\n  CreateActivityCommand,\n  CreateStateMachineCommand,\n  CreateStateMachineAliasCommand,\n  DeleteActivityCommand,\n  DeleteStateMachineCommand,\n  DeleteStateMachineAliasCommand,\n  DeleteStateMachineVersionCommand,\n  DescribeActivityCommand,\n  DescribeExecutionCommand,\n  DescribeMapRunCommand,\n  DescribeStateMachineCommand,\n  DescribeStateMachineAliasCommand,\n  DescribeStateMachineForExecutionCommand,\n  GetActivityTaskCommand,\n  GetExecutionHistoryCommand,\n  ListActivitiesCommand,\n  ListExecutionsCommand,\n  ListMapRunsCommand,\n  ListStateMachineAliasesCommand,\n  ListStateMachinesCommand,\n  ListStateMachineVersionsCommand,\n  ListTagsForResourceCommand,\n  PublishStateMachineVersionCommand,\n  RedriveExecutionCommand,\n  SendTaskFailureCommand,\n  SendTaskHeartbeatCommand,\n  SendTaskSuccessCommand,\n  StartExecutionCommand,\n  StartSyncExecutionCommand,\n  StopExecutionCommand,\n  TagResourceCommand,\n  TestStateCommand,\n  UntagResourceCommand,\n  UpdateMapRunCommand,\n  UpdateStateMachineCommand,\n  UpdateStateMachineAliasCommand,\n};\n\nexport interface SFNService {\n  /**\n   * @see {@link CreateActivityCommand}\n   */\n  createActivity(\n    args: CreateActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ActivityLimitExceededError | InvalidNameError | TooManyTagsError,\n    CreateActivityCommandOutput\n  >;\n  /**\n   * @see {@link CreateStateMachineCommand}\n   */\n  createStateMachine(\n    args: CreateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidLoggingConfigurationError\n    | InvalidNameError\n    | InvalidTracingConfigurationError\n    | StateMachineAlreadyExistsError\n    | StateMachineDeletingError\n    | StateMachineLimitExceededError\n    | StateMachineTypeNotSupportedError\n    | TooManyTagsError\n    | ValidationError,\n    CreateStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link CreateStateMachineAliasCommand}\n   */\n  createStateMachineAlias(\n    args: CreateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidNameError\n    | ResourceNotFoundError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | ValidationError,\n    CreateStateMachineAliasCommandOutput\n  >;\n  /**\n   * @see {@link DeleteActivityCommand}\n   */\n  deleteActivity(\n    args: DeleteActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError,\n    DeleteActivityCommandOutput\n  >;\n  /**\n   * @see {@link DeleteStateMachineCommand}\n   */\n  deleteStateMachine(\n    args: DeleteStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | ValidationError,\n    DeleteStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link DeleteStateMachineAliasCommand}\n   */\n  deleteStateMachineAlias(\n    args: DeleteStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ResourceNotFoundError\n    | ValidationError,\n    DeleteStateMachineAliasCommandOutput\n  >;\n  /**\n   * @see {@link DeleteStateMachineVersionCommand}\n   */\n  deleteStateMachineVersion(\n    args: DeleteStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ConflictError | InvalidArnError | ValidationError,\n    DeleteStateMachineVersionCommandOutput\n  >;\n  /**\n   * @see {@link DescribeActivityCommand}\n   */\n  describeActivity(\n    args: DescribeActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ActivityDoesNotExistError | InvalidArnError,\n    DescribeActivityCommandOutput\n  >;\n  /**\n   * @see {@link DescribeExecutionCommand}\n   */\n  describeExecution(\n    args: DescribeExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError,\n    DescribeExecutionCommandOutput\n  >;\n  /**\n   * @see {@link DescribeMapRunCommand}\n   */\n  describeMapRun(\n    args: DescribeMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | ResourceNotFoundError,\n    DescribeMapRunCommandOutput\n  >;\n  /**\n   * @see {@link DescribeStateMachineCommand}\n   */\n  describeStateMachine(\n    args: DescribeStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | StateMachineDoesNotExistError,\n    DescribeStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link DescribeStateMachineAliasCommand}\n   */\n  describeStateMachineAlias(\n    args: DescribeStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | ResourceNotFoundError | ValidationError,\n    DescribeStateMachineAliasCommandOutput\n  >;\n  /**\n   * @see {@link DescribeStateMachineForExecutionCommand}\n   */\n  describeStateMachineForExecution(\n    args: DescribeStateMachineForExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError,\n    DescribeStateMachineForExecutionCommandOutput\n  >;\n  /**\n   * @see {@link GetActivityTaskCommand}\n   */\n  getActivityTask(\n    args: GetActivityTaskCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ActivityDoesNotExistError\n    | ActivityWorkerLimitExceededError\n    | InvalidArnError,\n    GetActivityTaskCommandOutput\n  >;\n  /**\n   * @see {@link GetExecutionHistoryCommand}\n   */\n  getExecutionHistory(\n    args: GetExecutionHistoryCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError,\n    GetExecutionHistoryCommandOutput\n  >;\n  /**\n   * @see {@link ListActivitiesCommand}\n   */\n  listActivities(\n    args: ListActivitiesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidTokenError,\n    ListActivitiesCommandOutput\n  >;\n  /**\n   * @see {@link ListExecutionsCommand}\n   */\n  listExecutions(\n    args: ListExecutionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | InvalidArnError\n    | InvalidTokenError\n    | ResourceNotFoundError\n    | StateMachineDoesNotExistError\n    | StateMachineTypeNotSupportedError\n    | ValidationError,\n    ListExecutionsCommandOutput\n  >;\n  /**\n   * @see {@link ListMapRunsCommand}\n   */\n  listMapRuns(\n    args: ListMapRunsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError,\n    ListMapRunsCommandOutput\n  >;\n  /**\n   * @see {@link ListStateMachineAliasesCommand}\n   */\n  listStateMachineAliases(\n    args: ListStateMachineAliasesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | InvalidArnError\n    | InvalidTokenError\n    | ResourceNotFoundError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError,\n    ListStateMachineAliasesCommandOutput\n  >;\n  /**\n   * @see {@link ListStateMachinesCommand}\n   */\n  listStateMachines(\n    args: ListStateMachinesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidTokenError,\n    ListStateMachinesCommandOutput\n  >;\n  /**\n   * @see {@link ListStateMachineVersionsCommand}\n   */\n  listStateMachineVersions(\n    args: ListStateMachineVersionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | InvalidTokenError | ValidationError,\n    ListStateMachineVersionsCommandOutput\n  >;\n  /**\n   * @see {@link ListTagsForResourceCommand}\n   */\n  listTagsForResource(\n    args: ListTagsForResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | ResourceNotFoundError,\n    ListTagsForResourceCommandOutput\n  >;\n  /**\n   * @see {@link PublishStateMachineVersionCommand}\n   */\n  publishStateMachineVersion(\n    args: PublishStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError,\n    PublishStateMachineVersionCommandOutput\n  >;\n  /**\n   * @see {@link RedriveExecutionCommand}\n   */\n  redriveExecution(\n    args: RedriveExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ExecutionDoesNotExistError\n    | ExecutionLimitExceededError\n    | ExecutionNotRedrivableError\n    | InvalidArnError,\n    RedriveExecutionCommandOutput\n  >;\n  /**\n   * @see {@link SendTaskFailureCommand}\n   */\n  sendTaskFailure(\n    args: SendTaskFailureCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError,\n    SendTaskFailureCommandOutput\n  >;\n  /**\n   * @see {@link SendTaskHeartbeatCommand}\n   */\n  sendTaskHeartbeat(\n    args: SendTaskHeartbeatCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError,\n    SendTaskHeartbeatCommandOutput\n  >;\n  /**\n   * @see {@link SendTaskSuccessCommand}\n   */\n  sendTaskSuccess(\n    args: SendTaskSuccessCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | InvalidOutputError\n    | InvalidTokenError\n    | TaskDoesNotExistError\n    | TaskTimedOutError,\n    SendTaskSuccessCommandOutput\n  >;\n  /**\n   * @see {@link StartExecutionCommand}\n   */\n  startExecution(\n    args: StartExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ExecutionAlreadyExistsError\n    | ExecutionLimitExceededError\n    | InvalidArnError\n    | InvalidExecutionInputError\n    | InvalidNameError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError,\n    StartExecutionCommandOutput\n  >;\n  /**\n   * @see {@link StartSyncExecutionCommand}\n   */\n  startSyncExecution(\n    args: StartSyncExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | InvalidArnError\n    | InvalidExecutionInputError\n    | InvalidNameError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | StateMachineTypeNotSupportedError,\n    StartSyncExecutionCommandOutput\n  >;\n  /**\n   * @see {@link StopExecutionCommand}\n   */\n  stopExecution(\n    args: StopExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError | ValidationError,\n    StopExecutionCommandOutput\n  >;\n  /**\n   * @see {@link TagResourceCommand}\n   */\n  tagResource(\n    args: TagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | ResourceNotFoundError | TooManyTagsError,\n    TagResourceCommandOutput\n  >;\n  /**\n   * @see {@link TestStateCommand}\n   */\n  testState(\n    args: TestStateCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidExecutionInputError\n    | ValidationError,\n    TestStateCommandOutput\n  >;\n  /**\n   * @see {@link UntagResourceCommand}\n   */\n  untagResource(\n    args: UntagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | ResourceNotFoundError,\n    UntagResourceCommandOutput\n  >;\n  /**\n   * @see {@link UpdateMapRunCommand}\n   */\n  updateMapRun(\n    args: UpdateMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    SdkError | InvalidArnError | ResourceNotFoundError | ValidationError,\n    UpdateMapRunCommandOutput\n  >;\n  /**\n   * @see {@link UpdateStateMachineCommand}\n   */\n  updateStateMachine(\n    args: UpdateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidLoggingConfigurationError\n    | InvalidTracingConfigurationError\n    | MissingRequiredParameterError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError,\n    UpdateStateMachineCommandOutput\n  >;\n  /**\n   * @see {@link UpdateStateMachineAliasCommand}\n   */\n  updateStateMachineAlias(\n    args: UpdateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    never,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ResourceNotFoundError\n    | StateMachineDeletingError\n    | ValidationError,\n    UpdateStateMachineAliasCommandOutput\n  >;\n}\n\nexport const BaseSFNServiceEffect = Effect.gen(function* (_) {\n  const client = yield* _(SFNClientInstanceTag);\n\n  return RR.toEntries(commands).reduce((acc, [command]) => {\n    const CommandCtor = commands[command] as any;\n    const methodImpl = (args: any, options: any) =>\n      Effect.tryPromise({\n        try: () => client.send(new CommandCtor(args), options ?? {}),\n        catch: (e) => {\n          if (e instanceof SFNServiceException) {\n            const ServiceException = Data.tagged<\n              TaggedException<SFNServiceException>\n            >(e.name);\n\n            return ServiceException({\n              ...e,\n              message: e.message,\n              stack: e.stack,\n            });\n          }\n          if (e instanceof Error) {\n            return SdkError({\n              ...e,\n              name: \"SdkError\",\n              message: e.message,\n              stack: e.stack,\n            });\n          }\n          throw e;\n        },\n      });\n    const methodName = (command[0].toLowerCase() + command.slice(1)).replace(\n      /Command$/,\n      \"\",\n    );\n    return { ...acc, [methodName]: methodImpl };\n  }, {}) as SFNService;\n});\n\nexport const SFNServiceEffect = BaseSFNServiceEffect.pipe(\n  Effect.provide(SFNClientInstanceLayer),\n);\n\nexport const DefaultSFNServiceEffect = BaseSFNServiceEffect.pipe(\n  Effect.provide(DefaultSFNClientInstanceLayer),\n);\n"]}

package/lib/esm/index.js

@@ -1,3 +1,4 @@
 export * from "./Context";
+export * from "./Errors";
 export * from "./SFN";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxPQUFPLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9Db250ZXh0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9TRk5cIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxPQUFPLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9Db250ZXh0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9FcnJvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1NGTlwiO1xuIl19

package/lib/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./Context";
+export * from "./Errors";
 export * from "./SFN";

package/lib/index.js

@@ -15,5 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Context"), exports);
+__exportStar(require("./Errors"), exports);
 __exportStar(require("./SFN"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDRDQUEwQjtBQUMxQix3Q0FBc0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9Db250ZXh0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9TRk5cIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDRDQUEwQjtBQUMxQiwyQ0FBeUI7QUFDekIsd0NBQXNCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vQ29udGV4dFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vRXJyb3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9TRk5cIjtcbiJdfQ==

package/package.json

@@ -37,7 +37,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.0",
+  "version": "0.2.0",
   "types": "lib/index.d.ts",
   "module": "lib/esm/index.js",
   "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"npx projen\".",