Refactor routing in App component to enhance navigation and improve error handling by integrating dynamic routes and updating the NotFound route.

node_modules/zod-to-json-schema/dist/cjs/Options.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultOptions = exports.defaultOptions = exports.jsonDescription = exports.ignoreOverride = void 0;
+exports.ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
+const jsonDescription = (jsonSchema, def) => {
+    if (def.description) {
+        try {
+            return {
+                ...jsonSchema,
+                ...JSON.parse(def.description),
+            };
+        }
+        catch { }
+    }
+    return jsonSchema;
+};
+exports.jsonDescription = jsonDescription;
+exports.defaultOptions = {
+    name: undefined,
+    $refStrategy: "root",
+    basePath: ["#"],
+    effectStrategy: "input",
+    pipeStrategy: "all",
+    dateStrategy: "format:date-time",
+    mapStrategy: "entries",
+    removeAdditionalStrategy: "passthrough",
+    allowedAdditionalProperties: true,
+    rejectedAdditionalProperties: false,
+    definitionPath: "definitions",
+    target: "jsonSchema7",
+    strictUnions: false,
+    definitions: {},
+    errorMessages: false,
+    markdownDescription: false,
+    patternStrategy: "escape",
+    applyRegexFlags: false,
+    emailStrategy: "format:email",
+    base64Strategy: "contentEncoding:base64",
+    nameStrategy: "ref",
+};
+const getDefaultOptions = (options) => (typeof options === "string"
+    ? {
+        ...exports.defaultOptions,
+        name: options,
+    }
+    : {
+        ...exports.defaultOptions,
+        ...options,
+    });
+exports.getDefaultOptions = getDefaultOptions;

node_modules/zod-to-json-schema/dist/cjs/Refs.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRefs = void 0;
+const Options_js_1 = require("./Options.js");
+const getRefs = (options) => {
+    const _options = (0, Options_js_1.getDefaultOptions)(options);
+    const currentPath = _options.name !== undefined
+        ? [..._options.basePath, _options.definitionPath, _options.name]
+        : _options.basePath;
+    return {
+        ..._options,
+        currentPath: currentPath,
+        propertyPath: undefined,
+        seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
+            def._def,
+            {
+                def: def._def,
+                path: [..._options.basePath, _options.definitionPath, name],
+                // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+                jsonSchema: undefined,
+            },
+        ])),
+    };
+};
+exports.getRefs = getRefs;

node_modules/zod-to-json-schema/dist/cjs/errorMessages.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setResponseValueAndErrors = exports.addErrorMessage = void 0;
+function addErrorMessage(res, key, errorMessage, refs) {
+    if (!refs?.errorMessages)
+        return;
+    if (errorMessage) {
+        res.errorMessage = {
+            ...res.errorMessage,
+            [key]: errorMessage,
+        };
+    }
+}
+exports.addErrorMessage = addErrorMessage;
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+    res[key] = value;
+    addErrorMessage(res, key, errorMessage, refs);
+}
+exports.setResponseValueAndErrors = setResponseValueAndErrors;

node_modules/zod-to-json-schema/dist/cjs/index.js

@@ -0,0 +1,55 @@
+"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("./Options.js"), exports);
+__exportStar(require("./Refs.js"), exports);
+__exportStar(require("./errorMessages.js"), exports);
+__exportStar(require("./parseDef.js"), exports);
+__exportStar(require("./parseTypes.js"), exports);
+__exportStar(require("./parsers/any.js"), exports);
+__exportStar(require("./parsers/array.js"), exports);
+__exportStar(require("./parsers/bigint.js"), exports);
+__exportStar(require("./parsers/boolean.js"), exports);
+__exportStar(require("./parsers/branded.js"), exports);
+__exportStar(require("./parsers/catch.js"), exports);
+__exportStar(require("./parsers/date.js"), exports);
+__exportStar(require("./parsers/default.js"), exports);
+__exportStar(require("./parsers/effects.js"), exports);
+__exportStar(require("./parsers/enum.js"), exports);
+__exportStar(require("./parsers/intersection.js"), exports);
+__exportStar(require("./parsers/literal.js"), exports);
+__exportStar(require("./parsers/map.js"), exports);
+__exportStar(require("./parsers/nativeEnum.js"), exports);
+__exportStar(require("./parsers/never.js"), exports);
+__exportStar(require("./parsers/null.js"), exports);
+__exportStar(require("./parsers/nullable.js"), exports);
+__exportStar(require("./parsers/number.js"), exports);
+__exportStar(require("./parsers/object.js"), exports);
+__exportStar(require("./parsers/optional.js"), exports);
+__exportStar(require("./parsers/pipeline.js"), exports);
+__exportStar(require("./parsers/promise.js"), exports);
+__exportStar(require("./parsers/readonly.js"), exports);
+__exportStar(require("./parsers/record.js"), exports);
+__exportStar(require("./parsers/set.js"), exports);
+__exportStar(require("./parsers/string.js"), exports);
+__exportStar(require("./parsers/tuple.js"), exports);
+__exportStar(require("./parsers/undefined.js"), exports);
+__exportStar(require("./parsers/union.js"), exports);
+__exportStar(require("./parsers/unknown.js"), exports);
+__exportStar(require("./selectParser.js"), exports);
+__exportStar(require("./zodToJsonSchema.js"), exports);
+const zodToJsonSchema_js_1 = require("./zodToJsonSchema.js");
+exports.default = zodToJsonSchema_js_1.zodToJsonSchema;

node_modules/zod-to-json-schema/dist/cjs/package.json

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

