@gabrielbryk/json-schema-to-zod 2.10.0 → 2.11.0

package/dist/cjs/parsers/parseArray.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseArray = void 0;
-const withMessage_js_1 = require("../utils/withMessage.js");
-const parseSchema_js_1 = require("./parseSchema.js");
-const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
-const parseArray = (schema, refs) => {
-    if (Array.isArray(schema.items)) {
-        let tuple = `z.tuple([${schema.items.map((v, i) => (0, parseSchema_js_1.parseSchema)(v, { ...refs, path: [...refs.path, "items", i] }))}])`;
-        if (schema.contains) {
-            const containsSchema = (0, parseSchema_js_1.parseSchema)(schema.contains, {
-                ...refs,
-                path: [...refs.path, "contains"],
-            });
-            const minContains = schema.minContains ?? (schema.contains ? 1 : undefined);
-            const maxContains = schema.maxContains;
-            tuple += `.superRefine((arr, ctx) => {
-  const matches = arr.filter((item) => ${containsSchema}.safeParse(item).success).length;
-  if (${minContains ?? 0} && matches < ${minContains ?? 0}) {
-    ctx.addIssue({ code: "custom", message: "Array contains too few matching items" });
-  }
-  if (${maxContains ?? "undefined"} !== undefined && matches > ${maxContains ?? "undefined"}) {
-    ctx.addIssue({ code: "custom", message: "Array contains too many matching items" });
-  }
-})`;
-        }
-        return tuple;
-    }
-    let r = !schema.items
-        ? `z.array(${(0, anyOrUnknown_js_1.anyOrUnknown)(refs)})`
-        : `z.array(${(0, parseSchema_js_1.parseSchema)(schema.items, {
-            ...refs,
-            path: [...refs.path, "items"],
-        })})`;
-    r += (0, withMessage_js_1.withMessage)(schema, "minItems", ({ json }) => ({
-        opener: `.min(${json}`,
-        closer: ")",
-        messagePrefix: ", { error: ",
-        messageCloser: " })",
-    }));
-    r += (0, withMessage_js_1.withMessage)(schema, "maxItems", ({ json }) => ({
-        opener: `.max(${json}`,
-        closer: ")",
-        messagePrefix: ", { error: ",
-        messageCloser: " })",
-    }));
-    if (schema.uniqueItems === true) {
-        r += `.superRefine((arr, ctx) => {
-  const seen = new Set();
-  for (const [index, value] of arr.entries()) {
-    let key;
-    if (value && typeof value === "object") {
-      try {
-        key = JSON.stringify(value);
-      } catch {
-        key = String(value);
-      }
-    } else {
-      key = JSON.stringify(value);
-    }
-
-    if (seen.has(key)) {
-      ctx.addIssue({ code: "custom", message: "Array items must be unique", path: [index] });
-      return;
-    }
-
-    seen.add(key);
-  }
-})`;
-    }
-    if (schema.contains) {
-        const containsSchema = (0, parseSchema_js_1.parseSchema)(schema.contains, {
-            ...refs,
-            path: [...refs.path, "contains"],
-        });
-        const minContains = schema.minContains ?? (schema.contains ? 1 : undefined);
-        const maxContains = schema.maxContains;
-        r += `.superRefine((arr, ctx) => {
-  const matches = arr.filter((item) => ${containsSchema}.safeParse(item).success).length;
-  if (${minContains ?? 0} && matches < ${minContains ?? 0}) {
-    ctx.addIssue({ code: "custom", message: "Array contains too few matching items" });
-  }
-  if (${maxContains ?? "undefined"} !== undefined && matches > ${maxContains ?? "undefined"}) {
-    ctx.addIssue({ code: "custom", message: "Array contains too many matching items" });
-  }
-})`;
-    }
-    return r;
-};
-exports.parseArray = parseArray;

package/dist/cjs/parsers/parseBoolean.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseBoolean = void 0;
-const parseBoolean = () => "z.boolean()";
-exports.parseBoolean = parseBoolean;

package/dist/cjs/parsers/parseConst.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseConst = void 0;
-const parseConst = (schema) => {
-    return `z.literal(${JSON.stringify(schema.const)})`;
-};
-exports.parseConst = parseConst;

