@gabrielbryk/json-schema-to-zod 2.7.2

package/dist/esm/parsers/parseObject.js

@@ -0,0 +1,283 @@
+import { parseAnyOf } from "./parseAnyOf.js";
+import { parseOneOf } from "./parseOneOf.js";
+import { its, parseSchema } from "./parseSchema.js";
+import { parseAllOf } from "./parseAllOf.js";
+import { parseIfThenElse } from "./parseIfThenElse.js";
+import { addJsdocs } from "../utils/jsdocs.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export 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 = 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 = addJsdocs(propSchema, result);
+                }
+                return result;
+            })
+                .join(", ");
+            properties += " })";
+        }
+    }
+    const additionalProperties = objectSchema.additionalProperties !== undefined
+        ? 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,
+                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: [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: [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
+    // 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 = its.an.anyOf(objectSchema) || its.a.oneOf(objectSchema) || its.an.allOf(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(), ${anyOrUnknown(refs)})`;
+    if (unevaluated === false && properties && !hasCompositionKeywords) {
+        output += ".strict()";
+    }
+    else if (unevaluated && typeof unevaluated !== 'boolean') {
+        const unevaluatedSchema = 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 (its.an.anyOf(objectSchema)) {
+        output += `.and(${parseAnyOf({
+            ...objectSchema,
+            anyOf: objectSchema.anyOf.map((x) => typeof x === "object" &&
+                !x.type &&
+                (x.properties || x.additionalProperties || x.patternProperties)
+                ? { ...x, type: "object" }
+                : x),
+        }, refs)})`;
+    }
+    if (its.a.oneOf(objectSchema)) {
+        output += `.and(${parseOneOf({
+            ...objectSchema,
+            oneOf: objectSchema.oneOf.map((x) => typeof x === "object" &&
+                !x.type &&
+                (x.properties || x.additionalProperties || x.patternProperties)
+                ? { ...x, type: "object" }
+                : x),
+        }, refs)})`;
+    }
+    if (its.an.allOf(objectSchema)) {
+        output += `.and(${parseAllOf({
+            ...objectSchema,
+            allOf: objectSchema.allOf.map((x) => typeof x === "object" &&
+                !x.type &&
+                (x.properties || x.additionalProperties || x.patternProperties)
+                ? { ...x, type: "object" }
+                : x),
+        }, refs)})`;
+    }
+    // Handle if/then/else conditionals on object schemas
+    if (its.a.conditional(objectSchema)) {
+        output += `.and(${parseIfThenElse(objectSchema, refs)})`;
+    }
+    // propertyNames
+    if (objectSchema.propertyNames) {
+        const normalizedPropNames = typeof objectSchema.propertyNames === "object" &&
+            !objectSchema.propertyNames.type &&
+            objectSchema.propertyNames.pattern
+            ? { ...objectSchema.propertyNames, type: "string" }
+            : objectSchema.propertyNames;
+        const propNameSchema = 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], idx) => {
+                const parsed = 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: "Dependent schema failed", path: [], params: { issues: result.error.issues } });
+    }
+  }`;
+            })
+                .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));
+};

package/dist/esm/parsers/parseOneOf.js

@@ -0,0 +1,49 @@
+import { parseSchema } from "./parseSchema.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export const parseOneOf = (schema, refs) => {
+    if (!schema.oneOf.length) {
+        return anyOrUnknown(refs);
+    }
+    if (schema.oneOf.length === 1) {
+        return parseSchema(schema.oneOf[0], {
+            ...refs,
+            path: [...refs.path, "oneOf", 0],
+        });
+    }
+    // Generate parsed schemas for each oneOf option
+    const parsedSchemas = schema.oneOf.map((s, i) => parseSchema(s, {
+        ...refs,
+        path: [...refs.path, "oneOf", i],
+    }));
+    // JSON Schema oneOf = exactly one must match (exclusive OR)
+    // Zod union = at least one must match (inclusive OR)
+    //
+    // By default, use simple z.union() which provides "at least one must match".
+    // This is more practical for most use cases, as strict oneOf enforcement
+    // often fails when schemas have overlapping base types.
+    //
+    // If strictOneOf is enabled, add superRefine to enforce "exactly one" constraint.
+    if (refs.strictOneOf) {
+        return `z.union([${parsedSchemas.join(", ")}]).superRefine((x, ctx) => {
+    const schemas = [${parsedSchemas.join(", ")}];
+    const errors = schemas.reduce<z.ZodError[]>(
+      (errors, schema) =>
+        ((result) =>
+          result.error ? [...errors, result.error] : errors)(
+          schema.safeParse(x),
+        ),
+      [],
+    );
+    if (schemas.length - errors.length !== 1) {
+      ctx.addIssue({
+        path: [],
+        code: "invalid_union",
+        errors: errors.map(e => e.issues),
+        message: "Invalid input: Should pass single schema",
+      });
+    }
+  })`;
+    }
+    // Default: use simple z.union() (at least one must match)
+    return `z.union([${parsedSchemas.join(", ")}])`;
+};

package/dist/esm/parsers/parseSchema.js

@@ -0,0 +1,281 @@
+import { parseAnyOf } from "./parseAnyOf.js";
+import { parseBoolean } from "./parseBoolean.js";
+import { parseDefault } from "./parseDefault.js";
+import { parseMultipleType } from "./parseMultipleType.js";
+import { parseNot } from "./parseNot.js";
+import { parseNull } from "./parseNull.js";
+import { parseAllOf } from "./parseAllOf.js";
+import { parseArray } from "./parseArray.js";
+import { parseConst } from "./parseConst.js";
+import { parseEnum } from "./parseEnum.js";
+import { parseIfThenElse } from "./parseIfThenElse.js";
+import { parseNumber } from "./parseNumber.js";
+import { parseObject } from "./parseObject.js";
+import { parseString } from "./parseString.js";
+import { parseOneOf } from "./parseOneOf.js";
+import { parseSimpleDiscriminatedOneOf } from "./parseSimpleDiscriminatedOneOf.js";
+import { parseNullable } from "./parseNullable.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export 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 ? 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 anyOrUnknown(refs);
+        }
+        seen.n += 1;
+    }
+    else {
+        seen = { r: undefined, n: 0 };
+        refs.seen.set(schema, seen);
+    }
+    if (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;
+};
+const parseRef = (schema, refs) => {
+    const resolved = resolveRef(refs.root, schema.$ref);
+    if (!resolved) {
+        return 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 = 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 (its.a.nullable(schema)) {
+        return parseNullable(schema, refs);
+    }
+    else if (its.an.object(schema)) {
+        return parseObject(schema, refs);
+    }
+    else if (its.an.array(schema)) {
+        return parseArray(schema, refs);
+    }
+    else if (its.an.anyOf(schema)) {
+        return parseAnyOf(schema, refs);
+    }
+    else if (its.an.allOf(schema)) {
+        return parseAllOf(schema, refs);
+    }
+    else if (its.a.simpleDiscriminatedOneOf(schema)) {
+        return parseSimpleDiscriminatedOneOf(schema, refs);
+    }
+    else if (its.a.oneOf(schema)) {
+        return parseOneOf(schema, refs);
+    }
+    else if (its.a.not(schema)) {
+        return parseNot(schema, refs);
+    }
+    else if (its.an.enum(schema)) {
+        return parseEnum(schema); //<-- needs to come before primitives
+    }
+    else if (its.a.const(schema)) {
+        return parseConst(schema);
+    }
+    else if (its.a.multipleType(schema)) {
+        return parseMultipleType(schema, refs);
+    }
+    else if (its.a.primitive(schema, "string")) {
+        return parseString(schema);
+    }
+    else if (its.a.primitive(schema, "number") ||
+        its.a.primitive(schema, "integer")) {
+        return parseNumber(schema);
+    }
+    else if (its.a.primitive(schema, "boolean")) {
+        return parseBoolean(schema);
+    }
+    else if (its.a.primitive(schema, "null")) {
+        return parseNull(schema);
+    }
+    else if (its.a.conditional(schema)) {
+        return parseIfThenElse(schema, refs);
+    }
+    else {
+        return parseDefault(schema, refs);
+    }
+};
+export const 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/esm/parsers/parseSimpleDiscriminatedOneOf.js

@@ -0,0 +1,25 @@
+import { parseSchema } from "./parseSchema.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export 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 = 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
+            ? parseSchema(schema.oneOf[0], {
+                ...refs,
+                path: [...refs.path, "oneOf", 0],
+            })
+            : `z.discriminatedUnion("${discriminator}", { ${entries.join(", ")} })`
+        : anyOrUnknown(refs);
+};