node_modules/zod-to-json-schema/dist/cjs/parseDef.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDef = void 0;
+const Options_js_1 = require("./Options.js");
+const selectParser_js_1 = require("./selectParser.js");
+function parseDef(def, refs, forceResolution = false) {
+    const seenItem = refs.seen.get(def);
+    if (refs.override) {
+        const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+        if (overrideResult !== Options_js_1.ignoreOverride) {
+            return overrideResult;
+        }
+    }
+    if (seenItem && !forceResolution) {
+        const seenSchema = get$ref(seenItem, refs);
+        if (seenSchema !== undefined) {
+            return seenSchema;
+        }
+    }
+    const newItem = { def, path: refs.currentPath, jsonSchema: undefined };
+    refs.seen.set(def, newItem);
+    const jsonSchemaOrGetter = (0, selectParser_js_1.selectParser)(def, def.typeName, refs);
+    // If the return was a function, then the inner definition needs to be extracted before a call to parseDef (recursive)
+    const jsonSchema = typeof jsonSchemaOrGetter === "function"
+        ? parseDef(jsonSchemaOrGetter(), refs)
+        : jsonSchemaOrGetter;
+    if (jsonSchema) {
+        addMeta(def, refs, jsonSchema);
+    }
+    if (refs.postProcess) {
+        const postProcessResult = refs.postProcess(jsonSchema, def, refs);
+        newItem.jsonSchema = jsonSchema;
+        return postProcessResult;
+    }
+    newItem.jsonSchema = jsonSchema;
+    return jsonSchema;
+}
+exports.parseDef = parseDef;
+const get$ref = (item, refs) => {
+    switch (refs.$refStrategy) {
+        case "root":
+            return { $ref: item.path.join("/") };
+        case "relative":
+            return { $ref: getRelativePath(refs.currentPath, item.path) };
+        case "none":
+        case "seen": {
+            if (item.path.length < refs.currentPath.length &&
+                item.path.every((value, index) => refs.currentPath[index] === value)) {
+                console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
+                return {};
+            }
+            return refs.$refStrategy === "seen" ? {} : undefined;
+        }
+    }
+};
+const getRelativePath = (pathA, pathB) => {
+    let i = 0;
+    for (; i < pathA.length && i < pathB.length; i++) {
+        if (pathA[i] !== pathB[i])
+            break;
+    }
+    return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
+};
+const addMeta = (def, refs, jsonSchema) => {
+    if (def.description) {
+        jsonSchema.description = def.description;
+        if (refs.markdownDescription) {
+            jsonSchema.markdownDescription = def.description;
+        }
+    }
+    return jsonSchema;
+};

node_modules/zod-to-json-schema/dist/cjs/parseTypes.js

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

node_modules/zod-to-json-schema/dist/cjs/parsers/any.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAnyDef = void 0;
+function parseAnyDef() {
+    return {};
+}
+exports.parseAnyDef = parseAnyDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/array.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArrayDef = void 0;
+const zod_1 = require("zod");
+const errorMessages_js_1 = require("../errorMessages.js");
+const parseDef_js_1 = require("../parseDef.js");
+function parseArrayDef(def, refs) {
+    const res = {
+        type: "array",
+    };
+    if (def.type?._def &&
+        def.type?._def?.typeName !== zod_1.ZodFirstPartyTypeKind.ZodAny) {
+        res.items = (0, parseDef_js_1.parseDef)(def.type._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, "items"],
+        });
+    }
+    if (def.minLength) {
+        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minItems", def.minLength.value, def.minLength.message, refs);
+    }
+    if (def.maxLength) {
+        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+    }
+    if (def.exactLength) {
+        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+    }
+    return res;
+}
+exports.parseArrayDef = parseArrayDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/bigint.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBigintDef = void 0;
+const errorMessages_js_1 = require("../errorMessages.js");
+function parseBigintDef(def, refs) {
+    const res = {
+        type: "integer",
+        format: "int64",
+    };
+    if (!def.checks)
+        return res;
+    for (const check of def.checks) {
+        switch (check.kind) {
+            case "min":
+                if (refs.target === "jsonSchema7") {
+                    if (check.inclusive) {
+                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minimum", check.value, check.message, refs);
+                    }
+                    else {
+                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "exclusiveMinimum", check.value, check.message, refs);
+                    }
+                }
+                else {
+                    if (!check.inclusive) {
+                        res.exclusiveMinimum = true;
+                    }
+                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minimum", check.value, check.message, refs);
+                }
+                break;
+            case "max":
+                if (refs.target === "jsonSchema7") {
+                    if (check.inclusive) {
+                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maximum", check.value, check.message, refs);
+                    }
+                    else {
+                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "exclusiveMaximum", check.value, check.message, refs);
+                    }
+                }
+                else {
+                    if (!check.inclusive) {
+                        res.exclusiveMaximum = true;
+                    }
+                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maximum", check.value, check.message, refs);
+                }
+                break;
+            case "multipleOf":
+                (0, errorMessages_js_1.setResponseValueAndErrors)(res, "multipleOf", check.value, check.message, refs);
+                break;
+        }
+    }
+    return res;
+}
+exports.parseBigintDef = parseBigintDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/boolean.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBooleanDef = void 0;
+function parseBooleanDef() {
+    return {
+        type: "boolean",
+    };
+}
+exports.parseBooleanDef = parseBooleanDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/branded.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBrandedDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+function parseBrandedDef(_def, refs) {
+    return (0, parseDef_js_1.parseDef)(_def.type._def, refs);
+}
+exports.parseBrandedDef = parseBrandedDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/catch.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCatchDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+const parseCatchDef = (def, refs) => {
+    return (0, parseDef_js_1.parseDef)(def.innerType._def, refs);
+};
+exports.parseCatchDef = parseCatchDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/date.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDateDef = void 0;
+const errorMessages_js_1 = require("../errorMessages.js");
+function parseDateDef(def, refs, overrideDateStrategy) {
+    const strategy = overrideDateStrategy ?? refs.dateStrategy;
+    if (Array.isArray(strategy)) {
+        return {
+            anyOf: strategy.map((item, i) => parseDateDef(def, refs, item)),
+        };
+    }
+    switch (strategy) {
+        case "string":
+        case "format:date-time":
+            return {
+                type: "string",
+                format: "date-time",
+            };
+        case "format:date":
+            return {
+                type: "string",
+                format: "date",
+            };
+        case "integer":
+            return integerDateParser(def, refs);
+    }
+}
+exports.parseDateDef = parseDateDef;
+const integerDateParser = (def, refs) => {
+    const res = {
+        type: "integer",
+        format: "unix-time",
+    };
+    if (refs.target === "openApi3") {
+        return res;
+    }
+    for (const check of def.checks) {
+        switch (check.kind) {
+            case "min":
+                (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minimum", check.value, // This is in milliseconds
+                check.message, refs);
+                break;
+            case "max":
+                (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maximum", check.value, // This is in milliseconds
+                check.message, refs);
+                break;
+        }
+    }
+    return res;
+};

