effect-app 4.0.0-beta.21 → 4.0.0-beta.210

package/dist/Schema/Class.js

@@ -1,28 +1,195 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { pipe, Struct as Struct2 } from "effect";
+import { Effect, Option, Schema, SchemaAST, SchemaIssue } from "effect";
 import * as S from "effect/Schema";
-export const Class = (identifier) => (fields, annotations) => {
-    const cls = S.Class;
-    return class extends cls(identifier)(fields, annotations) {
-        constructor(a, b = true) {
-            super(a, b);
-        }
-        // static readonly include = include(fields)
-        static pick = (...selection) => pipe(this["fields"], Struct2.pick(selection));
-        static omit = (...selection) => pipe(this["fields"], Struct2.omit(selection));
+import { copyOrigin } from "../utils.js";
+import { concurrencyUnbounded } from "./ext.js";
+import * as SchemaParser from "./SchemaParser.js";
+/**
+ * Build a modified Declaration that accepts struct-matching values during
+ * encoding, given the original Declaration and the class's fields.
+ */
+function makeRelaxedDeclaration(ast, fields, cls) {
+    const parseOptions = ast.annotations?.["parseOptions"];
+    const structSchema = Schema.Struct(fields);
+    const annotatedStruct = parseOptions ? S.toType(structSchema).annotate({ parseOptions }) : S.toType(structSchema);
+    const decodeStruct = SchemaParser.decodeUnknownEffect(annotatedStruct);
+    return new SchemaAST.Declaration(ast.typeParameters, () => (input, self, options) => {
+        if (input instanceof cls) {
+            return Effect.succeed(input);
+        }
+        if (input !== null && typeof input === "object") {
+            return decodeStruct(input, options);
+        }
+        return Effect.fail(new SchemaIssue.InvalidType(self, Option.some(input)));
+    }, ast.annotations, ast.checks, ast.encoding, ast.context);
+}
+// ---------------------------------------------------------------------------
+// Class — like Schema.Class but with relaxed encoding
+// ---------------------------------------------------------------------------
+/**
+ * Like `Schema.Class`, but the resulting class accepts plain objects matching
+ * the struct schema during encoding — not only `instanceof` or type-id
+ * checks.
+ *
+ * @example
+ * ```ts
+ * import { Schema } from "effect"
+ * import { Class } from "./Class.js"
+ *
+ * class A extends Class<A>("A")({ a: Schema.String }) {}
+ *
+ * // Construction works as normal:
+ * new A({ a: "hello" })
+ *
+ * // Encoding accepts plain objects:
+ * Schema.encodeUnknownSync(A)({ a: "hello" }) // { a: "hello" }
+ * ```
+ */
+export const Class = (identifier) => (fields, annotations, options) => {
+    const relaxed = options?.strict === false;
+    // Build the original Schema.Class
+    const Base = S.Class(identifier)(fields, { ...concurrencyUnbounded, ...annotations });
+    // Get the original ast getter from the base class
+    const originalAstDescriptor = Object.getOwnPropertyDescriptor(Base, "ast");
+    // Cache per-class to avoid recomputing
+    const astCache = new WeakMap();
+    const copyCache = new WeakMap();
+    return class extends Base {
+        static get copy() {
+            let cached = copyCache.get(this);
+            if (cached === undefined) {
+                cached = copyOrigin(this);
+                copyCache.set(this, cached);
+            }
+            return cached;
+        }
+        static get ast() {
+            let cached = astCache.get(this);
+            if (cached !== undefined)
+                return cached;
+            // Call the original getter with `this` bound to the actual user class,
+            // so getClassSchema(this) creates a schema that uses `new this(...)`.
+            const originalAst = originalAstDescriptor.get.call(this);
+            cached = relaxed ? makeRelaxedDeclaration(originalAst, Base.fields, this) : originalAst;
+            astCache.set(this, cached);
+            return cached;
+        }
+        static mapFields(f, options) {
+            return Base.mapFields(f, options).annotate(concurrencyUnbounded);
+        }
+    };
+};
+// ---------------------------------------------------------------------------
+// TaggedClass — like Schema.TaggedClass but with relaxed encoding
+// ---------------------------------------------------------------------------
+/**
+ * Like `Schema.TaggedClass`, but the resulting class accepts plain objects
+ * matching the struct schema during encoding.
+ *
+ * @example
+ * ```ts
+ * import { Schema } from "effect"
+ * import { TaggedClass } from "./Class.js"
+ *
+ * class Circle extends TaggedClass<Circle>()("Circle", {
+ *   radius: Schema.Number
+ * }) {}
+ *
+ * Schema.encodeUnknownSync(Circle)({ _tag: "Circle", radius: 5 })
+ * ```
+ */
+export const TaggedClass = (identifier) => (tag, fields, annotations, options) => {
+    const relaxed = options?.strict === false;
+    const Base = S.TaggedClass(identifier)(tag, fields, { ...concurrencyUnbounded, ...annotations });
+    const originalAstDescriptor = Object.getOwnPropertyDescriptor(Base, "ast");
+    const astCache = new WeakMap();
+    const copyCache = new WeakMap();
+    return class extends Base {
+        static get copy() {
+            let cached = copyCache.get(this);
+            if (cached === undefined) {
+                cached = copyOrigin(this);
+                copyCache.set(this, cached);
+            }
+            return cached;
+        }
+        static get ast() {
+            let cached = astCache.get(this);
+            if (cached !== undefined)
+                return cached;
+            const originalAst = originalAstDescriptor.get.call(this);
+            cached = relaxed ? makeRelaxedDeclaration(originalAst, Base.fields, this) : originalAst;
+            astCache.set(this, cached);
+            return cached;
+        }
+        static mapFields(f, options) {
+            return Base.mapFields(f, options).annotate(concurrencyUnbounded);
+        }
     };
 };
-export const TaggedClass = (identifier) => (tag, fields, annotations) => {
-    const cls = S.TaggedClass;
-    return class extends cls(identifier)(tag, fields, annotations) {
-        constructor(a, b = true) {
-            super(a, b);
-        }
-        // static readonly include = include(fields)
-        static pick = (...selection) => pipe(this["fields"], Struct2.pick(selection));
-        static omit = (...selection) => pipe(this["fields"], Struct2.omit(selection));
+// ---------------------------------------------------------------------------
+// ErrorClass — like Schema.ErrorClass but with relaxed encoding
+// ---------------------------------------------------------------------------
+export const ErrorClass = (identifier) => (fields, annotations, options) => {
+    const relaxed = options?.strict === false;
+    const Base = S.ErrorClass(identifier)(fields, { ...concurrencyUnbounded, ...annotations });
+    const originalAstDescriptor = Object.getOwnPropertyDescriptor(Base, "ast");
+    const astCache = new WeakMap();
+    const copyCache = new WeakMap();
+    return class extends Base {
+        static get copy() {
+            let cached = copyCache.get(this);
+            if (cached === undefined) {
+                cached = copyOrigin(this);
+                copyCache.set(this, cached);
+            }
+            return cached;
+        }
+        static get ast() {
+            let cached = astCache.get(this);
+            if (cached !== undefined)
+                return cached;
+            const originalAst = originalAstDescriptor.get.call(this);
+            cached = relaxed ? makeRelaxedDeclaration(originalAst, Base.fields, this) : originalAst;
+            astCache.set(this, cached);
+            return cached;
+        }
+        static mapFields(f, options) {
+            return Base.mapFields(f, options).annotate(concurrencyUnbounded);
+        }
+    };
+};
+// ---------------------------------------------------------------------------
+// TaggedErrorClass — like Schema.TaggedErrorClass but with relaxed encoding
+// ---------------------------------------------------------------------------
+export const TaggedErrorClass = (identifier) => (tag, fields, annotations, options) => {
+    const relaxed = options?.strict === false;
+    const Base = S.TaggedErrorClass(identifier)(tag, fields, { ...concurrencyUnbounded, ...annotations });
+    const originalAstDescriptor = Object.getOwnPropertyDescriptor(Base, "ast");
+    const astCache = new WeakMap();
+    const copyCache = new WeakMap();
+    return class extends Base {
+        static get copy() {
+            let cached = copyCache.get(this);
+            if (cached === undefined) {
+                cached = copyOrigin(this);
+                copyCache.set(this, cached);
+            }
+            return cached;
+        }
+        static get ast() {
+            let cached = astCache.get(this);
+            if (cached !== undefined)
+                return cached;
+            const originalAst = originalAstDescriptor.get.call(this);
+            cached = relaxed ? makeRelaxedDeclaration(originalAst, Base.fields, this) : originalAst;
+            astCache.set(this, cached);
+            return cached;
+        }
+        static mapFields(f, options) {
+            return Base.mapFields(f, options).annotate(concurrencyUnbounded);
+        }
     };
 };
-export const ExtendedClass = Class;
-export const ExtendedTaggedClass = TaggedClass;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2xhc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvU2NoZW1hL0NsYXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHVEQUF1RDtBQUN2RCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sSUFBSSxPQUFPLEVBQUUsTUFBTSxRQUFRLENBQUE7QUFFaEQsT0FBTyxLQUFLLENBQUMsTUFBTSxlQUFlLENBQUE7QUF5QmxDLE1BQU0sQ0FBQyxNQUFNLEtBQUssR0FRWixDQUFDLFVBQVUsRUFBRSxFQUFFLENBQUMsQ0FBQyxNQUFNLEVBQUUsV0FBVyxFQUFFLEVBQUU7SUFDMUMsTUFBTSxHQUFHLEdBQUcsQ0FBQyxDQUFDLEtBQVksQ0FBQTtJQUMxQixPQUFPLEtBQU0sU0FBUSxHQUFHLENBQUMsVUFBVSxDQUFDLENBQUMsTUFBTSxFQUFFLFdBQVcsQ0FBQztRQUN2RCxZQUFZLENBQU0sRUFBRSxDQUFDLEdBQUcsSUFBSTtZQUMxQixLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFBO1FBQ2IsQ0FBQztRQUNELDRDQUE0QztRQUM1QyxNQUFNLENBQVUsSUFBSSxHQUFHLENBQUMsR0FBRyxTQUFnQixFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQTtRQUM3RixNQUFNLENBQVUsSUFBSSxHQUFHLENBQUMsR0FBRyxTQUFnQixFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQTtLQUN2RixDQUFBO0FBQ1YsQ0FBQyxDQUFBO0FBRUgsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQVNsQixDQUFDLFVBQVUsRUFBRSxFQUFFLENBQUMsQ0FBQyxHQUFHLEVBQUUsTUFBTSxFQUFFLFdBQVcsRUFBRSxFQUFFO0lBQy9DLE1BQU0sR0FBRyxHQUFHLENBQUMsQ0FBQyxXQUFrQixDQUFBO0lBQ2hDLE9BQU8sS0FBTSxTQUFRLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQyxHQUFHLEVBQUUsTUFBTSxFQUFFLFdBQVcsQ0FBQztRQUM1RCxZQUFZLENBQU0sRUFBRSxDQUFDLEdBQUcsSUFBSTtZQUMxQixLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFBO1FBQ2IsQ0FBQztRQUNELDRDQUE0QztRQUM1QyxNQUFNLENBQVUsSUFBSSxHQUFHLENBQUMsR0FBRyxTQUFnQixFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQTtRQUM3RixNQUFNLENBQVUsSUFBSSxHQUFHLENBQUMsR0FBRyxTQUFnQixFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQTtLQUN2RixDQUFBO0FBQ1YsQ0FBQyxDQUFBO0FBRUgsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQU90QixLQUFZLENBQUE7QUFhaEIsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBVzVCLFdBQWtCLENBQUEifQ==
+export const Opaque = S.Opaque;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Class.js","sourceRoot":"","sources":["../../src/Schema/Class.ts"],"names":[],"mappings":"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"}

package/dist/Schema/FastCheck.d.ts

@@ -7,4 +7,4 @@ export declare const ALPHABET_UC: string;
 export declare const UC_alphabet: (min: number, max: number) => (fc: FC) => fc.Arbitrary<string>;
 export declare const LC_alphabet: (min: number, max: number) => (fc: Pick<FC, "array" | "integer">) => fc.Arbitrary<string>;
 export declare const Numbers: (min: number, max: number) => (fc: Pick<FC, "array" | "integer">) => fc.Arbitrary<string>;
-//# sourceMappingURL=FastCheck.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRmFzdENoZWNrLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvU2NoZW1hL0Zhc3RDaGVjay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssS0FBSyxFQUFFLE1BQU0sWUFBWSxDQUFBO0FBRXJDLFlBQVksRUFBRSxTQUFTLEVBQUUsTUFBTSxZQUFZLENBQUE7QUFDM0MsS0FBSyxFQUFFLEdBQUcsT0FBTyxFQUFFLENBQUE7QUFFbkIsWUFBWSxFQUFFLEVBQUUsRUFBRSxDQUFBO0FBRWxCLGVBQU8sTUFBTSxRQUFRLCtCQUErQixDQUFBO0FBQ3BELGVBQU8sTUFBTSxXQUFXLFFBQXlCLENBQUE7QUFJakQsZUFBTyxNQUFNLFdBQVcsUUFBUyxNQUFNLE9BQU8sTUFBTSxVQUFVLEVBQUUseUJBQ3NCLENBQUE7QUFHdEYsZUFBTyxNQUFNLFdBQVcsUUFBUyxNQUFNLE9BQU8sTUFBTSxVQUFVLElBQUksQ0FBQyxFQUFFLEVBQUUsT0FBTyxHQUFHLFNBQVMsQ0FBQyx5QkFDTCxDQUFBO0FBSXRGLGVBQU8sTUFBTSxPQUFPLFFBQVMsTUFBTSxPQUFPLE1BQU0sVUFBVSxJQUFJLENBQUMsRUFBRSxFQUFFLE9BQU8sR0FBRyxTQUFTLENBQUMseUJBQ0YsQ0FBQSJ9

package/dist/Schema/FastCheck.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FastCheck.d.ts","sourceRoot":"","sources":["../../src/Schema/FastCheck.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAA;AAErC,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC3C,KAAK,EAAE,GAAG,OAAO,EAAE,CAAA;AAEnB,YAAY,EAAE,EAAE,EAAE,CAAA;AAElB,eAAO,MAAM,QAAQ,+BAA+B,CAAA;AACpD,eAAO,MAAM,WAAW,QAAyB,CAAA;AAIjD,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,KAAK,MAAM,MAAM,IAAI,EAAE,yBACsB,CAAA;AAGtF,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,EAAE,EAAE,OAAO,GAAG,SAAS,CAAC,yBACL,CAAA;AAItF,eAAO,MAAM,OAAO,GAAI,KAAK,MAAM,EAAE,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,EAAE,EAAE,OAAO,GAAG,SAAS,CAAC,yBACF,CAAA"}
+{"version":3,"file":"FastCheck.d.ts","sourceRoot":"","sources":["../../src/Schema/FastCheck.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAA;AAErC,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC3C,KAAK,EAAE,GAAG,OAAO,EAAE,CAAA;AAEnB,YAAY,EAAE,EAAE,EAAE,CAAA;AAElB,eAAO,MAAM,QAAQ,+BAA+B,CAAA;AACpD,eAAO,MAAM,WAAW,QAAyB,CAAA;AAIjD,eAAO,MAAM,WAAW,QAAS,MAAM,OAAO,MAAM,UAAU,EAAE,yBACsB,CAAA;AAGtF,eAAO,MAAM,WAAW,QAAS,MAAM,OAAO,MAAM,UAAU,IAAI,CAAC,EAAE,EAAE,OAAO,GAAG,SAAS,CAAC,yBACL,CAAA;AAItF,eAAO,MAAM,OAAO,QAAS,MAAM,OAAO,MAAM,UAAU,IAAI,CAAC,EAAE,EAAE,OAAO,GAAG,SAAS,CAAC,yBACF,CAAA"}

package/dist/Schema/Methods.d.ts

@@ -3,4 +3,4 @@ export type WriteMethods = "POST" | "PUT" | "PATCH" | "DELETE";
 export type Rest = ReadMethods | WriteMethods;
 export type System = "OPTIONS" | "HEAD" | "TRACE";
 export type All = Rest | System;
-//# sourceMappingURL=Methods.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWV0aG9kcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL1NjaGVtYS9NZXRob2RzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sTUFBTSxXQUFXLEdBQUcsS0FBSyxDQUFBO0FBQy9CLE1BQU0sTUFBTSxZQUFZLEdBQUcsTUFBTSxHQUFHLEtBQUssR0FBRyxPQUFPLEdBQUcsUUFBUSxDQUFBO0FBRTlELE1BQU0sTUFBTSxJQUFJLEdBQUcsV0FBVyxHQUFHLFlBQVksQ0FBQTtBQUU3QyxNQUFNLE1BQU0sTUFBTSxHQUFHLFNBQVMsR0FBRyxNQUFNLEdBQUcsT0FBTyxDQUFBO0FBRWpELE1BQU0sTUFBTSxHQUFHLEdBQUcsSUFBSSxHQUFHLE1BQU0sQ0FBQSJ9

package/dist/Schema/SchemaParser.d.ts

@@ -0,0 +1,5 @@
+import * as SchemaParser from "effect/SchemaParser";
+export * from "effect/SchemaParser";
+export declare const decodeEffectConcurrently: typeof SchemaParser.decodeEffect;
+export declare const decodeUnknownEffectConcurrently: typeof SchemaParser.decodeUnknownEffect;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2NoZW1hUGFyc2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvU2NoZW1hL1NjaGVtYVBhcnNlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssWUFBWSxNQUFNLHFCQUFxQixDQUFBO0FBR25ELGNBQWMscUJBQXFCLENBQUE7QUFFbkMsZUFBTyxNQUFNLHdCQUF3QixFQUFFLE9BQU8sWUFBWSxDQUFDLFlBRTFELENBQUE7QUFFRCxlQUFPLE1BQU0sK0JBQStCLEVBQUUsT0FBTyxZQUFZLENBQUMsbUJBRWpFLENBQUEifQ==

package/dist/Schema/SchemaParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaParser.d.ts","sourceRoot":"","sources":["../../src/Schema/SchemaParser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,qBAAqB,CAAA;AAGnD,cAAc,qBAAqB,CAAA;AAEnC,eAAO,MAAM,wBAAwB,EAAE,OAAO,YAAY,CAAC,YAE1D,CAAA;AAED,eAAO,MAAM,+BAA+B,EAAE,OAAO,YAAY,CAAC,mBAEjE,CAAA"}

package/dist/Schema/SchemaParser.js

@@ -0,0 +1,6 @@
+import * as SchemaParser from "effect/SchemaParser";
+import { withDefaultParseOptions } from "./ext.js";
+export * from "effect/SchemaParser";
+export const decodeEffectConcurrently = withDefaultParseOptions(SchemaParser.decodeEffect);
+export const decodeUnknownEffectConcurrently = withDefaultParseOptions(SchemaParser.decodeUnknownEffect);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2NoZW1hUGFyc2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL1NjaGVtYS9TY2hlbWFQYXJzZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLFlBQVksTUFBTSxxQkFBcUIsQ0FBQTtBQUNuRCxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxVQUFVLENBQUE7QUFFbEQsY0FBYyxxQkFBcUIsQ0FBQTtBQUVuQyxNQUFNLENBQUMsTUFBTSx3QkFBd0IsR0FBcUMsdUJBQXVCLENBQy9GLFlBQVksQ0FBQyxZQUFZLENBQzFCLENBQUE7QUFFRCxNQUFNLENBQUMsTUFBTSwrQkFBK0IsR0FBNEMsdUJBQXVCLENBQzdHLFlBQVksQ0FBQyxtQkFBbUIsQ0FDakMsQ0FBQSJ9

package/dist/Schema/SpecialJsonSchema.d.ts

@@ -0,0 +1,33 @@
+/**
+ * SpecialJsonSchema — A variant of Schema.toJsonSchemaDocument that
+ * post-processes the output (e.g. flattens simple allOf).
+ */
+import { type JsonSchema, type Schema } from "effect";
+/**
+ * Converts a schema to a JSON Schema Document (draft-2020-12), with
+ * post-processing that flattens simple allOf entries.
+ */
+export declare function specialJsonSchemaDocument(schema: Schema.Top, options?: Schema.ToJsonSchemaOptions): JsonSchema.Document<"draft-2020-12">;
+/**
+ * Flattens `allOf` entries into the parent when the parent already has a
+ * `type` and every `allOf` entry is a plain constraint object (no `$ref`,
+ * no `type`). Merged properties from `allOf` entries win on conflict.
+ */
+export declare function flattenSimpleAllOf(obj: unknown): unknown;
+/**
+ * Recursively removes `additionalProperties: false` from JSON Schema objects.
+ * Only removes when the value is exactly `false` -- other values are left intact.
+ */
+export declare function removeAdditionalPropertiesFalse(obj: unknown): unknown;
+/**
+ * Flattens nested `anyOf` entries: if an anyOf entry is itself just `{ anyOf: [...] }`
+ * with no other keys, its children are inlined. If only one item remains, the anyOf
+ * wrapper is removed entirely.
+ */
+export declare function flattenNestedAnyOf(obj: unknown): unknown;
+/**
+ * Applies JSON Schema post-processing: flattens simple allOf,
+ * flattens nested anyOf, then strips additionalProperties: false.
+ */
+export declare function postProcessJsonSchema(obj: JsonSchema.JsonSchema): JsonSchema.JsonSchema;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3BlY2lhbEpzb25TY2hlbWEuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9TY2hlbWEvU3BlY2lhbEpzb25TY2hlbWEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBQ0gsT0FBTyxFQUFFLEtBQUssVUFBVSxFQUFFLEtBQUssTUFBTSxFQUF3QixNQUFNLFFBQVEsQ0FBQTtBQUUzRTs7O0dBR0c7QUFDSCx3QkFBZ0IseUJBQXlCLENBQ3ZDLE1BQU0sRUFBRSxNQUFNLENBQUMsR0FBRyxFQUNsQixPQUFPLENBQUMsRUFBRSxNQUFNLENBQUMsbUJBQW1CLEdBQ25DLFVBQVUsQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFDLENBWXRDO0FBRUQ7Ozs7R0FJRztBQUNILHdCQUFnQixrQkFBa0IsQ0FBQyxHQUFHLEVBQUUsT0FBTyxHQUFHLE9BQU8sQ0E2QnhEO0FBRUQ7OztHQUdHO0FBQ0gsd0JBQWdCLCtCQUErQixDQUFDLEdBQUcsRUFBRSxPQUFPLEdBQUcsT0FBTyxDQWVyRTtBQUVEOzs7O0dBSUc7QUFDSCx3QkFBZ0Isa0JBQWtCLENBQUMsR0FBRyxFQUFFLE9BQU8sR0FBRyxPQUFPLENBdUN4RDtBQUVEOzs7R0FHRztBQUNILHdCQUFnQixxQkFBcUIsQ0FBQyxHQUFHLEVBQUUsVUFBVSxDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUMsVUFBVSxDQUV2RiJ9

package/dist/Schema/SpecialJsonSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpecialJsonSchema.d.ts","sourceRoot":"","sources":["../../src/Schema/SpecialJsonSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,MAAM,EAAwB,MAAM,QAAQ,CAAA;AAE3E;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,GAAG,EAClB,OAAO,CAAC,EAAE,MAAM,CAAC,mBAAmB,GACnC,UAAU,CAAC,QAAQ,CAAC,eAAe,CAAC,CAYtC;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CA6BxD;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAerE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAuCxD;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,UAAU,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAEvF"}

package/dist/Schema/SpecialJsonSchema.js

@@ -0,0 +1,122 @@
+/**
+ * SpecialJsonSchema — A variant of Schema.toJsonSchemaDocument that
+ * post-processes the output (e.g. flattens simple allOf).
+ */
+import { SchemaRepresentation } from "effect";
+/**
+ * Converts a schema to a JSON Schema Document (draft-2020-12), with
+ * post-processing that flattens simple allOf entries.
+ */
+export function specialJsonSchemaDocument(schema, options) {
+    const doc = SchemaRepresentation.fromAST(schema.ast);
+    const jd = SchemaRepresentation.toJsonSchemaDocument(doc, options);
+    const processedDefs = {};
+    for (const [key, def] of Object.entries(jd.definitions)) {
+        processedDefs[key] = postProcessJsonSchema(def);
+    }
+    return {
+        dialect: "draft-2020-12",
+        schema: postProcessJsonSchema(jd.schema),
+        definitions: processedDefs
+    };
+}
+/**
+ * Flattens `allOf` entries into the parent when the parent already has a
+ * `type` and every `allOf` entry is a plain constraint object (no `$ref`,
+ * no `type`). Merged properties from `allOf` entries win on conflict.
+ */
+export function flattenSimpleAllOf(obj) {
+    if (obj === null || typeof obj !== "object")
+        return obj;
+    if (globalThis.Array.isArray(obj)) {
+        return obj.map(flattenSimpleAllOf);
+    }
+    const record = obj;
+    const result = {};
+    for (const [key, value] of Object.entries(record)) {
+        result[key] = flattenSimpleAllOf(value);
+    }
+    if (result["type"] && globalThis.Array.isArray(result["allOf"])) {
+        const allOf = result["allOf"];
+        const canFlatten = allOf.every((entry) => typeof entry === "object" && entry !== null && !("$ref" in entry) && !("type" in entry));
+        if (canFlatten) {
+            const { allOf: _, ...rest } = result;
+            const merged = { ...rest };
+            for (const entry of allOf) {
+                Object.assign(merged, entry);
+            }
+            return merged;
+        }
+    }
+    return result;
+}
+/**
+ * Recursively removes `additionalProperties: false` from JSON Schema objects.
+ * Only removes when the value is exactly `false` -- other values are left intact.
+ */
+export function removeAdditionalPropertiesFalse(obj) {
+    if (obj === null || typeof obj !== "object")
+        return obj;
+    if (globalThis.Array.isArray(obj)) {
+        return obj.map(removeAdditionalPropertiesFalse);
+    }
+    const record = obj;
+    const result = {};
+    for (const [key, value] of Object.entries(record)) {
+        if (key === "additionalProperties" && value === false)
+            continue;
+        result[key] = removeAdditionalPropertiesFalse(value);
+    }
+    return result;
+}
+/**
+ * Flattens nested `anyOf` entries: if an anyOf entry is itself just `{ anyOf: [...] }`
+ * with no other keys, its children are inlined. If only one item remains, the anyOf
+ * wrapper is removed entirely.
+ */
+export function flattenNestedAnyOf(obj) {
+    if (obj === null || typeof obj !== "object")
+        return obj;
+    if (globalThis.Array.isArray(obj))
+        return obj.map(flattenNestedAnyOf);
+    const record = obj;
+    const result = {};
+    for (const [key, value] of Object.entries(record)) {
+        result[key] = flattenNestedAnyOf(value);
+    }
+    if (globalThis.Array.isArray(result["anyOf"])) {
+        const anyOf = result["anyOf"];
+        const flattened = [];
+        for (const entry of anyOf) {
+            if (typeof entry === "object"
+                && entry !== null
+                && !globalThis.Array.isArray(entry)
+                && "anyOf" in entry
+                && Object.keys(entry).length === 1
+                && globalThis.Array.isArray(entry["anyOf"])) {
+                flattened.push(...entry["anyOf"]);
+            }
+            else {
+                flattened.push(entry);
+            }
+        }
+        if (flattened.length === 1) {
+            const { anyOf: _, ...rest } = result;
+            const single = flattened[0];
+            if (typeof single === "object" && single !== null && !globalThis.Array.isArray(single)) {
+                return { ...rest, ...single };
+            }
+            return single;
+        }
+        result["anyOf"] = flattened;
+    }
+    return result;
+}
+/**
+ * Applies JSON Schema post-processing: flattens simple allOf,
+ * flattens nested anyOf, then strips additionalProperties: false.
+ */
+export function postProcessJsonSchema(obj) {
+    return removeAdditionalPropertiesFalse(flattenNestedAnyOf(flattenSimpleAllOf(obj)));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/Schema/SpecialOpenApi.d.ts

@@ -0,0 +1,32 @@
+/**
+ * SpecialOpenApi — Deduplicates `components/schemas` entries in an OpenAPI spec
+ * and applies JSON Schema post-processing (null removal, allOf flattening).
+ *
+ * When `OpenApi.fromApi` generates the spec, different AST nodes sharing the
+ * same identifier can produce duplicate entries (e.g. "X" and "X1") in
+ * `components.schemas`. This module provides a transform function that
+ * collapses those duplicates, rewrites all `$ref` pointers accordingly,
+ * and post-processes schemas for better codegen compatibility.
+ *
+ * Usage with the OpenApi `Transform` annotation:
+ *
+ * ```ts
+ * import { OpenApi } from "effect/unstable"
+ * import { deduplicateOpenApiSchemas } from "./SpecialOpenApi.js"
+ *
+ * const api = HttpApi.make("myApi")
+ *   .pipe(HttpApi.annotateContext(OpenApi.annotations({ transform: deduplicateOpenApiSchemas })))
+ * ```
+ */
+/**
+ * Deduplicates `components.schemas` entries in an OpenAPI spec.
+ *
+ * Entries sharing the same base identifier (e.g. "X" and "X1") whose JSON
+ * representations are identical are collapsed into a single canonical entry,
+ * and all `$ref` pointers throughout the spec are rewritten to point to
+ * the canonical key.
+ *
+ * Designed to be used as the `transform` option in `OpenApi.annotations`.
+ */
+export declare function deduplicateOpenApiSchemas(spec: Record<string, any>): Record<string, any>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3BlY2lhbE9wZW5BcGkuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9TY2hlbWEvU3BlY2lhbE9wZW5BcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FtQkc7QUFJSDs7Ozs7Ozs7O0dBU0c7QUFDSCx3QkFBZ0IseUJBQXlCLENBQ3ZDLElBQUksRUFBRSxNQUFNLENBQUMsTUFBTSxFQUFFLEdBQUcsQ0FBQyxHQUN4QixNQUFNLENBQUMsTUFBTSxFQUFFLEdBQUcsQ0FBQyxDQXFEckIifQ==

package/dist/Schema/SpecialOpenApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpecialOpenApi.d.ts","sourceRoot":"","sources":["../../src/Schema/SpecialOpenApi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACxB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAqDrB"}

package/dist/Schema/SpecialOpenApi.js

@@ -0,0 +1,123 @@
+/**
+ * SpecialOpenApi — Deduplicates `components/schemas` entries in an OpenAPI spec
+ * and applies JSON Schema post-processing (null removal, allOf flattening).
+ *
+ * When `OpenApi.fromApi` generates the spec, different AST nodes sharing the
+ * same identifier can produce duplicate entries (e.g. "X" and "X1") in
+ * `components.schemas`. This module provides a transform function that
+ * collapses those duplicates, rewrites all `$ref` pointers accordingly,
+ * and post-processes schemas for better codegen compatibility.
+ *
+ * Usage with the OpenApi `Transform` annotation:
+ *
+ * ```ts
+ * import { OpenApi } from "effect/unstable"
+ * import { deduplicateOpenApiSchemas } from "./SpecialOpenApi.js"
+ *
+ * const api = HttpApi.make("myApi")
+ *   .pipe(HttpApi.annotateContext(OpenApi.annotations({ transform: deduplicateOpenApiSchemas })))
+ * ```
+ */
+import { postProcessJsonSchema } from "./SpecialJsonSchema.js";
+/**
+ * Deduplicates `components.schemas` entries in an OpenAPI spec.
+ *
+ * Entries sharing the same base identifier (e.g. "X" and "X1") whose JSON
+ * representations are identical are collapsed into a single canonical entry,
+ * and all `$ref` pointers throughout the spec are rewritten to point to
+ * the canonical key.
+ *
+ * Designed to be used as the `transform` option in `OpenApi.annotations`.
+ */
+export function deduplicateOpenApiSchemas(spec) {
+    const components = spec["components"];
+    if (!components)
+        return spec;
+    const schemas = components["schemas"];
+    if (!schemas)
+        return spec;
+    const keys = Object.keys(schemas);
+    if (keys.length === 0)
+        return spec;
+    // Group keys by base identifier (strip trailing digits)
+    const groups = new Map();
+    for (const key of keys) {
+        const base = getBaseIdentifier(key);
+        const fingerprint = JSON.stringify(schemas[key]);
+        const group = groups.get(base);
+        if (group === undefined) {
+            groups.set(base, [{ key, fingerprint }]);
+        }
+        else {
+            group.push({ key, fingerprint });
+        }
+    }
+    // Build remapping from duplicate keys to canonical keys
+    const remapping = new Map();
+    for (const [, group] of groups) {
+        if (group.length <= 1)
+            continue;
+        const seen = new Map(); // fingerprint -> canonical key
+        for (const entry of group) {
+            const canonical = seen.get(entry.fingerprint);
+            if (canonical !== undefined) {
+                remapping.set(entry.key, canonical);
+            }
+            else {
+                seen.set(entry.fingerprint, entry.key);
+            }
+        }
+    }
+    if (remapping.size === 0)
+        return postProcessJsonSchema(spec);
+    // Build new schemas object without duplicates
+    const newSchemas = {};
+    for (const key of keys) {
+        if (!remapping.has(key)) {
+            newSchemas[key] = schemas[key];
+        }
+    }
+    // Deep clone the spec, replace schemas, and rewrite all $ref pointers
+    const newSpec = structuredClone(spec);
+    newSpec["components"]["schemas"] = newSchemas;
+    rewriteRefs(newSpec, remapping);
+    return postProcessJsonSchema(newSpec);
+}
+/**
+ * Extracts the base identifier from a schema key by stripping trailing
+ * digits appended by the gen() function.
+ * E.g. "X1" -> "X", "X" -> "X", "MyType2" -> "MyType"
+ */
+function getBaseIdentifier(key) {
+    const match = key.match(/^(.+?)(\d+)$/);
+    return match ? match[1] : key;
+}
+/**
+ * Recursively rewrites `$ref` values in a JSON object tree.
+ * Mutates the object in-place (caller should pass a deep clone).
+ */
+function rewriteRefs(obj, remapping) {
+    if (obj === null || typeof obj !== "object")
+        return;
+    if (Array.isArray(obj)) {
+        for (const item of obj) {
+            rewriteRefs(item, remapping);
+        }
+        return;
+    }
+    if (typeof obj.$ref === "string") {
+        // OpenAPI refs look like "#/components/schemas/X1"
+        const prefix = "#/components/schemas/";
+        if (obj.$ref.startsWith(prefix)) {
+            const refKey = obj.$ref.slice(prefix.length);
+            const canonical = remapping.get(refKey);
+            if (canonical !== undefined) {
+                obj.$ref = prefix + canonical;
+            }
+        }
+    }
+    for (const value of Object.values(obj)) {
+        rewriteRefs(value, remapping);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3BlY2lhbE9wZW5BcGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvU2NoZW1hL1NwZWNpYWxPcGVuQXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBbUJHO0FBRUgsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sd0JBQXdCLENBQUE7QUFFOUQ7Ozs7Ozs7OztHQVNHO0FBQ0gsTUFBTSxVQUFVLHlCQUF5QixDQUN2QyxJQUF5QjtJQUV6QixNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFvQyxDQUFBO0lBQ3hFLElBQUksQ0FBQyxVQUFVO1FBQUUsT0FBTyxJQUFJLENBQUE7SUFDNUIsTUFBTSxPQUFPLEdBQUcsVUFBVSxDQUFDLFNBQVMsQ0FBb0MsQ0FBQTtJQUN4RSxJQUFJLENBQUMsT0FBTztRQUFFLE9BQU8sSUFBSSxDQUFBO0lBRXpCLE1BQU0sSUFBSSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUE7SUFDakMsSUFBSSxJQUFJLENBQUMsTUFBTSxLQUFLLENBQUM7UUFBRSxPQUFPLElBQUksQ0FBQTtJQUVsQyx3REFBd0Q7SUFDeEQsTUFBTSxNQUFNLEdBQUcsSUFBSSxHQUFHLEVBQXVELENBQUE7SUFDN0UsS0FBSyxNQUFNLEdBQUcsSUFBSSxJQUFJLEVBQUUsQ0FBQztRQUN2QixNQUFNLElBQUksR0FBRyxpQkFBaUIsQ0FBQyxHQUFHLENBQUMsQ0FBQTtRQUNuQyxNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFBO1FBQ2hELE1BQU0sS0FBSyxHQUFHLE1BQU0sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUE7UUFDOUIsSUFBSSxLQUFLLEtBQUssU0FBUyxFQUFFLENBQUM7WUFDeEIsTUFBTSxDQUFDLEdBQUcsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxFQUFFLEdBQUcsRUFBRSxXQUFXLEVBQUUsQ0FBQyxDQUFDLENBQUE7UUFDMUMsQ0FBQzthQUFNLENBQUM7WUFDTixLQUFLLENBQUMsSUFBSSxDQUFDLEVBQUUsR0FBRyxFQUFFLFdBQVcsRUFBRSxDQUFDLENBQUE7UUFDbEMsQ0FBQztJQUNILENBQUM7SUFFRCx3REFBd0Q7SUFDeEQsTUFBTSxTQUFTLEdBQUcsSUFBSSxHQUFHLEVBQWtCLENBQUE7SUFDM0MsS0FBSyxNQUFNLENBQUMsRUFBRSxLQUFLLENBQUMsSUFBSSxNQUFNLEVBQUUsQ0FBQztRQUMvQixJQUFJLEtBQUssQ0FBQyxNQUFNLElBQUksQ0FBQztZQUFFLFNBQVE7UUFDL0IsTUFBTSxJQUFJLEdBQUcsSUFBSSxHQUFHLEVBQWtCLENBQUEsQ0FBQywrQkFBK0I7UUFDdEUsS0FBSyxNQUFNLEtBQUssSUFBSSxLQUFLLEVBQUUsQ0FBQztZQUMxQixNQUFNLFNBQVMsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxXQUFXLENBQUMsQ0FBQTtZQUM3QyxJQUFJLFNBQVMsS0FBSyxTQUFTLEVBQUUsQ0FBQztnQkFDNUIsU0FBUyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsR0FBRyxFQUFFLFNBQVMsQ0FBQyxDQUFBO1lBQ3JDLENBQUM7aUJBQU0sQ0FBQztnQkFDTixJQUFJLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxXQUFXLEVBQUUsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFBO1lBQ3hDLENBQUM7UUFDSCxDQUFDO0lBQ0gsQ0FBQztJQUVELElBQUksU0FBUyxDQUFDLElBQUksS0FBSyxDQUFDO1FBQUUsT0FBTyxxQkFBcUIsQ0FBQyxJQUFJLENBQUMsQ0FBQTtJQUU1RCw4Q0FBOEM7SUFDOUMsTUFBTSxVQUFVLEdBQXdCLEVBQUUsQ0FBQTtJQUMxQyxLQUFLLE1BQU0sR0FBRyxJQUFJLElBQUksRUFBRSxDQUFDO1FBQ3ZCLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDeEIsVUFBVSxDQUFDLEdBQUcsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQTtRQUNoQyxDQUFDO0lBQ0gsQ0FBQztJQUVELHNFQUFzRTtJQUN0RSxNQUFNLE9BQU8sR0FBRyxlQUFlLENBQUMsSUFBSSxDQUFDLENBQUE7SUFDckMsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUFDLFNBQVMsQ0FBQyxHQUFHLFVBQVUsQ0FBQTtJQUM3QyxXQUFXLENBQUMsT0FBTyxFQUFFLFNBQVMsQ0FBQyxDQUFBO0lBRS9CLE9BQU8scUJBQXFCLENBQUMsT0FBTyxDQUFDLENBQUE7QUFDdkMsQ0FBQztBQUVEOzs7O0dBSUc7QUFDSCxTQUFTLGlCQUFpQixDQUFDLEdBQVc7SUFDcEMsTUFBTSxLQUFLLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxjQUFjLENBQUMsQ0FBQTtJQUN2QyxPQUFPLEtBQUssQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBRSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUE7QUFDaEMsQ0FBQztBQUVEOzs7R0FHRztBQUNILFNBQVMsV0FBVyxDQUFDLEdBQVEsRUFBRSxTQUE4QjtJQUMzRCxJQUFJLEdBQUcsS0FBSyxJQUFJLElBQUksT0FBTyxHQUFHLEtBQUssUUFBUTtRQUFFLE9BQU07SUFFbkQsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7UUFDdkIsS0FBSyxNQUFNLElBQUksSUFBSSxHQUFHLEVBQUUsQ0FBQztZQUN2QixXQUFXLENBQUMsSUFBSSxFQUFFLFNBQVMsQ0FBQyxDQUFBO1FBQzlCLENBQUM7UUFDRCxPQUFNO0lBQ1IsQ0FBQztJQUVELElBQUksT0FBTyxHQUFHLENBQUMsSUFBSSxLQUFLLFFBQVEsRUFBRSxDQUFDO1FBQ2pDLG1EQUFtRDtRQUNuRCxNQUFNLE1BQU0sR0FBRyx1QkFBdUIsQ0FBQTtRQUN0QyxJQUFJLEdBQUcsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7WUFDaEMsTUFBTSxNQUFNLEdBQUcsR0FBRyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFBO1lBQzVDLE1BQU0sU0FBUyxHQUFHLFNBQVMsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUE7WUFDdkMsSUFBSSxTQUFTLEtBQUssU0FBUyxFQUFFLENBQUM7Z0JBQzVCLEdBQUcsQ0FBQyxJQUFJLEdBQUcsTUFBTSxHQUFHLFNBQVMsQ0FBQTtZQUMvQixDQUFDO1FBQ0gsQ0FBQztJQUNILENBQUM7SUFFRCxLQUFLLE1BQU0sS0FBSyxJQUFJLE1BQU0sQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQztRQUN2QyxXQUFXLENBQUMsS0FBSyxFQUFFLFNBQVMsQ0FBQyxDQUFBO0lBQy9CLENBQUM7QUFDSCxDQUFDIn0=

package/dist/Schema/brand.d.ts

@@ -27,9 +27,11 @@ export interface Constructor<in out A extends B.Brand<any>> {
 type BrandAnnotations<C extends B.Brand<any>> = S.Annotations.Filter & (C extends string ? {
     readonly toArbitrary?: S.Annotations.ToArbitrary.Declaration<C, readonly []>;
 } : {});
-export declare const fromBrand: <C extends B.Brand<any>>(constructor: Constructor<C>, options?: BrandAnnotations<C>) => <Self extends S.Top>(self: Self) => S.brand<Self["~rebuild.out"], B.Brand.Keys<C>>;
+export interface BrandedSchema<S extends S.Top, C extends B.Brand<any>> extends S.Bottom<C, S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], BrandedSchema<S, C>, S["~type.make.in"], S["Iso"], S["~type.parameters"], C, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+}
+export declare const fromBrand: <C extends B.Brand<any>>(constructor: Constructor<C>, options?: BrandAnnotations<C>) => <Self extends S.Top>(self: Self) => BrandedSchema<Self, C>;
 export type Brands<P> = P extends B.Brand<any> ? B.Brand.Brands<P> : never;
 export type Unbranded<P> = P extends B.Brand<any> ? B.Brand.Unbranded<P> : P;
 export declare const nominal: <A extends B.Brand<any>>() => Constructor<A>;
 export {};
-//# sourceMappingURL=brand.d.ts.map
+//# sourceMappingURL=data:application/json;base64,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