package/dist/cjs/parsers/parseDefault.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseDefault = void 0;
-const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
-const parseDefault = (_schema, refs) => {
-    return (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
-};
-exports.parseDefault = parseDefault;

package/dist/cjs/parsers/parseEnum.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseEnum = void 0;
-const parseEnum = (schema) => {
-    if (schema.enum.length === 0) {
-        return "z.never()";
-    }
-    else if (schema.enum.length === 1) {
-        // union does not work when there is only one element
-        return `z.literal(${JSON.stringify(schema.enum[0])})`;
-    }
-    else if (schema.enum.every((x) => typeof x === "string")) {
-        return `z.enum([${schema.enum.map((x) => JSON.stringify(x))}])`;
-    }
-    else {
-        return `z.union([${schema.enum
-            .map((x) => `z.literal(${JSON.stringify(x)})`)
-            .join(", ")}])`;
-    }
-};
-exports.parseEnum = parseEnum;

package/dist/cjs/parsers/parseIfThenElse.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseIfThenElse = void 0;
-const parseSchema_js_1 = require("./parseSchema.js");
-const parseIfThenElse = (schema, refs) => {
-    const $if = (0, parseSchema_js_1.parseSchema)(schema.if, { ...refs, path: [...refs.path, "if"] });
-    const $then = (0, parseSchema_js_1.parseSchema)(schema.then, {
-        ...refs,
-        path: [...refs.path, "then"],
-    });
-    const $else = (0, parseSchema_js_1.parseSchema)(schema.else, {
-        ...refs,
-        path: [...refs.path, "else"],
-    });
-    let result = `z.union([${$then}, ${$else}]).superRefine((value,ctx) => {
-  const result = ${$if}.safeParse(value).success
-    ? ${$then}.safeParse(value)
-    : ${$else}.safeParse(value);
-  if (!result.success) {
-    const issues = result.error.issues;
-    issues.forEach((issue) => ctx.addIssue(issue))
-  }
-})`;
-    // Store original if/then/else for JSON Schema round-trip
-    if (refs.preserveJsonSchemaForRoundTrip) {
-        const conditionalMeta = JSON.stringify({
-            if: schema.if,
-            then: schema.then,
-            else: schema.else,
-        });
-        result += `.meta({ __jsonSchema: { conditional: ${conditionalMeta} } })`;
-    }
-    return result;
-};
-exports.parseIfThenElse = parseIfThenElse;

package/dist/cjs/parsers/parseMultipleType.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMultipleType = void 0;
-const parseSchema_js_1 = require("./parseSchema.js");
-const parseMultipleType = (schema, refs) => {
-    return `z.union([${schema.type
-        .map((type) => (0, parseSchema_js_1.parseSchema)({ ...schema, type }, { ...refs, withoutDefaults: true }))
-        .join(", ")}])`;
-};
-exports.parseMultipleType = parseMultipleType;

package/dist/cjs/parsers/parseNot.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNot = void 0;
-const parseSchema_js_1 = require("./parseSchema.js");
-const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
-const parseNot = (schema, refs) => {
-    return `${(0, anyOrUnknown_js_1.anyOrUnknown)(refs)}.refine((value) => !${(0, parseSchema_js_1.parseSchema)(schema.not, {
-        ...refs,
-        path: [...refs.path, "not"],
-    })}.safeParse(value).success, "Invalid input: Should NOT be valid against schema")`;
-};
-exports.parseNot = parseNot;

package/dist/cjs/parsers/parseNull.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNull = void 0;
-const parseNull = () => "z.null()";
-exports.parseNull = parseNull;

package/dist/cjs/parsers/parseNullable.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNullable = void 0;
-const omit_js_1 = require("../utils/omit.js");
-const parseSchema_js_1 = require("./parseSchema.js");
-/**
- * For compatibility with open api 3.0 nullable
- */
-const parseNullable = (schema, refs) => {
-    return `${(0, parseSchema_js_1.parseSchema)((0, omit_js_1.omit)(schema, "nullable"), refs, true)}.nullable()`;
-};
-exports.parseNullable = parseNullable;

package/dist/cjs/parsers/parseNumber.js

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNumber = void 0;
-const withMessage_js_1 = require("../utils/withMessage.js");
-const parseNumber = (schema) => {
-    const formatError = schema.errorMessage?.format;
-    const numericFormatMap = {
-        int32: "z.int32",
-        uint32: "z.uint32",
-        float32: "z.float32",
-        float64: "z.float64",
-        safeint: "z.safeint",
-        int64: "z.int64",
-        uint64: "z.uint64",
-    };
-    const mappedFormat = schema.format && numericFormatMap[schema.format] ? numericFormatMap[schema.format] : undefined;
-    const formatParams = formatError !== undefined ? `{ error: ${JSON.stringify(formatError)} }` : "";
-    let r = mappedFormat ? `${mappedFormat}(${formatParams})` : "z.number()";
-    if (schema.type === "integer") {
-        if (!mappedFormat) {
-            r += (0, withMessage_js_1.withMessage)(schema, "type", () => ({
-                opener: ".int(",
-                closer: ")",
-                messagePrefix: "{ error: ",
-                messageCloser: " })",
-            }));
-        }
-    }
-    else {
-        if (!mappedFormat) {
-            r += (0, withMessage_js_1.withMessage)(schema, "format", ({ value }) => {
-                if (value === "int64") {
-                    return {
-                        opener: ".int(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                }
-            });
-        }
-    }
-    r += (0, withMessage_js_1.withMessage)(schema, "multipleOf", ({ value, json }) => {
-        if (value === 1) {
-            if (r.startsWith("z.number().int(")) {
-                return;
-            }
-            return {
-                opener: ".int(",
-                closer: ")",
-                messagePrefix: "{ error: ",
-                messageCloser: " })",
-            };
-        }
-        return {
-            opener: `.multipleOf(${json}`,
-            closer: ")",
-            messagePrefix: ", { error: ",
-            messageCloser: " })",
-        };
-    });
-    if (typeof schema.minimum === "number") {
-        if (schema.exclusiveMinimum === true) {
-            r += (0, withMessage_js_1.withMessage)(schema, "minimum", ({ json }) => ({
-                opener: `.gt(${json}`,
-                closer: ")",
-                messagePrefix: ", { error: ",
-                messageCloser: " })",
-            }));
-        }
-        else {
-            r += (0, withMessage_js_1.withMessage)(schema, "minimum", ({ json }) => ({
-                opener: `.gte(${json}`,
-                closer: ")",
-                messagePrefix: ", { error: ",
-                messageCloser: " })",
-            }));
-        }
-    }
-    else if (typeof schema.exclusiveMinimum === "number") {
-        r += (0, withMessage_js_1.withMessage)(schema, "exclusiveMinimum", ({ json }) => ({
-            opener: `.gt(${json}`,
-            closer: ")",
-            messagePrefix: ", { error: ",
-            messageCloser: " })",
-        }));
-    }
-    if (typeof schema.maximum === "number") {
-        if (schema.exclusiveMaximum === true) {
-            r += (0, withMessage_js_1.withMessage)(schema, "maximum", ({ json }) => ({
-                opener: `.lt(${json}`,
-                closer: ")",
-                messagePrefix: ", { error: ",
-                messageCloser: " })",
-            }));
-        }
-        else {
-            r += (0, withMessage_js_1.withMessage)(schema, "maximum", ({ json }) => ({
-                opener: `.lte(${json}`,
-                closer: ")",
-                messagePrefix: ", { error: ",
-                messageCloser: " })",
-            }));
-        }
-    }
-    else if (typeof schema.exclusiveMaximum === "number") {
-        r += (0, withMessage_js_1.withMessage)(schema, "exclusiveMaximum", ({ json }) => ({
-            opener: `.lt(${json}`,
-            closer: ")",
-            messagePrefix: ", { error: ",
-            messageCloser: " })",
-        }));
-    }
-    return r;
-};
-exports.parseNumber = parseNumber;

package/dist/cjs/parsers/parseObject.js

@@ -1,315 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseObject = parseObject;
-const parseAnyOf_js_1 = require("./parseAnyOf.js");
-const parseOneOf_js_1 = require("./parseOneOf.js");
-const parseSchema_js_1 = require("./parseSchema.js");
-const parseAllOf_js_1 = require("./parseAllOf.js");
-const parseIfThenElse_js_1 = require("./parseIfThenElse.js");
-const jsdocs_js_1 = require("../utils/jsdocs.js");
-const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
-function parseObject(objectSchema, refs) {
-    let properties = undefined;
-    if (objectSchema.properties) {
-        if (!Object.keys(objectSchema.properties).length) {
-            properties = "z.object({})";
-        }
-        else {
-            properties = "z.object({ ";
-            properties += Object.keys(objectSchema.properties)
-                .map((key) => {
-                const propSchema = objectSchema.properties[key];
-                const parsedProp = (0, parseSchema_js_1.parseSchema)(propSchema, {
-                    ...refs,
-                    path: [...refs.path, "properties", key],
-                });
-                const hasDefault = typeof propSchema === "object" && propSchema.default !== undefined;
-                const required = Array.isArray(objectSchema.required)
-                    ? objectSchema.required.includes(key)
-                    : typeof propSchema === "object" && propSchema.required === true;
-                const optional = !hasDefault && !required;
-                const valueWithOptional = optional
-                    ? `${parsedProp}.optional()`
-                    : parsedProp;
-                let result = shouldUseGetter(valueWithOptional, refs)
-                    ? `get ${JSON.stringify(key)}(){ return ${valueWithOptional} }`
-                    : `${JSON.stringify(key)}: ${valueWithOptional}`;
-                if (refs.withJsdocs && typeof propSchema === "object") {
-                    result = (0, jsdocs_js_1.addJsdocs)(propSchema, result);
-                }
-                return result;
-            })
-                .join(", ");
-            properties += " })";
-        }
-    }
-    const additionalProperties = objectSchema.additionalProperties !== undefined
-        ? (0, parseSchema_js_1.parseSchema)(objectSchema.additionalProperties, {
-            ...refs,
-            path: [...refs.path, "additionalProperties"],
-        })
-        : undefined;
-    const unevaluated = objectSchema.unevaluatedProperties;
-    let patternProperties = undefined;
-    if (objectSchema.patternProperties) {
-        const parsedPatternProperties = Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([key, value]) => {
-            return [
-                key,
-                (0, parseSchema_js_1.parseSchema)(value, {
-                    ...refs,
-                    path: [...refs.path, "patternProperties", key],
-                }),
-            ];
-        }, {}));
-        patternProperties = "";
-        if (properties) {
-            if (additionalProperties) {
-                patternProperties += `.catchall(z.union([${[
-                    ...Object.values(parsedPatternProperties),
-                    additionalProperties,
-                ].join(", ")}]))`;
-            }
-            else if (Object.keys(parsedPatternProperties).length > 1) {
-                patternProperties += `.catchall(z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
-            }
-            else {
-                patternProperties += `.catchall(${Object.values(parsedPatternProperties)})`;
-            }
-        }
-        else {
-            if (additionalProperties) {
-                patternProperties += `z.record(z.string(), z.union([${[
-                    ...Object.values(parsedPatternProperties),
-                    additionalProperties,
-                ].join(", ")}]))`;
-            }
-            else if (Object.keys(parsedPatternProperties).length > 1) {
-                patternProperties += `z.record(z.string(), z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
-            }
-            else {
-                patternProperties += `z.record(z.string(), ${Object.values(parsedPatternProperties)})`;
-            }
-        }
-        patternProperties += ".superRefine((value, ctx) => {\n";
-        patternProperties += "for (const key in value) {\n";
-        if (additionalProperties) {
-            if (objectSchema.properties) {
-                patternProperties += `let evaluated = [${Object.keys(objectSchema.properties)
-                    .map((key) => JSON.stringify(key))
-                    .join(", ")}].includes(key)\n`;
-            }
-            else {
-                patternProperties += `let evaluated = false\n`;
-            }
-        }
-        for (const key in objectSchema.patternProperties) {
-            patternProperties +=
-                "if (key.match(new RegExp(" + JSON.stringify(key) + "))) {\n";
-            if (additionalProperties) {
-                patternProperties += "evaluated = true\n";
-            }
-            patternProperties +=
-                "const result = " +
-                    parsedPatternProperties[key] +
-                    ".safeParse(value[key])\n";
-            patternProperties += "if (!result.success) {\n";
-            patternProperties += `ctx.addIssue({
-          path: [...(ctx.path ?? []), key],
-          code: 'custom',
-          message: \`Invalid input: Key matching regex /\${key}/ must match schema\`,
-          params: {
-            issues: result.error.issues
-          }
-        })\n`;
-            patternProperties += "}\n";
-            patternProperties += "}\n";
-        }
-        if (additionalProperties) {
-            patternProperties += "if (!evaluated) {\n";
-            patternProperties +=
-                "const result = " + additionalProperties + ".safeParse(value[key])\n";
-            patternProperties += "if (!result.success) {\n";
-            patternProperties += `ctx.addIssue({
-          path: [...(ctx.path ?? []), key],
-          code: 'custom',
-          message: \`Invalid input: must match catchall schema\`,
-          params: {
-            issues: result.error.issues
-          }
-        })\n`;
-            patternProperties += "}\n";
-            patternProperties += "}\n";
-        }
-        patternProperties += "}\n";
-        patternProperties += "})";
-        // Store original patternProperties in meta for JSON Schema round-trip
-        if (refs.preserveJsonSchemaForRoundTrip) {
-            const patternPropsJson = JSON.stringify(Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([pattern, schema]) => [
-                pattern,
-                schema
-            ])));
-            patternProperties += `.meta({ __jsonSchema: { patternProperties: ${patternPropsJson} } })`;
-        }
-    }
-    // Check if there will be an .and() call that adds properties from oneOf/anyOf/allOf/if-then-else
-    // In that case, we should NOT use .strict() because it will reject the additional keys
-    // before the union gets a chance to validate them.
-    const hasCompositionKeywords = parseSchema_js_1.its.an.anyOf(objectSchema) || parseSchema_js_1.its.a.oneOf(objectSchema) || parseSchema_js_1.its.an.allOf(objectSchema) || parseSchema_js_1.its.a.conditional(objectSchema);
-    let output = properties
-        ? patternProperties
-            ? properties + patternProperties
-            : additionalProperties
-                ? additionalProperties === "z.never()"
-                    // Don't use .strict() if there are composition keywords that add properties
-                    ? hasCompositionKeywords
-                        ? properties
-                        : properties + ".strict()"
-                    : properties + `.catchall(${additionalProperties})`
-                : properties
-        : patternProperties
-            ? patternProperties
-            : additionalProperties
-                ? `z.record(z.string(), ${additionalProperties})`
-                : `z.record(z.string(), ${(0, anyOrUnknown_js_1.anyOrUnknown)(refs)})`;
-    if (unevaluated === false && properties && !hasCompositionKeywords) {
-        output += ".strict()";
-    }
-    else if (unevaluated && typeof unevaluated !== 'boolean') {
-        const unevaluatedSchema = (0, parseSchema_js_1.parseSchema)(unevaluated, {
-            ...refs,
-            path: [...refs.path, "unevaluatedProperties"],
-        });
-        const knownKeys = objectSchema.properties ? Object.keys(objectSchema.properties) : [];
-        const patterns = objectSchema.patternProperties
-            ? Object.keys(objectSchema.patternProperties).map((p) => new RegExp(p))
-            : [];
-        output += `.superRefine((value, ctx) => {
-  for (const key in value) {
-    const isKnown = ${JSON.stringify(knownKeys)}.includes(key);
-    const matchesPattern = ${patterns.length ? "[" + patterns.map((r) => r.toString()).join(",") + "]" : "[]"}.some((r) => r.test(key));
-    if (!isKnown && !matchesPattern) {
-      const result = ${unevaluatedSchema}.safeParse(value[key]);
-      if (!result.success) {
-        ctx.addIssue({ code: "custom", path: [key], message: "Invalid unevaluated property", params: { issues: result.error.issues } });
-      }
-    }
-  }
-})`;
-    }
-    if (parseSchema_js_1.its.an.anyOf(objectSchema)) {
-        output += `.and(${(0, parseAnyOf_js_1.parseAnyOf)({
-            ...objectSchema,
-            anyOf: objectSchema.anyOf.map((x) => typeof x === "object" &&
-                x !== null &&
-                !x.type &&
-                (x.properties || x.additionalProperties || x.patternProperties)
-                ? { ...x, type: "object" }
-                : x),
-        }, refs)})`;
-    }
-    if (parseSchema_js_1.its.a.oneOf(objectSchema)) {
-        output += `.and(${(0, parseOneOf_js_1.parseOneOf)({
-            ...objectSchema,
-            oneOf: objectSchema.oneOf.map((x) => typeof x === "object" &&
-                x !== null &&
-                !x.type &&
-                (x.properties || x.additionalProperties || x.patternProperties)
-                ? { ...x, type: "object" }
-                : x),
-        }, refs)})`;
-    }
-    if (parseSchema_js_1.its.an.allOf(objectSchema)) {
-        output += `.and(${(0, parseAllOf_js_1.parseAllOf)({
-            ...objectSchema,
-            allOf: objectSchema.allOf.map((x) => typeof x === "object" &&
-                x !== null &&
-                !x.type &&
-                (x.properties || x.additionalProperties || x.patternProperties)
-                ? { ...x, type: "object" }
-                : x),
-        }, refs)})`;
-    }
-    // Handle if/then/else conditionals on object schemas
-    if (parseSchema_js_1.its.a.conditional(objectSchema)) {
-        output += `.and(${(0, parseIfThenElse_js_1.parseIfThenElse)(objectSchema, refs)})`;
-    }
-    // propertyNames
-    if (objectSchema.propertyNames) {
-        const normalizedPropNames = typeof objectSchema.propertyNames === "object" &&
-            objectSchema.propertyNames !== null &&
-            !objectSchema.propertyNames.type &&
-            objectSchema.propertyNames.pattern
-            ? { ...objectSchema.propertyNames, type: "string" }
-            : objectSchema.propertyNames;
-        const propNameSchema = (0, parseSchema_js_1.parseSchema)(normalizedPropNames, {
-            ...refs,
-            path: [...refs.path, "propertyNames"],
-        });
-        output += `.superRefine((value, ctx) => {
-  for (const key in value) {
-    const result = ${propNameSchema}.safeParse(key);
-    if (!result.success) {
-      ctx.addIssue({
-        path: [key],
-        code: "custom",
-        message: "Invalid property name",
-        params: { issues: result.error.issues }
-      });
-    }
-  }
-})`;
-    }
-    // dependentSchemas
-    if (objectSchema.dependentSchemas && typeof objectSchema.dependentSchemas === "object") {
-        const entries = Object.entries(objectSchema.dependentSchemas);
-        if (entries.length) {
-            output += `.superRefine((obj, ctx) => {
-  ${entries
-                .map(([key, schema]) => {
-                const parsed = (0, parseSchema_js_1.parseSchema)(schema, { ...refs, path: [...refs.path, "dependentSchemas", key] });
-                return `if (Object.prototype.hasOwnProperty.call(obj, ${JSON.stringify(key)})) {
-    const result = ${parsed}.safeParse(obj);
-    if (!result.success) {
-      ctx.addIssue({ code: "custom", message: ${objectSchema.errorMessage?.dependentSchemas ?? JSON.stringify("Dependent schema failed")}, path: [], params: { issues: result.error.issues } });
-    }
-  }`;
-            })
-                .join("\n  ")}
-})`;
-        }
-    }
-    // dependentRequired
-    if (objectSchema.dependentRequired && typeof objectSchema.dependentRequired === "object") {
-        const entries = Object.entries(objectSchema.dependentRequired);
-        if (entries.length) {
-            const depRequiredMessage = objectSchema.errorMessage?.dependentRequired ??
-                "Dependent required properties missing";
-            output += `.superRefine((obj, ctx) => {
-  ${entries
-                .map(([prop, deps]) => {
-                const arr = Array.isArray(deps) ? deps : [];
-                if (!arr.length)
-                    return "";
-                const jsonDeps = JSON.stringify(arr);
-                return `if (Object.prototype.hasOwnProperty.call(obj, ${JSON.stringify(prop)})) {
-    const missing = ${jsonDeps}.filter((d) => !Object.prototype.hasOwnProperty.call(obj, d));
-    if (missing.length) {
-      ctx.addIssue({ code: "custom", message: ${JSON.stringify(depRequiredMessage)}, path: [], params: { missing } });
-    }
-  }`;
-            })
-                .filter(Boolean)
-                .join("\n  ")}
-})`;
-        }
-    }
-    return output;
-}
-const shouldUseGetter = (parsed, refs) => {
-    if (!parsed)
-        return false;
-    if (refs.currentSchemaName && parsed.includes(refs.currentSchemaName)) {
-        return true;
-    }
-    return Boolean(refs.inProgress && refs.inProgress.has(parsed));
-};