node_modules/zod-to-json-schema/dist/cjs/parsers/default.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDefaultDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+function parseDefaultDef(_def, refs) {
+    return {
+        ...(0, parseDef_js_1.parseDef)(_def.innerType._def, refs),
+        default: _def.defaultValue(),
+    };
+}
+exports.parseDefaultDef = parseDefaultDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/effects.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEffectsDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+function parseEffectsDef(_def, refs) {
+    return refs.effectStrategy === "input"
+        ? (0, parseDef_js_1.parseDef)(_def.schema._def, refs)
+        : {};
+}
+exports.parseEffectsDef = parseEffectsDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/enum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnumDef = void 0;
+function parseEnumDef(def) {
+    return {
+        type: "string",
+        enum: Array.from(def.values),
+    };
+}
+exports.parseEnumDef = parseEnumDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/intersection.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIntersectionDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+const isJsonSchema7AllOfType = (type) => {
+    if ("type" in type && type.type === "string")
+        return false;
+    return "allOf" in type;
+};
+function parseIntersectionDef(def, refs) {
+    const allOf = [
+        (0, parseDef_js_1.parseDef)(def.left._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, "allOf", "0"],
+        }),
+        (0, parseDef_js_1.parseDef)(def.right._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, "allOf", "1"],
+        }),
+    ].filter((x) => !!x);
+    let unevaluatedProperties = refs.target === "jsonSchema2019-09"
+        ? { unevaluatedProperties: false }
+        : undefined;
+    const mergedAllOf = [];
+    // If either of the schemas is an allOf, merge them into a single allOf
+    allOf.forEach((schema) => {
+        if (isJsonSchema7AllOfType(schema)) {
+            mergedAllOf.push(...schema.allOf);
+            if (schema.unevaluatedProperties === undefined) {
+                // If one of the schemas has no unevaluatedProperties set,
+                // the merged schema should also have no unevaluatedProperties set
+                unevaluatedProperties = undefined;
+            }
+        }
+        else {
+            let nestedSchema = schema;
+            if ("additionalProperties" in schema &&
+                schema.additionalProperties === false) {
+                const { additionalProperties, ...rest } = schema;
+                nestedSchema = rest;
+            }
+            else {
+                // As soon as one of the schemas has additionalProperties set not to false, we allow unevaluatedProperties
+                unevaluatedProperties = undefined;
+            }
+            mergedAllOf.push(nestedSchema);
+        }
+    });
+    return mergedAllOf.length
+        ? {
+            allOf: mergedAllOf,
+            ...unevaluatedProperties,
+        }
+        : undefined;
+}
+exports.parseIntersectionDef = parseIntersectionDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/literal.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLiteralDef = void 0;
+function parseLiteralDef(def, refs) {
+    const parsedType = typeof def.value;
+    if (parsedType !== "bigint" &&
+        parsedType !== "number" &&
+        parsedType !== "boolean" &&
+        parsedType !== "string") {
+        return {
+            type: Array.isArray(def.value) ? "array" : "object",
+        };
+    }
+    if (refs.target === "openApi3") {
+        return {
+            type: parsedType === "bigint" ? "integer" : parsedType,
+            enum: [def.value],
+        };
+    }
+    return {
+        type: parsedType === "bigint" ? "integer" : parsedType,
+        const: def.value,
+    };
+}
+exports.parseLiteralDef = parseLiteralDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/map.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMapDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+const record_js_1 = require("./record.js");
+function parseMapDef(def, refs) {
+    if (refs.mapStrategy === "record") {
+        return (0, record_js_1.parseRecordDef)(def, refs);
+    }
+    const keys = (0, parseDef_js_1.parseDef)(def.keyType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", "items", "0"],
+    }) || {};
+    const values = (0, parseDef_js_1.parseDef)(def.valueType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", "items", "1"],
+    }) || {};
+    return {
+        type: "array",
+        maxItems: 125,
+        items: {
+            type: "array",
+            items: [keys, values],
+            minItems: 2,
+            maxItems: 2,
+        },
+    };
+}
+exports.parseMapDef = parseMapDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/nativeEnum.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNativeEnumDef = void 0;
+function parseNativeEnumDef(def) {
+    const object = def.values;
+    const actualKeys = Object.keys(def.values).filter((key) => {
+        return typeof object[object[key]] !== "number";
+    });
+    const actualValues = actualKeys.map((key) => object[key]);
+    const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
+    return {
+        type: parsedTypes.length === 1
+            ? parsedTypes[0] === "string"
+                ? "string"
+                : "number"
+            : ["string", "number"],
+        enum: actualValues,
+    };
+}
+exports.parseNativeEnumDef = parseNativeEnumDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/never.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNeverDef = void 0;
+function parseNeverDef() {
+    return {
+        not: {},
+    };
+}
+exports.parseNeverDef = parseNeverDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/null.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNullDef = void 0;
+function parseNullDef(refs) {
+    return refs.target === "openApi3"
+        ? {
+            enum: ["null"],
+            nullable: true,
+        }
+        : {
+            type: "null",
+        };
+}
+exports.parseNullDef = parseNullDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/nullable.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNullableDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+const union_js_1 = require("./union.js");
+function parseNullableDef(def, refs) {
+    if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) &&
+        (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
+        if (refs.target === "openApi3") {
+            return {
+                type: union_js_1.primitiveMappings[def.innerType._def.typeName],
+                nullable: true,
+            };
+        }
+        return {
+            type: [
+                union_js_1.primitiveMappings[def.innerType._def.typeName],
+                "null",
+            ],
+        };
+    }
+    if (refs.target === "openApi3") {
+        const base = (0, parseDef_js_1.parseDef)(def.innerType._def, {
+            ...refs,
+            currentPath: [...refs.currentPath],
+        });
+        if (base && "$ref" in base)
+            return { allOf: [base], nullable: true };
+        return base && { ...base, nullable: true };
+    }
+    const base = (0, parseDef_js_1.parseDef)(def.innerType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "anyOf", "0"],
+    });
+    return base && { anyOf: [base, { type: "null" }] };
+}
+exports.parseNullableDef = parseNullableDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/number.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNumberDef = void 0;
+const errorMessages_js_1 = require("../errorMessages.js");
+function parseNumberDef(def, refs) {
+    const res = {
+        type: "number",
+    };
+    if (!def.checks)
+        return res;
+    for (const check of def.checks) {
+        switch (check.kind) {
+            case "int":
+                res.type = "integer";
+                (0, errorMessages_js_1.addErrorMessage)(res, "type", check.message, refs);
+                break;
+            case "min":
+                if (refs.target === "jsonSchema7") {
+                    if (check.inclusive) {
+                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minimum", check.value, check.message, refs);
+                    }
+                    else {
+                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "exclusiveMinimum", check.value, check.message, refs);
+                    }
+                }
+                else {
+                    if (!check.inclusive) {
+                        res.exclusiveMinimum = true;
+                    }
+                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minimum", check.value, check.message, refs);
+                }
+                break;
+            case "max":
+                if (refs.target === "jsonSchema7") {
+                    if (check.inclusive) {
+                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maximum", check.value, check.message, refs);
+                    }
+                    else {
+                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "exclusiveMaximum", check.value, check.message, refs);
+                    }
+                }
+                else {
+                    if (!check.inclusive) {
+                        res.exclusiveMaximum = true;
+                    }
+                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maximum", check.value, check.message, refs);
+                }
+                break;
+            case "multipleOf":
+                (0, errorMessages_js_1.setResponseValueAndErrors)(res, "multipleOf", check.value, check.message, refs);
+                break;
+        }
+    }
+    return res;
+}
+exports.parseNumberDef = parseNumberDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/object.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseObjectDef = void 0;
+const zod_1 = require("zod");
+const parseDef_js_1 = require("../parseDef.js");
+function parseObjectDef(def, refs) {
+    const forceOptionalIntoNullable = refs.target === "openAi";
+    const result = {
+        type: "object",
+        properties: {},
+    };
+    const required = [];
+    const shape = def.shape();
+    for (const propName in shape) {
+        let propDef = shape[propName];
+        if (propDef === undefined || propDef._def === undefined) {
+            continue;
+        }
+        let propOptional = safeIsOptional(propDef);
+        if (propOptional && forceOptionalIntoNullable) {
+            if (propDef instanceof zod_1.ZodOptional) {
+                propDef = propDef._def.innerType;
+            }
+            if (!propDef.isNullable()) {
+                propDef = propDef.nullable();
+            }
+            propOptional = false;
+        }
+        const parsedDef = (0, parseDef_js_1.parseDef)(propDef._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, "properties", propName],
+            propertyPath: [...refs.currentPath, "properties", propName],
+        });
+        if (parsedDef === undefined) {
+            continue;
+        }
+        result.properties[propName] = parsedDef;
+        if (!propOptional) {
+            required.push(propName);
+        }
+    }
+    if (required.length) {
+        result.required = required;
+    }
+    const additionalProperties = decideAdditionalProperties(def, refs);
+    if (additionalProperties !== undefined) {
+        result.additionalProperties = additionalProperties;
+    }
+    return result;
+}
+exports.parseObjectDef = parseObjectDef;
+function decideAdditionalProperties(def, refs) {
+    if (def.catchall._def.typeName !== "ZodNever") {
+        return (0, parseDef_js_1.parseDef)(def.catchall._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, "additionalProperties"],
+        });
+    }
+    switch (def.unknownKeys) {
+        case "passthrough":
+            return refs.allowedAdditionalProperties;
+        case "strict":
+            return refs.rejectedAdditionalProperties;
+        case "strip":
+            return refs.removeAdditionalStrategy === "strict"
+                ? refs.allowedAdditionalProperties
+                : refs.rejectedAdditionalProperties;
+    }
+}
+function safeIsOptional(schema) {
+    try {
+        return schema.isOptional();
+    }
+    catch {
+        return true;
+    }
+}

