effect-app 4.0.0-beta.16 → 4.0.0-beta.161

package/dist/Operations.d.ts

@@ -1,91 +1,409 @@
 import * as S from "./Schema.js";
 export type OperationId = S.StringId;
-export declare const OperationId: S.WithDefaults<S.brand<S.String, "NonEmptyString" | "NonEmptyString64k" | "NonEmptyString2k" | "NonEmptyString255" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString80" | "NonEmptyString100" | "StringId"> & {
+export declare const OperationId: S.WithDefaults<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
+    readonly Type: S.StringId;
+    readonly Iso: S.StringId;
+    readonly "~type.make": S.StringId;
+} & {
     make: () => S.StringId;
-    withDefault: S.withConstructorDefault<S.brand<S.String, "NonEmptyString" | "NonEmptyString64k" | "NonEmptyString2k" | "NonEmptyString255" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString80" | "NonEmptyString100" | "StringId"> & S.WithoutConstructorDefault>;
-}> & S.brand<S.String, "NonEmptyString" | "NonEmptyString64k" | "NonEmptyString2k" | "NonEmptyString255" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString80" | "NonEmptyString100" | "StringId"> & {
+    withDefault: S.withConstructorDefault<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.StringId;
+        readonly Iso: S.StringId;
+        readonly "~type.make": S.StringId;
+    }>;
+}> & Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
+    readonly Type: S.StringId;
+    readonly Iso: S.StringId;
+    readonly "~type.make": S.StringId;
+} & {
     make: () => S.StringId;
-    withDefault: S.withConstructorDefault<S.brand<S.String, "NonEmptyString" | "NonEmptyString64k" | "NonEmptyString2k" | "NonEmptyString255" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString80" | "NonEmptyString100" | "StringId"> & S.WithoutConstructorDefault>;
+    withDefault: S.withConstructorDefault<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.StringId;
+        readonly Iso: S.StringId;
+        readonly "~type.make": S.StringId;
+    }>;
 };
-declare const OperationProgress_base: S.EnhancedClass<OperationProgress, S.Struct<{
-    completed: S.WithDefaults<S.brand<import("effect/Schema").Int, "NonNegativeInt" | "Int" | "NonNegativeNumber">> & S.brand<import("effect/Schema").Int, "NonNegativeInt" | "Int" | "NonNegativeNumber"> & {
-        withDefault: S.withConstructorDefault<S.WithDefaults<S.brand<import("effect/Schema").Int, "NonNegativeInt" | "Int" | "NonNegativeNumber">> & S.brand<import("effect/Schema").Int, "NonNegativeInt" | "Int" | "NonNegativeNumber"> & S.WithoutConstructorDefault>;
+declare const OperationProgress_base: import("effect/Schema").Opaque<OperationProgress, Omit<S.Struct<{
+    readonly completed: S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonNegativeInt;
+        readonly Iso: S.NonNegativeInt;
+        readonly "~type.make": S.NonNegativeInt;
+    }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonNegativeInt;
+        readonly Iso: S.NonNegativeInt;
+        readonly "~type.make": S.NonNegativeInt;
+    } & {
+        withDefault: S.withConstructorDefault<S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+            readonly Type: S.NonNegativeInt;
+            readonly Iso: S.NonNegativeInt;
+            readonly "~type.make": S.NonNegativeInt;
+        }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+            readonly Type: S.NonNegativeInt;
+            readonly Iso: S.NonNegativeInt;
+            readonly "~type.make": S.NonNegativeInt;
+        }>;
+    };
+    readonly total: S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonNegativeInt;
+        readonly Iso: S.NonNegativeInt;
+        readonly "~type.make": S.NonNegativeInt;
+    }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonNegativeInt;
+        readonly Iso: S.NonNegativeInt;
+        readonly "~type.make": S.NonNegativeInt;
+    } & {
+        withDefault: S.withConstructorDefault<S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+            readonly Type: S.NonNegativeInt;
+            readonly Iso: S.NonNegativeInt;
+            readonly "~type.make": S.NonNegativeInt;
+        }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+            readonly Type: S.NonNegativeInt;
+            readonly Iso: S.NonNegativeInt;
+            readonly "~type.make": S.NonNegativeInt;
+        }>;
+    };
+}>, "Encoded"> & {
+    readonly Encoded: OperationProgress.Encoded;
+}, {}> & Omit<S.Struct<{
+    readonly completed: S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonNegativeInt;
+        readonly Iso: S.NonNegativeInt;
+        readonly "~type.make": S.NonNegativeInt;
+    }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonNegativeInt;
+        readonly Iso: S.NonNegativeInt;
+        readonly "~type.make": S.NonNegativeInt;
+    } & {
+        withDefault: S.withConstructorDefault<S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+            readonly Type: S.NonNegativeInt;
+            readonly Iso: S.NonNegativeInt;
+            readonly "~type.make": S.NonNegativeInt;
+        }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+            readonly Type: S.NonNegativeInt;
+            readonly Iso: S.NonNegativeInt;
+            readonly "~type.make": S.NonNegativeInt;
+        }>;
     };
-    total: S.WithDefaults<S.brand<import("effect/Schema").Int, "NonNegativeInt" | "Int" | "NonNegativeNumber">> & S.brand<import("effect/Schema").Int, "NonNegativeInt" | "Int" | "NonNegativeNumber"> & {
-        withDefault: S.withConstructorDefault<S.WithDefaults<S.brand<import("effect/Schema").Int, "NonNegativeInt" | "Int" | "NonNegativeNumber">> & S.brand<import("effect/Schema").Int, "NonNegativeInt" | "Int" | "NonNegativeNumber"> & S.WithoutConstructorDefault>;
+    readonly total: S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonNegativeInt;
+        readonly Iso: S.NonNegativeInt;
+        readonly "~type.make": S.NonNegativeInt;
+    }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonNegativeInt;
+        readonly Iso: S.NonNegativeInt;
+        readonly "~type.make": S.NonNegativeInt;
+    } & {
+        withDefault: S.withConstructorDefault<S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+            readonly Type: S.NonNegativeInt;
+            readonly Iso: S.NonNegativeInt;
+            readonly "~type.make": S.NonNegativeInt;
+        }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
+            readonly Type: S.NonNegativeInt;
+            readonly Iso: S.NonNegativeInt;
+            readonly "~type.make": S.NonNegativeInt;
+        }>;
     };
