@zuplo/cli 6.69.10 → 6.70.0

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

@@ -0,0 +1,80 @@
+import { parseDef } from "../parseDef.js";
+export const primitiveMappings = {
+    ZodString: "string",
+    ZodNumber: "number",
+    ZodBigInt: "integer",
+    ZodBoolean: "boolean",
+    ZodNull: "null",
+};
+export 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 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 = 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);
+}
+const asAnyOf = (def, refs) => {
+    const anyOf = (def.options instanceof Map
+        ? Array.from(def.options.values())
+        : def.options)
+        .map((x, i) => 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;
+};

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

@@ -0,0 +1,4 @@
+import { parseAnyDef } from "./any.js";
+export function parseUnknownDef(refs) {
+    return parseAnyDef(refs);
+}

package/node_modules/zod-to-json-schema/dist/esm/selectParser.js

@@ -0,0 +1,105 @@
+import { ZodFirstPartyTypeKind } from "zod/v3";
+import { parseAnyDef } from "./parsers/any.js";
+import { parseArrayDef } from "./parsers/array.js";
+import { parseBigintDef } from "./parsers/bigint.js";
+import { parseBooleanDef } from "./parsers/boolean.js";
+import { parseBrandedDef } from "./parsers/branded.js";
+import { parseCatchDef } from "./parsers/catch.js";
+import { parseDateDef } from "./parsers/date.js";
+import { parseDefaultDef } from "./parsers/default.js";
+import { parseEffectsDef } from "./parsers/effects.js";
+import { parseEnumDef } from "./parsers/enum.js";
+import { parseIntersectionDef } from "./parsers/intersection.js";
+import { parseLiteralDef } from "./parsers/literal.js";
+import { parseMapDef } from "./parsers/map.js";
+import { parseNativeEnumDef } from "./parsers/nativeEnum.js";
+import { parseNeverDef } from "./parsers/never.js";
+import { parseNullDef } from "./parsers/null.js";
+import { parseNullableDef } from "./parsers/nullable.js";
+import { parseNumberDef } from "./parsers/number.js";
+import { parseObjectDef } from "./parsers/object.js";
+import { parseOptionalDef } from "./parsers/optional.js";
+import { parsePipelineDef } from "./parsers/pipeline.js";
+import { parsePromiseDef } from "./parsers/promise.js";
+import { parseRecordDef } from "./parsers/record.js";
+import { parseSetDef } from "./parsers/set.js";
+import { parseStringDef } from "./parsers/string.js";
+import { parseTupleDef } from "./parsers/tuple.js";
+import { parseUndefinedDef } from "./parsers/undefined.js";
+import { parseUnionDef } from "./parsers/union.js";
+import { parseUnknownDef } from "./parsers/unknown.js";
+import { parseReadonlyDef } from "./parsers/readonly.js";
+export const selectParser = (def, typeName, refs) => {
+    switch (typeName) {
+        case ZodFirstPartyTypeKind.ZodString:
+            return parseStringDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodNumber:
+            return parseNumberDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodObject:
+            return parseObjectDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodBigInt:
+            return parseBigintDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodBoolean:
+            return parseBooleanDef();
+        case ZodFirstPartyTypeKind.ZodDate:
+            return parseDateDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodUndefined:
+            return parseUndefinedDef(refs);
+        case ZodFirstPartyTypeKind.ZodNull:
+            return parseNullDef(refs);
+        case ZodFirstPartyTypeKind.ZodArray:
+            return parseArrayDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodUnion:
+        case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+            return parseUnionDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodIntersection:
+            return parseIntersectionDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodTuple:
+            return parseTupleDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodRecord:
+            return parseRecordDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodLiteral:
+            return parseLiteralDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodEnum:
+            return parseEnumDef(def);
+        case ZodFirstPartyTypeKind.ZodNativeEnum:
+            return parseNativeEnumDef(def);
+        case ZodFirstPartyTypeKind.ZodNullable:
+            return parseNullableDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodOptional:
+            return parseOptionalDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodMap:
+            return parseMapDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodSet:
+            return parseSetDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodLazy:
+            return () => def.getter()._def;
+        case ZodFirstPartyTypeKind.ZodPromise:
+            return parsePromiseDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodNaN:
+        case ZodFirstPartyTypeKind.ZodNever:
+            return parseNeverDef(refs);
+        case ZodFirstPartyTypeKind.ZodEffects:
+            return parseEffectsDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodAny:
+            return parseAnyDef(refs);
+        case ZodFirstPartyTypeKind.ZodUnknown:
+            return parseUnknownDef(refs);
+        case ZodFirstPartyTypeKind.ZodDefault:
+            return parseDefaultDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodBranded:
+            return parseBrandedDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodReadonly:
+            return parseReadonlyDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodCatch:
+            return parseCatchDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodPipeline:
+            return parsePipelineDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodFunction:
+        case ZodFirstPartyTypeKind.ZodVoid:
+        case ZodFirstPartyTypeKind.ZodSymbol:
+            return undefined;
+        default:
+            return ((_) => undefined)(typeName);
+    }
+};

package/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js

@@ -0,0 +1,87 @@
+import { parseDef } from "./parseDef.js";
+import { getRefs } from "./Refs.js";
+import { parseAnyDef } from "./parsers/any.js";
+const zodToJsonSchema = (schema, options) => {
+    const refs = getRefs(options);
+    let definitions = typeof options === "object" && options.definitions
+        ? Object.entries(options.definitions).reduce((acc, [name, schema]) => ({
+            ...acc,
+            [name]: parseDef(schema._def, {
+                ...refs,
+                currentPath: [...refs.basePath, refs.definitionPath, name],
+            }, true) ?? parseAnyDef(refs),
+        }), {})
+        : undefined;
+    const name = typeof options === "string"
+        ? options
+        : options?.nameStrategy === "title"
+            ? undefined
+            : options?.name;
+    const main = parseDef(schema._def, name === undefined
+        ? refs
+        : {
+            ...refs,
+            currentPath: [...refs.basePath, refs.definitionPath, name],
+        }, false) ?? parseAnyDef(refs);
+    const title = typeof options === "object" &&
+        options.name !== undefined &&
+        options.nameStrategy === "title"
+        ? options.name
+        : undefined;
+    if (title !== undefined) {
+        main.title = title;
+    }
+    if (refs.flags.hasReferencedOpenAiAnyType) {
+        if (!definitions) {
+            definitions = {};
+        }
+        if (!definitions[refs.openAiAnyTypeName]) {
+            definitions[refs.openAiAnyTypeName] = {
+                // Skipping "object" as no properties can be defined and additionalProperties must be "false"
+                type: ["string", "number", "integer", "boolean", "array", "null"],
+                items: {
+                    $ref: refs.$refStrategy === "relative"
+                        ? "1"
+                        : [
+                            ...refs.basePath,
+                            refs.definitionPath,
+                            refs.openAiAnyTypeName,
+                        ].join("/"),
+                },
+            };
+        }
+    }
+    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;
+};
+export { zodToJsonSchema };

package/node_modules/zod-to-json-schema/dist/types/Options.d.ts

@@ -0,0 +1,37 @@
+import { ZodSchema, ZodTypeDef } from "zod/v3";
+import { Refs, Seen } from "./Refs";
+import { JsonSchema7Type } from "./parseTypes";
+export type Targets = "jsonSchema7" | "jsonSchema2019-09" | "openApi3" | "openAi";
+export type DateStrategy = "format:date-time" | "format:date" | "string" | "integer";
+export declare const ignoreOverride: unique symbol;
+export type OverrideCallback = (def: ZodTypeDef, refs: Refs, seen: Seen | undefined, forceResolution?: boolean) => JsonSchema7Type | undefined | typeof ignoreOverride;
+export type PostProcessCallback = (jsonSchema: JsonSchema7Type | undefined, def: ZodTypeDef, refs: Refs) => JsonSchema7Type | undefined;
+export declare const jsonDescription: PostProcessCallback;
+export type Options<Target extends Targets = "jsonSchema7"> = {
+    name: string | undefined;
+    $refStrategy: "root" | "relative" | "none" | "seen";
+    basePath: string[];
+    effectStrategy: "input" | "any";
+    pipeStrategy: "input" | "output" | "all";
+    dateStrategy: DateStrategy | DateStrategy[];
+    mapStrategy: "entries" | "record";
+    removeAdditionalStrategy: "passthrough" | "strict";
+    allowedAdditionalProperties: true | undefined;
+    rejectedAdditionalProperties: false | undefined;
+    target: Target;
+    strictUnions: boolean;
+    definitionPath: string;
+    definitions: Record<string, ZodSchema>;
+    errorMessages: boolean;
+    markdownDescription: boolean;
+    patternStrategy: "escape" | "preserve";
+    applyRegexFlags: boolean;
+    emailStrategy: "format:email" | "format:idn-email" | "pattern:zod";
+    base64Strategy: "format:binary" | "contentEncoding:base64" | "pattern:zod";
+    nameStrategy: "ref" | "title";
+    override?: OverrideCallback;
+    postProcess?: PostProcessCallback;
+    openAiAnyTypeName: string;
+};
+export declare const defaultOptions: Options;
+export declare const getDefaultOptions: <Target extends Targets>(options: string | Partial<Options<Target>> | undefined) => Options<Target>;

package/node_modules/zod-to-json-schema/dist/types/Refs.d.ts

@@ -0,0 +1,17 @@
+import { ZodTypeDef } from "zod/v3";
+import { Options, Targets } from "./Options.js";
+import { JsonSchema7Type } from "./parseTypes.js";
+export type Refs = {
+    seen: Map<ZodTypeDef, Seen>;
+    currentPath: string[];
+    propertyPath: string[] | undefined;
+    flags: {
+        hasReferencedOpenAiAnyType: boolean;
+    };
+} & Options<Targets>;
+export type Seen = {
+    def: ZodTypeDef;
+    path: string[];
+    jsonSchema: JsonSchema7Type | undefined;
+};
+export declare const getRefs: (options?: string | Partial<Options<Targets>>) => Refs;

package/node_modules/zod-to-json-schema/dist/types/errorMessages.d.ts

@@ -0,0 +1,15 @@
+import { JsonSchema7TypeUnion } from "./parseTypes.js";
+import { Refs } from "./Refs.js";
+export type ErrorMessages<T extends JsonSchema7TypeUnion | {
+    format: string;
+} | {
+    pattern: string;
+}, OmitProperties extends string = ""> = Partial<Omit<{
+    [key in keyof T]: string;
+}, OmitProperties | "type" | "errorMessages">>;
+export declare function addErrorMessage<T extends {
+    errorMessage?: ErrorMessages<any>;
+}>(res: T, key: keyof T, errorMessage: string | undefined, refs: Refs): void;
+export declare function setResponseValueAndErrors<Json7Type extends JsonSchema7TypeUnion & {
+    errorMessage?: ErrorMessages<Json7Type>;
+}, Key extends keyof Omit<Json7Type, "errorMessage">>(res: Json7Type, key: Key, value: Json7Type[Key], errorMessage: string | undefined, refs: Refs): void;

package/node_modules/zod-to-json-schema/dist/types/getRelativePath.d.ts

@@ -0,0 +1 @@
+export declare const getRelativePath: (pathA: string[], pathB: string[]) => string;

package/node_modules/zod-to-json-schema/dist/types/index.d.ts

@@ -0,0 +1,40 @@
+export * from "./Options.js";
+export * from "./Refs.js";
+export * from "./errorMessages.js";
+export * from "./getRelativePath.js";
+export * from "./parseDef.js";
+export * from "./parseTypes.js";
+export * from "./parsers/any.js";
+export * from "./parsers/array.js";
+export * from "./parsers/bigint.js";
+export * from "./parsers/boolean.js";
+export * from "./parsers/branded.js";
+export * from "./parsers/catch.js";
+export * from "./parsers/date.js";
+export * from "./parsers/default.js";
+export * from "./parsers/effects.js";
+export * from "./parsers/enum.js";
+export * from "./parsers/intersection.js";
+export * from "./parsers/literal.js";
+export * from "./parsers/map.js";
+export * from "./parsers/nativeEnum.js";
+export * from "./parsers/never.js";
+export * from "./parsers/null.js";
+export * from "./parsers/nullable.js";
+export * from "./parsers/number.js";
+export * from "./parsers/object.js";
+export * from "./parsers/optional.js";
+export * from "./parsers/pipeline.js";
+export * from "./parsers/promise.js";
+export * from "./parsers/readonly.js";
+export * from "./parsers/record.js";
+export * from "./parsers/set.js";
+export * from "./parsers/string.js";
+export * from "./parsers/tuple.js";
+export * from "./parsers/undefined.js";
+export * from "./parsers/union.js";
+export * from "./parsers/unknown.js";
+export * from "./selectParser.js";
+export * from "./zodToJsonSchema.js";
+import { zodToJsonSchema } from "./zodToJsonSchema.js";
+export default zodToJsonSchema;

package/node_modules/zod-to-json-schema/dist/types/parseDef.d.ts

@@ -0,0 +1,4 @@
+import { ZodTypeDef } from "zod/v3";
+import { Refs } from "./Refs.js";
+import { JsonSchema7Type } from "./parseTypes.js";
+export declare function parseDef(def: ZodTypeDef, refs: Refs, forceResolution?: boolean): JsonSchema7Type | undefined;

package/node_modules/zod-to-json-schema/dist/types/parseTypes.d.ts

@@ -0,0 +1,34 @@
+import { JsonSchema7AnyType } from "./parsers/any.js";
+import { JsonSchema7ArrayType } from "./parsers/array.js";
+import { JsonSchema7BigintType } from "./parsers/bigint.js";
+import { JsonSchema7BooleanType } from "./parsers/boolean.js";
+import { JsonSchema7DateType } from "./parsers/date.js";
+import { JsonSchema7EnumType } from "./parsers/enum.js";
+import { JsonSchema7AllOfType } from "./parsers/intersection.js";
+import { JsonSchema7LiteralType } from "./parsers/literal.js";
+import { JsonSchema7MapType } from "./parsers/map.js";
+import { JsonSchema7NativeEnumType } from "./parsers/nativeEnum.js";
+import { JsonSchema7NeverType } from "./parsers/never.js";
+import { JsonSchema7NullType } from "./parsers/null.js";
+import { JsonSchema7NullableType } from "./parsers/nullable.js";
+import { JsonSchema7NumberType } from "./parsers/number.js";
+import { JsonSchema7ObjectType } from "./parsers/object.js";
+import { JsonSchema7RecordType } from "./parsers/record.js";
+import { JsonSchema7SetType } from "./parsers/set.js";
+import { JsonSchema7StringType } from "./parsers/string.js";
+import { JsonSchema7TupleType } from "./parsers/tuple.js";
+import { JsonSchema7UndefinedType } from "./parsers/undefined.js";
+import { JsonSchema7UnionType } from "./parsers/union.js";
+import { JsonSchema7UnknownType } from "./parsers/unknown.js";
+type JsonSchema7RefType = {
+    $ref: string;
+};
+type JsonSchema7Meta = {
+    title?: string;
+    default?: any;
+    description?: string;
+    markdownDescription?: string;
+};
+export type JsonSchema7TypeUnion = JsonSchema7StringType | JsonSchema7ArrayType | JsonSchema7NumberType | JsonSchema7BigintType | JsonSchema7BooleanType | JsonSchema7DateType | JsonSchema7EnumType | JsonSchema7LiteralType | JsonSchema7NativeEnumType | JsonSchema7NullType | JsonSchema7NumberType | JsonSchema7ObjectType | JsonSchema7RecordType | JsonSchema7TupleType | JsonSchema7UnionType | JsonSchema7UndefinedType | JsonSchema7RefType | JsonSchema7NeverType | JsonSchema7MapType | JsonSchema7AnyType | JsonSchema7NullableType | JsonSchema7AllOfType | JsonSchema7UnknownType | JsonSchema7SetType;
+export type JsonSchema7Type = JsonSchema7TypeUnion & JsonSchema7Meta;
+export {};

package/node_modules/zod-to-json-schema/dist/types/parsers/any.d.ts

@@ -0,0 +1,5 @@
+import { Refs } from "../Refs.js";
+export type JsonSchema7AnyType = {
+    $ref?: string;
+};
+export declare function parseAnyDef(refs: Refs): JsonSchema7AnyType;

package/node_modules/zod-to-json-schema/dist/types/parsers/array.d.ts

@@ -0,0 +1,12 @@
+import { ZodArrayDef } from "zod/v3";
+import { ErrorMessages } from "../errorMessages.js";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export type JsonSchema7ArrayType = {
+    type: "array";
+    items?: JsonSchema7Type;
+    minItems?: number;
+    maxItems?: number;
+    errorMessages?: ErrorMessages<JsonSchema7ArrayType, "items">;
+};
+export declare function parseArrayDef(def: ZodArrayDef, refs: Refs): JsonSchema7ArrayType;

package/node_modules/zod-to-json-schema/dist/types/parsers/bigint.d.ts

@@ -0,0 +1,14 @@
+import { ZodBigIntDef } from "zod/v3";
+import { Refs } from "../Refs.js";
+import { ErrorMessages } from "../errorMessages.js";
+export type JsonSchema7BigintType = {
+    type: "integer";
+    format: "int64";
+    minimum?: BigInt;
+    exclusiveMinimum?: BigInt;
+    maximum?: BigInt;
+    exclusiveMaximum?: BigInt;
+    multipleOf?: BigInt;
+    errorMessage?: ErrorMessages<JsonSchema7BigintType>;
+};
+export declare function parseBigintDef(def: ZodBigIntDef, refs: Refs): JsonSchema7BigintType;

package/node_modules/zod-to-json-schema/dist/types/parsers/boolean.d.ts

@@ -0,0 +1,4 @@
+export type JsonSchema7BooleanType = {
+    type: "boolean";
+};
+export declare function parseBooleanDef(): JsonSchema7BooleanType;

package/node_modules/zod-to-json-schema/dist/types/parsers/branded.d.ts

@@ -0,0 +1,3 @@
+import { ZodBrandedDef } from "zod/v3";
+import { Refs } from "../Refs.js";
+export declare function parseBrandedDef(_def: ZodBrandedDef<any>, refs: Refs): import("../parseTypes.js").JsonSchema7Type | undefined;

package/node_modules/zod-to-json-schema/dist/types/parsers/catch.d.ts

@@ -0,0 +1,3 @@
+import { ZodCatchDef } from "zod/v3";
+import { Refs } from "../Refs.js";
+export declare const parseCatchDef: (def: ZodCatchDef<any>, refs: Refs) => import("../parseTypes.js").JsonSchema7Type | undefined;

package/node_modules/zod-to-json-schema/dist/types/parsers/date.d.ts

@@ -0,0 +1,15 @@
+import { ZodDateDef } from "zod/v3";
+import { Refs } from "../Refs.js";
+import { ErrorMessages } from "../errorMessages.js";
+import { JsonSchema7NumberType } from "./number.js";
+import { DateStrategy } from "../Options.js";
+export type JsonSchema7DateType = {
+    type: "integer" | "string";
+    format: "unix-time" | "date-time" | "date";
+    minimum?: number;
+    maximum?: number;
+    errorMessage?: ErrorMessages<JsonSchema7NumberType>;
+} | {
+    anyOf: JsonSchema7DateType[];
+};
+export declare function parseDateDef(def: ZodDateDef, refs: Refs, overrideDateStrategy?: DateStrategy): JsonSchema7DateType;

package/node_modules/zod-to-json-schema/dist/types/parsers/default.d.ts

@@ -0,0 +1,6 @@
+import { ZodDefaultDef } from "zod/v3";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export declare function parseDefaultDef(_def: ZodDefaultDef, refs: Refs): JsonSchema7Type & {
+    default: any;
+};

package/node_modules/zod-to-json-schema/dist/types/parsers/effects.d.ts

@@ -0,0 +1,4 @@
+import { ZodEffectsDef } from "zod/v3";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export declare function parseEffectsDef(_def: ZodEffectsDef, refs: Refs): JsonSchema7Type | undefined;

package/node_modules/zod-to-json-schema/dist/types/parsers/enum.d.ts

@@ -0,0 +1,6 @@
+import { ZodEnumDef } from "zod/v3";
+export type JsonSchema7EnumType = {
+    type: "string";
+    enum: string[];
+};
+export declare function parseEnumDef(def: ZodEnumDef): JsonSchema7EnumType;

package/node_modules/zod-to-json-schema/dist/types/parsers/intersection.d.ts

@@ -0,0 +1,8 @@
+import { ZodIntersectionDef } from "zod/v3";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export type JsonSchema7AllOfType = {
+    allOf: JsonSchema7Type[];
+    unevaluatedProperties?: boolean;
+};
+export declare function parseIntersectionDef(def: ZodIntersectionDef, refs: Refs): JsonSchema7AllOfType | JsonSchema7Type | undefined;

package/node_modules/zod-to-json-schema/dist/types/parsers/literal.d.ts

@@ -0,0 +1,9 @@
+import { ZodLiteralDef } from "zod/v3";
+import { Refs } from "../Refs.js";
+export type JsonSchema7LiteralType = {
+    type: "string" | "number" | "integer" | "boolean";
+    const: string | number | boolean;
+} | {
+    type: "object" | "array";
+};
+export declare function parseLiteralDef(def: ZodLiteralDef, refs: Refs): JsonSchema7LiteralType;

package/node_modules/zod-to-json-schema/dist/types/parsers/map.d.ts

@@ -0,0 +1,15 @@
+import { ZodMapDef } from "zod/v3";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+import { JsonSchema7RecordType } from "./record.js";
+export type JsonSchema7MapType = {
+    type: "array";
+    maxItems: 125;
+    items: {
+        type: "array";
+        items: [JsonSchema7Type, JsonSchema7Type];
+        minItems: 2;
+        maxItems: 2;
+    };
+};
+export declare function parseMapDef(def: ZodMapDef, refs: Refs): JsonSchema7MapType | JsonSchema7RecordType;

package/node_modules/zod-to-json-schema/dist/types/parsers/nativeEnum.d.ts

@@ -0,0 +1,6 @@
+import { ZodNativeEnumDef } from "zod/v3";
+export type JsonSchema7NativeEnumType = {
+    type: "string" | "number" | ["string", "number"];
+    enum: (string | number)[];
+};
+export declare function parseNativeEnumDef(def: ZodNativeEnumDef): JsonSchema7NativeEnumType;

package/node_modules/zod-to-json-schema/dist/types/parsers/never.d.ts

@@ -0,0 +1,6 @@
+import { Refs } from "../Refs.js";
+import { JsonSchema7AnyType } from "./any.js";
+export type JsonSchema7NeverType = {
+    not: JsonSchema7AnyType;
+};
+export declare function parseNeverDef(refs: Refs): JsonSchema7NeverType | undefined;

package/node_modules/zod-to-json-schema/dist/types/parsers/null.d.ts

@@ -0,0 +1,5 @@
+import { Refs } from "../Refs.js";
+export type JsonSchema7NullType = {
+    type: "null";
+};
+export declare function parseNullDef(refs: Refs): JsonSchema7NullType;

package/node_modules/zod-to-json-schema/dist/types/parsers/nullable.d.ts

@@ -0,0 +1,10 @@
+import { ZodNullableDef } from "zod/v3";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+import { JsonSchema7NullType } from "./null.js";
+export type JsonSchema7NullableType = {
+    anyOf: [JsonSchema7Type, JsonSchema7NullType];
+} | {
+    type: [string, "null"];
+};
+export declare function parseNullableDef(def: ZodNullableDef, refs: Refs): JsonSchema7NullableType | undefined;

package/node_modules/zod-to-json-schema/dist/types/parsers/number.d.ts

@@ -0,0 +1,13 @@
+import { ZodNumberDef } from "zod/v3";
+import { ErrorMessages } from "../errorMessages.js";
+import { Refs } from "../Refs.js";
+export type JsonSchema7NumberType = {
+    type: "number" | "integer";
+    minimum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+    errorMessage?: ErrorMessages<JsonSchema7NumberType>;
+};
+export declare function parseNumberDef(def: ZodNumberDef, refs: Refs): JsonSchema7NumberType;

package/node_modules/zod-to-json-schema/dist/types/parsers/object.d.ts

@@ -0,0 +1,10 @@
+import { ZodObjectDef } from "zod/v3";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export type JsonSchema7ObjectType = {
+    type: "object";
+    properties: Record<string, JsonSchema7Type>;
+    additionalProperties?: boolean | JsonSchema7Type;
+    required?: string[];
+};
+export declare function parseObjectDef(def: ZodObjectDef, refs: Refs): JsonSchema7ObjectType;

package/node_modules/zod-to-json-schema/dist/types/parsers/optional.d.ts

@@ -0,0 +1,4 @@
+import { ZodOptionalDef } from "zod/v3";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export declare const parseOptionalDef: (def: ZodOptionalDef, refs: Refs) => JsonSchema7Type | undefined;

package/node_modules/zod-to-json-schema/dist/types/parsers/pipeline.d.ts

@@ -0,0 +1,5 @@
+import { ZodPipelineDef } from "zod/v3";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+import { JsonSchema7AllOfType } from "./intersection.js";
+export declare const parsePipelineDef: (def: ZodPipelineDef<any, any>, refs: Refs) => JsonSchema7AllOfType | JsonSchema7Type | undefined;

package/node_modules/zod-to-json-schema/dist/types/parsers/promise.d.ts

@@ -0,0 +1,4 @@
+import { ZodPromiseDef } from "zod/v3";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export declare function parsePromiseDef(def: ZodPromiseDef, refs: Refs): JsonSchema7Type | undefined;