node_modules/zod-to-json-schema/dist/cjs/parsers/optional.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOptionalDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+const parseOptionalDef = (def, refs) => {
+    if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
+        return (0, parseDef_js_1.parseDef)(def.innerType._def, refs);
+    }
+    const innerSchema = (0, parseDef_js_1.parseDef)(def.innerType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "anyOf", "1"],
+    });
+    return innerSchema
+        ? {
+            anyOf: [
+                {
+                    not: {},
+                },
+                innerSchema,
+            ],
+        }
+        : {};
+};
+exports.parseOptionalDef = parseOptionalDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/pipeline.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePipelineDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+const parsePipelineDef = (def, refs) => {
+    if (refs.pipeStrategy === "input") {
+        return (0, parseDef_js_1.parseDef)(def.in._def, refs);
+    }
+    else if (refs.pipeStrategy === "output") {
+        return (0, parseDef_js_1.parseDef)(def.out._def, refs);
+    }
+    const a = (0, parseDef_js_1.parseDef)(def.in._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "allOf", "0"],
+    });
+    const b = (0, parseDef_js_1.parseDef)(def.out._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"],
+    });
+    return {
+        allOf: [a, b].filter((x) => x !== undefined),
+    };
+};
+exports.parsePipelineDef = parsePipelineDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/promise.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePromiseDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+function parsePromiseDef(def, refs) {
+    return (0, parseDef_js_1.parseDef)(def.type._def, refs);
+}
+exports.parsePromiseDef = parsePromiseDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/readonly.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseReadonlyDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+const parseReadonlyDef = (def, refs) => {
+    return (0, parseDef_js_1.parseDef)(def.innerType._def, refs);
+};
+exports.parseReadonlyDef = parseReadonlyDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/record.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRecordDef = void 0;
+const zod_1 = require("zod");
+const parseDef_js_1 = require("../parseDef.js");
+const string_js_1 = require("./string.js");
+const branded_js_1 = require("./branded.js");
+function parseRecordDef(def, refs) {
+    if (refs.target === "openAi") {
+        console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
+    }
+    if (refs.target === "openApi3" &&
+        def.keyType?._def.typeName === zod_1.ZodFirstPartyTypeKind.ZodEnum) {
+        return {
+            type: "object",
+            required: def.keyType._def.values,
+            properties: def.keyType._def.values.reduce((acc, key) => ({
+                ...acc,
+                [key]: (0, parseDef_js_1.parseDef)(def.valueType._def, {
+                    ...refs,
+                    currentPath: [...refs.currentPath, "properties", key],
+                }) ?? {},
+            }), {}),
+            additionalProperties: refs.rejectedAdditionalProperties,
+        };
+    }
+    const schema = {
+        type: "object",
+        additionalProperties: (0, parseDef_js_1.parseDef)(def.valueType._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, "additionalProperties"],
+        }) ?? refs.allowedAdditionalProperties,
+    };
+    if (refs.target === "openApi3") {
+        return schema;
+    }
+    if (def.keyType?._def.typeName === zod_1.ZodFirstPartyTypeKind.ZodString &&
+        def.keyType._def.checks?.length) {
+        const { type, ...keyType } = (0, string_js_1.parseStringDef)(def.keyType._def, refs);
+        return {
+            ...schema,
+            propertyNames: keyType,
+        };
+    }
+    else if (def.keyType?._def.typeName === zod_1.ZodFirstPartyTypeKind.ZodEnum) {
+        return {
+            ...schema,
+            propertyNames: {
+                enum: def.keyType._def.values,
+            },
+        };
+    }
+    else if (def.keyType?._def.typeName === zod_1.ZodFirstPartyTypeKind.ZodBranded &&
+        def.keyType._def.type._def.typeName === zod_1.ZodFirstPartyTypeKind.ZodString &&
+        def.keyType._def.type._def.checks?.length) {
+        const { type, ...keyType } = (0, branded_js_1.parseBrandedDef)(def.keyType._def, refs);
+        return {
+            ...schema,
+            propertyNames: keyType,
+        };
+    }
+    return schema;
+}
+exports.parseRecordDef = parseRecordDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/set.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSetDef = void 0;
+const errorMessages_js_1 = require("../errorMessages.js");
+const parseDef_js_1 = require("../parseDef.js");
+function parseSetDef(def, refs) {
+    const items = (0, parseDef_js_1.parseDef)(def.valueType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items"],
+    });
+    const schema = {
+        type: "array",
+        uniqueItems: true,
+        items,
+    };
+    if (def.minSize) {
+        (0, errorMessages_js_1.setResponseValueAndErrors)(schema, "minItems", def.minSize.value, def.minSize.message, refs);
+    }
+    if (def.maxSize) {
+        (0, errorMessages_js_1.setResponseValueAndErrors)(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+    }
+    return schema;
+}
+exports.parseSetDef = parseSetDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/string.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStringDef = exports.zodPatterns = void 0;
+const errorMessages_js_1 = require("../errorMessages.js");
+let emojiRegex = undefined;
+/**
+ * Generated from the regular expressions found here as of 2024-05-22:
+ * https://github.com/colinhacks/zod/blob/master/src/types.ts.
+ *
+ * Expressions with /i flag have been changed accordingly.
+ */
+exports.zodPatterns = {
+    /**
+     * `c` was changed to `[cC]` to replicate /i flag
+     */
+    cuid: /^[cC][^\s-]{8,}$/,
+    cuid2: /^[0-9a-z]+$/,
+    ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+    /**
+     * `a-z` was added to replicate /i flag
+     */
+    email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+    /**
+     * Constructed a valid Unicode RegExp
+     *
+     * Lazily instantiate since this type of regex isn't supported
+     * in all envs (e.g. React Native).
+     *
+     * See:
+     * https://github.com/colinhacks/zod/issues/2433
+     * Fix in Zod:
+     * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+     */
+    emoji: () => {
+        if (emojiRegex === undefined) {
+            emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+        }
+        return emojiRegex;
+    },
+    /**
+     * Unused
+     */
+    uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+    /**
+     * Unused
+     */
+    ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+    ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+    /**
+     * Unused
+     */
+    ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+    ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+    base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+    base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+    nanoid: /^[a-zA-Z0-9_-]{21}$/,
+    jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/,
+};
+function parseStringDef(def, refs) {
+    const res = {
+        type: "string",
+    };
+    if (def.checks) {
+        for (const check of def.checks) {
+            switch (check.kind) {
+                case "min":
+                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minLength", typeof res.minLength === "number"
+                        ? Math.max(res.minLength, check.value)
+                        : check.value, check.message, refs);
+                    break;
+                case "max":
+                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maxLength", typeof res.maxLength === "number"
+                        ? Math.min(res.maxLength, check.value)
+                        : check.value, check.message, refs);
+                    break;
+                case "email":
+                    switch (refs.emailStrategy) {
+                        case "format:email":
+                            addFormat(res, "email", check.message, refs);
+                            break;
+                        case "format:idn-email":
+                            addFormat(res, "idn-email", check.message, refs);
+                            break;
+                        case "pattern:zod":
+                            addPattern(res, exports.zodPatterns.email, check.message, refs);
+                            break;
+                    }
+                    break;
+                case "url":
+                    addFormat(res, "uri", check.message, refs);
+                    break;
+                case "uuid":
+                    addFormat(res, "uuid", check.message, refs);
+                    break;
+                case "regex":
+                    addPattern(res, check.regex, check.message, refs);
+                    break;
+                case "cuid":
+                    addPattern(res, exports.zodPatterns.cuid, check.message, refs);
+                    break;
+                case "cuid2":
+                    addPattern(res, exports.zodPatterns.cuid2, check.message, refs);
+                    break;
+                case "startsWith":
+                    addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
+                    break;
+                case "endsWith":
+                    addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
+                    break;
+                case "datetime":
+                    addFormat(res, "date-time", check.message, refs);
+                    break;
+                case "date":
+                    addFormat(res, "date", check.message, refs);
+                    break;
+                case "time":
+                    addFormat(res, "time", check.message, refs);
+                    break;
+                case "duration":
+                    addFormat(res, "duration", check.message, refs);
+                    break;
+                case "length":
+                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minLength", typeof res.minLength === "number"
+                        ? Math.max(res.minLength, check.value)
+                        : check.value, check.message, refs);
+                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maxLength", typeof res.maxLength === "number"
+                        ? Math.min(res.maxLength, check.value)
+                        : check.value, check.message, refs);
+                    break;
+                case "includes": {
+                    addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
+                    break;
+                }
+                case "ip": {
+                    if (check.version !== "v6") {
+                        addFormat(res, "ipv4", check.message, refs);
+                    }
+                    if (check.version !== "v4") {
+                        addFormat(res, "ipv6", check.message, refs);
+                    }
+                    break;
+                }
+                case "base64url":
+                    addPattern(res, exports.zodPatterns.base64url, check.message, refs);
+                    break;
+                case "jwt":
+                    addPattern(res, exports.zodPatterns.jwt, check.message, refs);
+                    break;
+                case "cidr": {
+                    if (check.version !== "v6") {
+                        addPattern(res, exports.zodPatterns.ipv4Cidr, check.message, refs);
+                    }
+                    if (check.version !== "v4") {
+                        addPattern(res, exports.zodPatterns.ipv6Cidr, check.message, refs);
+                    }
+                    break;
+                }
+                case "emoji":
+                    addPattern(res, exports.zodPatterns.emoji(), check.message, refs);
+                    break;
+                case "ulid": {
+                    addPattern(res, exports.zodPatterns.ulid, check.message, refs);
+                    break;
+                }
+                case "base64": {
+                    switch (refs.base64Strategy) {
+                        case "format:binary": {
+                            addFormat(res, "binary", check.message, refs);
+                            break;
+                        }
+                        case "contentEncoding:base64": {
+                            (0, errorMessages_js_1.setResponseValueAndErrors)(res, "contentEncoding", "base64", check.message, refs);
+                            break;
+                        }
+                        case "pattern:zod": {
+                            addPattern(res, exports.zodPatterns.base64, check.message, refs);
+                            break;
+                        }
+                    }
+                    break;
+                }
+                case "nanoid": {
+                    addPattern(res, exports.zodPatterns.nanoid, check.message, refs);
+                }
+                case "toLowerCase":
+                case "toUpperCase":
+                case "trim":
+                    break;
+                default:
+                    /* c8 ignore next */
+                    ((_) => { })(check);
+            }
+        }
+    }
+    return res;
+}
+exports.parseStringDef = parseStringDef;
+function escapeLiteralCheckValue(literal, refs) {
+    return refs.patternStrategy === "escape"
+        ? escapeNonAlphaNumeric(literal)
+        : literal;
+}
+const ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function escapeNonAlphaNumeric(source) {
+    let result = "";
+    for (let i = 0; i < source.length; i++) {
+        if (!ALPHA_NUMERIC.has(source[i])) {
+            result += "\\";
+        }
+        result += source[i];
+    }
+    return result;
+}
+// Adds a "format" keyword to the schema. If a format exists, both formats will be joined in an allOf-node, along with subsequent ones.
+function addFormat(schema, value, message, refs) {
+    if (schema.format || schema.anyOf?.some((x) => x.format)) {
+        if (!schema.anyOf) {
+            schema.anyOf = [];
+        }
+        if (schema.format) {
+            schema.anyOf.push({
+                format: schema.format,
+                ...(schema.errorMessage &&
+                    refs.errorMessages && {
+                    errorMessage: { format: schema.errorMessage.format },
+                }),
+            });
+            delete schema.format;
+            if (schema.errorMessage) {
+                delete schema.errorMessage.format;
+                if (Object.keys(schema.errorMessage).length === 0) {
+                    delete schema.errorMessage;
+                }
+            }
+        }
+        schema.anyOf.push({
+            format: value,
+            ...(message &&
+                refs.errorMessages && { errorMessage: { format: message } }),
+        });
+    }
+    else {
+        (0, errorMessages_js_1.setResponseValueAndErrors)(schema, "format", value, message, refs);
+    }
+}
+// Adds a "pattern" keyword to the schema. If a pattern exists, both patterns will be joined in an allOf-node, along with subsequent ones.
+function addPattern(schema, regex, message, refs) {
+    if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
+        if (!schema.allOf) {
+            schema.allOf = [];
+        }
+        if (schema.pattern) {
+            schema.allOf.push({
+                pattern: schema.pattern,
+                ...(schema.errorMessage &&
+                    refs.errorMessages && {
+                    errorMessage: { pattern: schema.errorMessage.pattern },
+                }),
+            });
+            delete schema.pattern;
+            if (schema.errorMessage) {
+                delete schema.errorMessage.pattern;
+                if (Object.keys(schema.errorMessage).length === 0) {
+                    delete schema.errorMessage;
+                }
+            }
+        }
+        schema.allOf.push({
+            pattern: stringifyRegExpWithFlags(regex, refs),
+            ...(message &&
+                refs.errorMessages && { errorMessage: { pattern: message } }),
+        });
+    }
+    else {
+        (0, errorMessages_js_1.setResponseValueAndErrors)(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
+    }
+}
+// Mutate z.string.regex() in a best attempt to accommodate for regex flags when applyRegexFlags is true
+function stringifyRegExpWithFlags(regex, refs) {
+    if (!refs.applyRegexFlags || !regex.flags) {
+        return regex.source;
+    }
+    // Currently handled flags
+    const flags = {
+        i: regex.flags.includes("i"),
+        m: regex.flags.includes("m"),
+        s: regex.flags.includes("s"), // `.` matches newlines
+    };
+    // The general principle here is to step through each character, one at a time, applying mutations as flags require. We keep track when the current character is escaped, and when it's inside a group /like [this]/ or (also) a range like /[a-z]/. The following is fairly brittle imperative code; edit at your peril!
+    const source = flags.i ? regex.source.toLowerCase() : regex.source;
+    let pattern = "";
+    let isEscaped = false;
+    let inCharGroup = false;
+    let inCharRange = false;
+    for (let i = 0; i < source.length; i++) {
+        if (isEscaped) {
+            pattern += source[i];
+            isEscaped = false;
+            continue;
+        }
+        if (flags.i) {
+            if (inCharGroup) {
+                if (source[i].match(/[a-z]/)) {
+                    if (inCharRange) {
+                        pattern += source[i];
+                        pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+                        inCharRange = false;
+                    }
+                    else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
+                        pattern += source[i];
+                        inCharRange = true;
+                    }
+                    else {
+                        pattern += `${source[i]}${source[i].toUpperCase()}`;
+                    }
+                    continue;
+                }
+            }
+            else if (source[i].match(/[a-z]/)) {
+                pattern += `[${source[i]}${source[i].toUpperCase()}]`;
+                continue;
+            }
+        }
+        if (flags.m) {
+            if (source[i] === "^") {
+                pattern += `(^|(?<=[\r\n]))`;
+                continue;
+            }
+            else if (source[i] === "$") {
+                pattern += `($|(?=[\r\n]))`;
+                continue;
+            }
+        }
+        if (flags.s && source[i] === ".") {
+            pattern += inCharGroup ? `${source[i]}\r\n` : `[${source[i]}\r\n]`;
+            continue;
+        }
+        pattern += source[i];
+        if (source[i] === "\\") {
+            isEscaped = true;
+        }
+        else if (inCharGroup && source[i] === "]") {
+            inCharGroup = false;
+        }
+        else if (!inCharGroup && source[i] === "[") {
+            inCharGroup = true;
+        }
+    }
+    try {
+        new RegExp(pattern);
+    }
+    catch {
+        console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
+        return regex.source;
+    }
+    return pattern;
+}