-}>, {}>;
+}>, keyof S.Top>;
 export declare class OperationProgress extends OperationProgress_base {
 }
-declare const OperationSuccess_base: S.EnhancedTaggedClass<OperationSuccess, "OperationSuccess", {
-    readonly _tag: S.tag<"OperationSuccess">;
-} & {
-    message: S.withConstructorDefault<import("effect/Schema").NullOr<S.WithDefaults<S.brand<S.String, "NonEmptyString" | "NonEmptyString64k" | "NonEmptyString2k">> & S.brand<S.String, "NonEmptyString" | "NonEmptyString64k" | "NonEmptyString2k">> & S.WithoutConstructorDefault>;
-}, OperationSuccess.Encoded>;
+declare const OperationSuccess_base: import("effect/Schema").Opaque<OperationSuccess, Omit<S.TaggedStruct<"OperationSuccess", {
+    readonly message: S.withConstructorDefault<import("effect/Schema").NullOr<S.WithDefaults<Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonEmptyString2k;
+        readonly Iso: S.NonEmptyString2k;
+        readonly "~type.make": S.NonEmptyString2k;
+    }> & Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonEmptyString2k;
+        readonly Iso: S.NonEmptyString2k;
+        readonly "~type.make": S.NonEmptyString2k;
+    }>>;
+}>, "Encoded"> & {
+    readonly Encoded: OperationSuccess.Encoded;
+}, {}> & Omit<S.TaggedStruct<"OperationSuccess", {
+    readonly message: S.withConstructorDefault<import("effect/Schema").NullOr<S.WithDefaults<Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonEmptyString2k;
+        readonly Iso: S.NonEmptyString2k;
+        readonly "~type.make": S.NonEmptyString2k;
+    }> & Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonEmptyString2k;
+        readonly Iso: S.NonEmptyString2k;
+        readonly "~type.make": S.NonEmptyString2k;
+    }>>;
+}>, keyof S.Top> & {
+    make(input?: {
+        readonly _tag?: "OperationSuccess";
+        readonly message?: S.NonEmptyString2k | null;
+    } | undefined, options?: S.MakeOptions): OperationSuccess;
+    makeOption(input?: {
+        readonly _tag?: "OperationSuccess";
+        readonly message?: S.NonEmptyString2k | null;
+    } | undefined, options?: S.MakeOptions): import("effect/Option").Option<OperationSuccess>;
+    makeEffect(input?: {
+        readonly _tag?: "OperationSuccess";
+        readonly message?: S.NonEmptyString2k | null;
+    } | undefined, options?: S.MakeOptions): import("effect/Effect").Effect<OperationSuccess, S.SchemaError, never>;
+};
 export declare class OperationSuccess extends OperationSuccess_base {
 }
-declare const OperationFailure_base: S.EnhancedTaggedClass<OperationFailure, "OperationFailure", {
-    readonly _tag: S.tag<"OperationFailure">;
-} & {
-    message: S.withConstructorDefault<import("effect/Schema").NullOr<S.WithDefaults<S.brand<S.String, "NonEmptyString" | "NonEmptyString64k" | "NonEmptyString2k">> & S.brand<S.String, "NonEmptyString" | "NonEmptyString64k" | "NonEmptyString2k">> & S.WithoutConstructorDefault>;
-}, OperationFailure.Encoded>;
+declare const OperationFailure_base: import("effect/Schema").Opaque<OperationFailure, Omit<S.TaggedStruct<"OperationFailure", {
+    readonly message: S.withConstructorDefault<import("effect/Schema").NullOr<S.WithDefaults<Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonEmptyString2k;
+        readonly Iso: S.NonEmptyString2k;
+        readonly "~type.make": S.NonEmptyString2k;
+    }> & Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonEmptyString2k;
+        readonly Iso: S.NonEmptyString2k;
+        readonly "~type.make": S.NonEmptyString2k;
+    }>>;
+}>, "Encoded"> & {
+    readonly Encoded: OperationFailure.Encoded;
+}, {}> & Omit<S.TaggedStruct<"OperationFailure", {
+    readonly message: S.withConstructorDefault<import("effect/Schema").NullOr<S.WithDefaults<Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonEmptyString2k;
+        readonly Iso: S.NonEmptyString2k;
+        readonly "~type.make": S.NonEmptyString2k;
+    }> & Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonEmptyString2k;
+        readonly Iso: S.NonEmptyString2k;
+        readonly "~type.make": S.NonEmptyString2k;
+    }>>;
+}>, keyof S.Top> & {
+    make(input?: {
+        readonly _tag?: "OperationFailure";
+        readonly message?: S.NonEmptyString2k | null;
+    } | undefined, options?: S.MakeOptions): OperationFailure;
+    makeOption(input?: {
+        readonly _tag?: "OperationFailure";
+        readonly message?: S.NonEmptyString2k | null;
+    } | undefined, options?: S.MakeOptions): import("effect/Option").Option<OperationFailure>;
+    makeEffect(input?: {
+        readonly _tag?: "OperationFailure";
+        readonly message?: S.NonEmptyString2k | null;
+    } | undefined, options?: S.MakeOptions): import("effect/Effect").Effect<OperationFailure, S.SchemaError, never>;
+};
 export declare class OperationFailure extends OperationFailure_base {
 }
 export declare const OperationResult: S.Union<[typeof OperationSuccess, typeof OperationFailure]> & {
-    is: <I>(input: I) => input is any;
-    isA: S.Is<{
-        _tag: string;
-    }>;
-    isAnyOf: S.IsAny<{
-        _tag: string;
+    readonly cases: {
+        OperationFailure: typeof OperationFailure;
+        OperationSuccess: typeof OperationSuccess;
+    };
+    readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: OperationFailure | OperationSuccess) => value is Extract<OperationFailure, {
+        _tag: Keys;
+    }> | Extract<OperationSuccess, {
+        _tag: Keys;
     }>;
-    tagMap: any;
-    tags: any;
+    readonly guards: {
+        OperationFailure: (u: unknown) => u is OperationFailure;
+        OperationSuccess: (u: unknown) => u is OperationSuccess;
+    };
+    readonly match: {
+        <Cases extends { [M in typeof OperationSuccess | typeof OperationFailure as M["Type"]["_tag"]]: (value: M["Type"]) => any; }>(value: OperationFailure | OperationSuccess, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+        <Cases extends { [M in typeof OperationSuccess | typeof OperationFailure as M["Type"]["_tag"]]: (value: M["Type"]) => any; }>(cases: Cases): (value: OperationFailure | OperationSuccess) => Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+    };
+} & {
+    readonly tags: import("effect/Schema").Literals<["OperationSuccess", "OperationFailure"]>;
+    readonly generateGuards: <K extends string>(property: K) => {
+        readonly isOperationFailure: <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: OperationFailure; };
+        readonly isOperationSuccess: <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: OperationSuccess; };
+    } & {
+        readonly isAnyOf: <const Tags extends ReadonlyArray<"OperationFailure" | "OperationSuccess">>(tags: Tags) => <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: Extract<OperationFailure, {
+            readonly _tag: Tags[number];
+        }> | Extract<OperationSuccess, {
+            readonly _tag: Tags[number];
+        }>; };
+    };
+    readonly generateGuardsFor: <A>() => <K extends { [K_1 in keyof A & string]: A[K_1] extends OperationFailure | OperationSuccess ? K_1 : never; }[keyof A & string]>(property: K) => {
+        readonly isOperationFailure: (target: A) => target is A & { readonly [P in K]: OperationFailure; };
+        readonly isOperationSuccess: (target: A) => target is A & { readonly [P in K]: OperationSuccess; };
+    } & {
+        readonly isAnyOf: <const Tags extends ReadonlyArray<"OperationFailure" | "OperationSuccess">>(tags: Tags) => (target: A) => target is A & { readonly [P in K]: Extract<OperationFailure, {
+            readonly _tag: Tags[number];
+        }> | Extract<OperationSuccess, {
+            readonly _tag: Tags[number];
+        }>; };
+    };
 };
 export type OperationResult = S.Schema.Type<typeof OperationResult>;
