npm - @effect-aws/client-sfn - Versions diffs - 1.1.1 → 1.3.0 - Mend

@effect-aws/client-sfn 1.1.1 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/CHANGELOG.md +12 -0
package/lib/Errors.d.ts +22 -16
package/lib/Errors.js +39 -27
package/lib/SFNClientInstanceConfig.d.ts +1 -3
package/lib/SFNClientInstanceConfig.js +22 -38
package/lib/SFNService.d.ts +70 -41
package/lib/SFNService.js +11 -23
package/lib/esm/Errors.js +37 -2
package/lib/esm/SFNClientInstanceConfig.js +17 -10
package/lib/esm/SFNService.js +12 -25
package/package.json +10 -12

package/CHANGELOG.md CHANGED Viewed

@@ -1,5 +1,17 @@
 # @effect-aws/client-sfn
+## 1.3.0
+### Minor Changes
+- [#58](https://github.com/floydspace/effect-aws/pull/58) [`888dc8c`](https://github.com/floydspace/effect-aws/commit/888dc8ca0d7104e33a24426a1aacedb48e8fc3ac) Thanks [@floydspace](https://github.com/floydspace)! - use Effect.Tag instead of Context.GenericTag for service, upgrade sdk, handle only known errors
+## 1.2.0
+### Minor Changes
+- [`0cfcda0`](https://github.com/floydspace/effect-aws/commit/0cfcda0d5617916d966807f5d5120df9ba461c12) Thanks [@floydspace](https://github.com/floydspace)! - upgrade effect to v3
 ## 1.1.1
 ### Patch Changes

package/lib/Errors.d.ts CHANGED Viewed

@@ -1,38 +1,44 @@
-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";
+import type { ActivityAlreadyExists, ActivityDoesNotExist, ActivityLimitExceeded, ActivityWorkerLimitExceeded, ConflictException, ExecutionAlreadyExists, ExecutionDoesNotExist, ExecutionLimitExceeded, ExecutionNotRedrivable, InvalidArn, InvalidDefinition, InvalidEncryptionConfiguration, InvalidExecutionInput, InvalidLoggingConfiguration, InvalidName, InvalidOutput, InvalidToken, InvalidTracingConfiguration, KmsAccessDeniedException, KmsInvalidStateException, KmsThrottlingException, MissingRequiredParameter, ResourceNotFound, ServiceQuotaExceededException, StateMachineAlreadyExists, StateMachineDeleting, StateMachineDoesNotExist, StateMachineLimitExceeded, StateMachineTypeNotSupported, TaskDoesNotExist, TaskTimedOut, TooManyTags, ValidationException } from "@aws-sdk/client-sfn";
+import { Data } from "effect";
+export declare const AllServiceErrors: string[];
 export type TaggedException<T extends {
     name: string;
 }> = T & {
     readonly _tag: T["name"];
 };
+export type ActivityAlreadyExistsError = TaggedException<ActivityAlreadyExists>;
 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 ExecutionAlreadyExistsError = TaggedException<ExecutionAlreadyExists>;
+export type ExecutionDoesNotExistError = TaggedException<ExecutionDoesNotExist>;
+export type ExecutionLimitExceededError = TaggedException<ExecutionLimitExceeded>;
+export type ExecutionNotRedrivableError = TaggedException<ExecutionNotRedrivable>;
 export type InvalidArnError = TaggedException<InvalidArn>;
 export type InvalidDefinitionError = TaggedException<InvalidDefinition>;
+export type InvalidEncryptionConfigurationError = TaggedException<InvalidEncryptionConfiguration>;
+export type InvalidExecutionInputError = TaggedException<InvalidExecutionInput>;
 export type InvalidLoggingConfigurationError = TaggedException<InvalidLoggingConfiguration>;
+export type InvalidNameError = TaggedException<InvalidName>;
+export type InvalidOutputError = TaggedException<InvalidOutput>;
+export type InvalidTokenError = TaggedException<InvalidToken>;
 export type InvalidTracingConfigurationError = TaggedException<InvalidTracingConfiguration>;
+export type KmsAccessDeniedError = TaggedException<KmsAccessDeniedException>;
+export type KmsInvalidStateError = TaggedException<KmsInvalidStateException>;
+export type KmsThrottlingError = TaggedException<KmsThrottlingException>;
+export type MissingRequiredParameterError = TaggedException<MissingRequiredParameter>;
+export type ResourceNotFoundError = TaggedException<ResourceNotFound>;
+export type ServiceQuotaExceededError = TaggedException<ServiceQuotaExceededException>;
 export type StateMachineAlreadyExistsError = TaggedException<StateMachineAlreadyExists>;
 export type StateMachineDeletingError = TaggedException<StateMachineDeleting>;
+export type StateMachineDoesNotExistError = TaggedException<StateMachineDoesNotExist>;
 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 TooManyTagsError = TaggedException<TooManyTags>;
+export type ValidationError = TaggedException<ValidationException>;
 export type SdkError = TaggedException<Error & {
     name: "SdkError";
 }>;

package/lib/Errors.js CHANGED Viewed

@@ -1,29 +1,41 @@
 "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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
+exports.SdkError = exports.AllServiceErrors = void 0;
+const effect_1 = require("effect");
+exports.AllServiceErrors = [
+    "ActivityAlreadyExists",
+    "ActivityDoesNotExist",
+    "ActivityLimitExceeded",
+    "ActivityWorkerLimitExceeded",
+    "ConflictException",
+    "ExecutionAlreadyExists",
+    "ExecutionDoesNotExist",
+    "ExecutionLimitExceeded",
+    "ExecutionNotRedrivable",
+    "InvalidArn",
+    "InvalidDefinition",
+    "InvalidEncryptionConfiguration",
+    "InvalidExecutionInput",
+    "InvalidLoggingConfiguration",
+    "InvalidName",
+    "InvalidOutput",
+    "InvalidToken",
+    "InvalidTracingConfiguration",
+    "KmsAccessDeniedException",
+    "KmsInvalidStateException",
+    "KmsThrottlingException",
+    "MissingRequiredParameter",
+    "ResourceNotFound",
+    "ServiceQuotaExceededException",
+    "StateMachineAlreadyExists",
+    "StateMachineDeleting",
+    "StateMachineDoesNotExist",
+    "StateMachineLimitExceeded",
+    "StateMachineTypeNotSupported",
+    "TaskDoesNotExist",
+    "TaskTimedOut",
+    "TooManyTags",
+    "ValidationException",
+];
+exports.SdkError = effect_1.Data.tagged("SdkError");
+//# sourceMappingURL=data:application/json;base64,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

package/lib/SFNClientInstanceConfig.d.ts CHANGED Viewed

@@ -2,9 +2,7 @@
  * @since 1.0.0
  */
 import type { SFNClientConfig } from "@aws-sdk/client-sfn";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
+import { Context, Effect, Layer } from "effect";
 declare const SFNClientInstanceConfig_base: Context.TagClass<SFNClientInstanceConfig, "@effect-aws/client-sfn/SFNClientInstanceConfig", SFNClientConfig>;
 /**
  * @since 1.0.0

package/lib/SFNClientInstanceConfig.js CHANGED Viewed

@@ -1,54 +1,38 @@
 "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.DefaultSFNClientConfigLayer = exports.makeDefaultSFNClientInstanceConfig = exports.SFNClientInstanceConfig = void 0;
-const Context = __importStar(require("effect/Context"));
-const Effect = __importStar(require("effect/Effect"));
-const Layer = __importStar(require("effect/Layer"));
-const Runtime = __importStar(require("effect/Runtime"));
+const effect_1 = require("effect");
 /**
  * @since 1.0.0
  * @category tags
  */
-class SFNClientInstanceConfig extends Context.Tag("@effect-aws/client-sfn/SFNClientInstanceConfig")() {
+class SFNClientInstanceConfig extends effect_1.Context.Tag("@effect-aws/client-sfn/SFNClientInstanceConfig")() {
 }
 exports.SFNClientInstanceConfig = SFNClientInstanceConfig;
 /**
  * @since 1.0.0
  * @category constructors
  */
-exports.makeDefaultSFNClientInstanceConfig = Effect.gen(function* (_) {
-    const runtime = yield* _(Effect.runtime());
-    const runSync = Runtime.runSync(runtime);
+exports.makeDefaultSFNClientInstanceConfig = effect_1.Effect.gen(function* (_) {
+    const runtime = yield* _(effect_1.Effect.runtime());
+    const runSync = effect_1.Runtime.runSync(runtime);
     return {
         logger: {
-            info: (m) => Effect.logInfo(m).pipe(runSync),
-            warn: (m) => Effect.logWarning(m).pipe(runSync),
-            error: (m) => Effect.logError(m).pipe(runSync),
-            debug: (m) => Effect.logDebug(m).pipe(runSync),
-            trace: (m) => Effect.logTrace(m).pipe(runSync),
+            info(m) {
+                effect_1.Effect.logInfo(m).pipe(runSync);
+            },
+            warn(m) {
+                effect_1.Effect.logWarning(m).pipe(runSync);
+            },
+            error(m) {
+                effect_1.Effect.logError(m).pipe(runSync);
+            },
+            debug(m) {
+                effect_1.Effect.logDebug(m).pipe(runSync);
+            },
+            trace(m) {
+                effect_1.Effect.logTrace(m).pipe(runSync);
+            },
         },
     };
 });
@@ -56,5 +40,5 @@ exports.makeDefaultSFNClientInstanceConfig = Effect.gen(function* (_) {
  * @since 1.0.0
  * @category layers
  */
-exports.DefaultSFNClientConfigLayer = Layer.effect(SFNClientInstanceConfig, exports.makeDefaultSFNClientInstanceConfig);
-//# sourceMappingURL=data:application/json;base64,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
+exports.DefaultSFNClientConfigLayer = effect_1.Layer.effect(SFNClientInstanceConfig, exports.makeDefaultSFNClientInstanceConfig);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/SFNService.d.ts CHANGED Viewed

@@ -1,25 +1,21 @@
 /**
  * @since 1.0.0
  */
-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 { Context, Effect, Layer } from "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";
+import { type CreateActivityCommandInput, type CreateActivityCommandOutput, type CreateStateMachineCommandInput, type CreateStateMachineCommandOutput, type CreateStateMachineAliasCommandInput, type CreateStateMachineAliasCommandOutput, type DeleteActivityCommandInput, type DeleteActivityCommandOutput, type DeleteStateMachineCommandInput, type DeleteStateMachineCommandOutput, type DeleteStateMachineAliasCommandInput, type DeleteStateMachineAliasCommandOutput, type DeleteStateMachineVersionCommandInput, type DeleteStateMachineVersionCommandOutput, type DescribeActivityCommandInput, type DescribeActivityCommandOutput, type DescribeExecutionCommandInput, type DescribeExecutionCommandOutput, type DescribeMapRunCommandInput, type DescribeMapRunCommandOutput, type DescribeStateMachineCommandInput, type DescribeStateMachineCommandOutput, type DescribeStateMachineAliasCommandInput, type DescribeStateMachineAliasCommandOutput, type DescribeStateMachineForExecutionCommandInput, type DescribeStateMachineForExecutionCommandOutput, type GetActivityTaskCommandInput, type GetActivityTaskCommandOutput, type GetExecutionHistoryCommandInput, type GetExecutionHistoryCommandOutput, type ListActivitiesCommandInput, type ListActivitiesCommandOutput, type ListExecutionsCommandInput, type ListExecutionsCommandOutput, type ListMapRunsCommandInput, type ListMapRunsCommandOutput, type ListStateMachineAliasesCommandInput, type ListStateMachineAliasesCommandOutput, type ListStateMachinesCommandInput, type ListStateMachinesCommandOutput, type ListStateMachineVersionsCommandInput, type ListStateMachineVersionsCommandOutput, type ListTagsForResourceCommandInput, type ListTagsForResourceCommandOutput, type PublishStateMachineVersionCommandInput, type PublishStateMachineVersionCommandOutput, type RedriveExecutionCommandInput, type RedriveExecutionCommandOutput, type SendTaskFailureCommandInput, type SendTaskFailureCommandOutput, type SendTaskHeartbeatCommandInput, type SendTaskHeartbeatCommandOutput, type SendTaskSuccessCommandInput, type SendTaskSuccessCommandOutput, type StartExecutionCommandInput, type StartExecutionCommandOutput, type StartSyncExecutionCommandInput, type StartSyncExecutionCommandOutput, type StopExecutionCommandInput, type StopExecutionCommandOutput, type TagResourceCommandInput, type TagResourceCommandOutput, type TestStateCommandInput, type TestStateCommandOutput, type UntagResourceCommandInput, type UntagResourceCommandOutput, type UpdateMapRunCommandInput, type UpdateMapRunCommandOutput, type UpdateStateMachineCommandInput, type UpdateStateMachineCommandOutput, type UpdateStateMachineAliasCommandInput, type UpdateStateMachineAliasCommandOutput, type ValidateStateMachineDefinitionCommandInput, type ValidateStateMachineDefinitionCommandOutput } from "@aws-sdk/client-sfn";
+import { type HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+import { Effect, Layer } from "effect";
+import { ActivityAlreadyExistsError, ActivityDoesNotExistError, ActivityLimitExceededError, ActivityWorkerLimitExceededError, ConflictError, ExecutionAlreadyExistsError, ExecutionDoesNotExistError, ExecutionLimitExceededError, ExecutionNotRedrivableError, InvalidArnError, InvalidDefinitionError, InvalidEncryptionConfigurationError, InvalidExecutionInputError, InvalidLoggingConfigurationError, InvalidNameError, InvalidOutputError, InvalidTokenError, InvalidTracingConfigurationError, KmsAccessDeniedError, KmsInvalidStateError, KmsThrottlingError, MissingRequiredParameterError, ResourceNotFoundError, ServiceQuotaExceededError, StateMachineAlreadyExistsError, StateMachineDeletingError, StateMachineDoesNotExistError, StateMachineLimitExceededError, StateMachineTypeNotSupportedError, TaskDoesNotExistError, TaskTimedOutError, TooManyTagsError, ValidationError, SdkError } from "./Errors";
 import { SFNClientInstance } from "./SFNClientInstance";
-/**
- * @since 1.0.0
- * @category models
- */
-export interface SFNService {
+interface SFNService$ {
     readonly _: unique symbol;
     /**
      * @see {@link CreateActivityCommand}
      */
-    createActivity(args: CreateActivityCommandInput, options?: __HttpHandlerOptions): Effect.Effect<CreateActivityCommandOutput, SdkError | ActivityLimitExceededError | InvalidNameError | TooManyTagsError>;
+    createActivity(args: CreateActivityCommandInput, options?: __HttpHandlerOptions): Effect.Effect<CreateActivityCommandOutput, SdkError | ActivityAlreadyExistsError | ActivityLimitExceededError | InvalidEncryptionConfigurationError | InvalidNameError | KmsAccessDeniedError | KmsThrottlingError | TooManyTagsError>;
     /**
      * @see {@link CreateStateMachineCommand}
      */
-    createStateMachine(args: CreateStateMachineCommandInput, options?: __HttpHandlerOptions): Effect.Effect<CreateStateMachineCommandOutput, SdkError | ConflictError | InvalidArnError | InvalidDefinitionError | InvalidLoggingConfigurationError | InvalidNameError | InvalidTracingConfigurationError | StateMachineAlreadyExistsError | StateMachineDeletingError | StateMachineLimitExceededError | StateMachineTypeNotSupportedError | TooManyTagsError | ValidationError>;
+    createStateMachine(args: CreateStateMachineCommandInput, options?: __HttpHandlerOptions): Effect.Effect<CreateStateMachineCommandOutput, SdkError | ConflictError | InvalidArnError | InvalidDefinitionError | InvalidEncryptionConfigurationError | InvalidLoggingConfigurationError | InvalidNameError | InvalidTracingConfigurationError | KmsAccessDeniedError | KmsThrottlingError | StateMachineAlreadyExistsError | StateMachineDeletingError | StateMachineLimitExceededError | StateMachineTypeNotSupportedError | TooManyTagsError | ValidationError>;
     /**
      * @see {@link CreateStateMachineAliasCommand}
      */
@@ -47,7 +43,7 @@ export interface SFNService {
     /**
      * @see {@link DescribeExecutionCommand}
      */
-    describeExecution(args: DescribeExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<DescribeExecutionCommandOutput, SdkError | ExecutionDoesNotExistError | InvalidArnError>;
+    describeExecution(args: DescribeExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<DescribeExecutionCommandOutput, SdkError | ExecutionDoesNotExistError | InvalidArnError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError>;
     /**
      * @see {@link DescribeMapRunCommand}
      */
@@ -55,7 +51,7 @@ export interface SFNService {
     /**
      * @see {@link DescribeStateMachineCommand}
      */
-    describeStateMachine(args: DescribeStateMachineCommandInput, options?: __HttpHandlerOptions): Effect.Effect<DescribeStateMachineCommandOutput, SdkError | InvalidArnError | StateMachineDoesNotExistError>;
+    describeStateMachine(args: DescribeStateMachineCommandInput, options?: __HttpHandlerOptions): Effect.Effect<DescribeStateMachineCommandOutput, SdkError | InvalidArnError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | StateMachineDoesNotExistError>;
     /**
      * @see {@link DescribeStateMachineAliasCommand}
      */
@@ -63,15 +59,15 @@ export interface SFNService {
     /**
      * @see {@link DescribeStateMachineForExecutionCommand}
      */
-    describeStateMachineForExecution(args: DescribeStateMachineForExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<DescribeStateMachineForExecutionCommandOutput, SdkError | ExecutionDoesNotExistError | InvalidArnError>;
+    describeStateMachineForExecution(args: DescribeStateMachineForExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<DescribeStateMachineForExecutionCommandOutput, SdkError | ExecutionDoesNotExistError | InvalidArnError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError>;
     /**
      * @see {@link GetActivityTaskCommand}
      */
-    getActivityTask(args: GetActivityTaskCommandInput, options?: __HttpHandlerOptions): Effect.Effect<GetActivityTaskCommandOutput, SdkError | ActivityDoesNotExistError | ActivityWorkerLimitExceededError | InvalidArnError>;
+    getActivityTask(args: GetActivityTaskCommandInput, options?: __HttpHandlerOptions): Effect.Effect<GetActivityTaskCommandOutput, SdkError | ActivityDoesNotExistError | ActivityWorkerLimitExceededError | InvalidArnError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError>;
     /**
      * @see {@link GetExecutionHistoryCommand}
      */
-    getExecutionHistory(args: GetExecutionHistoryCommandInput, options?: __HttpHandlerOptions): Effect.Effect<GetExecutionHistoryCommandOutput, SdkError | ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError>;
+    getExecutionHistory(args: GetExecutionHistoryCommandInput, options?: __HttpHandlerOptions): Effect.Effect<GetExecutionHistoryCommandOutput, SdkError | ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError>;
     /**
      * @see {@link ListActivitiesCommand}
      */
@@ -107,11 +103,11 @@ export interface SFNService {
     /**
      * @see {@link RedriveExecutionCommand}
      */
-    redriveExecution(args: RedriveExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<RedriveExecutionCommandOutput, SdkError | ExecutionDoesNotExistError | ExecutionLimitExceededError | ExecutionNotRedrivableError | InvalidArnError>;
+    redriveExecution(args: RedriveExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<RedriveExecutionCommandOutput, SdkError | ExecutionDoesNotExistError | ExecutionLimitExceededError | ExecutionNotRedrivableError | InvalidArnError | ValidationError>;
     /**
      * @see {@link SendTaskFailureCommand}
      */
-    sendTaskFailure(args: SendTaskFailureCommandInput, options?: __HttpHandlerOptions): Effect.Effect<SendTaskFailureCommandOutput, SdkError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError>;
+    sendTaskFailure(args: SendTaskFailureCommandInput, options?: __HttpHandlerOptions): Effect.Effect<SendTaskFailureCommandOutput, SdkError | InvalidTokenError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | TaskDoesNotExistError | TaskTimedOutError>;
     /**
      * @see {@link SendTaskHeartbeatCommand}
      */
@@ -119,19 +115,19 @@ export interface SFNService {
     /**
      * @see {@link SendTaskSuccessCommand}
      */
-    sendTaskSuccess(args: SendTaskSuccessCommandInput, options?: __HttpHandlerOptions): Effect.Effect<SendTaskSuccessCommandOutput, SdkError | InvalidOutputError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError>;
+    sendTaskSuccess(args: SendTaskSuccessCommandInput, options?: __HttpHandlerOptions): Effect.Effect<SendTaskSuccessCommandOutput, SdkError | InvalidOutputError | InvalidTokenError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | TaskDoesNotExistError | TaskTimedOutError>;
     /**
      * @see {@link StartExecutionCommand}
      */
-    startExecution(args: StartExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<StartExecutionCommandOutput, SdkError | ExecutionAlreadyExistsError | ExecutionLimitExceededError | InvalidArnError | InvalidExecutionInputError | InvalidNameError | StateMachineDeletingError | StateMachineDoesNotExistError | ValidationError>;
+    startExecution(args: StartExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<StartExecutionCommandOutput, SdkError | ExecutionAlreadyExistsError | ExecutionLimitExceededError | InvalidArnError | InvalidExecutionInputError | InvalidNameError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | StateMachineDeletingError | StateMachineDoesNotExistError | ValidationError>;
     /**
      * @see {@link StartSyncExecutionCommand}
      */
-    startSyncExecution(args: StartSyncExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<StartSyncExecutionCommandOutput, SdkError | InvalidArnError | InvalidExecutionInputError | InvalidNameError | StateMachineDeletingError | StateMachineDoesNotExistError | StateMachineTypeNotSupportedError>;
+    startSyncExecution(args: StartSyncExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<StartSyncExecutionCommandOutput, SdkError | InvalidArnError | InvalidExecutionInputError | InvalidNameError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | StateMachineDeletingError | StateMachineDoesNotExistError | StateMachineTypeNotSupportedError>;
     /**
      * @see {@link StopExecutionCommand}
      */
-    stopExecution(args: StopExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<StopExecutionCommandOutput, SdkError | ExecutionDoesNotExistError | InvalidArnError | ValidationError>;
+    stopExecution(args: StopExecutionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<StopExecutionCommandOutput, SdkError | ExecutionDoesNotExistError | InvalidArnError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | ValidationError>;
     /**
      * @see {@link TagResourceCommand}
      */
@@ -151,22 +147,69 @@ export interface SFNService {
     /**
      * @see {@link UpdateStateMachineCommand}
      */
-    updateStateMachine(args: UpdateStateMachineCommandInput, options?: __HttpHandlerOptions): Effect.Effect<UpdateStateMachineCommandOutput, SdkError | ConflictError | InvalidArnError | InvalidDefinitionError | InvalidLoggingConfigurationError | InvalidTracingConfigurationError | MissingRequiredParameterError | ServiceQuotaExceededError | StateMachineDeletingError | StateMachineDoesNotExistError | ValidationError>;
+    updateStateMachine(args: UpdateStateMachineCommandInput, options?: __HttpHandlerOptions): Effect.Effect<UpdateStateMachineCommandOutput, SdkError | ConflictError | InvalidArnError | InvalidDefinitionError | InvalidEncryptionConfigurationError | InvalidLoggingConfigurationError | InvalidTracingConfigurationError | KmsAccessDeniedError | KmsThrottlingError | MissingRequiredParameterError | ServiceQuotaExceededError | StateMachineDeletingError | StateMachineDoesNotExistError | ValidationError>;
     /**
      * @see {@link UpdateStateMachineAliasCommand}
      */
     updateStateMachineAlias(args: UpdateStateMachineAliasCommandInput, options?: __HttpHandlerOptions): Effect.Effect<UpdateStateMachineAliasCommandOutput, SdkError | ConflictError | InvalidArnError | ResourceNotFoundError | StateMachineDeletingError | ValidationError>;
+    /**
+     * @see {@link ValidateStateMachineDefinitionCommand}
+     */
+    validateStateMachineDefinition(args: ValidateStateMachineDefinitionCommandInput, options?: __HttpHandlerOptions): Effect.Effect<ValidateStateMachineDefinitionCommandOutput, SdkError | ValidationError>;
 }
+declare const SFNService_base: import("effect/Context").TagClass<SFNService, "@effect-aws/client-sfn/SFNService", SFNService$> & {
+    readonly _: Effect.Effect<SFNService$["_"], never, SFNService>;
+    createActivity: (args: CreateActivityCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<CreateActivityCommandOutput, ActivityAlreadyExistsError | ActivityLimitExceededError | InvalidEncryptionConfigurationError | InvalidNameError | KmsAccessDeniedError | KmsThrottlingError | TooManyTagsError | SdkError, SFNService>;
+    createStateMachine: (args: CreateStateMachineCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<CreateStateMachineCommandOutput, ConflictError | InvalidArnError | InvalidDefinitionError | InvalidEncryptionConfigurationError | InvalidLoggingConfigurationError | InvalidNameError | InvalidTracingConfigurationError | KmsAccessDeniedError | KmsThrottlingError | StateMachineAlreadyExistsError | StateMachineDeletingError | StateMachineLimitExceededError | StateMachineTypeNotSupportedError | TooManyTagsError | ValidationError | SdkError, SFNService>;
+    createStateMachineAlias: (args: CreateStateMachineAliasCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<CreateStateMachineAliasCommandOutput, ConflictError | InvalidArnError | InvalidNameError | ResourceNotFoundError | ServiceQuotaExceededError | StateMachineDeletingError | ValidationError | SdkError, SFNService>;
+    deleteActivity: (args: DeleteActivityCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<DeleteActivityCommandOutput, InvalidArnError | SdkError, SFNService>;
+    deleteStateMachine: (args: DeleteStateMachineCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<DeleteStateMachineCommandOutput, InvalidArnError | ValidationError | SdkError, SFNService>;
+    deleteStateMachineAlias: (args: DeleteStateMachineAliasCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<DeleteStateMachineAliasCommandOutput, ConflictError | InvalidArnError | ResourceNotFoundError | ValidationError | SdkError, SFNService>;
+    deleteStateMachineVersion: (args: DeleteStateMachineVersionCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<DeleteStateMachineVersionCommandOutput, ConflictError | InvalidArnError | ValidationError | SdkError, SFNService>;
+    describeActivity: (args: DescribeActivityCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<DescribeActivityCommandOutput, ActivityDoesNotExistError | InvalidArnError | SdkError, SFNService>;
+    describeExecution: (args: DescribeExecutionCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<DescribeExecutionCommandOutput, ExecutionDoesNotExistError | InvalidArnError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | SdkError, SFNService>;
+    describeMapRun: (args: DescribeMapRunCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<DescribeMapRunCommandOutput, InvalidArnError | ResourceNotFoundError | SdkError, SFNService>;
+    describeStateMachine: (args: DescribeStateMachineCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<DescribeStateMachineCommandOutput, InvalidArnError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | StateMachineDoesNotExistError | SdkError, SFNService>;
+    describeStateMachineAlias: (args: DescribeStateMachineAliasCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<DescribeStateMachineAliasCommandOutput, InvalidArnError | ResourceNotFoundError | ValidationError | SdkError, SFNService>;
+    describeStateMachineForExecution: (args: DescribeStateMachineForExecutionCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<DescribeStateMachineForExecutionCommandOutput, ExecutionDoesNotExistError | InvalidArnError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | SdkError, SFNService>;
+    getActivityTask: (args: GetActivityTaskCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<GetActivityTaskCommandOutput, ActivityDoesNotExistError | ActivityWorkerLimitExceededError | InvalidArnError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | SdkError, SFNService>;
+    getExecutionHistory: (args: GetExecutionHistoryCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<GetExecutionHistoryCommandOutput, ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | SdkError, SFNService>;
+    listActivities: (args: ListActivitiesCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<ListActivitiesCommandOutput, InvalidTokenError | SdkError, SFNService>;
+    listExecutions: (args: ListExecutionsCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<ListExecutionsCommandOutput, InvalidArnError | InvalidTokenError | ResourceNotFoundError | StateMachineDoesNotExistError | StateMachineTypeNotSupportedError | ValidationError | SdkError, SFNService>;
+    listMapRuns: (args: ListMapRunsCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<ListMapRunsCommandOutput, ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError | SdkError, SFNService>;
+    listStateMachineAliases: (args: ListStateMachineAliasesCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<ListStateMachineAliasesCommandOutput, InvalidArnError | InvalidTokenError | ResourceNotFoundError | StateMachineDeletingError | StateMachineDoesNotExistError | SdkError, SFNService>;
+    listStateMachines: (args: ListStateMachinesCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<ListStateMachinesCommandOutput, InvalidTokenError | SdkError, SFNService>;
+    listStateMachineVersions: (args: ListStateMachineVersionsCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<ListStateMachineVersionsCommandOutput, InvalidArnError | InvalidTokenError | ValidationError | SdkError, SFNService>;
+    listTagsForResource: (args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<ListTagsForResourceCommandOutput, InvalidArnError | ResourceNotFoundError | SdkError, SFNService>;
+    publishStateMachineVersion: (args: PublishStateMachineVersionCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<PublishStateMachineVersionCommandOutput, ConflictError | InvalidArnError | ServiceQuotaExceededError | StateMachineDeletingError | StateMachineDoesNotExistError | ValidationError | SdkError, SFNService>;
+    redriveExecution: (args: RedriveExecutionCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<RedriveExecutionCommandOutput, ExecutionDoesNotExistError | ExecutionLimitExceededError | ExecutionNotRedrivableError | InvalidArnError | ValidationError | SdkError, SFNService>;
+    sendTaskFailure: (args: SendTaskFailureCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<SendTaskFailureCommandOutput, InvalidTokenError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | TaskDoesNotExistError | TaskTimedOutError | SdkError, SFNService>;
+    sendTaskHeartbeat: (args: SendTaskHeartbeatCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<SendTaskHeartbeatCommandOutput, InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError | SdkError, SFNService>;
+    sendTaskSuccess: (args: SendTaskSuccessCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<SendTaskSuccessCommandOutput, InvalidOutputError | InvalidTokenError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | TaskDoesNotExistError | TaskTimedOutError | SdkError, SFNService>;
+    startExecution: (args: StartExecutionCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<StartExecutionCommandOutput, ExecutionAlreadyExistsError | ExecutionLimitExceededError | InvalidArnError | InvalidExecutionInputError | InvalidNameError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | StateMachineDeletingError | StateMachineDoesNotExistError | ValidationError | SdkError, SFNService>;
+    startSyncExecution: (args: StartSyncExecutionCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<StartSyncExecutionCommandOutput, InvalidArnError | InvalidExecutionInputError | InvalidNameError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | StateMachineDeletingError | StateMachineDoesNotExistError | StateMachineTypeNotSupportedError | SdkError, SFNService>;
+    stopExecution: (args: StopExecutionCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<StopExecutionCommandOutput, ExecutionDoesNotExistError | InvalidArnError | KmsAccessDeniedError | KmsInvalidStateError | KmsThrottlingError | ValidationError | SdkError, SFNService>;
+    tagResource: (args: TagResourceCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<TagResourceCommandOutput, InvalidArnError | ResourceNotFoundError | TooManyTagsError | SdkError, SFNService>;
+    testState: (args: TestStateCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<TestStateCommandOutput, InvalidArnError | InvalidDefinitionError | InvalidExecutionInputError | ValidationError | SdkError, SFNService>;
+    untagResource: (args: UntagResourceCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<UntagResourceCommandOutput, InvalidArnError | ResourceNotFoundError | SdkError, SFNService>;
+    updateMapRun: (args: UpdateMapRunCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<UpdateMapRunCommandOutput, InvalidArnError | ResourceNotFoundError | ValidationError | SdkError, SFNService>;
+    updateStateMachine: (args: UpdateStateMachineCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<UpdateStateMachineCommandOutput, ConflictError | InvalidArnError | InvalidDefinitionError | InvalidEncryptionConfigurationError | InvalidLoggingConfigurationError | InvalidTracingConfigurationError | KmsAccessDeniedError | KmsThrottlingError | MissingRequiredParameterError | ServiceQuotaExceededError | StateMachineDeletingError | StateMachineDoesNotExistError | ValidationError | SdkError, SFNService>;
+    updateStateMachineAlias: (args: UpdateStateMachineAliasCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<UpdateStateMachineAliasCommandOutput, ConflictError | InvalidArnError | ResourceNotFoundError | StateMachineDeletingError | ValidationError | SdkError, SFNService>;
+    validateStateMachineDefinition: (args: ValidateStateMachineDefinitionCommandInput, options?: __HttpHandlerOptions | undefined) => Effect.Effect<ValidateStateMachineDefinitionCommandOutput, ValidationError | SdkError, SFNService>;
+} & {
+    use: <X>(body: (_: SFNService$) => X) => X extends Effect.Effect<infer A, infer E, infer R> ? Effect.Effect<A, E, R | SFNService> : Effect.Effect<X, never, SFNService>;
+};
 /**
  * @since 1.0.0
- * @category tags
+ * @category models
  */
-export declare const SFNService: Context.Tag<SFNService, SFNService>;
+export declare class SFNService extends SFNService_base {
+}
 /**
  * @since 1.0.0
  * @category constructors
  */
-export declare const makeSFNService: Effect.Effect<SFNService, never, SFNClientInstance>;
+export declare const makeSFNService: Effect.Effect<SFNService$, never, SFNClientInstance>;
 /**
  * @since 1.0.0
  * @category layers
@@ -182,18 +225,4 @@ export declare const SFNServiceLayer: Layer.Layer<SFNService, never, import("./S
  * @category layers
  */
 export declare const DefaultSFNServiceLayer: Layer.Layer<SFNService, never, never>;
-/**
- * @since 0.1.0
- * @deprecated
- */
-export declare const BaseSFNServiceEffect: Effect.Effect<SFNService, never, SFNClientInstance>;
-/**
- * @since 0.1.0
- * @deprecated
- */
-export declare const SFNServiceEffect: Effect.Effect<SFNService, never, import("./SFNClientInstanceConfig").SFNClientInstanceConfig>;
-/**
- * @since 0.1.0
- * @deprecated
- */
-export declare const DefaultSFNServiceEffect: Effect.Effect<SFNService, never, never>;
+export {};

package/lib/SFNService.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultSFNServiceEffect = exports.SFNServiceEffect = exports.BaseSFNServiceEffect = exports.DefaultSFNServiceLayer = exports.SFNServiceLayer = exports.BaseSFNServiceLayer = exports.makeSFNService = exports.SFNService = void 0;
+exports.DefaultSFNServiceLayer = exports.SFNServiceLayer = exports.BaseSFNServiceLayer = exports.makeSFNService = exports.SFNService = void 0;
 /**
  * @since 1.0.0
  */
@@ -46,24 +46,28 @@ const commands = {
     UpdateMapRunCommand: client_sfn_1.UpdateMapRunCommand,
     UpdateStateMachineCommand: client_sfn_1.UpdateStateMachineCommand,
     UpdateStateMachineAliasCommand: client_sfn_1.UpdateStateMachineAliasCommand,
+    ValidateStateMachineDefinitionCommand: client_sfn_1.ValidateStateMachineDefinitionCommand,
 };
 /**
  * @since 1.0.0
- * @category tags
+ * @category models
  */
-exports.SFNService = effect_1.Context.GenericTag("@effect-aws/client-sfn/SFNService");
+class SFNService extends effect_1.Effect.Tag("@effect-aws/client-sfn/SFNService")() {
+}
+exports.SFNService = SFNService;
 /**
  * @since 1.0.0
  * @category constructors
  */
 exports.makeSFNService = effect_1.Effect.gen(function* (_) {
     const client = yield* _(SFNClientInstance_1.SFNClientInstance);
-    return effect_1.ReadonlyRecord.toEntries(commands).reduce((acc, [command]) => {
+    return effect_1.Record.toEntries(commands).reduce((acc, [command]) => {
         const CommandCtor = commands[command];
         const methodImpl = (args, options) => effect_1.Effect.tryPromise({
             try: () => client.send(new CommandCtor(args), options !== null && options !== void 0 ? options : {}),
             catch: (e) => {
-                if (e instanceof client_sfn_1.SFNServiceException) {
+                if (e instanceof client_sfn_1.SFNServiceException &&
+                    Errors_1.AllServiceErrors.includes(e.name)) {
                     const ServiceException = effect_1.Data.tagged(e.name);
                     return ServiceException({
                         ...e,
@@ -90,7 +94,7 @@ exports.makeSFNService = effect_1.Effect.gen(function* (_) {
  * @since 1.0.0
  * @category layers
  */
-exports.BaseSFNServiceLayer = effect_1.Layer.effect(exports.SFNService, exports.makeSFNService);
+exports.BaseSFNServiceLayer = effect_1.Layer.effect(SFNService, exports.makeSFNService);
 /**
  * @since 1.0.0
  * @category layers
@@ -101,20 +105,4 @@ exports.SFNServiceLayer = exports.BaseSFNServiceLayer.pipe(effect_1.Layer.provid
  * @category layers
  */
 exports.DefaultSFNServiceLayer = exports.SFNServiceLayer.pipe(effect_1.Layer.provide(SFNClientInstanceConfig_1.DefaultSFNClientConfigLayer));
-// -------------------- Danger Zone --------------------
-/**
- * @since 0.1.0
- * @deprecated
- */
-exports.BaseSFNServiceEffect = exports.makeSFNService;
-/**
- * @since 0.1.0
- * @deprecated
- */
-exports.SFNServiceEffect = exports.BaseSFNServiceEffect.pipe(effect_1.Effect.provide(SFNClientInstance_1.SFNClientInstanceLayer));
-/**
- * @since 0.1.0
- * @deprecated
- */
-exports.DefaultSFNServiceEffect = exports.BaseSFNServiceEffect.pipe(effect_1.Effect.provide(SFNClientInstance_1.DefaultSFNClientInstanceLayer));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SFNService.js","sourceRoot":"","sources":["../src/SFNService.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @since 1.0.0\n */\nimport {\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 { Context, Data, Effect, Layer, ReadonlyRecord } from \"effect\";\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\";\nimport {\n  DefaultSFNClientInstanceLayer,\n  SFNClientInstance,\n  SFNClientInstanceLayer,\n} from \"./SFNClientInstance\";\nimport { DefaultSFNClientConfigLayer } from \"./SFNClientInstanceConfig\";\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\n/**\n * @since 1.0.0\n * @category models\n */\nexport interface SFNService {\n  readonly _: unique symbol;\n\n  /**\n   * @see {@link CreateActivityCommand}\n   */\n  createActivity(\n    args: CreateActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    CreateActivityCommandOutput,\n    SdkError | ActivityLimitExceededError | InvalidNameError | TooManyTagsError\n  >;\n  /**\n   * @see {@link CreateStateMachineCommand}\n   */\n  createStateMachine(\n    args: CreateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    CreateStateMachineCommandOutput,\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  >;\n  /**\n   * @see {@link CreateStateMachineAliasCommand}\n   */\n  createStateMachineAlias(\n    args: CreateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    CreateStateMachineAliasCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidNameError\n    | ResourceNotFoundError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | ValidationError\n  >;\n  /**\n   * @see {@link DeleteActivityCommand}\n   */\n  deleteActivity(\n    args: DeleteActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<DeleteActivityCommandOutput, SdkError | InvalidArnError>;\n  /**\n   * @see {@link DeleteStateMachineCommand}\n   */\n  deleteStateMachine(\n    args: DeleteStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DeleteStateMachineCommandOutput,\n    SdkError | InvalidArnError | ValidationError\n  >;\n  /**\n   * @see {@link DeleteStateMachineAliasCommand}\n   */\n  deleteStateMachineAlias(\n    args: DeleteStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DeleteStateMachineAliasCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ResourceNotFoundError\n    | ValidationError\n  >;\n  /**\n   * @see {@link DeleteStateMachineVersionCommand}\n   */\n  deleteStateMachineVersion(\n    args: DeleteStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DeleteStateMachineVersionCommandOutput,\n    SdkError | ConflictError | InvalidArnError | ValidationError\n  >;\n  /**\n   * @see {@link DescribeActivityCommand}\n   */\n  describeActivity(\n    args: DescribeActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeActivityCommandOutput,\n    SdkError | ActivityDoesNotExistError | InvalidArnError\n  >;\n  /**\n   * @see {@link DescribeExecutionCommand}\n   */\n  describeExecution(\n    args: DescribeExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeExecutionCommandOutput,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError\n  >;\n  /**\n   * @see {@link DescribeMapRunCommand}\n   */\n  describeMapRun(\n    args: DescribeMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeMapRunCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError\n  >;\n  /**\n   * @see {@link DescribeStateMachineCommand}\n   */\n  describeStateMachine(\n    args: DescribeStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeStateMachineCommandOutput,\n    SdkError | InvalidArnError | StateMachineDoesNotExistError\n  >;\n  /**\n   * @see {@link DescribeStateMachineAliasCommand}\n   */\n  describeStateMachineAlias(\n    args: DescribeStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeStateMachineAliasCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError | ValidationError\n  >;\n  /**\n   * @see {@link DescribeStateMachineForExecutionCommand}\n   */\n  describeStateMachineForExecution(\n    args: DescribeStateMachineForExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeStateMachineForExecutionCommandOutput,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError\n  >;\n  /**\n   * @see {@link GetActivityTaskCommand}\n   */\n  getActivityTask(\n    args: GetActivityTaskCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    GetActivityTaskCommandOutput,\n    | SdkError\n    | ActivityDoesNotExistError\n    | ActivityWorkerLimitExceededError\n    | InvalidArnError\n  >;\n  /**\n   * @see {@link GetExecutionHistoryCommand}\n   */\n  getExecutionHistory(\n    args: GetExecutionHistoryCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    GetExecutionHistoryCommandOutput,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError\n  >;\n  /**\n   * @see {@link ListActivitiesCommand}\n   */\n  listActivities(\n    args: ListActivitiesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<ListActivitiesCommandOutput, SdkError | InvalidTokenError>;\n  /**\n   * @see {@link ListExecutionsCommand}\n   */\n  listExecutions(\n    args: ListExecutionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListExecutionsCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidTokenError\n    | ResourceNotFoundError\n    | StateMachineDoesNotExistError\n    | StateMachineTypeNotSupportedError\n    | ValidationError\n  >;\n  /**\n   * @see {@link ListMapRunsCommand}\n   */\n  listMapRuns(\n    args: ListMapRunsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListMapRunsCommandOutput,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError\n  >;\n  /**\n   * @see {@link ListStateMachineAliasesCommand}\n   */\n  listStateMachineAliases(\n    args: ListStateMachineAliasesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListStateMachineAliasesCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidTokenError\n    | ResourceNotFoundError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n  >;\n  /**\n   * @see {@link ListStateMachinesCommand}\n   */\n  listStateMachines(\n    args: ListStateMachinesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListStateMachinesCommandOutput,\n    SdkError | InvalidTokenError\n  >;\n  /**\n   * @see {@link ListStateMachineVersionsCommand}\n   */\n  listStateMachineVersions(\n    args: ListStateMachineVersionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListStateMachineVersionsCommandOutput,\n    SdkError | InvalidArnError | InvalidTokenError | ValidationError\n  >;\n  /**\n   * @see {@link ListTagsForResourceCommand}\n   */\n  listTagsForResource(\n    args: ListTagsForResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListTagsForResourceCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError\n  >;\n  /**\n   * @see {@link PublishStateMachineVersionCommand}\n   */\n  publishStateMachineVersion(\n    args: PublishStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    PublishStateMachineVersionCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError\n  >;\n  /**\n   * @see {@link RedriveExecutionCommand}\n   */\n  redriveExecution(\n    args: RedriveExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    RedriveExecutionCommandOutput,\n    | SdkError\n    | ExecutionDoesNotExistError\n    | ExecutionLimitExceededError\n    | ExecutionNotRedrivableError\n    | InvalidArnError\n  >;\n  /**\n   * @see {@link SendTaskFailureCommand}\n   */\n  sendTaskFailure(\n    args: SendTaskFailureCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    SendTaskFailureCommandOutput,\n    SdkError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError\n  >;\n  /**\n   * @see {@link SendTaskHeartbeatCommand}\n   */\n  sendTaskHeartbeat(\n    args: SendTaskHeartbeatCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    SendTaskHeartbeatCommandOutput,\n    SdkError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError\n  >;\n  /**\n   * @see {@link SendTaskSuccessCommand}\n   */\n  sendTaskSuccess(\n    args: SendTaskSuccessCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    SendTaskSuccessCommandOutput,\n    | SdkError\n    | InvalidOutputError\n    | InvalidTokenError\n    | TaskDoesNotExistError\n    | TaskTimedOutError\n  >;\n  /**\n   * @see {@link StartExecutionCommand}\n   */\n  startExecution(\n    args: StartExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    StartExecutionCommandOutput,\n    | SdkError\n    | ExecutionAlreadyExistsError\n    | ExecutionLimitExceededError\n    | InvalidArnError\n    | InvalidExecutionInputError\n    | InvalidNameError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError\n  >;\n  /**\n   * @see {@link StartSyncExecutionCommand}\n   */\n  startSyncExecution(\n    args: StartSyncExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    StartSyncExecutionCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidExecutionInputError\n    | InvalidNameError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | StateMachineTypeNotSupportedError\n  >;\n  /**\n   * @see {@link StopExecutionCommand}\n   */\n  stopExecution(\n    args: StopExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    StopExecutionCommandOutput,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError | ValidationError\n  >;\n  /**\n   * @see {@link TagResourceCommand}\n   */\n  tagResource(\n    args: TagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    TagResourceCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError | TooManyTagsError\n  >;\n  /**\n   * @see {@link TestStateCommand}\n   */\n  testState(\n    args: TestStateCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    TestStateCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidExecutionInputError\n    | ValidationError\n  >;\n  /**\n   * @see {@link UntagResourceCommand}\n   */\n  untagResource(\n    args: UntagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UntagResourceCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError\n  >;\n  /**\n   * @see {@link UpdateMapRunCommand}\n   */\n  updateMapRun(\n    args: UpdateMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UpdateMapRunCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError | ValidationError\n  >;\n  /**\n   * @see {@link UpdateStateMachineCommand}\n   */\n  updateStateMachine(\n    args: UpdateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UpdateStateMachineCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidLoggingConfigurationError\n    | InvalidTracingConfigurationError\n    | MissingRequiredParameterError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError\n  >;\n  /**\n   * @see {@link UpdateStateMachineAliasCommand}\n   */\n  updateStateMachineAlias(\n    args: UpdateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UpdateStateMachineAliasCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ResourceNotFoundError\n    | StateMachineDeletingError\n    | ValidationError\n  >;\n}\n\n/**\n * @since 1.0.0\n * @category tags\n */\nexport const SFNService = Context.GenericTag<SFNService>(\n  \"@effect-aws/client-sfn/SFNService\",\n);\n\n/**\n * @since 1.0.0\n * @category constructors\n */\nexport const makeSFNService = Effect.gen(function* (_) {\n  const client = yield* _(SFNClientInstance);\n\n  return ReadonlyRecord.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\n/**\n * @since 1.0.0\n * @category layers\n */\nexport const BaseSFNServiceLayer = Layer.effect(SFNService, makeSFNService);\n\n/**\n * @since 1.0.0\n * @category layers\n */\nexport const SFNServiceLayer = BaseSFNServiceLayer.pipe(\n  Layer.provide(SFNClientInstanceLayer),\n);\n\n/**\n * @since 1.0.0\n * @category layers\n */\nexport const DefaultSFNServiceLayer = SFNServiceLayer.pipe(\n  Layer.provide(DefaultSFNClientConfigLayer),\n);\n\n// -------------------- Danger Zone --------------------\n\n/**\n * @since 0.1.0\n * @deprecated\n */\nexport const BaseSFNServiceEffect = makeSFNService;\n\n/**\n * @since 0.1.0\n * @deprecated\n */\nexport const SFNServiceEffect = BaseSFNServiceEffect.pipe(\n  Effect.provide(SFNClientInstanceLayer),\n);\n\n/**\n * @since 0.1.0\n * @deprecated\n */\nexport const DefaultSFNServiceEffect = BaseSFNServiceEffect.pipe(\n  Effect.provide(DefaultSFNClientInstanceLayer),\n);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SFNService.js","sourceRoot":"","sources":["../src/SFNService.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @since 1.0.0\n */\nimport {\n  SFNServiceException,\n  CreateActivityCommand,\n  type CreateActivityCommandInput,\n  type CreateActivityCommandOutput,\n  CreateStateMachineCommand,\n  type CreateStateMachineCommandInput,\n  type CreateStateMachineCommandOutput,\n  CreateStateMachineAliasCommand,\n  type CreateStateMachineAliasCommandInput,\n  type CreateStateMachineAliasCommandOutput,\n  DeleteActivityCommand,\n  type DeleteActivityCommandInput,\n  type DeleteActivityCommandOutput,\n  DeleteStateMachineCommand,\n  type DeleteStateMachineCommandInput,\n  type DeleteStateMachineCommandOutput,\n  DeleteStateMachineAliasCommand,\n  type DeleteStateMachineAliasCommandInput,\n  type DeleteStateMachineAliasCommandOutput,\n  DeleteStateMachineVersionCommand,\n  type DeleteStateMachineVersionCommandInput,\n  type DeleteStateMachineVersionCommandOutput,\n  DescribeActivityCommand,\n  type DescribeActivityCommandInput,\n  type DescribeActivityCommandOutput,\n  DescribeExecutionCommand,\n  type DescribeExecutionCommandInput,\n  type DescribeExecutionCommandOutput,\n  DescribeMapRunCommand,\n  type DescribeMapRunCommandInput,\n  type DescribeMapRunCommandOutput,\n  DescribeStateMachineCommand,\n  type DescribeStateMachineCommandInput,\n  type DescribeStateMachineCommandOutput,\n  DescribeStateMachineAliasCommand,\n  type DescribeStateMachineAliasCommandInput,\n  type DescribeStateMachineAliasCommandOutput,\n  DescribeStateMachineForExecutionCommand,\n  type DescribeStateMachineForExecutionCommandInput,\n  type DescribeStateMachineForExecutionCommandOutput,\n  GetActivityTaskCommand,\n  type GetActivityTaskCommandInput,\n  type GetActivityTaskCommandOutput,\n  GetExecutionHistoryCommand,\n  type GetExecutionHistoryCommandInput,\n  type GetExecutionHistoryCommandOutput,\n  ListActivitiesCommand,\n  type ListActivitiesCommandInput,\n  type ListActivitiesCommandOutput,\n  ListExecutionsCommand,\n  type ListExecutionsCommandInput,\n  type ListExecutionsCommandOutput,\n  ListMapRunsCommand,\n  type ListMapRunsCommandInput,\n  type ListMapRunsCommandOutput,\n  ListStateMachineAliasesCommand,\n  type ListStateMachineAliasesCommandInput,\n  type ListStateMachineAliasesCommandOutput,\n  ListStateMachinesCommand,\n  type ListStateMachinesCommandInput,\n  type ListStateMachinesCommandOutput,\n  ListStateMachineVersionsCommand,\n  type ListStateMachineVersionsCommandInput,\n  type ListStateMachineVersionsCommandOutput,\n  ListTagsForResourceCommand,\n  type ListTagsForResourceCommandInput,\n  type ListTagsForResourceCommandOutput,\n  PublishStateMachineVersionCommand,\n  type PublishStateMachineVersionCommandInput,\n  type PublishStateMachineVersionCommandOutput,\n  RedriveExecutionCommand,\n  type RedriveExecutionCommandInput,\n  type RedriveExecutionCommandOutput,\n  SendTaskFailureCommand,\n  type SendTaskFailureCommandInput,\n  type SendTaskFailureCommandOutput,\n  SendTaskHeartbeatCommand,\n  type SendTaskHeartbeatCommandInput,\n  type SendTaskHeartbeatCommandOutput,\n  SendTaskSuccessCommand,\n  type SendTaskSuccessCommandInput,\n  type SendTaskSuccessCommandOutput,\n  StartExecutionCommand,\n  type StartExecutionCommandInput,\n  type StartExecutionCommandOutput,\n  StartSyncExecutionCommand,\n  type StartSyncExecutionCommandInput,\n  type StartSyncExecutionCommandOutput,\n  StopExecutionCommand,\n  type StopExecutionCommandInput,\n  type StopExecutionCommandOutput,\n  TagResourceCommand,\n  type TagResourceCommandInput,\n  type TagResourceCommandOutput,\n  TestStateCommand,\n  type TestStateCommandInput,\n  type TestStateCommandOutput,\n  UntagResourceCommand,\n  type UntagResourceCommandInput,\n  type UntagResourceCommandOutput,\n  UpdateMapRunCommand,\n  type UpdateMapRunCommandInput,\n  type UpdateMapRunCommandOutput,\n  UpdateStateMachineCommand,\n  type UpdateStateMachineCommandInput,\n  type UpdateStateMachineCommandOutput,\n  UpdateStateMachineAliasCommand,\n  type UpdateStateMachineAliasCommandInput,\n  type UpdateStateMachineAliasCommandOutput,\n  ValidateStateMachineDefinitionCommand,\n  type ValidateStateMachineDefinitionCommandInput,\n  type ValidateStateMachineDefinitionCommandOutput,\n} from \"@aws-sdk/client-sfn\";\nimport { type HttpHandlerOptions as __HttpHandlerOptions } from \"@aws-sdk/types\";\nimport { Data, Effect, Layer, Record } from \"effect\";\nimport {\n  AllServiceErrors,\n  ActivityAlreadyExistsError,\n  ActivityDoesNotExistError,\n  ActivityLimitExceededError,\n  ActivityWorkerLimitExceededError,\n  ConflictError,\n  ExecutionAlreadyExistsError,\n  ExecutionDoesNotExistError,\n  ExecutionLimitExceededError,\n  ExecutionNotRedrivableError,\n  InvalidArnError,\n  InvalidDefinitionError,\n  InvalidEncryptionConfigurationError,\n  InvalidExecutionInputError,\n  InvalidLoggingConfigurationError,\n  InvalidNameError,\n  InvalidOutputError,\n  InvalidTokenError,\n  InvalidTracingConfigurationError,\n  KmsAccessDeniedError,\n  KmsInvalidStateError,\n  KmsThrottlingError,\n  MissingRequiredParameterError,\n  ResourceNotFoundError,\n  ServiceQuotaExceededError,\n  StateMachineAlreadyExistsError,\n  StateMachineDeletingError,\n  StateMachineDoesNotExistError,\n  StateMachineLimitExceededError,\n  StateMachineTypeNotSupportedError,\n  TaskDoesNotExistError,\n  TaskTimedOutError,\n  TooManyTagsError,\n  ValidationError,\n  SdkError,\n  TaggedException,\n} from \"./Errors\";\nimport { SFNClientInstance, SFNClientInstanceLayer } from \"./SFNClientInstance\";\nimport { DefaultSFNClientConfigLayer } from \"./SFNClientInstanceConfig\";\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  ValidateStateMachineDefinitionCommand,\n};\n\ninterface SFNService$ {\n  readonly _: unique symbol;\n\n  /**\n   * @see {@link CreateActivityCommand}\n   */\n  createActivity(\n    args: CreateActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    CreateActivityCommandOutput,\n    | SdkError\n    | ActivityAlreadyExistsError\n    | ActivityLimitExceededError\n    | InvalidEncryptionConfigurationError\n    | InvalidNameError\n    | KmsAccessDeniedError\n    | KmsThrottlingError\n    | TooManyTagsError\n  >;\n\n  /**\n   * @see {@link CreateStateMachineCommand}\n   */\n  createStateMachine(\n    args: CreateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    CreateStateMachineCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidEncryptionConfigurationError\n    | InvalidLoggingConfigurationError\n    | InvalidNameError\n    | InvalidTracingConfigurationError\n    | KmsAccessDeniedError\n    | KmsThrottlingError\n    | StateMachineAlreadyExistsError\n    | StateMachineDeletingError\n    | StateMachineLimitExceededError\n    | StateMachineTypeNotSupportedError\n    | TooManyTagsError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link CreateStateMachineAliasCommand}\n   */\n  createStateMachineAlias(\n    args: CreateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    CreateStateMachineAliasCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidNameError\n    | ResourceNotFoundError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link DeleteActivityCommand}\n   */\n  deleteActivity(\n    args: DeleteActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<DeleteActivityCommandOutput, SdkError | InvalidArnError>;\n\n  /**\n   * @see {@link DeleteStateMachineCommand}\n   */\n  deleteStateMachine(\n    args: DeleteStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DeleteStateMachineCommandOutput,\n    SdkError | InvalidArnError | ValidationError\n  >;\n\n  /**\n   * @see {@link DeleteStateMachineAliasCommand}\n   */\n  deleteStateMachineAlias(\n    args: DeleteStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DeleteStateMachineAliasCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ResourceNotFoundError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link DeleteStateMachineVersionCommand}\n   */\n  deleteStateMachineVersion(\n    args: DeleteStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DeleteStateMachineVersionCommandOutput,\n    SdkError | ConflictError | InvalidArnError | ValidationError\n  >;\n\n  /**\n   * @see {@link DescribeActivityCommand}\n   */\n  describeActivity(\n    args: DescribeActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeActivityCommandOutput,\n    SdkError | ActivityDoesNotExistError | InvalidArnError\n  >;\n\n  /**\n   * @see {@link DescribeExecutionCommand}\n   */\n  describeExecution(\n    args: DescribeExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeExecutionCommandOutput,\n    | SdkError\n    | ExecutionDoesNotExistError\n    | InvalidArnError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n  >;\n\n  /**\n   * @see {@link DescribeMapRunCommand}\n   */\n  describeMapRun(\n    args: DescribeMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeMapRunCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError\n  >;\n\n  /**\n   * @see {@link DescribeStateMachineCommand}\n   */\n  describeStateMachine(\n    args: DescribeStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeStateMachineCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n    | StateMachineDoesNotExistError\n  >;\n\n  /**\n   * @see {@link DescribeStateMachineAliasCommand}\n   */\n  describeStateMachineAlias(\n    args: DescribeStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeStateMachineAliasCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError | ValidationError\n  >;\n\n  /**\n   * @see {@link DescribeStateMachineForExecutionCommand}\n   */\n  describeStateMachineForExecution(\n    args: DescribeStateMachineForExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeStateMachineForExecutionCommandOutput,\n    | SdkError\n    | ExecutionDoesNotExistError\n    | InvalidArnError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n  >;\n\n  /**\n   * @see {@link GetActivityTaskCommand}\n   */\n  getActivityTask(\n    args: GetActivityTaskCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    GetActivityTaskCommandOutput,\n    | SdkError\n    | ActivityDoesNotExistError\n    | ActivityWorkerLimitExceededError\n    | InvalidArnError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n  >;\n\n  /**\n   * @see {@link GetExecutionHistoryCommand}\n   */\n  getExecutionHistory(\n    args: GetExecutionHistoryCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    GetExecutionHistoryCommandOutput,\n    | SdkError\n    | ExecutionDoesNotExistError\n    | InvalidArnError\n    | InvalidTokenError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n  >;\n\n  /**\n   * @see {@link ListActivitiesCommand}\n   */\n  listActivities(\n    args: ListActivitiesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<ListActivitiesCommandOutput, SdkError | InvalidTokenError>;\n\n  /**\n   * @see {@link ListExecutionsCommand}\n   */\n  listExecutions(\n    args: ListExecutionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListExecutionsCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidTokenError\n    | ResourceNotFoundError\n    | StateMachineDoesNotExistError\n    | StateMachineTypeNotSupportedError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link ListMapRunsCommand}\n   */\n  listMapRuns(\n    args: ListMapRunsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListMapRunsCommandOutput,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError\n  >;\n\n  /**\n   * @see {@link ListStateMachineAliasesCommand}\n   */\n  listStateMachineAliases(\n    args: ListStateMachineAliasesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListStateMachineAliasesCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidTokenError\n    | ResourceNotFoundError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n  >;\n\n  /**\n   * @see {@link ListStateMachinesCommand}\n   */\n  listStateMachines(\n    args: ListStateMachinesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListStateMachinesCommandOutput,\n    SdkError | InvalidTokenError\n  >;\n\n  /**\n   * @see {@link ListStateMachineVersionsCommand}\n   */\n  listStateMachineVersions(\n    args: ListStateMachineVersionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListStateMachineVersionsCommandOutput,\n    SdkError | InvalidArnError | InvalidTokenError | ValidationError\n  >;\n\n  /**\n   * @see {@link ListTagsForResourceCommand}\n   */\n  listTagsForResource(\n    args: ListTagsForResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListTagsForResourceCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError\n  >;\n\n  /**\n   * @see {@link PublishStateMachineVersionCommand}\n   */\n  publishStateMachineVersion(\n    args: PublishStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    PublishStateMachineVersionCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link RedriveExecutionCommand}\n   */\n  redriveExecution(\n    args: RedriveExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    RedriveExecutionCommandOutput,\n    | SdkError\n    | ExecutionDoesNotExistError\n    | ExecutionLimitExceededError\n    | ExecutionNotRedrivableError\n    | InvalidArnError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link SendTaskFailureCommand}\n   */\n  sendTaskFailure(\n    args: SendTaskFailureCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    SendTaskFailureCommandOutput,\n    | SdkError\n    | InvalidTokenError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n    | TaskDoesNotExistError\n    | TaskTimedOutError\n  >;\n\n  /**\n   * @see {@link SendTaskHeartbeatCommand}\n   */\n  sendTaskHeartbeat(\n    args: SendTaskHeartbeatCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    SendTaskHeartbeatCommandOutput,\n    SdkError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError\n  >;\n\n  /**\n   * @see {@link SendTaskSuccessCommand}\n   */\n  sendTaskSuccess(\n    args: SendTaskSuccessCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    SendTaskSuccessCommandOutput,\n    | SdkError\n    | InvalidOutputError\n    | InvalidTokenError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n    | TaskDoesNotExistError\n    | TaskTimedOutError\n  >;\n\n  /**\n   * @see {@link StartExecutionCommand}\n   */\n  startExecution(\n    args: StartExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    StartExecutionCommandOutput,\n    | SdkError\n    | ExecutionAlreadyExistsError\n    | ExecutionLimitExceededError\n    | InvalidArnError\n    | InvalidExecutionInputError\n    | InvalidNameError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link StartSyncExecutionCommand}\n   */\n  startSyncExecution(\n    args: StartSyncExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    StartSyncExecutionCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidExecutionInputError\n    | InvalidNameError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | StateMachineTypeNotSupportedError\n  >;\n\n  /**\n   * @see {@link StopExecutionCommand}\n   */\n  stopExecution(\n    args: StopExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    StopExecutionCommandOutput,\n    | SdkError\n    | ExecutionDoesNotExistError\n    | InvalidArnError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link TagResourceCommand}\n   */\n  tagResource(\n    args: TagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    TagResourceCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError | TooManyTagsError\n  >;\n\n  /**\n   * @see {@link TestStateCommand}\n   */\n  testState(\n    args: TestStateCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    TestStateCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidExecutionInputError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link UntagResourceCommand}\n   */\n  untagResource(\n    args: UntagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UntagResourceCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError\n  >;\n\n  /**\n   * @see {@link UpdateMapRunCommand}\n   */\n  updateMapRun(\n    args: UpdateMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UpdateMapRunCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError | ValidationError\n  >;\n\n  /**\n   * @see {@link UpdateStateMachineCommand}\n   */\n  updateStateMachine(\n    args: UpdateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UpdateStateMachineCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidEncryptionConfigurationError\n    | InvalidLoggingConfigurationError\n    | InvalidTracingConfigurationError\n    | KmsAccessDeniedError\n    | KmsThrottlingError\n    | MissingRequiredParameterError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link UpdateStateMachineAliasCommand}\n   */\n  updateStateMachineAlias(\n    args: UpdateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UpdateStateMachineAliasCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ResourceNotFoundError\n    | StateMachineDeletingError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link ValidateStateMachineDefinitionCommand}\n   */\n  validateStateMachineDefinition(\n    args: ValidateStateMachineDefinitionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ValidateStateMachineDefinitionCommandOutput,\n    SdkError | ValidationError\n  >;\n}\n\n/**\n * @since 1.0.0\n * @category models\n */\nexport class SFNService extends Effect.Tag(\"@effect-aws/client-sfn/SFNService\")<\n  SFNService,\n  SFNService$\n>() {}\n\n/**\n * @since 1.0.0\n * @category constructors\n */\nexport const makeSFNService = Effect.gen(function* (_) {\n  const client = yield* _(SFNClientInstance);\n\n  return Record.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 (\n            e instanceof SFNServiceException &&\n            AllServiceErrors.includes(e.name)\n          ) {\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\n/**\n * @since 1.0.0\n * @category layers\n */\nexport const BaseSFNServiceLayer = Layer.effect(SFNService, makeSFNService);\n\n/**\n * @since 1.0.0\n * @category layers\n */\nexport const SFNServiceLayer = BaseSFNServiceLayer.pipe(\n  Layer.provide(SFNClientInstanceLayer),\n);\n\n/**\n * @since 1.0.0\n * @category layers\n */\nexport const DefaultSFNServiceLayer = SFNServiceLayer.pipe(\n  Layer.provide(DefaultSFNClientConfigLayer),\n);\n"]}

package/lib/esm/Errors.js CHANGED Viewed

@@ -1,3 +1,38 @@
-import * as Data from "effect/Data";
+import { Data } from "effect";
+export const AllServiceErrors = [
+    "ActivityAlreadyExists",
+    "ActivityDoesNotExist",
+    "ActivityLimitExceeded",
+    "ActivityWorkerLimitExceeded",
+    "ConflictException",
+    "ExecutionAlreadyExists",
+    "ExecutionDoesNotExist",
+    "ExecutionLimitExceeded",
+    "ExecutionNotRedrivable",
+    "InvalidArn",
+    "InvalidDefinition",
+    "InvalidEncryptionConfiguration",
+    "InvalidExecutionInput",
+    "InvalidLoggingConfiguration",
+    "InvalidName",
+    "InvalidOutput",
+    "InvalidToken",
+    "InvalidTracingConfiguration",
+    "KmsAccessDeniedException",
+    "KmsInvalidStateException",
+    "KmsThrottlingException",
+    "MissingRequiredParameter",
+    "ResourceNotFound",
+    "ServiceQuotaExceededException",
+    "StateMachineAlreadyExists",
+    "StateMachineDeleting",
+    "StateMachineDoesNotExist",
+    "StateMachineLimitExceeded",
+    "StateMachineTypeNotSupported",
+    "TaskDoesNotExist",
+    "TaskTimedOut",
+    "TooManyTags",
+    "ValidationException",
+];
 export const SdkError = Data.tagged("SdkError");
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/SFNClientInstanceConfig.js CHANGED Viewed

@@ -1,7 +1,4 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Runtime from "effect/Runtime";
+import { Context, Effect, Layer, Runtime } from "effect";
 /**
  * @since 1.0.0
  * @category tags
@@ -17,11 +14,21 @@ export const makeDefaultSFNClientInstanceConfig = Effect.gen(function* (_) {
     const runSync = Runtime.runSync(runtime);
     return {
         logger: {
-            info: (m) => Effect.logInfo(m).pipe(runSync),
-            warn: (m) => Effect.logWarning(m).pipe(runSync),
-            error: (m) => Effect.logError(m).pipe(runSync),
-            debug: (m) => Effect.logDebug(m).pipe(runSync),
-            trace: (m) => Effect.logTrace(m).pipe(runSync),
+            info(m) {
+                Effect.logInfo(m).pipe(runSync);
+            },
+            warn(m) {
+                Effect.logWarning(m).pipe(runSync);
+            },
+            error(m) {
+                Effect.logError(m).pipe(runSync);
+            },
+            debug(m) {
+                Effect.logDebug(m).pipe(runSync);
+            },
+            trace(m) {
+                Effect.logTrace(m).pipe(runSync);
+            },
         },
     };
 });
@@ -30,4 +37,4 @@ export const makeDefaultSFNClientInstanceConfig = Effect.gen(function* (_) {
  * @category layers
  */
 export const DefaultSFNClientConfigLayer = Layer.effect(SFNClientInstanceConfig, makeDefaultSFNClientInstanceConfig);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/SFNService.js CHANGED Viewed

@@ -1,10 +1,10 @@
 /**
  * @since 1.0.0
  */
-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 { Context, Data, Effect, Layer, ReadonlyRecord } from "effect";
-import { SdkError, } from "./Errors";
-import { DefaultSFNClientInstanceLayer, SFNClientInstance, SFNClientInstanceLayer, } from "./SFNClientInstance";
+import { SFNServiceException, CreateActivityCommand, CreateStateMachineCommand, CreateStateMachineAliasCommand, DeleteActivityCommand, DeleteStateMachineCommand, DeleteStateMachineAliasCommand, DeleteStateMachineVersionCommand, DescribeActivityCommand, DescribeExecutionCommand, DescribeMapRunCommand, DescribeStateMachineCommand, DescribeStateMachineAliasCommand, DescribeStateMachineForExecutionCommand, GetActivityTaskCommand, GetExecutionHistoryCommand, ListActivitiesCommand, ListExecutionsCommand, ListMapRunsCommand, ListStateMachineAliasesCommand, ListStateMachinesCommand, ListStateMachineVersionsCommand, ListTagsForResourceCommand, PublishStateMachineVersionCommand, RedriveExecutionCommand, SendTaskFailureCommand, SendTaskHeartbeatCommand, SendTaskSuccessCommand, StartExecutionCommand, StartSyncExecutionCommand, StopExecutionCommand, TagResourceCommand, TestStateCommand, UntagResourceCommand, UpdateMapRunCommand, UpdateStateMachineCommand, UpdateStateMachineAliasCommand, ValidateStateMachineDefinitionCommand, } from "@aws-sdk/client-sfn";
+import { Data, Effect, Layer, Record } from "effect";
+import { AllServiceErrors, SdkError, } from "./Errors";
+import { SFNClientInstance, SFNClientInstanceLayer } from "./SFNClientInstance";
 import { DefaultSFNClientConfigLayer } from "./SFNClientInstanceConfig";
 const commands = {
     CreateActivityCommand,
@@ -43,24 +43,27 @@ const commands = {
     UpdateMapRunCommand,
     UpdateStateMachineCommand,
     UpdateStateMachineAliasCommand,
+    ValidateStateMachineDefinitionCommand,
 };
 /**
  * @since 1.0.0
- * @category tags
+ * @category models
  */
-export const SFNService = Context.GenericTag("@effect-aws/client-sfn/SFNService");
+export class SFNService extends Effect.Tag("@effect-aws/client-sfn/SFNService")() {
+}
 /**
  * @since 1.0.0
  * @category constructors
  */
 export const makeSFNService = Effect.gen(function* (_) {
     const client = yield* _(SFNClientInstance);
-    return ReadonlyRecord.toEntries(commands).reduce((acc, [command]) => {
+    return Record.toEntries(commands).reduce((acc, [command]) => {
         const CommandCtor = commands[command];
         const methodImpl = (args, options) => Effect.tryPromise({
             try: () => client.send(new CommandCtor(args), options !== null && options !== void 0 ? options : {}),
             catch: (e) => {
-                if (e instanceof SFNServiceException) {
+                if (e instanceof SFNServiceException &&
+                    AllServiceErrors.includes(e.name)) {
                     const ServiceException = Data.tagged(e.name);
                     return ServiceException({
                         ...e,
@@ -98,20 +101,4 @@ export const SFNServiceLayer = BaseSFNServiceLayer.pipe(Layer.provide(SFNClientI
  * @category layers
  */
 export const DefaultSFNServiceLayer = SFNServiceLayer.pipe(Layer.provide(DefaultSFNClientConfigLayer));
-// -------------------- Danger Zone --------------------
-/**
- * @since 0.1.0
- * @deprecated
- */
-export const BaseSFNServiceEffect = makeSFNService;
-/**
- * @since 0.1.0
- * @deprecated
- */
-export const SFNServiceEffect = BaseSFNServiceEffect.pipe(Effect.provide(SFNClientInstanceLayer));
-/**
- * @since 0.1.0
- * @deprecated
- */
-export const DefaultSFNServiceEffect = BaseSFNServiceEffect.pipe(Effect.provide(DefaultSFNClientInstanceLayer));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SFNService.js","sourceRoot":"","sources":["../../src/SFNService.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @since 1.0.0\n */\nimport {\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 { Context, Data, Effect, Layer, ReadonlyRecord } from \"effect\";\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\";\nimport {\n  DefaultSFNClientInstanceLayer,\n  SFNClientInstance,\n  SFNClientInstanceLayer,\n} from \"./SFNClientInstance\";\nimport { DefaultSFNClientConfigLayer } from \"./SFNClientInstanceConfig\";\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\n/**\n * @since 1.0.0\n * @category models\n */\nexport interface SFNService {\n  readonly _: unique symbol;\n\n  /**\n   * @see {@link CreateActivityCommand}\n   */\n  createActivity(\n    args: CreateActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    CreateActivityCommandOutput,\n    SdkError | ActivityLimitExceededError | InvalidNameError | TooManyTagsError\n  >;\n  /**\n   * @see {@link CreateStateMachineCommand}\n   */\n  createStateMachine(\n    args: CreateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    CreateStateMachineCommandOutput,\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  >;\n  /**\n   * @see {@link CreateStateMachineAliasCommand}\n   */\n  createStateMachineAlias(\n    args: CreateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    CreateStateMachineAliasCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidNameError\n    | ResourceNotFoundError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | ValidationError\n  >;\n  /**\n   * @see {@link DeleteActivityCommand}\n   */\n  deleteActivity(\n    args: DeleteActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<DeleteActivityCommandOutput, SdkError | InvalidArnError>;\n  /**\n   * @see {@link DeleteStateMachineCommand}\n   */\n  deleteStateMachine(\n    args: DeleteStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DeleteStateMachineCommandOutput,\n    SdkError | InvalidArnError | ValidationError\n  >;\n  /**\n   * @see {@link DeleteStateMachineAliasCommand}\n   */\n  deleteStateMachineAlias(\n    args: DeleteStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DeleteStateMachineAliasCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ResourceNotFoundError\n    | ValidationError\n  >;\n  /**\n   * @see {@link DeleteStateMachineVersionCommand}\n   */\n  deleteStateMachineVersion(\n    args: DeleteStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DeleteStateMachineVersionCommandOutput,\n    SdkError | ConflictError | InvalidArnError | ValidationError\n  >;\n  /**\n   * @see {@link DescribeActivityCommand}\n   */\n  describeActivity(\n    args: DescribeActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeActivityCommandOutput,\n    SdkError | ActivityDoesNotExistError | InvalidArnError\n  >;\n  /**\n   * @see {@link DescribeExecutionCommand}\n   */\n  describeExecution(\n    args: DescribeExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeExecutionCommandOutput,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError\n  >;\n  /**\n   * @see {@link DescribeMapRunCommand}\n   */\n  describeMapRun(\n    args: DescribeMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeMapRunCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError\n  >;\n  /**\n   * @see {@link DescribeStateMachineCommand}\n   */\n  describeStateMachine(\n    args: DescribeStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeStateMachineCommandOutput,\n    SdkError | InvalidArnError | StateMachineDoesNotExistError\n  >;\n  /**\n   * @see {@link DescribeStateMachineAliasCommand}\n   */\n  describeStateMachineAlias(\n    args: DescribeStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeStateMachineAliasCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError | ValidationError\n  >;\n  /**\n   * @see {@link DescribeStateMachineForExecutionCommand}\n   */\n  describeStateMachineForExecution(\n    args: DescribeStateMachineForExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeStateMachineForExecutionCommandOutput,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError\n  >;\n  /**\n   * @see {@link GetActivityTaskCommand}\n   */\n  getActivityTask(\n    args: GetActivityTaskCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    GetActivityTaskCommandOutput,\n    | SdkError\n    | ActivityDoesNotExistError\n    | ActivityWorkerLimitExceededError\n    | InvalidArnError\n  >;\n  /**\n   * @see {@link GetExecutionHistoryCommand}\n   */\n  getExecutionHistory(\n    args: GetExecutionHistoryCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    GetExecutionHistoryCommandOutput,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError\n  >;\n  /**\n   * @see {@link ListActivitiesCommand}\n   */\n  listActivities(\n    args: ListActivitiesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<ListActivitiesCommandOutput, SdkError | InvalidTokenError>;\n  /**\n   * @see {@link ListExecutionsCommand}\n   */\n  listExecutions(\n    args: ListExecutionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListExecutionsCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidTokenError\n    | ResourceNotFoundError\n    | StateMachineDoesNotExistError\n    | StateMachineTypeNotSupportedError\n    | ValidationError\n  >;\n  /**\n   * @see {@link ListMapRunsCommand}\n   */\n  listMapRuns(\n    args: ListMapRunsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListMapRunsCommandOutput,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError\n  >;\n  /**\n   * @see {@link ListStateMachineAliasesCommand}\n   */\n  listStateMachineAliases(\n    args: ListStateMachineAliasesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListStateMachineAliasesCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidTokenError\n    | ResourceNotFoundError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n  >;\n  /**\n   * @see {@link ListStateMachinesCommand}\n   */\n  listStateMachines(\n    args: ListStateMachinesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListStateMachinesCommandOutput,\n    SdkError | InvalidTokenError\n  >;\n  /**\n   * @see {@link ListStateMachineVersionsCommand}\n   */\n  listStateMachineVersions(\n    args: ListStateMachineVersionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListStateMachineVersionsCommandOutput,\n    SdkError | InvalidArnError | InvalidTokenError | ValidationError\n  >;\n  /**\n   * @see {@link ListTagsForResourceCommand}\n   */\n  listTagsForResource(\n    args: ListTagsForResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListTagsForResourceCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError\n  >;\n  /**\n   * @see {@link PublishStateMachineVersionCommand}\n   */\n  publishStateMachineVersion(\n    args: PublishStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    PublishStateMachineVersionCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError\n  >;\n  /**\n   * @see {@link RedriveExecutionCommand}\n   */\n  redriveExecution(\n    args: RedriveExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    RedriveExecutionCommandOutput,\n    | SdkError\n    | ExecutionDoesNotExistError\n    | ExecutionLimitExceededError\n    | ExecutionNotRedrivableError\n    | InvalidArnError\n  >;\n  /**\n   * @see {@link SendTaskFailureCommand}\n   */\n  sendTaskFailure(\n    args: SendTaskFailureCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    SendTaskFailureCommandOutput,\n    SdkError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError\n  >;\n  /**\n   * @see {@link SendTaskHeartbeatCommand}\n   */\n  sendTaskHeartbeat(\n    args: SendTaskHeartbeatCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    SendTaskHeartbeatCommandOutput,\n    SdkError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError\n  >;\n  /**\n   * @see {@link SendTaskSuccessCommand}\n   */\n  sendTaskSuccess(\n    args: SendTaskSuccessCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    SendTaskSuccessCommandOutput,\n    | SdkError\n    | InvalidOutputError\n    | InvalidTokenError\n    | TaskDoesNotExistError\n    | TaskTimedOutError\n  >;\n  /**\n   * @see {@link StartExecutionCommand}\n   */\n  startExecution(\n    args: StartExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    StartExecutionCommandOutput,\n    | SdkError\n    | ExecutionAlreadyExistsError\n    | ExecutionLimitExceededError\n    | InvalidArnError\n    | InvalidExecutionInputError\n    | InvalidNameError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError\n  >;\n  /**\n   * @see {@link StartSyncExecutionCommand}\n   */\n  startSyncExecution(\n    args: StartSyncExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    StartSyncExecutionCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidExecutionInputError\n    | InvalidNameError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | StateMachineTypeNotSupportedError\n  >;\n  /**\n   * @see {@link StopExecutionCommand}\n   */\n  stopExecution(\n    args: StopExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    StopExecutionCommandOutput,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError | ValidationError\n  >;\n  /**\n   * @see {@link TagResourceCommand}\n   */\n  tagResource(\n    args: TagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    TagResourceCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError | TooManyTagsError\n  >;\n  /**\n   * @see {@link TestStateCommand}\n   */\n  testState(\n    args: TestStateCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    TestStateCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidExecutionInputError\n    | ValidationError\n  >;\n  /**\n   * @see {@link UntagResourceCommand}\n   */\n  untagResource(\n    args: UntagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UntagResourceCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError\n  >;\n  /**\n   * @see {@link UpdateMapRunCommand}\n   */\n  updateMapRun(\n    args: UpdateMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UpdateMapRunCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError | ValidationError\n  >;\n  /**\n   * @see {@link UpdateStateMachineCommand}\n   */\n  updateStateMachine(\n    args: UpdateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UpdateStateMachineCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidLoggingConfigurationError\n    | InvalidTracingConfigurationError\n    | MissingRequiredParameterError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError\n  >;\n  /**\n   * @see {@link UpdateStateMachineAliasCommand}\n   */\n  updateStateMachineAlias(\n    args: UpdateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UpdateStateMachineAliasCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ResourceNotFoundError\n    | StateMachineDeletingError\n    | ValidationError\n  >;\n}\n\n/**\n * @since 1.0.0\n * @category tags\n */\nexport const SFNService = Context.GenericTag<SFNService>(\n  \"@effect-aws/client-sfn/SFNService\",\n);\n\n/**\n * @since 1.0.0\n * @category constructors\n */\nexport const makeSFNService = Effect.gen(function* (_) {\n  const client = yield* _(SFNClientInstance);\n\n  return ReadonlyRecord.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\n/**\n * @since 1.0.0\n * @category layers\n */\nexport const BaseSFNServiceLayer = Layer.effect(SFNService, makeSFNService);\n\n/**\n * @since 1.0.0\n * @category layers\n */\nexport const SFNServiceLayer = BaseSFNServiceLayer.pipe(\n  Layer.provide(SFNClientInstanceLayer),\n);\n\n/**\n * @since 1.0.0\n * @category layers\n */\nexport const DefaultSFNServiceLayer = SFNServiceLayer.pipe(\n  Layer.provide(DefaultSFNClientConfigLayer),\n);\n\n// -------------------- Danger Zone --------------------\n\n/**\n * @since 0.1.0\n * @deprecated\n */\nexport const BaseSFNServiceEffect = makeSFNService;\n\n/**\n * @since 0.1.0\n * @deprecated\n */\nexport const SFNServiceEffect = BaseSFNServiceEffect.pipe(\n  Effect.provide(SFNClientInstanceLayer),\n);\n\n/**\n * @since 0.1.0\n * @deprecated\n */\nexport const DefaultSFNServiceEffect = BaseSFNServiceEffect.pipe(\n  Effect.provide(DefaultSFNClientInstanceLayer),\n);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SFNService.js","sourceRoot":"","sources":["../../src/SFNService.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @since 1.0.0\n */\nimport {\n  SFNServiceException,\n  CreateActivityCommand,\n  type CreateActivityCommandInput,\n  type CreateActivityCommandOutput,\n  CreateStateMachineCommand,\n  type CreateStateMachineCommandInput,\n  type CreateStateMachineCommandOutput,\n  CreateStateMachineAliasCommand,\n  type CreateStateMachineAliasCommandInput,\n  type CreateStateMachineAliasCommandOutput,\n  DeleteActivityCommand,\n  type DeleteActivityCommandInput,\n  type DeleteActivityCommandOutput,\n  DeleteStateMachineCommand,\n  type DeleteStateMachineCommandInput,\n  type DeleteStateMachineCommandOutput,\n  DeleteStateMachineAliasCommand,\n  type DeleteStateMachineAliasCommandInput,\n  type DeleteStateMachineAliasCommandOutput,\n  DeleteStateMachineVersionCommand,\n  type DeleteStateMachineVersionCommandInput,\n  type DeleteStateMachineVersionCommandOutput,\n  DescribeActivityCommand,\n  type DescribeActivityCommandInput,\n  type DescribeActivityCommandOutput,\n  DescribeExecutionCommand,\n  type DescribeExecutionCommandInput,\n  type DescribeExecutionCommandOutput,\n  DescribeMapRunCommand,\n  type DescribeMapRunCommandInput,\n  type DescribeMapRunCommandOutput,\n  DescribeStateMachineCommand,\n  type DescribeStateMachineCommandInput,\n  type DescribeStateMachineCommandOutput,\n  DescribeStateMachineAliasCommand,\n  type DescribeStateMachineAliasCommandInput,\n  type DescribeStateMachineAliasCommandOutput,\n  DescribeStateMachineForExecutionCommand,\n  type DescribeStateMachineForExecutionCommandInput,\n  type DescribeStateMachineForExecutionCommandOutput,\n  GetActivityTaskCommand,\n  type GetActivityTaskCommandInput,\n  type GetActivityTaskCommandOutput,\n  GetExecutionHistoryCommand,\n  type GetExecutionHistoryCommandInput,\n  type GetExecutionHistoryCommandOutput,\n  ListActivitiesCommand,\n  type ListActivitiesCommandInput,\n  type ListActivitiesCommandOutput,\n  ListExecutionsCommand,\n  type ListExecutionsCommandInput,\n  type ListExecutionsCommandOutput,\n  ListMapRunsCommand,\n  type ListMapRunsCommandInput,\n  type ListMapRunsCommandOutput,\n  ListStateMachineAliasesCommand,\n  type ListStateMachineAliasesCommandInput,\n  type ListStateMachineAliasesCommandOutput,\n  ListStateMachinesCommand,\n  type ListStateMachinesCommandInput,\n  type ListStateMachinesCommandOutput,\n  ListStateMachineVersionsCommand,\n  type ListStateMachineVersionsCommandInput,\n  type ListStateMachineVersionsCommandOutput,\n  ListTagsForResourceCommand,\n  type ListTagsForResourceCommandInput,\n  type ListTagsForResourceCommandOutput,\n  PublishStateMachineVersionCommand,\n  type PublishStateMachineVersionCommandInput,\n  type PublishStateMachineVersionCommandOutput,\n  RedriveExecutionCommand,\n  type RedriveExecutionCommandInput,\n  type RedriveExecutionCommandOutput,\n  SendTaskFailureCommand,\n  type SendTaskFailureCommandInput,\n  type SendTaskFailureCommandOutput,\n  SendTaskHeartbeatCommand,\n  type SendTaskHeartbeatCommandInput,\n  type SendTaskHeartbeatCommandOutput,\n  SendTaskSuccessCommand,\n  type SendTaskSuccessCommandInput,\n  type SendTaskSuccessCommandOutput,\n  StartExecutionCommand,\n  type StartExecutionCommandInput,\n  type StartExecutionCommandOutput,\n  StartSyncExecutionCommand,\n  type StartSyncExecutionCommandInput,\n  type StartSyncExecutionCommandOutput,\n  StopExecutionCommand,\n  type StopExecutionCommandInput,\n  type StopExecutionCommandOutput,\n  TagResourceCommand,\n  type TagResourceCommandInput,\n  type TagResourceCommandOutput,\n  TestStateCommand,\n  type TestStateCommandInput,\n  type TestStateCommandOutput,\n  UntagResourceCommand,\n  type UntagResourceCommandInput,\n  type UntagResourceCommandOutput,\n  UpdateMapRunCommand,\n  type UpdateMapRunCommandInput,\n  type UpdateMapRunCommandOutput,\n  UpdateStateMachineCommand,\n  type UpdateStateMachineCommandInput,\n  type UpdateStateMachineCommandOutput,\n  UpdateStateMachineAliasCommand,\n  type UpdateStateMachineAliasCommandInput,\n  type UpdateStateMachineAliasCommandOutput,\n  ValidateStateMachineDefinitionCommand,\n  type ValidateStateMachineDefinitionCommandInput,\n  type ValidateStateMachineDefinitionCommandOutput,\n} from \"@aws-sdk/client-sfn\";\nimport { type HttpHandlerOptions as __HttpHandlerOptions } from \"@aws-sdk/types\";\nimport { Data, Effect, Layer, Record } from \"effect\";\nimport {\n  AllServiceErrors,\n  ActivityAlreadyExistsError,\n  ActivityDoesNotExistError,\n  ActivityLimitExceededError,\n  ActivityWorkerLimitExceededError,\n  ConflictError,\n  ExecutionAlreadyExistsError,\n  ExecutionDoesNotExistError,\n  ExecutionLimitExceededError,\n  ExecutionNotRedrivableError,\n  InvalidArnError,\n  InvalidDefinitionError,\n  InvalidEncryptionConfigurationError,\n  InvalidExecutionInputError,\n  InvalidLoggingConfigurationError,\n  InvalidNameError,\n  InvalidOutputError,\n  InvalidTokenError,\n  InvalidTracingConfigurationError,\n  KmsAccessDeniedError,\n  KmsInvalidStateError,\n  KmsThrottlingError,\n  MissingRequiredParameterError,\n  ResourceNotFoundError,\n  ServiceQuotaExceededError,\n  StateMachineAlreadyExistsError,\n  StateMachineDeletingError,\n  StateMachineDoesNotExistError,\n  StateMachineLimitExceededError,\n  StateMachineTypeNotSupportedError,\n  TaskDoesNotExistError,\n  TaskTimedOutError,\n  TooManyTagsError,\n  ValidationError,\n  SdkError,\n  TaggedException,\n} from \"./Errors\";\nimport { SFNClientInstance, SFNClientInstanceLayer } from \"./SFNClientInstance\";\nimport { DefaultSFNClientConfigLayer } from \"./SFNClientInstanceConfig\";\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  ValidateStateMachineDefinitionCommand,\n};\n\ninterface SFNService$ {\n  readonly _: unique symbol;\n\n  /**\n   * @see {@link CreateActivityCommand}\n   */\n  createActivity(\n    args: CreateActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    CreateActivityCommandOutput,\n    | SdkError\n    | ActivityAlreadyExistsError\n    | ActivityLimitExceededError\n    | InvalidEncryptionConfigurationError\n    | InvalidNameError\n    | KmsAccessDeniedError\n    | KmsThrottlingError\n    | TooManyTagsError\n  >;\n\n  /**\n   * @see {@link CreateStateMachineCommand}\n   */\n  createStateMachine(\n    args: CreateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    CreateStateMachineCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidEncryptionConfigurationError\n    | InvalidLoggingConfigurationError\n    | InvalidNameError\n    | InvalidTracingConfigurationError\n    | KmsAccessDeniedError\n    | KmsThrottlingError\n    | StateMachineAlreadyExistsError\n    | StateMachineDeletingError\n    | StateMachineLimitExceededError\n    | StateMachineTypeNotSupportedError\n    | TooManyTagsError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link CreateStateMachineAliasCommand}\n   */\n  createStateMachineAlias(\n    args: CreateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    CreateStateMachineAliasCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidNameError\n    | ResourceNotFoundError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link DeleteActivityCommand}\n   */\n  deleteActivity(\n    args: DeleteActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<DeleteActivityCommandOutput, SdkError | InvalidArnError>;\n\n  /**\n   * @see {@link DeleteStateMachineCommand}\n   */\n  deleteStateMachine(\n    args: DeleteStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DeleteStateMachineCommandOutput,\n    SdkError | InvalidArnError | ValidationError\n  >;\n\n  /**\n   * @see {@link DeleteStateMachineAliasCommand}\n   */\n  deleteStateMachineAlias(\n    args: DeleteStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DeleteStateMachineAliasCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ResourceNotFoundError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link DeleteStateMachineVersionCommand}\n   */\n  deleteStateMachineVersion(\n    args: DeleteStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DeleteStateMachineVersionCommandOutput,\n    SdkError | ConflictError | InvalidArnError | ValidationError\n  >;\n\n  /**\n   * @see {@link DescribeActivityCommand}\n   */\n  describeActivity(\n    args: DescribeActivityCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeActivityCommandOutput,\n    SdkError | ActivityDoesNotExistError | InvalidArnError\n  >;\n\n  /**\n   * @see {@link DescribeExecutionCommand}\n   */\n  describeExecution(\n    args: DescribeExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeExecutionCommandOutput,\n    | SdkError\n    | ExecutionDoesNotExistError\n    | InvalidArnError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n  >;\n\n  /**\n   * @see {@link DescribeMapRunCommand}\n   */\n  describeMapRun(\n    args: DescribeMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeMapRunCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError\n  >;\n\n  /**\n   * @see {@link DescribeStateMachineCommand}\n   */\n  describeStateMachine(\n    args: DescribeStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeStateMachineCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n    | StateMachineDoesNotExistError\n  >;\n\n  /**\n   * @see {@link DescribeStateMachineAliasCommand}\n   */\n  describeStateMachineAlias(\n    args: DescribeStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeStateMachineAliasCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError | ValidationError\n  >;\n\n  /**\n   * @see {@link DescribeStateMachineForExecutionCommand}\n   */\n  describeStateMachineForExecution(\n    args: DescribeStateMachineForExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    DescribeStateMachineForExecutionCommandOutput,\n    | SdkError\n    | ExecutionDoesNotExistError\n    | InvalidArnError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n  >;\n\n  /**\n   * @see {@link GetActivityTaskCommand}\n   */\n  getActivityTask(\n    args: GetActivityTaskCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    GetActivityTaskCommandOutput,\n    | SdkError\n    | ActivityDoesNotExistError\n    | ActivityWorkerLimitExceededError\n    | InvalidArnError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n  >;\n\n  /**\n   * @see {@link GetExecutionHistoryCommand}\n   */\n  getExecutionHistory(\n    args: GetExecutionHistoryCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    GetExecutionHistoryCommandOutput,\n    | SdkError\n    | ExecutionDoesNotExistError\n    | InvalidArnError\n    | InvalidTokenError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n  >;\n\n  /**\n   * @see {@link ListActivitiesCommand}\n   */\n  listActivities(\n    args: ListActivitiesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<ListActivitiesCommandOutput, SdkError | InvalidTokenError>;\n\n  /**\n   * @see {@link ListExecutionsCommand}\n   */\n  listExecutions(\n    args: ListExecutionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListExecutionsCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidTokenError\n    | ResourceNotFoundError\n    | StateMachineDoesNotExistError\n    | StateMachineTypeNotSupportedError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link ListMapRunsCommand}\n   */\n  listMapRuns(\n    args: ListMapRunsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListMapRunsCommandOutput,\n    SdkError | ExecutionDoesNotExistError | InvalidArnError | InvalidTokenError\n  >;\n\n  /**\n   * @see {@link ListStateMachineAliasesCommand}\n   */\n  listStateMachineAliases(\n    args: ListStateMachineAliasesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListStateMachineAliasesCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidTokenError\n    | ResourceNotFoundError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n  >;\n\n  /**\n   * @see {@link ListStateMachinesCommand}\n   */\n  listStateMachines(\n    args: ListStateMachinesCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListStateMachinesCommandOutput,\n    SdkError | InvalidTokenError\n  >;\n\n  /**\n   * @see {@link ListStateMachineVersionsCommand}\n   */\n  listStateMachineVersions(\n    args: ListStateMachineVersionsCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListStateMachineVersionsCommandOutput,\n    SdkError | InvalidArnError | InvalidTokenError | ValidationError\n  >;\n\n  /**\n   * @see {@link ListTagsForResourceCommand}\n   */\n  listTagsForResource(\n    args: ListTagsForResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ListTagsForResourceCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError\n  >;\n\n  /**\n   * @see {@link PublishStateMachineVersionCommand}\n   */\n  publishStateMachineVersion(\n    args: PublishStateMachineVersionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    PublishStateMachineVersionCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link RedriveExecutionCommand}\n   */\n  redriveExecution(\n    args: RedriveExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    RedriveExecutionCommandOutput,\n    | SdkError\n    | ExecutionDoesNotExistError\n    | ExecutionLimitExceededError\n    | ExecutionNotRedrivableError\n    | InvalidArnError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link SendTaskFailureCommand}\n   */\n  sendTaskFailure(\n    args: SendTaskFailureCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    SendTaskFailureCommandOutput,\n    | SdkError\n    | InvalidTokenError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n    | TaskDoesNotExistError\n    | TaskTimedOutError\n  >;\n\n  /**\n   * @see {@link SendTaskHeartbeatCommand}\n   */\n  sendTaskHeartbeat(\n    args: SendTaskHeartbeatCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    SendTaskHeartbeatCommandOutput,\n    SdkError | InvalidTokenError | TaskDoesNotExistError | TaskTimedOutError\n  >;\n\n  /**\n   * @see {@link SendTaskSuccessCommand}\n   */\n  sendTaskSuccess(\n    args: SendTaskSuccessCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    SendTaskSuccessCommandOutput,\n    | SdkError\n    | InvalidOutputError\n    | InvalidTokenError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n    | TaskDoesNotExistError\n    | TaskTimedOutError\n  >;\n\n  /**\n   * @see {@link StartExecutionCommand}\n   */\n  startExecution(\n    args: StartExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    StartExecutionCommandOutput,\n    | SdkError\n    | ExecutionAlreadyExistsError\n    | ExecutionLimitExceededError\n    | InvalidArnError\n    | InvalidExecutionInputError\n    | InvalidNameError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link StartSyncExecutionCommand}\n   */\n  startSyncExecution(\n    args: StartSyncExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    StartSyncExecutionCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidExecutionInputError\n    | InvalidNameError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | StateMachineTypeNotSupportedError\n  >;\n\n  /**\n   * @see {@link StopExecutionCommand}\n   */\n  stopExecution(\n    args: StopExecutionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    StopExecutionCommandOutput,\n    | SdkError\n    | ExecutionDoesNotExistError\n    | InvalidArnError\n    | KmsAccessDeniedError\n    | KmsInvalidStateError\n    | KmsThrottlingError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link TagResourceCommand}\n   */\n  tagResource(\n    args: TagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    TagResourceCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError | TooManyTagsError\n  >;\n\n  /**\n   * @see {@link TestStateCommand}\n   */\n  testState(\n    args: TestStateCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    TestStateCommandOutput,\n    | SdkError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidExecutionInputError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link UntagResourceCommand}\n   */\n  untagResource(\n    args: UntagResourceCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UntagResourceCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError\n  >;\n\n  /**\n   * @see {@link UpdateMapRunCommand}\n   */\n  updateMapRun(\n    args: UpdateMapRunCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UpdateMapRunCommandOutput,\n    SdkError | InvalidArnError | ResourceNotFoundError | ValidationError\n  >;\n\n  /**\n   * @see {@link UpdateStateMachineCommand}\n   */\n  updateStateMachine(\n    args: UpdateStateMachineCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UpdateStateMachineCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | InvalidDefinitionError\n    | InvalidEncryptionConfigurationError\n    | InvalidLoggingConfigurationError\n    | InvalidTracingConfigurationError\n    | KmsAccessDeniedError\n    | KmsThrottlingError\n    | MissingRequiredParameterError\n    | ServiceQuotaExceededError\n    | StateMachineDeletingError\n    | StateMachineDoesNotExistError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link UpdateStateMachineAliasCommand}\n   */\n  updateStateMachineAlias(\n    args: UpdateStateMachineAliasCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    UpdateStateMachineAliasCommandOutput,\n    | SdkError\n    | ConflictError\n    | InvalidArnError\n    | ResourceNotFoundError\n    | StateMachineDeletingError\n    | ValidationError\n  >;\n\n  /**\n   * @see {@link ValidateStateMachineDefinitionCommand}\n   */\n  validateStateMachineDefinition(\n    args: ValidateStateMachineDefinitionCommandInput,\n    options?: __HttpHandlerOptions,\n  ): Effect.Effect<\n    ValidateStateMachineDefinitionCommandOutput,\n    SdkError | ValidationError\n  >;\n}\n\n/**\n * @since 1.0.0\n * @category models\n */\nexport class SFNService extends Effect.Tag(\"@effect-aws/client-sfn/SFNService\")<\n  SFNService,\n  SFNService$\n>() {}\n\n/**\n * @since 1.0.0\n * @category constructors\n */\nexport const makeSFNService = Effect.gen(function* (_) {\n  const client = yield* _(SFNClientInstance);\n\n  return Record.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 (\n            e instanceof SFNServiceException &&\n            AllServiceErrors.includes(e.name)\n          ) {\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\n/**\n * @since 1.0.0\n * @category layers\n */\nexport const BaseSFNServiceLayer = Layer.effect(SFNService, makeSFNService);\n\n/**\n * @since 1.0.0\n * @category layers\n */\nexport const SFNServiceLayer = BaseSFNServiceLayer.pipe(\n  Layer.provide(SFNClientInstanceLayer),\n);\n\n/**\n * @since 1.0.0\n * @category layers\n */\nexport const DefaultSFNServiceLayer = SFNServiceLayer.pipe(\n  Layer.provide(DefaultSFNClientConfigLayer),\n);\n"]}

package/package.json CHANGED Viewed

@@ -7,23 +7,21 @@
   },
   "devDependencies": {
     "@types/node": "^18",
-    "@typescript-eslint/eslint-plugin": "^6",
-    "@typescript-eslint/parser": "^6",
+    "@typescript-eslint/eslint-plugin": "^7",
+    "@typescript-eslint/parser": "^7",
     "aws-sdk-client-mock": "^3.0.0",
     "aws-sdk-client-mock-jest": "^3.0.0",
-    "constructs": "^10.0.0",
-    "effect": "2.3.1",
+    "effect": "3.0.0",
     "eslint": "^8",
-    "eslint-config-prettier": "^9.0.0",
+    "eslint-config-prettier": "^9.1.0",
     "eslint-import-resolver-typescript": "^3.6.1",
-    "eslint-plugin-import": "^2.28.1",
-    "eslint-plugin-prettier": "^5.0.0",
-    "prettier": "^3.0.3",
-    "projen": "^0.79.6",
-    "typescript": "^5.2.2"
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-prettier": "^5.2.1",
+    "prettier": "^3.2.5",
+    "typescript": "^5.4.2"
   },
   "peerDependencies": {
-    "effect": ">=2.3.1 <2.5.0"
+    "effect": ">=3.0.0 <4.0.0"
   },
   "dependencies": {
     "@aws-sdk/client-sfn": "^3",
@@ -35,7 +33,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.1",
+  "version": "1.3.0",
   "types": "lib/index.d.ts",
   "module": "lib/esm/index.js",
   "sideEffects": [],