node_modules/zod-to-json-schema/dist/cjs/parsers/tuple.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTupleDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+function parseTupleDef(def, refs) {
+    if (def.rest) {
+        return {
+            type: "array",
+            minItems: def.items.length,
+            items: def.items
+                .map((x, i) => (0, parseDef_js_1.parseDef)(x._def, {
+                ...refs,
+                currentPath: [...refs.currentPath, "items", `${i}`],
+            }))
+                .reduce((acc, x) => (x === undefined ? acc : [...acc, x]), []),
+            additionalItems: (0, parseDef_js_1.parseDef)(def.rest._def, {
+                ...refs,
+                currentPath: [...refs.currentPath, "additionalItems"],
+            }),
+        };
+    }
+    else {
+        return {
+            type: "array",
+            minItems: def.items.length,
+            maxItems: def.items.length,
+            items: def.items
+                .map((x, i) => (0, parseDef_js_1.parseDef)(x._def, {
+                ...refs,
+                currentPath: [...refs.currentPath, "items", `${i}`],
+            }))
+                .reduce((acc, x) => (x === undefined ? acc : [...acc, x]), []),
+        };
+    }
+}
+exports.parseTupleDef = parseTupleDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/undefined.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUndefinedDef = void 0;
+function parseUndefinedDef() {
+    return {
+        not: {},
+    };
+}
+exports.parseUndefinedDef = parseUndefinedDef;