-declare const Operation_base: S.EnhancedClass<Operation, S.Struct<{
-    id: S.WithDefaults<S.brand<S.String, "NonEmptyString" | "NonEmptyString64k" | "NonEmptyString2k" | "NonEmptyString255" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString80" | "NonEmptyString100" | "StringId"> & {
+declare const Operation_base: import("effect/Schema").Opaque<Operation, Omit<S.Struct<{
+    readonly id: S.WithDefaults<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.StringId;
+        readonly Iso: S.StringId;
+        readonly "~type.make": S.StringId;
+    } & {
         make: () => S.StringId;
-        withDefault: S.withConstructorDefault<S.brand<S.String, "NonEmptyString" | "NonEmptyString64k" | "NonEmptyString2k" | "NonEmptyString255" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString80" | "NonEmptyString100" | "StringId"> & S.WithoutConstructorDefault>;
-    }> & S.brand<S.String, "NonEmptyString" | "NonEmptyString64k" | "NonEmptyString2k" | "NonEmptyString255" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString80" | "NonEmptyString100" | "StringId"> & {
+        withDefault: S.withConstructorDefault<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
+            readonly Type: S.StringId;
+            readonly Iso: S.StringId;
+            readonly "~type.make": S.StringId;
+        }>;
+    }> & Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.StringId;
+        readonly Iso: S.StringId;
+        readonly "~type.make": S.StringId;
+    } & {
         make: () => S.StringId;
-        withDefault: S.withConstructorDefault<S.brand<S.String, "NonEmptyString" | "NonEmptyString64k" | "NonEmptyString2k" | "NonEmptyString255" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString80" | "NonEmptyString100" | "StringId"> & S.WithoutConstructorDefault>;
+        withDefault: S.withConstructorDefault<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
+            readonly Type: S.StringId;
+            readonly Iso: S.StringId;
+            readonly "~type.make": S.StringId;
+        }>;
+    };
+    readonly title: S.WithDefaults<Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonEmptyString2k;
+        readonly Iso: S.NonEmptyString2k;
+        readonly "~type.make": S.NonEmptyString2k;
+    }> & Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonEmptyString2k;
+        readonly Iso: S.NonEmptyString2k;
+        readonly "~type.make": S.NonEmptyString2k;
     };
