@gabrielbryk/json-schema-to-zod 2.7.2

package/dist/cjs/parsers/parseSchema.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.its = exports.parseSchema = void 0;
+const parseAnyOf_js_1 = require("./parseAnyOf.js");
+const parseBoolean_js_1 = require("./parseBoolean.js");
+const parseDefault_js_1 = require("./parseDefault.js");
+const parseMultipleType_js_1 = require("./parseMultipleType.js");
+const parseNot_js_1 = require("./parseNot.js");
+const parseNull_js_1 = require("./parseNull.js");
+const parseAllOf_js_1 = require("./parseAllOf.js");
+const parseArray_js_1 = require("./parseArray.js");
+const parseConst_js_1 = require("./parseConst.js");
+const parseEnum_js_1 = require("./parseEnum.js");
+const parseIfThenElse_js_1 = require("./parseIfThenElse.js");
+const parseNumber_js_1 = require("./parseNumber.js");
+const parseObject_js_1 = require("./parseObject.js");
+const parseString_js_1 = require("./parseString.js");
+const parseOneOf_js_1 = require("./parseOneOf.js");
+const parseSimpleDiscriminatedOneOf_js_1 = require("./parseSimpleDiscriminatedOneOf.js");
+const parseNullable_js_1 = require("./parseNullable.js");
+const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
+const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockMeta) => {
+    // Ensure ref bookkeeping exists so $ref declarations and getter-based recursion work
+    refs.root = refs.root ?? schema;
+    refs.declarations = refs.declarations ?? new Map();
+    refs.inProgress = refs.inProgress ?? new Set();
+    refs.refNameByPointer = refs.refNameByPointer ?? new Map();
+    refs.usedNames = refs.usedNames ?? new Set();
+    if (typeof schema !== "object")
+        return schema ? (0, anyOrUnknown_js_1.anyOrUnknown)(refs) : "z.never()";
+    if (refs.parserOverride) {
+        const custom = refs.parserOverride(schema, refs);
+        if (typeof custom === "string") {
+            return custom;
+        }
+    }
+    let seen = refs.seen.get(schema);
+    if (seen) {
+        if (seen.r !== undefined) {
+            return seen.r;
+        }
+        if (refs.depth === undefined || seen.n >= refs.depth) {
+            return (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
+        }
+        seen.n += 1;
+    }
+    else {
+        seen = { r: undefined, n: 0 };
+        refs.seen.set(schema, seen);
+    }
+    if (exports.its.a.ref(schema)) {
+        const parsedRef = parseRef(schema, refs);
+        seen.r = parsedRef;
+        return parsedRef;
+    }
+    let parsed = selectParser(schema, refs);
+    if (!blockMeta) {
+        if (!refs.withoutDescribes) {
+            parsed = addDescribes(schema, parsed, refs);
+        }
+        if (!refs.withoutDefaults) {
+            parsed = addDefaults(schema, parsed);
+        }
+        parsed = addAnnotations(schema, parsed);
+    }
+    seen.r = parsed;
+    return parsed;
+};
+exports.parseSchema = parseSchema;
+const parseRef = (schema, refs) => {
+    const resolved = resolveRef(refs.root, schema.$ref);
+    if (!resolved) {
+        return (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
+    }
+    const { schema: target, path } = resolved;
+    const refName = getOrCreateRefName(schema.$ref, path, refs);
+    if (!refs.declarations.has(refName) && !refs.inProgress.has(refName)) {
+        refs.inProgress.add(refName);
+        const declaration = (0, exports.parseSchema)(target, {
+            ...refs,
+            path,
+            currentSchemaName: refName,
+            root: refs.root,
+        });
+        refs.inProgress.delete(refName);
+        refs.declarations.set(refName, declaration);
+    }
+    return refName;
+};
+const addDescribes = (schema, parsed, refs) => {
+    // Use .meta() for richer metadata when withMeta is enabled
+    if (refs?.withMeta) {
+        const meta = {};
+        if (schema.$id)
+            meta.id = schema.$id;
+        if (schema.title)
+            meta.title = schema.title;
+        if (schema.description)
+            meta.description = schema.description;
+        if (schema.examples)
+            meta.examples = schema.examples;
+        if (schema.deprecated)
+            meta.deprecated = schema.deprecated;
+        if (Object.keys(meta).length > 0) {
+            parsed += `.meta(${JSON.stringify(meta)})`;
+        }
+    }
+    else if (schema.description) {
+        parsed += `.describe(${JSON.stringify(schema.description)})`;
+    }
+    return parsed;
+};
+const resolveRef = (root, ref) => {
+    if (!root || !ref.startsWith("#/"))
+        return undefined;
+    const rawSegments = ref
+        .slice(2)
+        .split("/")
+        .filter((segment) => segment.length > 0)
+        .map(decodePointerSegment);
+    let current = root;
+    for (const segment of rawSegments) {
+        if (typeof current !== "object" || current === null)
+            return undefined;
+        current = current[segment];
+    }
+    return { schema: current, path: rawSegments };
+};
+const decodePointerSegment = (segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~");
+const getOrCreateRefName = (pointer, path, refs) => {
+    if (refs.refNameByPointer?.has(pointer)) {
+        return refs.refNameByPointer.get(pointer);
+    }
+    const preferred = buildNameFromPath(path, refs.usedNames);
+    refs.refNameByPointer?.set(pointer, preferred);
+    refs.usedNames?.add(preferred);
+    return preferred;
+};
+const buildNameFromPath = (path, used) => {
+    const filtered = path.filter((segment) => segment !== "$defs" && segment !== "definitions" && segment !== "properties");
+    const base = filtered.length
+        ? filtered
+            .map((segment) => typeof segment === "number"
+            ? `Ref${segment}`
+            : segment
+                .replace(/[^a-zA-Z0-9_$]/g, " ")
+                .split(" ")
+                .filter(Boolean)
+                .map(capitalize)
+                .join(""))
+            .join("")
+        : "Ref";
+    const sanitized = sanitizeIdentifier(base || "Ref");
+    if (!used || !used.has(sanitized))
+        return sanitized;
+    let counter = 2;
+    let candidate = `${sanitized}${counter}`;
+    while (used.has(candidate)) {
+        counter += 1;
+        candidate = `${sanitized}${counter}`;
+    }
+    return candidate;
+};
+const sanitizeIdentifier = (value) => {
+    const cleaned = value.replace(/^[^a-zA-Z_$]+/, "").replace(/[^a-zA-Z0-9_$]/g, "");
+    return cleaned || "Ref";
+};
+const capitalize = (value) => value.length ? value[0].toUpperCase() + value.slice(1) : value;
+const addDefaults = (schema, parsed) => {
+    if (schema.default !== undefined) {
+        parsed += `.default(${JSON.stringify(schema.default)})`;
+    }
+    return parsed;
+};
+const addAnnotations = (schema, parsed) => {
+    if (schema.readOnly) {
+        parsed += ".readonly()";
+    }
+    return parsed;
+};
+const selectParser = (schema, refs) => {
+    if (exports.its.a.nullable(schema)) {
+        return (0, parseNullable_js_1.parseNullable)(schema, refs);
+    }
+    else if (exports.its.an.object(schema)) {
+        return (0, parseObject_js_1.parseObject)(schema, refs);
+    }
+    else if (exports.its.an.array(schema)) {
+        return (0, parseArray_js_1.parseArray)(schema, refs);
+    }
+    else if (exports.its.an.anyOf(schema)) {
+        return (0, parseAnyOf_js_1.parseAnyOf)(schema, refs);
+    }
+    else if (exports.its.an.allOf(schema)) {
+        return (0, parseAllOf_js_1.parseAllOf)(schema, refs);
+    }
+    else if (exports.its.a.simpleDiscriminatedOneOf(schema)) {
+        return (0, parseSimpleDiscriminatedOneOf_js_1.parseSimpleDiscriminatedOneOf)(schema, refs);
+    }
+    else if (exports.its.a.oneOf(schema)) {
+        return (0, parseOneOf_js_1.parseOneOf)(schema, refs);
+    }
+    else if (exports.its.a.not(schema)) {
+        return (0, parseNot_js_1.parseNot)(schema, refs);
+    }
+    else if (exports.its.an.enum(schema)) {
+        return (0, parseEnum_js_1.parseEnum)(schema); //<-- needs to come before primitives
+    }
+    else if (exports.its.a.const(schema)) {
+        return (0, parseConst_js_1.parseConst)(schema);
+    }
+    else if (exports.its.a.multipleType(schema)) {
+        return (0, parseMultipleType_js_1.parseMultipleType)(schema, refs);
+    }
+    else if (exports.its.a.primitive(schema, "string")) {
+        return (0, parseString_js_1.parseString)(schema);
+    }
+    else if (exports.its.a.primitive(schema, "number") ||
+        exports.its.a.primitive(schema, "integer")) {
+        return (0, parseNumber_js_1.parseNumber)(schema);
+    }
+    else if (exports.its.a.primitive(schema, "boolean")) {
+        return (0, parseBoolean_js_1.parseBoolean)(schema);
+    }
+    else if (exports.its.a.primitive(schema, "null")) {
+        return (0, parseNull_js_1.parseNull)(schema);
+    }
+    else if (exports.its.a.conditional(schema)) {
+        return (0, parseIfThenElse_js_1.parseIfThenElse)(schema, refs);
+    }
+    else {
+        return (0, parseDefault_js_1.parseDefault)(schema, refs);
+    }
+};
+exports.its = {
+    an: {
+        object: (x) => x.type === "object",
+        array: (x) => x.type === "array",
+        anyOf: (x) => x.anyOf !== undefined,
+        allOf: (x) => x.allOf !== undefined,
+        enum: (x) => x.enum !== undefined,
+    },
+    a: {
+        nullable: (x) => x.nullable === true,
+        multipleType: (x) => Array.isArray(x.type),
+        not: (x) => x.not !== undefined,
+        ref: (x) => typeof x.$ref === "string",
+        const: (x) => x.const !== undefined,
+        primitive: (x, p) => x.type === p,
+        conditional: (x) => Boolean("if" in x && x.if && "then" in x && "else" in x && x.then && x.else),
+        simpleDiscriminatedOneOf: (x) => {
+            if (!x.oneOf ||
+                !Array.isArray(x.oneOf) ||
+                x.oneOf.length === 0 ||
+                !x.discriminator ||
+                typeof x.discriminator !== "object" ||
+                !("propertyName" in x.discriminator) ||
+                typeof x.discriminator.propertyName !== "string") {
+                return false;
+            }
+            const discriminatorProp = x.discriminator.propertyName;
+            return x.oneOf.every((schema) => {
+                if (!schema ||
+                    typeof schema !== "object" ||
+                    schema.type !== "object" ||
+                    !schema.properties ||
+                    typeof schema.properties !== "object" ||
+                    !(discriminatorProp in schema.properties)) {
+                    return false;
+                }
+                const property = schema.properties[discriminatorProp];
+                return (property &&
+                    typeof property === "object" &&
+                    (property.type === undefined || property.type === "string") &&
+                    // Ensure discriminator has a constant value (const or single-value enum)
+                    (property.const !== undefined ||
+                        (property.enum && Array.isArray(property.enum) && property.enum.length === 1)) &&
+                    // Ensure discriminator property is required
+                    Array.isArray(schema.required) &&
+                    schema.required.includes(discriminatorProp));
+            });
+        },
+        oneOf: (x) => x.oneOf !== undefined,
+    },
+};

package/dist/cjs/parsers/parseSimpleDiscriminatedOneOf.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSimpleDiscriminatedOneOf = void 0;
+const parseSchema_js_1 = require("./parseSchema.js");
+const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
+const parseSimpleDiscriminatedOneOf = (schema, refs) => {
+    const discriminator = schema.discriminator.propertyName;
+    const entries = schema.oneOf.map((option, i) => {
+        const opt = option;
+        const discriminatorSchema = opt.properties[discriminator];
+        const value = discriminatorSchema.const ??
+            (discriminatorSchema.enum && discriminatorSchema.enum[0]);
+        const parsed = (0, parseSchema_js_1.parseSchema)(option, {
+            ...refs,
+            path: [...refs.path, "oneOf", i],
+        });
+        const key = typeof value === "string" ? JSON.stringify(value) : JSON.stringify(String(value));
+        return `${key}: ${parsed}`;
+    });
+    return schema.oneOf.length
+        ? schema.oneOf.length === 1
+            ? (0, parseSchema_js_1.parseSchema)(schema.oneOf[0], {
+                ...refs,
+                path: [...refs.path, "oneOf", 0],
+            })
+            : `z.discriminatedUnion("${discriminator}", { ${entries.join(", ")} })`
+        : (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
+};
+exports.parseSimpleDiscriminatedOneOf = parseSimpleDiscriminatedOneOf;

package/dist/cjs/parsers/parseString.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseString = void 0;
+const withMessage_js_1 = require("../utils/withMessage.js");
+const parseSchema_js_1 = require("./parseSchema.js");
+const parseString = (schema) => {
+    let r = "z.string()";
+    r += (0, withMessage_js_1.withMessage)(schema, "format", ({ value }) => {
+        switch (value) {
+            case "email":
+                return [".email(", ")"];
+            case "ip":
+                return [".ip(", ")"];
+            case "ipv4":
+                return ['.ip({ version: "v4"', ", message: ", " })"];
+            case "ipv6":
+                return ['.ip({ version: "v6"', ", message: ", " })"];
+            case "uri":
+                return [".url(", ")"];
+            case "uuid":
+                return [".uuid(", ")"];
+            case "date-time":
+                return [".datetime({ offset: true", ", message: ", " })"];
+            case "time":
+                return [".time(", ")"];
+            case "date":
+                return [".date(", ")"];
+            case "binary":
+                return [".base64(", ")"];
+            case "duration":
+                return [".duration(", ")"];
+        }
+    });
+    r += (0, withMessage_js_1.withMessage)(schema, "pattern", ({ json }) => [
+        `.regex(new RegExp(${json})`,
+        ", ",
+        ")",
+    ]);
+    r += (0, withMessage_js_1.withMessage)(schema, "minLength", ({ json }) => [
+        `.min(${json}`,
+        ", ",
+        ")",
+    ]);
+    r += (0, withMessage_js_1.withMessage)(schema, "maxLength", ({ json }) => [
+        `.max(${json}`,
+        ", ",
+        ")",
+    ]);
+    r += (0, withMessage_js_1.withMessage)(schema, "contentEncoding", ({ value }) => {
+        if (value === "base64") {
+            return [".base64(", ")"];
+        }
+    });
+    const contentMediaType = (0, withMessage_js_1.withMessage)(schema, "contentMediaType", ({ value }) => {
+        if (value === "application/json") {
+            return [
+                ".transform((str, ctx) => { try { return JSON.parse(str); } catch (err) { ctx.addIssue({ code: \"custom\", message: \"Invalid JSON\" }); }}",
+                ", ",
+                ")"
+            ];
+        }
+    });
+    if (contentMediaType != "") {
+        r += contentMediaType;
+        r += (0, withMessage_js_1.withMessage)(schema, "contentSchema", ({ value }) => {
+            if (value && value instanceof Object) {
+                return [
+                    `.pipe(${(0, parseSchema_js_1.parseSchema)(value)}`,
+                    ", ",
+                    ")"
+                ];
+            }
+        });
+    }
+    return r;
+};
+exports.parseString = parseString;

package/dist/cjs/utils/anyOrUnknown.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anyOrUnknown = void 0;
+/**
+ * Returns "z.unknown()" if the useUnknown option is enabled, otherwise "z.any()".
+ * This helper is used throughout the library for fallback cases.
+ *
+ * @param refs - The refs object containing options
+ * @returns The appropriate Zod schema string
+ */
+const anyOrUnknown = (refs) => {
+    return refs?.useUnknown ? "z.unknown()" : "z.any()";
+};
+exports.anyOrUnknown = anyOrUnknown;

package/dist/cjs/utils/cliTools.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.parseOrReadJSON = parseOrReadJSON;
+exports.readPipe = readPipe;
+exports.printParams = printParams;
+const fs_1 = require("fs");
+function parseArgs(params, args, help) {
+    const result = {};
+    if (help) {
+        let index = args.indexOf("--help");
+        if (index === -1) {
+            index = args.indexOf("-h");
+        }
+        if (index !== -1) {
+            printParams({
+                ...params,
+                help: {
+                    shorthand: "h",
+                    description: typeof help === "string" ? help : "Display this message :)",
+                },
+            });
+            process.exit(0);
+        }
+    }
+    for (const name in params) {
+        const { shorthand, required, value } = params[name];
+        let index = args.indexOf("--" + name);
+        if (index === -1 && shorthand) {
+            index = args.indexOf("-" + shorthand);
+        }
+        if (index === -1) {
+            if (required || required === "") {
+                throw new Error(typeof required === "string" && required !== ""
+                    ? required
+                    : `Missing required argument ${name}`);
+            }
+            result[name] = false;
+            continue;
+        }
+        if (value) {
+            const val = args[index + 1];
+            if (val === undefined) {
+                throw new Error(`Expected a value for argument ${name}`);
+            }
+            if (value === "number") {
+                const asNumber = Number(val);
+                if (isNaN(asNumber)) {
+                    throw new Error(`Value of argument ${name} must be a valid number`);
+                }
+                result[name] = asNumber;
+                continue;
+            }
+            if (Array.isArray(value) && !value.includes(val)) {
+                throw new Error(`Value of argument ${name} must be one of ${value}`);
+            }
+            result[name] = val;
+        }
+        else {
+            result[name] = true;
+        }
+    }
+    return result;
+}
+function parseOrReadJSON(jsonOrPath) {
+    jsonOrPath = jsonOrPath.trim();
+    if (jsonOrPath.length < 255 &&
+        (0, fs_1.statSync)(jsonOrPath, { throwIfNoEntry: false })?.isFile()) {
+        jsonOrPath = (0, fs_1.readFileSync)(jsonOrPath, "utf-8");
+    }
+    return JSON.parse(jsonOrPath);
+}
+function readPipe() {
+    return new Promise((resolve, reject) => {
+        let buf = "";
+        process.stdin
+            .setEncoding("utf-8")
+            .on("end", () => resolve(buf))
+            .on("error", reject)
+            .on("readable", () => {
+            let chunk;
+            while ((chunk = process.stdin.read()) != null) {
+                buf += chunk;
+            }
+        });
+    });
+}
+function printParams(params) {
+    const longest = Object.keys(params).reduce((l, c) => (c.length > l ? c.length : l), 5);
+    const header = "Name " + " ".repeat(longest - 2) + "Short Description";
+    console.log(header);
+    for (const name in params) {
+        let { shorthand, description } = params[name];
+        if (shorthand) {
+            shorthand = " -" + shorthand;
+        }
+        else {
+            shorthand = "   ";
+        }
+        if (description) {
+            description = "    " + description;
+        }
+        else {
+            description = "";
+        }
+        console.log("--" + name + " ".repeat(longest - name.length) + shorthand + description);
+    }
+}

package/dist/cjs/utils/half.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.half = void 0;
+const half = (arr) => {
+    return [arr.slice(0, arr.length / 2), arr.slice(arr.length / 2)];
+};
+exports.half = half;

package/dist/cjs/utils/jsdocs.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addJsdocs = exports.expandJsdocs = void 0;
+const expandJsdocs = (jsdocs) => {
+    const lines = jsdocs.split("\n");
+    const result = lines.length === 1
+        ? lines[0]
+        : `\n${lines.map(x => `* ${x}`)
+            .join("\n")}\n`;
+    return `/**${result}*/\n`;
+};
+exports.expandJsdocs = expandJsdocs;
+const addJsdocs = (schema, parsed) => {
+    const description = schema.description;
+    if (!description) {
+        return parsed;
+    }
+    return `\n${(0, exports.expandJsdocs)(description)}${parsed}`;
+};
+exports.addJsdocs = addJsdocs;

package/dist/cjs/utils/omit.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.omit = void 0;
+const omit = (obj, ...keys) => Object.keys(obj).reduce((acc, key) => {
+    if (!keys.includes(key)) {
+        acc[key] = obj[key];
+    }
+    return acc;
+}, {});
+exports.omit = omit;

package/dist/cjs/utils/withMessage.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withMessage = withMessage;
+function withMessage(schema, key, get) {
+    const value = schema[key];
+    let r = "";
+    if (value !== undefined) {
+        const got = get({ value, json: JSON.stringify(value) });
+        if (got) {
+            const opener = got[0];
+            const prefix = got.length === 3 ? got[1] : "";
+            const closer = got.length === 3 ? got[2] : got[1];
+            r += opener;
+            if (schema.errorMessage?.[key] !== undefined) {
+                r += prefix + JSON.stringify(schema.errorMessage[key]);
+            }
+            r;
+            r += closer;
+        }
+    }
+    return r;
+}

package/dist/cjs/zodToJsonSchema.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Post-processor for Zod's z.toJSONSchema() output.
+ *
+ * When `preserveJsonSchemaForRoundTrip` was used during JSON Schema → Zod conversion,
+ * this function reconstructs the original JSON Schema features from the stored __jsonSchema meta.
+ *
+ * Usage:
+ * 1. Convert JSON Schema to Zod code with `preserveJsonSchemaForRoundTrip: true`
+ * 2. Evaluate the Zod code to get a schema instance
+ * 3. Call Zod's `z.toJSONSchema(schema)` to get JSON Schema output
+ * 4. Pass that output to `reconstructJsonSchema()` to restore preserved features
+ *
+ * Handles:
+ * - patternProperties (stored in __jsonSchema.patternProperties)
+ * - if/then/else conditionals (stored in __jsonSchema.conditional)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconstructJsonSchema = reconstructJsonSchema;
+/**
+ * Recursively process a JSON Schema to reconstruct original features from __jsonSchema meta.
+ *
+ * Handles special cases:
+ * - allOf[object, {__jsonSchema: {conditional: ...}}] -> object with if/then/else at top level
+ * - patternProperties meta -> patternProperties at current level
+ */
+function reconstructJsonSchema(schema) {
+    if (typeof schema !== "object" || schema === null) {
+        return schema;
+    }
+    const result = { ...schema };
+    // Handle allOf structures created by .and() with conditionals
+    // Pattern: allOf: [mainSchema, {__jsonSchema: {conditional: ...}, anyOf: [...]}]
+    if (Array.isArray(result.allOf) &&
+        result.allOf.length === 2 &&
+        typeof result.allOf[1] === "object" &&
+        result.allOf[1] !== null) {
+        const secondElement = result.allOf[1];
+        // Check if second element has conditional meta
+        if (secondElement.__jsonSchema &&
+            typeof secondElement.__jsonSchema === "object" &&
+            secondElement.__jsonSchema.conditional) {
+            // Extract the main schema and conditional
+            const mainSchema = reconstructJsonSchema(result.allOf[0]);
+            const conditionalMeta = secondElement.__jsonSchema
+                .conditional;
+            // Merge: main schema + if/then/else at top level
+            const merged = {
+                ...mainSchema,
+                if: conditionalMeta.if,
+                then: conditionalMeta.then,
+                else: conditionalMeta.else,
+            };
+            // Recursively process the merged result
+            return reconstructJsonSchema(merged);
+        }
+    }
+    // Check for __jsonSchema meta at this level
+    if (result.__jsonSchema && typeof result.__jsonSchema === "object") {
+        const preserved = result.__jsonSchema;
+        // Reconstruct patternProperties
+        if (preserved.patternProperties) {
+            result.patternProperties = preserved.patternProperties;
+        }
+        // Reconstruct if/then/else conditional (for non-allOf cases)
+        if (preserved.conditional) {
+            const conditional = preserved.conditional;
+            result.if = conditional.if;
+            result.then = conditional.then;
+            result.else = conditional.else;
+        }
+        // Remove the __jsonSchema meta from the output
+        delete result.__jsonSchema;
+    }
+    // Recursively process nested schemas
+    for (const [key, value] of Object.entries(result)) {
+        if (typeof value === "object" && value !== null) {
+            if (Array.isArray(value)) {
+                result[key] = value.map((item) => typeof item === "object" && item !== null
+                    ? reconstructJsonSchema(item)
+                    : item);
+            }
+            else {
+                result[key] = reconstructJsonSchema(value);
+            }
+        }
+    }
+    return result;
+}

package/dist/esm/Types.js

@@ -0,0 +1 @@
+export {};