node_modules/zod-to-json-schema/dist/cjs/parsers/union.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUnionDef = exports.primitiveMappings = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+exports.primitiveMappings = {
+    ZodString: "string",
+    ZodNumber: "number",
+    ZodBigInt: "integer",
+    ZodBoolean: "boolean",
+    ZodNull: "null",
+};
+function parseUnionDef(def, refs) {
+    if (refs.target === "openApi3")
+        return asAnyOf(def, refs);
+    const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+    // This blocks tries to look ahead a bit to produce nicer looking schemas with type array instead of anyOf.
+    if (options.every((x) => x._def.typeName in exports.primitiveMappings &&
+        (!x._def.checks || !x._def.checks.length))) {
+        // all types in union are primitive and lack checks, so might as well squash into {type: [...]}
+        const types = options.reduce((types, x) => {
+            const type = exports.primitiveMappings[x._def.typeName]; //Can be safely casted due to row 43
+            return type && !types.includes(type) ? [...types, type] : types;
+        }, []);
+        return {
+            type: types.length > 1 ? types : types[0],
+        };
+    }
+    else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+        // all options literals
+        const types = options.reduce((acc, x) => {
+            const type = typeof x._def.value;
+            switch (type) {
+                case "string":
+                case "number":
+                case "boolean":
+                    return [...acc, type];
+                case "bigint":
+                    return [...acc, "integer"];
+                case "object":
+                    if (x._def.value === null)
+                        return [...acc, "null"];
+                case "symbol":
+                case "undefined":
+                case "function":
+                default:
+                    return acc;
+            }
+        }, []);
+        if (types.length === options.length) {
+            // all the literals are primitive, as far as null can be considered primitive
+            const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+            return {
+                type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+                enum: options.reduce((acc, x) => {
+                    return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+                }, []),
+            };
+        }
+    }
+    else if (options.every((x) => x._def.typeName === "ZodEnum")) {
+        return {
+            type: "string",
+            enum: options.reduce((acc, x) => [
+                ...acc,
+                ...x._def.values.filter((x) => !acc.includes(x)),
+            ], []),
+        };
+    }
+    return asAnyOf(def, refs);
+}
+exports.parseUnionDef = parseUnionDef;
+const asAnyOf = (def, refs) => {
+    const anyOf = (def.options instanceof Map
+        ? Array.from(def.options.values())
+        : def.options)
+        .map((x, i) => (0, parseDef_js_1.parseDef)(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "anyOf", `${i}`],
+    }))
+        .filter((x) => !!x &&
+        (!refs.strictUnions ||
+            (typeof x === "object" && Object.keys(x).length > 0)));
+    return anyOf.length ? { anyOf } : undefined;
+};