-    title: S.WithDefaults<S.brand<S.String, "NonEmptyString" | "NonEmptyString64k" | "NonEmptyString2k">> & S.brand<S.String, "NonEmptyString" | "NonEmptyString64k" | "NonEmptyString2k">;
-    progress: S.optional<typeof OperationProgress>;
-    result: S.optional<S.Union<[typeof OperationSuccess, typeof OperationFailure]> & {
-        is: <I>(input: I) => input is any;
-        isA: S.Is<{
-            _tag: string;
+    readonly progress: S.optional<typeof OperationProgress>;
+    readonly result: S.optional<S.Union<[typeof OperationSuccess, typeof OperationFailure]> & {
+        readonly cases: {
+            OperationFailure: typeof OperationFailure;
+            OperationSuccess: typeof OperationSuccess;
+        };
+        readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: OperationFailure | OperationSuccess) => value is Extract<OperationFailure, {
+            _tag: Keys;
+        }> | Extract<OperationSuccess, {
+            _tag: Keys;
         }>;
-        isAnyOf: S.IsAny<{
-            _tag: string;
+        readonly guards: {
+            OperationFailure: (u: unknown) => u is OperationFailure;
+            OperationSuccess: (u: unknown) => u is OperationSuccess;
+        };
+        readonly match: {
+            <Cases extends { [M in typeof OperationSuccess | typeof OperationFailure as M["Type"]["_tag"]]: (value: M["Type"]) => any; }>(value: OperationFailure | OperationSuccess, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+            <Cases extends { [M in typeof OperationSuccess | typeof OperationFailure as M["Type"]["_tag"]]: (value: M["Type"]) => any; }>(cases: Cases): (value: OperationFailure | OperationSuccess) => Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+        };
+    } & {
+        readonly tags: import("effect/Schema").Literals<["OperationSuccess", "OperationFailure"]>;
+        readonly generateGuards: <K extends string>(property: K) => {
+            readonly isOperationFailure: <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: OperationFailure; };
+            readonly isOperationSuccess: <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: OperationSuccess; };
+        } & {
+            readonly isAnyOf: <const Tags extends ReadonlyArray<"OperationFailure" | "OperationSuccess">>(tags: Tags) => <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: Extract<OperationFailure, {
+                readonly _tag: Tags[number];
+            }> | Extract<OperationSuccess, {
+                readonly _tag: Tags[number];
+            }>; };
+        };
+        readonly generateGuardsFor: <A>() => <K extends { [K_1 in keyof A & string]: A[K_1] extends OperationFailure | OperationSuccess ? K_1 : never; }[keyof A & string]>(property: K) => {
+            readonly isOperationFailure: (target: A) => target is A & { readonly [P in K]: OperationFailure; };
+            readonly isOperationSuccess: (target: A) => target is A & { readonly [P in K]: OperationSuccess; };
+        } & {
+            readonly isAnyOf: <const Tags extends ReadonlyArray<"OperationFailure" | "OperationSuccess">>(tags: Tags) => (target: A) => target is A & { readonly [P in K]: Extract<OperationFailure, {
+                readonly _tag: Tags[number];
+            }> | Extract<OperationSuccess, {
+                readonly _tag: Tags[number];
+            }>; };
+        };
+    }>;
+    readonly createdAt: S.withConstructorDefault<S.DateFromString>;
+    readonly updatedAt: S.withConstructorDefault<import("effect/Schema").NullOr<S.DateFromString & {
+        withDefault: S.withConstructorDefault<S.DateFromString>;
+        withDecodingDefaultType: S.withDecodingDefaultType<S.DateFromString>;
+    }>>;
+}>, "Encoded"> & {
+    readonly Encoded: Operation.Encoded;
+}, {}> & Omit<S.Struct<{
+    readonly id: S.WithDefaults<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.StringId;
+        readonly Iso: S.StringId;
+        readonly "~type.make": S.StringId;
+    } & {
+        make: () => S.StringId;
+        withDefault: S.withConstructorDefault<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
+            readonly Type: S.StringId;
+            readonly Iso: S.StringId;
+            readonly "~type.make": S.StringId;
+        }>;
+    }> & Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.StringId;
+        readonly Iso: S.StringId;
+        readonly "~type.make": S.StringId;
+    } & {
+        make: () => S.StringId;
+        withDefault: S.withConstructorDefault<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
+            readonly Type: S.StringId;
+            readonly Iso: S.StringId;
+            readonly "~type.make": S.StringId;
+        }>;
+    };
+    readonly title: S.WithDefaults<Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonEmptyString2k;
+        readonly Iso: S.NonEmptyString2k;
+        readonly "~type.make": S.NonEmptyString2k;
+    }> & Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
+        readonly Type: S.NonEmptyString2k;
+        readonly Iso: S.NonEmptyString2k;
+        readonly "~type.make": S.NonEmptyString2k;
+    };
+    readonly progress: S.optional<typeof OperationProgress>;
+    readonly result: S.optional<S.Union<[typeof OperationSuccess, typeof OperationFailure]> & {
+        readonly cases: {
+            OperationFailure: typeof OperationFailure;
+            OperationSuccess: typeof OperationSuccess;
+        };
+        readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: OperationFailure | OperationSuccess) => value is Extract<OperationFailure, {
+            _tag: Keys;
+        }> | Extract<OperationSuccess, {
+            _tag: Keys;
         }>;
-        tagMap: any;
-        tags: any;
+        readonly guards: {
+            OperationFailure: (u: unknown) => u is OperationFailure;
+            OperationSuccess: (u: unknown) => u is OperationSuccess;
+        };
+        readonly match: {
+            <Cases extends { [M in typeof OperationSuccess | typeof OperationFailure as M["Type"]["_tag"]]: (value: M["Type"]) => any; }>(value: OperationFailure | OperationSuccess, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+            <Cases extends { [M in typeof OperationSuccess | typeof OperationFailure as M["Type"]["_tag"]]: (value: M["Type"]) => any; }>(cases: Cases): (value: OperationFailure | OperationSuccess) => Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+        };
+    } & {
+        readonly tags: import("effect/Schema").Literals<["OperationSuccess", "OperationFailure"]>;
+        readonly generateGuards: <K extends string>(property: K) => {
+            readonly isOperationFailure: <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: OperationFailure; };
+            readonly isOperationSuccess: <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: OperationSuccess; };
+        } & {
+            readonly isAnyOf: <const Tags extends ReadonlyArray<"OperationFailure" | "OperationSuccess">>(tags: Tags) => <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: Extract<OperationFailure, {
+                readonly _tag: Tags[number];
+            }> | Extract<OperationSuccess, {
+                readonly _tag: Tags[number];
+            }>; };
+        };
+        readonly generateGuardsFor: <A>() => <K extends { [K_1 in keyof A & string]: A[K_1] extends OperationFailure | OperationSuccess ? K_1 : never; }[keyof A & string]>(property: K) => {
+            readonly isOperationFailure: (target: A) => target is A & { readonly [P in K]: OperationFailure; };
+            readonly isOperationSuccess: (target: A) => target is A & { readonly [P in K]: OperationSuccess; };
+        } & {
+            readonly isAnyOf: <const Tags extends ReadonlyArray<"OperationFailure" | "OperationSuccess">>(tags: Tags) => (target: A) => target is A & { readonly [P in K]: Extract<OperationFailure, {
+                readonly _tag: Tags[number];
+            }> | Extract<OperationSuccess, {
+                readonly _tag: Tags[number];
+            }>; };
+        };
     }>;
