@gabrielbryk/json-schema-to-zod 2.7.2

package/.prettierrc.json

@@ -0,0 +1,3 @@
+{
+  "semi": true
+}

package/CONTRIBUTING.md

@@ -0,0 +1,9 @@
+# Contributing
+
+Hey, thanks for wanting to contribute.
+
+Before you open a PR, make sure to open an issue and discuss the problem you want to solve. I will not consider PRs without issues.
+
+I use [gitmoji](https://gitmoji.dev/) for my commit messages because I think it's fun. I encourage you to do the same, but won't enforce it.
+
+I check PRs and issues very rarely so please be patient.

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2021, Stefan Terdell
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,157 @@
+# Json-Schema-to-Zod
+
+[![NPM Version](https://img.shields.io/npm/v/%40gabrielbryk%2Fjson-schema-to-zod.svg)](https://npmjs.org/package/@gabrielbryk/json-schema-to-zod)
+[![NPM Downloads](https://img.shields.io/npm/dw/%40gabrielbryk%2Fjson-schema-to-zod.svg)](https://npmjs.org/package/@gabrielbryk/json-schema-to-zod)
+
+# Notice of maintenance fork
+
+The original package is being deprecated upstream, but this fork (<https://github.com/gabrielbryk/json-schema-to-zod>) continues maintenance and publishes to `@gabrielbryk/json-schema-to-zod` on npm.
+
+## Summary
+
+A runtime package and CLI tool to convert JSON schema (draft 4+) objects or files into Zod schemas in the form of JavaScript code.
+
+Before v2 it used [`prettier`](https://www.npmjs.com/package/prettier) for formatting and [`json-refs`](https://www.npmjs.com/package/json-refs) to resolve schemas. To replicate the previous behaviour, please use their respective CLI tools.
+
+Since v2 the CLI supports piped JSON.
+
+_Looking for the exact opposite? Check out [zod-to-json-schema](https://npmjs.org/package/zod-to-json-schema)_
+
+## Usage
+
+### Online
+
+[Just paste your JSON schemas here!](https://stefanterdell.github.io/json-schema-to-zod-react/)
+
+### CLI
+
+#### Simplest example
+
+```console
+npm i -g @gabrielbryk/json-schema-to-zod
+```
+
+```console
+json-schema-to-zod -i mySchema.json -o mySchema.ts
+```
+
+#### Example with `$refs` resolved and output formatted
+
+```console
+npm i -g @gabrielbryk/json-schema-to-zod json-refs prettier
+```
+
+```console
+json-refs resolve mySchema.json | json-schema-to-zod | prettier --parser typescript > mySchema.ts
+```
+
+#### Options
+
+| Flag           | Shorthand | Function                                                                                       |
+| -------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| `--input`      | `-i`      | JSON or a source file path. Required if no data is piped.                                      |
+| `--output`     | `-o`      | A file path to write to. If not supplied stdout will be used.                                  |
+| `--name`       | `-n`      | The name of the schema in the output                                                           |
+| `--depth`      | `-d`      | Maximum depth of recursion in schema before falling back to `z.any()`. Defaults to 0.          |
+| `--module`     | `-m`      | Module syntax; `esm`, `cjs` or none. Defaults to `esm` in the CLI and `none` programmaticly.   |
+| `--type`       | `-t`      | Export a named type along with the schema. Requires `name` to be set and `module` to be `esm`. |
+| `--noImport`   | `-ni`     | Removes the `import { z } from 'zod';` or equivalent from the output.                          |
+| `--withJsdocs` | `-wj`     | Generate jsdocs off of the description property.                                               |
+
+### Programmatic
+
+#### Simple example
+
+```typescript
+import { jsonSchemaToZod } from "@gabrielbryk/json-schema-to-zod";
+
+const myObject = {
+  type: "object",
+  properties: {
+    hello: {
+      type: "string",
+    },
+  },
+};
+
+const module = jsonSchemaToZod(myObject, { module: "esm" });
+
+// `type` can be either a string or - outside of the CLI - a boolean. If its `true`, the name of the type will be the name of the schema with a capitalized first letter.
+const moduleWithType = jsonSchemaToZod(myObject, {
+  name: "mySchema",
+  module: "esm",
+  type: true,
+});
+
+const cjs = jsonSchemaToZod(myObject, { module: "cjs", name: "mySchema" });
+
+const justTheSchema = jsonSchemaToZod(myObject);
+```
+
+##### `module`
+
+```typescript
+import { z } from "zod";
+
+export default z.object({ hello: z.string().optional() });
+```
+
+##### `moduleWithType`
+
+```typescript
+import { z } from "zod";
+
+export const mySchema = z.object({ hello: z.string().optional() });
+export type MySchema = z.infer<typeof mySchema>;
+```
+
+##### `cjs`
+
+```typescript
+const { z } = require("zod");
+
+module.exports = { mySchema: z.object({ hello: z.string().optional() }) };
+```
+
+##### `justTheSchema`
+
+```typescript
+z.object({ hello: z.string().optional() });
+```
+
+#### Example with `$refs` resolved and output formatted
+
+```typescript
+import { z } from "zod";
+import { resolveRefs } from "json-refs";
+import { format } from "prettier";
+import jsonSchemaToZod from "@gabrielbryk/json-schema-to-zod";
+
+async function example(jsonSchema: Record<string, unknown>): Promise<string> {
+  const { resolved } = await resolveRefs(jsonSchema);
+  const code = jsonSchemaToZod(resolved);
+  const formatted = await format(code, { parser: "typescript" });
+
+  return formatted;
+}
+```
+
+#### Overriding a parser
+
+You can pass a function to the `parserOverride` option, which represents a function that receives the current schema node and the reference object, and should return a string when it wants to replace a default output. If the default output should be used for the node just return void.
+
+#### Schema factoring
+
+Factored schemas (like object schemas with "oneOf" etc.) is only partially supported. Here be dragons.
+
+#### Use at Runtime
+
+The output of this package is not meant to be used at runtime. JSON Schema and Zod does not overlap 100% and the scope of the parsers are purposefully limited in order to help the author avoid a permanent state of chaotic insanity. As this may cause some details of the original schema to be lost in translation, it is instead recommended to use tools such as [Ajv](https://ajv.js.org/) to validate your runtime values directly against the original JSON Schema.
+
+That said, it's possible in most cases to use `eval`. Here's an example that you shouldn't use:
+
+```typescript
+const zodSchema = eval(jsonSchemaToZod({ type: "string" }, { module: "cjs" }));
+
+zodSchema.safeParse("Please just use Ajv instead");
+```

package/createIndex.ts

@@ -0,0 +1,32 @@
+import { readdirSync, writeFileSync, statSync } from "fs";
+
+const ignore = ["src/index.ts", "src/cli.ts", "src/utils/cliTools.ts"];
+
+function checkSrcDir(path: string): string[] {
+  const lines: string[] = [];
+
+  for (const item of readdirSync(path)) {
+    const itemPath = path + "/" + item;
+
+    if (ignore.includes(itemPath)) {
+      continue;
+    }
+
+    if (statSync(itemPath).isDirectory()) {
+      lines.push(...checkSrcDir(itemPath));
+    } else if (item.endsWith(".ts")) {
+      lines.push('export * from "./' + itemPath.slice(4, -2) + 'js"');
+    }
+  }
+
+  return lines;
+}
+
+const lines = checkSrcDir("src");
+
+lines.push(
+  'import { jsonSchemaToZod } from "./jsonSchemaToZod.js"',
+  "export default jsonSchemaToZod",
+);
+
+writeFileSync("./src/index.ts", lines.join("\n"));

package/dist/cjs/Types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/cli.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsonSchemaToZod_js_1 = require("./jsonSchemaToZod.js");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const cliTools_js_1 = require("./utils/cliTools.js");
+const params = {
+    input: {
+        shorthand: "i",
+        value: "string",
+        required: process.stdin.isTTY &&
+            "input is required when no JSON or file path is piped",
+        description: "JSON or a source file path. Required if no data is piped.",
+    },
+    output: {
+        shorthand: "o",
+        value: "string",
+        description: "A file path to write to. If not supplied stdout will be used.",
+    },
+    name: {
+        shorthand: "n",
+        value: "string",
+        description: "The name of the schema in the output.",
+    },
+    depth: {
+        shorthand: "d",
+        value: "number",
+        description: "Maximum depth of recursion before falling back to z.any(). Defaults to 0.",
+    },
+    module: {
+        shorthand: "m",
+        value: ["esm", "cjs", "none"],
+        description: "Module syntax; 'esm', 'cjs' or 'none'. Defaults to 'esm'.",
+    },
+    type: {
+        shorthand: "t",
+        value: "string",
+        description: "The name of the (optional) inferred type export."
+    },
+    noImport: {
+        shorthand: "ni",
+        description: "Removes the `import { z } from 'zod';` or equivalent from the output."
+    },
+    withJsdocs: {
+        shorthand: "wj",
+        description: "Generate jsdocs off of the description property.",
+    },
+};
+async function main() {
+    const args = (0, cliTools_js_1.parseArgs)(params, process.argv, true);
+    const input = args.input || (await (0, cliTools_js_1.readPipe)());
+    const jsonSchema = (0, cliTools_js_1.parseOrReadJSON)(input);
+    const zodSchema = (0, jsonSchemaToZod_js_1.jsonSchemaToZod)(jsonSchema, {
+        name: args.name,
+        depth: args.depth,
+        module: args.module || "esm",
+        noImport: args.noImport,
+        type: args.type,
+        withJsdocs: args.withJsdocs,
+    });
+    if (args.output) {
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(args.output), { recursive: true });
+        (0, fs_1.writeFileSync)(args.output, zodSchema);
+    }
+    else {
+        console.log(zodSchema);
+    }
+}
+void main();

package/dist/cjs/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Types.js"), exports);
+__exportStar(require("./jsonSchemaToZod.js"), exports);
+__exportStar(require("./parsers/parseAllOf.js"), exports);
+__exportStar(require("./parsers/parseAnyOf.js"), exports);
+__exportStar(require("./parsers/parseArray.js"), exports);
+__exportStar(require("./parsers/parseBoolean.js"), exports);
+__exportStar(require("./parsers/parseConst.js"), exports);
+__exportStar(require("./parsers/parseDefault.js"), exports);
+__exportStar(require("./parsers/parseEnum.js"), exports);
+__exportStar(require("./parsers/parseIfThenElse.js"), exports);
+__exportStar(require("./parsers/parseMultipleType.js"), exports);
+__exportStar(require("./parsers/parseNot.js"), exports);
+__exportStar(require("./parsers/parseNull.js"), exports);
+__exportStar(require("./parsers/parseNullable.js"), exports);
+__exportStar(require("./parsers/parseNumber.js"), exports);
+__exportStar(require("./parsers/parseObject.js"), exports);
+__exportStar(require("./parsers/parseOneOf.js"), exports);
+__exportStar(require("./parsers/parseSchema.js"), exports);
+__exportStar(require("./parsers/parseSimpleDiscriminatedOneOf.js"), exports);
+__exportStar(require("./parsers/parseString.js"), exports);
+__exportStar(require("./utils/anyOrUnknown.js"), exports);
+__exportStar(require("./utils/half.js"), exports);
+__exportStar(require("./utils/jsdocs.js"), exports);
+__exportStar(require("./utils/omit.js"), exports);
+__exportStar(require("./utils/withMessage.js"), exports);
+__exportStar(require("./zodToJsonSchema.js"), exports);
+const jsonSchemaToZod_js_1 = require("./jsonSchemaToZod.js");
+exports.default = jsonSchemaToZod_js_1.jsonSchemaToZod;

package/dist/cjs/jsonSchemaToZod.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonSchemaToZod = void 0;
+const parseSchema_js_1 = require("./parsers/parseSchema.js");
+const jsdocs_js_1 = require("./utils/jsdocs.js");
+const jsonSchemaToZod = (schema, { module, name, type, noImport, ...rest } = {}) => {
+    if (type && (!name || module !== "esm")) {
+        throw new Error("Option `type` requires `name` to be set and `module` to be `esm`");
+    }
+    const declarations = new Map();
+    const refNameByPointer = new Map();
+    const usedNames = new Set();
+    const exportRefs = rest.exportRefs ?? true;
+    const withMeta = rest.withMeta ?? true;
+    if (name)
+        usedNames.add(name);
+    const parsedSchema = (0, parseSchema_js_1.parseSchema)(schema, {
+        module,
+        name,
+        path: [],
+        seen: new Map(),
+        declarations,
+        inProgress: new Set(),
+        refNameByPointer,
+        usedNames,
+        root: schema,
+        currentSchemaName: name,
+        ...rest,
+        withMeta,
+    });
+    const declarationBlock = declarations.size
+        ? Array.from(declarations.entries())
+            .map(([refName, value]) => {
+            const shouldExport = exportRefs && module === "esm";
+            const decl = `${shouldExport ? "export " : ""}const ${refName} = ${value}`;
+            return decl;
+        })
+            .join("\n")
+        : "";
+    const jsdocs = rest.withJsdocs && typeof schema !== "boolean" && schema.description
+        ? (0, jsdocs_js_1.expandJsdocs)(schema.description)
+        : "";
+    const lines = [];
+    if (module === "cjs" && !noImport) {
+        lines.push(`const { z } = require("zod")`);
+    }
+    if (module === "esm" && !noImport) {
+        lines.push(`import { z } from "zod"`);
+    }
+    if (declarationBlock) {
+        lines.push(declarationBlock);
+    }
+    if (module === "cjs") {
+        const payload = name ? `{ ${JSON.stringify(name)}: ${parsedSchema} }` : parsedSchema;
+        lines.push(`${jsdocs}module.exports = ${payload}`);
+    }
+    else if (module === "esm") {
+        lines.push(`${jsdocs}export ${name ? `const ${name} =` : `default`} ${parsedSchema}`);
+    }
+    else if (name) {
+        lines.push(`${jsdocs}const ${name} = ${parsedSchema}`);
+    }
+    else {
+        lines.push(`${jsdocs}${parsedSchema}`);
+    }
+    let typeLine;
+    if (type && name) {
+        let typeName = typeof type === "string"
+            ? type
+            : `${name[0].toUpperCase()}${name.substring(1)}`;
+        typeLine = `export type ${typeName} = z.infer<typeof ${name}>`;
+    }
+    const joined = lines.filter(Boolean).join("\n\n");
+    const combined = typeLine ? `${joined}\n${typeLine}` : joined;
+    const shouldEndWithNewline = module === "esm" || module === "cjs";
+    return `${combined}${shouldEndWithNewline ? "\n" : ""}`;
+};
+exports.jsonSchemaToZod = jsonSchemaToZod;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/parsers/parseAllOf.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAllOf = parseAllOf;
+const parseSchema_js_1 = require("./parseSchema.js");
+const half_js_1 = require("../utils/half.js");
+const originalIndex = Symbol("Original index");
+const ensureOriginalIndex = (arr) => {
+    let newArr = [];
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        if (typeof item === "boolean") {
+            newArr.push(item ? { [originalIndex]: i } : { [originalIndex]: i, not: {} });
+        }
+        else if (originalIndex in item) {
+            return arr;
+        }
+        else {
+            newArr.push({ ...item, [originalIndex]: i });
+        }
+    }
+    return newArr;
+};
+function parseAllOf(schema, refs) {
+    if (schema.allOf.length === 0) {
+        return "z.never()";
+    }
+    else if (schema.allOf.length === 1) {
+        const item = schema.allOf[0];
+        return (0, parseSchema_js_1.parseSchema)(item, {
+            ...refs,
+            path: [...refs.path, "allOf", item[originalIndex]],
+        });
+    }
+    else {
+        const [left, right] = (0, half_js_1.half)(ensureOriginalIndex(schema.allOf));
+        return `z.intersection(${parseAllOf({ allOf: left }, refs)}, ${parseAllOf({
+            allOf: right,
+        }, refs)})`;
+    }
+}

package/dist/cjs/parsers/parseAnyOf.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAnyOf = void 0;
+const parseSchema_js_1 = require("./parseSchema.js");
+const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
+const parseAnyOf = (schema, refs) => {
+    return schema.anyOf.length
+        ? schema.anyOf.length === 1
+            ? (0, parseSchema_js_1.parseSchema)(schema.anyOf[0], {
+                ...refs,
+                path: [...refs.path, "anyOf", 0],
+            })
+            : `z.union([${schema.anyOf
+                .map((schema, i) => (0, parseSchema_js_1.parseSchema)(schema, { ...refs, path: [...refs.path, "anyOf", i] }))
+                .join(", ")}])`
+        : (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
+};
+exports.parseAnyOf = parseAnyOf;

package/dist/cjs/parsers/parseArray.js

@@ -0,0 +1,71 @@
+"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 }) => [
+        `.min(${json}`,
+        ", ",
+        ")",
+    ]);
+    r += (0, withMessage_js_1.withMessage)(schema, "maxItems", ({ json }) => [
+        `.max(${json}`,
+        ", ",
+        ")",
+    ]);
+    if (schema.uniqueItems === true) {
+        r += (0, withMessage_js_1.withMessage)(schema, "uniqueItems", () => [
+            ".unique(",
+            "",
+            ")",
+        ]);
+    }
+    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

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

package/dist/cjs/parsers/parseConst.js

@@ -0,0 +1,7 @@
+"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

@@ -0,0 +1,8 @@
+"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

@@ -0,0 +1,21 @@
+"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

@@ -0,0 +1,34 @@
+"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) {
+    result.error.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

@@ -0,0 +1,10 @@
+"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

@@ -0,0 +1,12 @@
+"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;