node_modules/zod-to-json-schema/dist/cjs/parsers/unknown.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUnknownDef = void 0;
+function parseUnknownDef() {
+    return {};
+}
+exports.parseUnknownDef = parseUnknownDef;

node_modules/zod-to-json-schema/dist/cjs/selectParser.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectParser = void 0;
+const zod_1 = require("zod");
+const any_js_1 = require("./parsers/any.js");
+const array_js_1 = require("./parsers/array.js");
+const bigint_js_1 = require("./parsers/bigint.js");
+const boolean_js_1 = require("./parsers/boolean.js");
+const branded_js_1 = require("./parsers/branded.js");
+const catch_js_1 = require("./parsers/catch.js");
+const date_js_1 = require("./parsers/date.js");
+const default_js_1 = require("./parsers/default.js");
+const effects_js_1 = require("./parsers/effects.js");
+const enum_js_1 = require("./parsers/enum.js");
+const intersection_js_1 = require("./parsers/intersection.js");
+const literal_js_1 = require("./parsers/literal.js");
+const map_js_1 = require("./parsers/map.js");
+const nativeEnum_js_1 = require("./parsers/nativeEnum.js");
+const never_js_1 = require("./parsers/never.js");
+const null_js_1 = require("./parsers/null.js");
+const nullable_js_1 = require("./parsers/nullable.js");
+const number_js_1 = require("./parsers/number.js");
+const object_js_1 = require("./parsers/object.js");
+const optional_js_1 = require("./parsers/optional.js");
+const pipeline_js_1 = require("./parsers/pipeline.js");
+const promise_js_1 = require("./parsers/promise.js");
+const record_js_1 = require("./parsers/record.js");
+const set_js_1 = require("./parsers/set.js");
+const string_js_1 = require("./parsers/string.js");
+const tuple_js_1 = require("./parsers/tuple.js");
+const undefined_js_1 = require("./parsers/undefined.js");
+const union_js_1 = require("./parsers/union.js");
+const unknown_js_1 = require("./parsers/unknown.js");
+const readonly_js_1 = require("./parsers/readonly.js");
+const selectParser = (def, typeName, refs) => {
+    switch (typeName) {
+        case zod_1.ZodFirstPartyTypeKind.ZodString:
+            return (0, string_js_1.parseStringDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodNumber:
+            return (0, number_js_1.parseNumberDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodObject:
+            return (0, object_js_1.parseObjectDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodBigInt:
+            return (0, bigint_js_1.parseBigintDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodBoolean:
+            return (0, boolean_js_1.parseBooleanDef)();
+        case zod_1.ZodFirstPartyTypeKind.ZodDate:
+            return (0, date_js_1.parseDateDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodUndefined:
+            return (0, undefined_js_1.parseUndefinedDef)();
+        case zod_1.ZodFirstPartyTypeKind.ZodNull:
+            return (0, null_js_1.parseNullDef)(refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodArray:
+            return (0, array_js_1.parseArrayDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodUnion:
+        case zod_1.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+            return (0, union_js_1.parseUnionDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodIntersection:
+            return (0, intersection_js_1.parseIntersectionDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodTuple:
+            return (0, tuple_js_1.parseTupleDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodRecord:
+            return (0, record_js_1.parseRecordDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodLiteral:
+            return (0, literal_js_1.parseLiteralDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodEnum:
+            return (0, enum_js_1.parseEnumDef)(def);
+        case zod_1.ZodFirstPartyTypeKind.ZodNativeEnum:
+            return (0, nativeEnum_js_1.parseNativeEnumDef)(def);
+        case zod_1.ZodFirstPartyTypeKind.ZodNullable:
+            return (0, nullable_js_1.parseNullableDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodOptional:
+            return (0, optional_js_1.parseOptionalDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodMap:
+            return (0, map_js_1.parseMapDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodSet:
+            return (0, set_js_1.parseSetDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodLazy:
+            return () => def.getter()._def;
+        case zod_1.ZodFirstPartyTypeKind.ZodPromise:
+            return (0, promise_js_1.parsePromiseDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodNaN:
+        case zod_1.ZodFirstPartyTypeKind.ZodNever:
+            return (0, never_js_1.parseNeverDef)();
+        case zod_1.ZodFirstPartyTypeKind.ZodEffects:
+            return (0, effects_js_1.parseEffectsDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodAny:
+            return (0, any_js_1.parseAnyDef)();
+        case zod_1.ZodFirstPartyTypeKind.ZodUnknown:
+            return (0, unknown_js_1.parseUnknownDef)();
+        case zod_1.ZodFirstPartyTypeKind.ZodDefault:
+            return (0, default_js_1.parseDefaultDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodBranded:
+            return (0, branded_js_1.parseBrandedDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodReadonly:
+            return (0, readonly_js_1.parseReadonlyDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodCatch:
+            return (0, catch_js_1.parseCatchDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodPipeline:
+            return (0, pipeline_js_1.parsePipelineDef)(def, refs);
+        case zod_1.ZodFirstPartyTypeKind.ZodFunction:
+        case zod_1.ZodFirstPartyTypeKind.ZodVoid:
+        case zod_1.ZodFirstPartyTypeKind.ZodSymbol:
+            return undefined;
+        default:
+            /* c8 ignore next */
+            return ((_) => undefined)(typeName);
+    }
+};
+exports.selectParser = selectParser;

node_modules/zod-to-json-schema/dist/cjs/zodToJsonSchema.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodToJsonSchema = void 0;
+const parseDef_js_1 = require("./parseDef.js");
+const Refs_js_1 = require("./Refs.js");
+const zodToJsonSchema = (schema, options) => {
+    const refs = (0, Refs_js_1.getRefs)(options);
+    const definitions = typeof options === "object" && options.definitions
+        ? Object.entries(options.definitions).reduce((acc, [name, schema]) => ({
+            ...acc,
+            [name]: (0, parseDef_js_1.parseDef)(schema._def, {
+                ...refs,
+                currentPath: [...refs.basePath, refs.definitionPath, name],
+            }, true) ?? {},
+        }), {})
+        : undefined;
+    const name = typeof options === "string"
+        ? options
+        : options?.nameStrategy === "title"
+            ? undefined
+            : options?.name;
+    const main = (0, parseDef_js_1.parseDef)(schema._def, name === undefined
+        ? refs
+        : {
+            ...refs,
+            currentPath: [...refs.basePath, refs.definitionPath, name],
+        }, false) ?? {};
+    const title = typeof options === "object" &&
+        options.name !== undefined &&
+        options.nameStrategy === "title"
+        ? options.name
+        : undefined;
+    if (title !== undefined) {
+        main.title = title;
+    }
+    const combined = name === undefined
+        ? definitions
+            ? {
+                ...main,
+                [refs.definitionPath]: definitions,
+            }
+            : main
+        : {
+            $ref: [
+                ...(refs.$refStrategy === "relative" ? [] : refs.basePath),
+                refs.definitionPath,
+                name,
+            ].join("/"),
+            [refs.definitionPath]: {
+                ...definitions,
+                [name]: main,
+            },
+        };
+    if (refs.target === "jsonSchema7") {
+        combined.$schema = "http://json-schema.org/draft-07/schema#";
+    }
+    else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
+        combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+    }
+    if (refs.target === "openAi" &&
+        ("anyOf" in combined ||
+            "oneOf" in combined ||
+            "allOf" in combined ||
+            ("type" in combined && Array.isArray(combined.type)))) {
+        console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+    }
+    return combined;
+};
+exports.zodToJsonSchema = zodToJsonSchema;