-    createdAt: S.withConstructorDefault<S.decodeTo<import("effect/Schema").Date, S.String, never, never> & S.WithoutConstructorDefault>;
-    updatedAt: S.withConstructorDefault<import("effect/Schema").NullOr<S.decodeTo<import("effect/Schema").Date, S.String, never, never> & {
-        withDefault: S.withConstructorDefault<S.decodeTo<import("effect/Schema").Date, S.String, never, never> & S.WithoutConstructorDefault>;
-    }> & S.WithoutConstructorDefault>;
-}>, {}>;
+    readonly createdAt: S.withConstructorDefault<S.DateFromString>;
+    readonly updatedAt: S.withConstructorDefault<import("effect/Schema").NullOr<S.DateFromString & {
+        withDefault: S.withConstructorDefault<S.DateFromString>;
+        withDecodingDefaultType: S.withDecodingDefaultType<S.DateFromString>;
+    }>>;
+}>, keyof S.Top>;
 export declare class Operation extends Operation_base {
 }
 export declare namespace OperationProgress {
-    interface Encoded extends S.Struct.Encoded<typeof OperationProgress["fields"]> {
+    interface Encoded extends S.StructNestedEncoded<typeof OperationProgress> {
     }
 }
 export declare namespace OperationSuccess {
-    interface Encoded extends S.Struct.Encoded<typeof OperationSuccess["fields"]> {
+    interface Encoded extends S.StructNestedEncoded<typeof OperationSuccess> {
     }
 }
 export declare namespace OperationFailure {
-    interface Encoded extends S.Struct.Encoded<typeof OperationFailure["fields"]> {
+    interface Encoded extends S.StructNestedEncoded<typeof OperationFailure> {
     }
 }
 export declare namespace Operation {
-    interface Encoded extends S.Struct.Encoded<typeof Operation["fields"]> {
+    interface Encoded extends S.StructNestedEncoded<typeof Operation> {
     }
 }
 export {};
-//# sourceMappingURL=Operations.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9ucy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL09wZXJhdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLENBQUMsTUFBTSxhQUFhLENBQUE7QUFFaEMsTUFBTSxNQUFNLFdBQVcsR0FBRyxDQUFDLENBQUMsUUFBUSxDQUFBO0FBQ3BDLGVBQU8sTUFBTSxXQUFXOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBQWEsQ0FBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVyQyxxQkFBYSxpQkFBa0IsU0FBUSxzQkFNcEM7Q0FBRzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVOLHFCQUFhLGdCQUNYLFNBQVEscUJBRUw7Q0FDSDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVGLHFCQUFhLGdCQUNYLFNBQVEscUJBRUw7Q0FDSDtBQUVGLGVBQU8sTUFBTSxlQUFlOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBQXNELENBQUE7QUFDbEYsTUFBTSxNQUFNLGVBQWUsR0FBRyxDQUFDLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLGVBQWUsQ0FBQyxDQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVuRSxxQkFBYSxTQUFVLFNBQVEsY0FPNUI7Q0FBRztBQUtOLHlCQUFpQixpQkFBaUIsQ0FBQyxDQUFDO0lBQ2xDLFVBQWlCLE9BQVEsU0FBUSxDQUFDLENBQUMsbUJBQW1CLENBQUMsT0FBTyxpQkFBaUIsQ0FBQztLQUFHO0NBQ3BGO0FBQ0QseUJBQWlCLGdCQUFnQixDQUFDLENBQUM7SUFDakMsVUFBaUIsT0FBUSxTQUFRLENBQUMsQ0FBQyxtQkFBbUIsQ0FBQyxPQUFPLGdCQUFnQixDQUFDO0tBQUc7Q0FDbkY7QUFDRCx5QkFBaUIsZ0JBQWdCLENBQUMsQ0FBQztJQUNqQyxVQUFpQixPQUFRLFNBQVEsQ0FBQyxDQUFDLG1CQUFtQixDQUFDLE9BQU8sZ0JBQWdCLENBQUM7S0FBRztDQUNuRjtBQUNELHlCQUFpQixTQUFTLENBQUMsQ0FBQztJQUMxQixVQUFpQixPQUFRLFNBQVEsQ0FBQyxDQUFDLG1CQUFtQixDQUFDLE9BQU8sU0FBUyxDQUFDO0tBQUc7Q0FDNUUifQ==

package/dist/Operations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Operations.d.ts","sourceRoot":"","sources":["../src/Operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,aAAa,CAAA;AAEhC,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,QAAQ,CAAA;AACpC,eAAO,MAAM,WAAW;;;;;;CAAa,CAAA;;;;;;;;;AAErC,qBAAa,iBAAkB,SAAQ,sBAMrC;CAAG;;;;;;AAEL,qBAAa,gBACX,SAAQ,qBAEN;CACF;;;;;;AAEF,qBAAa,gBACX,SAAQ,qBAEN;CACF;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;CAAoD,CAAA;AAChF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,eAAe,CAAC,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEnE,qBAAa,SAAU,SAAQ,cAO7B;CAAG;AAKL,yBAAiB,iBAAiB,CAAC;IACjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,iBAAiB,CAAC,QAAQ,CAAC,CAAC;KAAG;CACzF;AACD,yBAAiB,gBAAgB,CAAC;IAChC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,gBAAgB,CAAC,QAAQ,CAAC,CAAC;KAAG;CACxF;AACD,yBAAiB,gBAAgB,CAAC;IAChC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,gBAAgB,CAAC,QAAQ,CAAC,CAAC;KAAG;CACxF;AACD,yBAAiB,SAAS,CAAC;IACzB,UAAiB,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC,QAAQ,CAAC,CAAC;KAAG;CACjF"}
+{"version":3,"file":"Operations.d.ts","sourceRoot":"","sources":["../src/Operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,aAAa,CAAA;AAEhC,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,QAAQ,CAAA;AACpC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;CAAa,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAErC,qBAAa,iBAAkB,SAAQ,sBAMpC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEN,qBAAa,gBACX,SAAQ,qBAEL;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,qBAAa,gBACX,SAAQ,qBAEL;CACH;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAsD,CAAA;AAClF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,eAAe,CAAC,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEnE,qBAAa,SAAU,SAAQ,cAO5B;CAAG;AAKN,yBAAiB,iBAAiB,CAAC,CAAC;IAClC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,mBAAmB,CAAC,OAAO,iBAAiB,CAAC;KAAG;CACpF;AACD,yBAAiB,gBAAgB,CAAC,CAAC;IACjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,mBAAmB,CAAC,OAAO,gBAAgB,CAAC;KAAG;CACnF;AACD,yBAAiB,gBAAgB,CAAC,CAAC;IACjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,mBAAmB,CAAC,OAAO,gBAAgB,CAAC;KAAG;CACnF;AACD,yBAAiB,SAAS,CAAC,CAAC;IAC1B,UAAiB,OAAQ,SAAQ,CAAC,CAAC,mBAAmB,CAAC,OAAO,SAAS,CAAC;KAAG;CAC5E"}

package/dist/Operations.js

@@ -1,29 +1,29 @@
 import * as S from "./Schema.js";
 export const OperationId = S.StringId;
-export class OperationProgress extends S.ExtendedClass("OperationProgress")({
+export class OperationProgress extends S.Opaque()(S.Struct({
     completed: S.NonNegativeInt,
     total: S.NonNegativeInt
-}) {
+})) {
 }
-export class OperationSuccess extends S.ExtendedTaggedClass()("OperationSuccess", {
+export class OperationSuccess extends S.Opaque()(S.TaggedStruct("OperationSuccess", {
     message: S.NullOr(S.NonEmptyString2k).withDefault
-}) {
+})) {
 }
-export class OperationFailure extends S.ExtendedTaggedClass()("OperationFailure", {
+export class OperationFailure extends S.Opaque()(S.TaggedStruct("OperationFailure", {
     message: S.NullOr(S.NonEmptyString2k).withDefault
-}) {
+})) {
 }
-export const OperationResult = S.TaggedUnion(OperationSuccess, OperationFailure);
-export class Operation extends S.ExtendedClass("Operation")({
+export const OperationResult = S.TaggedUnion([OperationSuccess, OperationFailure]);
+export class Operation extends S.Opaque()(S.Struct({
     id: OperationId,
     title: S.NonEmptyString2k,
     progress: S.optional(OperationProgress),
     result: S.optional(OperationResult),
     createdAt: S.Date.withDefault,
     updatedAt: S.NullOr(S.Date).withDefault
-}) {
+})) {
 }
 /* eslint-enable */
 //
 // codegen:end
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9PcGVyYXRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxDQUFDLE1BQU0sYUFBYSxDQUFBO0FBR2hDLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRyxDQUFDLENBQUMsUUFBUSxDQUFBO0FBRXJDLE1BQU0sT0FBTyxpQkFBa0IsU0FBUSxDQUFDLENBQUMsYUFBYSxDQUdwRCxtQkFBbUIsQ0FBQyxDQUFDO0lBQ3JCLFNBQVMsRUFBRSxDQUFDLENBQUMsY0FBYztJQUMzQixLQUFLLEVBQUUsQ0FBQyxDQUFDLGNBQWM7Q0FDeEIsQ0FBQztDQUFHO0FBRUwsTUFBTSxPQUFPLGdCQUNYLFNBQVEsQ0FBQyxDQUFDLG1CQUFtQixFQUE4QyxDQUFDLGtCQUFrQixFQUFFO0lBQzlGLE9BQU8sRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLFdBQVc7Q0FDbEQsQ0FBQztDQUNGO0FBRUYsTUFBTSxPQUFPLGdCQUNYLFNBQVEsQ0FBQyxDQUFDLG1CQUFtQixFQUE4QyxDQUFDLGtCQUFrQixFQUFFO0lBQzlGLE9BQU8sRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLFdBQVc7Q0FDbEQsQ0FBQztDQUNGO0FBRUYsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLENBQUMsQ0FBQyxXQUFXLENBQUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQTtBQUdoRixNQUFNLE9BQU8sU0FBVSxTQUFRLENBQUMsQ0FBQyxhQUFhLENBQStCLFdBQVcsQ0FBQyxDQUFDO0lBQ3hGLEVBQUUsRUFBRSxXQUFXO0lBQ2YsS0FBSyxFQUFFLENBQUMsQ0FBQyxnQkFBZ0I7SUFDekIsUUFBUSxFQUFFLENBQUMsQ0FBQyxRQUFRLENBQUMsaUJBQWlCLENBQUM7SUFDdkMsTUFBTSxFQUFFLENBQUMsQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFDO0lBQ25DLFNBQVMsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLFdBQVc7SUFDN0IsU0FBUyxFQUFFLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLFdBQVc7Q0FDeEMsQ0FBQztDQUFHO0FBaUJMLG1CQUFtQjtBQUNuQixFQUFFO0FBQ0YsY0FBYyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9PcGVyYXRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxDQUFDLE1BQU0sYUFBYSxDQUFBO0FBR2hDLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRyxDQUFDLENBQUMsUUFBUSxDQUFBO0FBRXJDLE1BQU0sT0FBTyxpQkFBa0IsU0FBUSxDQUFDLENBQUMsTUFBTSxFQUc1QyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUM7SUFDWCxTQUFTLEVBQUUsQ0FBQyxDQUFDLGNBQWM7SUFDM0IsS0FBSyxFQUFFLENBQUMsQ0FBQyxjQUFjO0NBQ3hCLENBQUMsQ0FBQztDQUFHO0FBRU4sTUFBTSxPQUFPLGdCQUNYLFNBQVEsQ0FBQyxDQUFDLE1BQU0sRUFBOEMsQ0FBQyxDQUFDLENBQUMsWUFBWSxDQUFDLGtCQUFrQixFQUFFO0lBQ2hHLE9BQU8sRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLFdBQVc7Q0FDbEQsQ0FBQyxDQUFDO0NBQ0g7QUFFRixNQUFNLE9BQU8sZ0JBQ1gsU0FBUSxDQUFDLENBQUMsTUFBTSxFQUE4QyxDQUFDLENBQUMsQ0FBQyxZQUFZLENBQUMsa0JBQWtCLEVBQUU7SUFDaEcsT0FBTyxFQUFFLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLGdCQUFnQixDQUFDLENBQUMsV0FBVztDQUNsRCxDQUFDLENBQUM7Q0FDSDtBQUVGLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxDQUFDLENBQUMsV0FBVyxDQUFDLENBQUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyxDQUFBO0FBR2xGLE1BQU0sT0FBTyxTQUFVLFNBQVEsQ0FBQyxDQUFDLE1BQU0sRUFBZ0MsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDO0lBQy9FLEVBQUUsRUFBRSxXQUFXO0lBQ2YsS0FBSyxFQUFFLENBQUMsQ0FBQyxnQkFBZ0I7SUFDekIsUUFBUSxFQUFFLENBQUMsQ0FBQyxRQUFRLENBQUMsaUJBQWlCLENBQUM7SUFDdkMsTUFBTSxFQUFFLENBQUMsQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFDO0lBQ25DLFNBQVMsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLFdBQVc7SUFDN0IsU0FBUyxFQUFFLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLFdBQVc7Q0FDeEMsQ0FBQyxDQUFDO0NBQUc7QUFpQk4sbUJBQW1CO0FBQ25CLEVBQUU7QUFDRixjQUFjIn0=

package/dist/Option.d.ts

@@ -23,4 +23,4 @@ export declare class PartialException {
  * Simulates a partial function
  */
 export declare function partial<ARGS extends any[], A>(f: (miss: <X>() => X) => (...args: ARGS) => A): (...args: ARGS) => Option.Option<A>;
-//# sourceMappingURL=Option.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3B0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvT3B0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sRUFBMkIsS0FBSyxJQUFJLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFDbEUsT0FBTyxLQUFLLE1BQU0sTUFBTSxlQUFlLENBQUE7QUFFdkMsY0FBYyxlQUFlLENBQUE7QUFFN0IsZUFBTyxNQUFNLGNBQWMsOENBQVEsQ0FBQTtBQUVuQyx3QkFBZ0Isa0JBQWtCLENBQUMsQ0FBQyxFQUFFLEVBQUUsRUFBRSxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxHQUFHLFNBQVMsNEJBRXJFO0FBRUQsZUFBTyxNQUFNLE1BQU0sMkNBR2pCLENBQUE7QUFFRixlQUFPLE1BQU0sUUFBUSxNQUFPLE9BQU8seUNBQTRDLENBQUE7QUFFL0U7O0dBRUc7QUFDSCx3QkFBZ0IsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLFNBQVMsWUFBWSxDQUFDLENBQUMsRUFBRSxNQUFNLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQ2hFLENBQUMsRUFBRSxDQUFDLEdBQ0gsQ0FBQyxDQUFDLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsS0FBSyxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFBO0FBQ25ELHdCQUFnQixDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsU0FBUyxNQUFNLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEtBQUssTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQTtBQU8zRixNQUFNLE1BQU0sRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEtBQUssQ0FBQTtBQUN2RCxLQUFLLFlBQVksQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJO0tBQ3ZCLENBQUMsSUFBSSxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsR0FBRyxLQUFLO0NBQzNDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQTtBQUVWLGVBQU8sTUFBTSxzQkFBc0IsZUFBVyxDQUFBO0FBQzlDLE1BQU0sTUFBTSxzQkFBc0IsR0FBRyxPQUFPLHNCQUFzQixDQUFBO0FBRWxFLHFCQUFhLGdCQUFnQjtJQUMzQixRQUFRLENBQUMsT0FBTyxFQUFFLHNCQUFzQixDQUF5QjtDQUNsRTtBQU1EOztHQUVHO0FBQ0gsd0JBQWdCLE9BQU8sQ0FBQyxJQUFJLFNBQVMsR0FBRyxFQUFFLEVBQUUsQ0FBQyxFQUMzQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsR0FBRyxJQUFJLEVBQUUsSUFBSSxLQUFLLENBQUMsR0FDNUMsQ0FBQyxHQUFHLElBQUksRUFBRSxJQUFJLEtBQUssTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FXckMifQ==

package/dist/Option.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Option.d.ts","sourceRoot":"","sources":["../src/Option.ts"],"names":[],"mappings":"AAIA,OAAO,EAA2B,KAAK,IAAI,EAAE,MAAM,eAAe,CAAA;AAClE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,cAAc,eAAe,CAAA;AAE7B,eAAO,MAAM,cAAc,8CAAQ,CAAA;AAEnC,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,4BAErE;AAED,eAAO,MAAM,MAAM,2CAGjB,CAAA;AAEF,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,yCAA4C,CAAA;AAE/E;;GAEG;AACH,wBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,YAAY,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAChE,CAAC,EAAE,CAAC,GACH,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AACnD,wBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AAO3F,MAAM,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AACvD,KAAK,YAAY,CAAC,CAAC,EAAE,CAAC,IAAI;KACvB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK;CAC3C,CAAC,MAAM,CAAC,CAAC,CAAA;AAEV,eAAO,MAAM,sBAAsB,eAAW,CAAA;AAC9C,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAA;AAElE,qBAAa,gBAAgB;IAC3B,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAyB;CAClE;AAMD;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,SAAS,GAAG,EAAE,EAAE,CAAC,EAC3C,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,CAAC,GAC5C,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAWrC"}
+{"version":3,"file":"Option.d.ts","sourceRoot":"","sources":["../src/Option.ts"],"names":[],"mappings":"AAIA,OAAO,EAA2B,KAAK,IAAI,EAAE,MAAM,eAAe,CAAA;AAClE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,cAAc,eAAe,CAAA;AAE7B,eAAO,MAAM,cAAc,8CAAQ,CAAA;AAEnC,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,4BAErE;AAED,eAAO,MAAM,MAAM,2CAGjB,CAAA;AAEF,eAAO,MAAM,QAAQ,MAAO,OAAO,yCAA4C,CAAA;AAE/E;;GAEG;AACH,wBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,YAAY,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAChE,CAAC,EAAE,CAAC,GACH,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AACnD,wBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AAO3F,MAAM,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AACvD,KAAK,YAAY,CAAC,CAAC,EAAE,CAAC,IAAI;KACvB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK;CAC3C,CAAC,MAAM,CAAC,CAAC,CAAA;AAEV,eAAO,MAAM,sBAAsB,eAAW,CAAA;AAC9C,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAA;AAElE,qBAAa,gBAAgB;IAC3B,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAyB;CAClE;AAMD;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,SAAS,GAAG,EAAE,EAAE,CAAC,EAC3C,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,CAAC,GAC5C,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAWrC"}

package/dist/Pure.d.ts

@@ -1,5 +1,5 @@
 import { Chunk, Effect, Result } from "effect";
-import * as ServiceMap from "./ServiceMap.js";
+import * as Context from "./Context.js";
 declare const S1: unique symbol;
 declare const S2: unique symbol;
 declare const W: unique symbol;
@@ -32,9 +32,9 @@ export declare function unifyPureEnv<X extends PureEnv<any, any, any>>(self: X):
 }] ? S2 : never>;
 export type Pure<W, S, S2, R, E, A> = Effect.Effect<A, E, PureEnvEnv<W, S, S2> | R>;
 export declare function GMUA_<W, S, S2, GR, GE, GA, MR, ME, MA, UR, UE, UA>(get: Pure<W, S, S2, GR, GE, GA>, modify: (i: GA) => Pure<W, S, S2, MR, ME, readonly [GA, MA]>, update: (i: GA) => Pure<W, S, S2, UR, UE, UA>): Pure<W, S, S2, GR | MR | UR, GE | ME | UE, MA>;
-export declare function GMUA<W, S, S2, GA, MR, ME, MA>(modify: (i: GA) => Pure<W, S, S2, MR, ME, readonly [GA, MA]>): <GR, GE, UR, UE, UA>(get: Pure<W, S, S2, GR, GE, GA>, update: (i: GA) => Pure<W, S, S2, UR, UE, UA>) => Pure<W, S, S2, MR | GR | UR, ME | GE | UE, MA>;
+export declare function GMUA<W, S, S2, GA, MR, ME, MA>(modify: (i: GA) => Pure<W, S, S2, MR, ME, readonly [GA, MA]>): <GR, GE, UR, UE, UA>(get: Pure<W, S, S2, GR, GE, GA>, update: (i: GA) => Pure<W, S, S2, UR, UE, UA>) => Pure<W, S, S2, GR | MR | UR, GE | ME | UE, MA>;
 export declare function GMU_<W, S, S2, GR, GE, GA, MR, ME, UR, UE, UA>(get: Pure<W, S, S2, GR, GE, GA>, modify: (i: GA) => Pure<W, S, S2, MR, ME, GA>, update: (i: GA) => Pure<W, S, S2, UR, UE, UA>): Pure<W, S, S2, GR | MR | UR, GE | ME | UE, UA>;
-export declare function GMU<W, S, S2, GA, MR, ME>(modify: (i: GA) => Pure<W, S, S2, MR, ME, GA>): <GR, GE, UR, UE, UA>(get: Pure<W, S, S2, GR, GE, GA>, update: (i: GA) => Pure<W, S, S2, UR, UE, UA>) => Pure<W, S, S2, MR | GR | UR, ME | GE | UE, UA>;
+export declare function GMU<W, S, S2, GA, MR, ME>(modify: (i: GA) => Pure<W, S, S2, MR, ME, GA>): <GR, GE, UR, UE, UA>(get: Pure<W, S, S2, GR, GE, GA>, update: (i: GA) => Pure<W, S, S2, UR, UE, UA>) => Pure<W, S, S2, GR | MR | UR, GE | ME | UE, UA>;
 export declare const ServiceTag: unique symbol;
 export type ServiceTag = typeof ServiceTag;
 export declare abstract class PhantomTypeParameter<Identifier extends keyof any, InstantiatedType> {
@@ -42,7 +42,7 @@ export declare abstract class PhantomTypeParameter<Identifier extends keyof any,
         readonly [NameP in Identifier]: (_: InstantiatedType) => InstantiatedType;
     };
 }
-export type ServiceShape<T extends ServiceMap.ServiceClass.Shape<any, any>> = Omit<T, keyof ServiceMap.ServiceClass.Shape<any, any>>;
+export type ServiceShape<T extends Context.ServiceClass.Shape<any, any>> = Omit<T, keyof Context.ServiceClass.Shape<any, any>>;
 export declare abstract class ServiceTagged<ServiceKey> extends PhantomTypeParameter<string, ServiceKey> {
 }
 export declare function makeService<T extends ServiceTagged<any>>(_: Omit<T, ServiceTag>): T;
@@ -80,4 +80,4 @@ export declare function updateWith<S2, S3>(upd: (s: S2) => S3): Effect.Effect<S3
 export declare function updateWithEffect<W, R, E, S2, S3>(upd: (s: S2, log: (evt: W) => PureLogT<W>) => Effect.Effect<S3, E, FixEnv<R, W, S2, S3>>): Effect.Effect<S3, E, FixEnv<R, W, S2, S3>>;
 export type FixEnv<R, W, S, S2> = Exclude<R, PureEnvEnv<any, any, any>> | PureEnvEnv<W, S, S2>;
 export {};
-//# sourceMappingURL=Pure.d.ts.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Pure.d.ts","sourceRoot":"","sources":["../src/Pure.ts"],"names":[],"mappings":"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"}