@es-joy/jsoe 0.16.0 → 0.17.0

package/vendor/zodex/dist/esm/dezerialize.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { SzOptional, SzNullable, SzReadonly, SzDefault, SzLiteral, SzArray, SzObject, SzUnion, SzDiscriminatedUnion, SzIntersection, SzTuple, SzRecord, SzMap, SzSet, SzFunction, SzEnum, SzNativeEnum, SzPromise, SzEffect, SzCatch, SzType, SzString, SzNumber, SzBoolean, SzBigInt, SzNaN, SzDate, SzAny, SzNever, SzNull, SzUndefined, SzSymbol, SzUnknown, SzVoid, SzRef } from "./types.js";
+import { ZodTypes } from "./zod-types.js";
+type DezerializerOptions = {
+    superRefinements?: {
+        [key: string]: (value: unknown, ctx: z.RefinementCtx) => Promise<void> | void;
+    };
+    transforms?: {
+        [key: string]: (value: unknown, ctx: z.RefinementCtx) => Promise<unknown> | unknown;
+    };
+    preprocesses?: {
+        [key: string]: (value: unknown, ctx: z.RefinementCtx) => unknown;
+    };
+    path: string;
+    pathToSchema: Map<string, ZodTypes>;
+    $refs: [z.ZodLazy<any>, string][];
+    originalShape: SzType;
+};
+type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+type OmitKey<T, K> = DistributiveOmit<T, keyof K>;
+export type Dezerialize<T extends SzType | SzRef> = T extends SzRef ? any : T extends SzOptional ? Dezerialize<OmitKey<T, SzOptional>> extends infer I ? I extends ZodTypes ? z.ZodOptional<I> : never : never : T extends SzNullable ? Dezerialize<OmitKey<T, SzNullable>> extends infer I ? I extends ZodTypes ? z.ZodNullable<I> : never : never : T extends SzReadonly ? Dezerialize<OmitKey<T, SzReadonly>> extends infer I ? I extends ZodTypes ? z.ZodReadonly<I> : never : never : T extends SzDefault<any> ? Dezerialize<OmitKey<T, SzDefault<any>>> extends infer I ? I extends ZodTypes ? z.ZodDefault<I> : never : never : T extends SzString ? z.ZodString : T extends SzNumber ? z.ZodNumber : T extends SzBoolean ? z.ZodBoolean : T extends SzBigInt ? z.ZodBigInt : T extends SzNaN ? z.ZodNaN : T extends SzDate ? z.ZodDate : T extends SzUndefined ? z.ZodUndefined : T extends SzNull ? z.ZodNull : T extends SzSymbol ? z.ZodSymbol : T extends SzAny ? z.ZodAny : T extends SzUnknown ? z.ZodUnknown : T extends SzNever ? z.ZodNever : T extends SzVoid ? z.ZodVoid : T extends SzLiteral<infer Value> ? z.ZodLiteral<Value> : T extends SzTuple<infer _Items> ? z.ZodTuple<any> : T extends SzSet<infer Value> ? z.ZodSet<Dezerialize<Value>> : T extends SzArray<infer Element> ? z.ZodArray<Dezerialize<Element>> : T extends SzObject<infer Properties> ? z.ZodObject<{
+    [Property in keyof Properties]: Dezerialize<Properties[Property]>;
+}> : T extends SzRecord<infer Key, infer Value> ? z.ZodRecord<Dezerialize<Key>, Dezerialize<Value>> : T extends SzMap<infer Key, infer Value> ? z.ZodMap<Dezerialize<Key>, Dezerialize<Value>> : T extends SzEnum<infer Values> ? z.ZodEnum<Values> : T extends SzUnion<infer _Options> ? z.ZodUnion<any> : T extends SzDiscriminatedUnion<infer Discriminator, infer _Options> ? z.ZodDiscriminatedUnion<Discriminator, any> : T extends SzIntersection<infer L, infer R> ? z.ZodIntersection<Dezerialize<L>, Dezerialize<R>> : T extends SzFunction<infer Args, infer Return> ? z.ZodFunction<Dezerialize<Args>, Dezerialize<Return>> : T extends SzPromise<infer Value> ? z.ZodPromise<Dezerialize<Value>> : T extends SzEffect<infer Value> ? z.ZodEffects<Dezerialize<Value>> : T extends SzCatch<infer Value> ? z.ZodCatch<Dezerialize<Value>> : T extends SzNativeEnum<infer Value> ? z.ZodNativeEnum<Value> : unknown;
+export declare function dezerializeRefs(shape: SzType, opts: DezerializerOptions): ZodTypes;
+export declare function dezerialize(shape: SzType, opts?: Partial<DezerializerOptions>): ZodTypes;
+export {};

package/vendor/zodex/dist/esm/dezerialize.js

@@ -0,0 +1,393 @@
+import { z } from "zod";
+function checkRef(item, opts) {
+    if ("$ref" in item) {
+        const lazy = z.lazy(() => z.null());
+        opts.$refs.push([lazy, item.$ref]);
+        return lazy;
+    }
+    return false;
+}
+const d = dezerializeRefs;
+const dezerializers = {
+    number: (shape) => {
+        let n = shape.coerce ? z.coerce.number() : z.number();
+        if (shape.min !== undefined) {
+            n = shape.minInclusive ? n.min(shape.min) : n.gt(shape.min);
+        }
+        if (shape.max !== undefined) {
+            n = shape.maxInclusive ? n.max(shape.max) : n.lt(shape.max);
+        }
+        if (shape.multipleOf !== undefined) {
+            n = n.multipleOf(shape.multipleOf);
+        }
+        if (shape.int) {
+            n = n.int();
+        }
+        if (shape.finite) {
+            n = n.finite();
+        }
+        return n;
+    },
+    string: (shape) => {
+        let s = shape.coerce ? z.coerce.string() : z.string();
+        if (shape.min !== undefined) {
+            s = s.min(shape.min);
+        }
+        if (shape.max !== undefined) {
+            s = s.max(shape.max);
+        }
+        if (shape.length !== undefined) {
+            s = s.length(shape.length);
+        }
+        if (shape.startsWith !== undefined) {
+            s = s.startsWith(shape.startsWith);
+        }
+        if (shape.endsWith !== undefined) {
+            s = s.endsWith(shape.endsWith);
+        }
+        if (shape.toLowerCase !== undefined) {
+            s = s.toLowerCase();
+        }
+        if (shape.toUpperCase !== undefined) {
+            s = s.toUpperCase();
+        }
+        if (shape.trim !== undefined) {
+            s = s.trim();
+        }
+        if ("includes" in shape) {
+            s = s.includes(shape.includes, { position: shape.position });
+        }
+        if ("regex" in shape) {
+            s = s.regex(new RegExp(shape.regex, shape.flags));
+        }
+        if ("kind" in shape) {
+            if (shape.kind == "ip") {
+                s = s.ip({ version: shape.version });
+            }
+            else if (shape.kind == "datetime") {
+                s = s.datetime({
+                    offset: shape.offset,
+                    precision: shape.precision,
+                    local: shape.local,
+                });
+            }
+            else if (shape.kind == "time") {
+                s = s.time({
+                    precision: shape.precision,
+                });
+            }
+            else {
+                s = s[shape.kind]();
+            }
+        }
+        return s;
+    },
+    boolean: (shape) => (shape.coerce ? z.coerce.boolean() : z.boolean()),
+    nan: () => z.nan(),
+    bigInt: (shape) => {
+        let i = shape.coerce ? z.coerce.bigint() : z.bigint();
+        if (shape.min !== undefined) {
+            const min = BigInt(shape.min);
+            i = shape.minInclusive ? i.min(min) : i.gt(min);
+        }
+        if (shape.max !== undefined) {
+            const max = BigInt(shape.max);
+            i = shape.maxInclusive ? i.max(max) : i.lt(max);
+        }
+        if (shape.multipleOf !== undefined) {
+            const multipleOf = BigInt(shape.multipleOf);
+            i = i.multipleOf(multipleOf);
+        }
+        return i;
+    },
+    date: (shape) => {
+        let i = shape.coerce ? z.coerce.date() : z.date();
+        if (shape.min !== undefined) {
+            i = i.min(new Date(shape.min));
+        }
+        if (shape.max !== undefined) {
+            i = i.max(new Date(shape.max));
+        }
+        return i;
+    },
+    undefined: () => z.undefined(),
+    null: () => z.null(),
+    any: () => z.any(),
+    unknown: () => z.unknown(),
+    never: () => z.never(),
+    void: () => z.void(),
+    literal: (shape) => z.literal(shape.value),
+    symbol: () => z.symbol(),
+    tuple: ((shape, opts) => {
+        let i = z.tuple(shape.items.map((item, idx) => {
+            return (checkRef(item, opts) ||
+                d(item, {
+                    ...opts,
+                    path: opts.path + "/items/" + idx,
+                }));
+        }));
+        if (shape.rest) {
+            const rest = checkRef(shape.rest, opts) ||
+                d(shape.rest, {
+                    ...opts,
+                    path: opts.path + "/rest",
+                });
+            i = i.rest(rest);
+        }
+        opts.pathToSchema.set(opts.path, i);
+        return i;
+    }),
+    set: ((shape, opts) => {
+        let i = z.set(checkRef(shape.value, opts) ||
+            d(shape.value, {
+                ...opts,
+                path: opts.path + "/value",
+            }));
+        if (shape.minSize !== undefined) {
+            i = i.min(shape.minSize);
+        }
+        if (shape.maxSize !== undefined) {
+            i = i.max(shape.maxSize);
+        }
+        opts.pathToSchema.set(opts.path, i);
+        return i;
+    }),
+    array: ((shape, opts) => {
+        let i = z.array(checkRef(shape.element, opts) ||
+            d(shape.element, {
+                ...opts,
+                path: opts.path + "/element",
+            }));
+        if (shape.minLength !== undefined) {
+            i = i.min(shape.minLength);
+        }
+        if (shape.maxLength !== undefined) {
+            i = i.max(shape.maxLength);
+        }
+        opts.pathToSchema.set(opts.path, i);
+        return i;
+    }),
+    object: ((shape, opts) => {
+        let i = z.object(Object.fromEntries(Object.entries(shape.properties).map(([key, value]) => {
+            return [
+                key,
+                checkRef(value, opts) ||
+                    d(value, {
+                        ...opts,
+                        path: opts.path + "/properties/" + key,
+                    }),
+            ];
+        })));
+        if (shape.catchall) {
+            i = i.catchall(d(shape.catchall, opts));
+        }
+        else if (shape.unknownKeys === "strict") {
+            i = i.strict();
+        }
+        else if (shape.unknownKeys === "passthrough") {
+            i = i.passthrough();
+        }
+        opts.pathToSchema.set(opts.path, i);
+        return i;
+    }),
+    record: ((shape, opts) => {
+        const i = z.record(checkRef(shape.key, opts) ||
+            d(shape.key, {
+                ...opts,
+                path: opts.path + "/key",
+            }), checkRef(shape.value, opts) ||
+            d(shape.value, {
+                ...opts,
+                path: opts.path + "/value",
+            }));
+        opts.pathToSchema.set(opts.path, i);
+        return i;
+    }),
+    map: ((shape, opts) => {
+        const i = z.map(checkRef(shape.key, opts) ||
+            d(shape.key, {
+                ...opts,
+                path: opts.path + "/key",
+            }), checkRef(shape.value, opts) ||
+            d(shape.value, {
+                ...opts,
+                path: opts.path + "/value",
+            }));
+        opts.pathToSchema.set(opts.path, i);
+        return i;
+    }),
+    nativeEnum: ((shape) => z.nativeEnum(shape.values)),
+    enum: ((shape) => z.enum(shape.values)),
+    union: ((shape, opts) => {
+        const i = z.union(shape.options.map((opt, idx) => checkRef(opt, opts) ||
+            d(opt, {
+                ...opts,
+                path: opts.path + "/options/" + idx,
+            })));
+        opts.pathToSchema.set(opts.path, i);
+        return i;
+    }),
+    discriminatedUnion: ((shape, opts) => {
+        const i = z.discriminatedUnion(shape.discriminator, shape.options.map((opt, idx) => checkRef(opt, opts) ||
+            d(opt, {
+                ...opts,
+                path: opts.path + "/options/" + idx,
+            })));
+        opts.pathToSchema.set(opts.path, i);
+        return i;
+    }),
+    intersection: ((shape, opts) => {
+        const i = z.intersection(checkRef(shape.left, opts) ||
+            d(shape.left, {
+                ...opts,
+                path: opts.path + "/left",
+            }), checkRef(shape.right, opts) ||
+            d(shape.right, {
+                ...opts,
+                path: opts.path + "/right",
+            }));
+        opts.pathToSchema.set(opts.path, i);
+        return i;
+    }),
+    function: ((shape, opts) => {
+        const i = z.function(checkRef(shape.args, opts) ||
+            d(shape.args, {
+                ...opts,
+                path: opts.path + "/args",
+            }), checkRef(shape.returns, opts) ||
+            d(shape.returns, {
+                ...opts,
+                path: opts.path + "/returns",
+            }));
+        opts.pathToSchema.set(opts.path, i);
+        return i;
+    }),
+    promise: ((shape, opts) => {
+        const i = z.promise(checkRef(shape.value, opts) ||
+            d(shape.value, {
+                ...opts,
+                path: opts.path + "/value",
+            }));
+        opts.pathToSchema.set(opts.path, i);
+        return i;
+    }),
+    catch: ((shape, opts) => {
+        let base = checkRef(shape.innerType, opts) ||
+            d(shape.innerType, {
+                ...opts,
+                path: opts.path + "/innerType",
+            });
+        base = base.catch(shape.value);
+        opts.pathToSchema.set(opts.path, base);
+        return base;
+    }),
+    effect: ((shape, opts) => {
+        let base = checkRef(shape.inner, opts) ||
+            d(shape.inner, {
+                ...opts,
+                path: opts.path + "/inner",
+            });
+        if (!("superRefinements" in opts ||
+            "transforms" in opts ||
+            "preprocesses" in opts)) {
+            opts.pathToSchema.set(opts.path, base);
+            return base;
+        }
+        for (const { name, type } of shape.effects) {
+            if (type === "refinement" && opts.superRefinements?.[name]) {
+                base = base.superRefine(opts.superRefinements[name]);
+            }
+            else if (type === "transform" && opts.transforms?.[name]) {
+                base = base.transform(opts.transforms[name]);
+            }
+            else if (type === "preprocess" && opts.preprocesses?.[name]) {
+                base = z.preprocess(opts.preprocesses[name], base);
+            }
+        }
+        opts.pathToSchema.set(opts.path, base);
+        return base;
+    }),
+};
+// Must match the exported Dezerialize types
+// export function dezerialize<T extends SzType>(shape: T, opts?: DezerializerOptions): Dezerialize<T> {
+export function dezerializeRefs(shape, opts) {
+    if ("isOptional" in shape) {
+        const { isOptional, ...rest } = shape;
+        const inner = d(rest, opts);
+        const result = isOptional ? inner.optional() : inner;
+        opts.pathToSchema.set(opts.path, result);
+        return result;
+    }
+    if ("isNullable" in shape) {
+        const { isNullable, ...rest } = shape;
+        const inner = d(rest, opts);
+        const result = isNullable ? inner.nullable() : inner;
+        opts.pathToSchema.set(opts.path, result);
+        return result;
+    }
+    if ("defaultValue" in shape) {
+        const { defaultValue, ...rest } = shape;
+        const inner = d(rest, opts);
+        const result = inner.default(shape.type === "bigInt"
+            ? BigInt(defaultValue)
+            : shape.type === "date"
+                ? new Date(defaultValue)
+                : defaultValue);
+        opts.pathToSchema.set(opts.path, result);
+        return result;
+    }
+    if ("readonly" in shape) {
+        const { readonly, ...rest } = shape;
+        const inner = d(rest, opts);
+        const result = readonly ? inner.readonly() : inner;
+        opts.pathToSchema.set(opts.path, result);
+        return result;
+    }
+    if ("description" in shape && typeof shape.description === "string") {
+        const { description, ...rest } = shape;
+        const inner = d(rest, opts);
+        const result = inner.describe(description);
+        opts.pathToSchema.set(opts.path, result);
+        return result;
+    }
+    return dezerializers[shape.type](shape, opts);
+}
+function resolvePointer(obj, pointer) {
+    const tokens = pointer.split("/").slice(1);
+    return tokens.reduce((acc, token) => {
+        /* c8 ignore next -- Guard */
+        if (acc === undefined)
+            return acc;
+        return acc[token.replace(/~1/g, "/").replace(/~0/g, "~")];
+    }, obj);
+}
+export function dezerialize(shape, opts = {}) {
+    if (!("path" in opts)) {
+        opts.path = "#";
+    }
+    if (!("pathToSchema" in opts)) {
+        opts.pathToSchema = new Map();
+    }
+    if (!("$refs" in opts)) {
+        opts.$refs = [];
+    }
+    if (!("originalShape" in opts)) {
+        opts.originalShape = shape;
+    }
+    const options = opts;
+    const dez = dezerializeRefs(shape, options);
+    for (const [lazy, $ref] of options.$refs) {
+        lazy._def.getter = () => {
+            const schema = options.pathToSchema.get($ref);
+            if (schema) {
+                return schema;
+            }
+            const obj = resolvePointer(options.originalShape, $ref);
+            // Ensure we act on the same options as the main document JSON
+            const dez = dezerialize(obj, options);
+            options.pathToSchema.set($ref, dez);
+            return dez;
+        };
+    }
+    return dez;
+}

package/vendor/zodex/dist/esm/index.d.ts

@@ -0,0 +1,9 @@
+import { SzType } from "./types.js";
+export * from "./dezerialize.js";
+export * from "./zerialize.js";
+export * from "./types.js";
+export { mapTypesToViews } from "./ui.js";
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type SzPropertyKeysOf<T extends SzType> = KeysOfUnion<Extract<T, {
+    type: "object";
+}>["properties"]>;

package/vendor/zodex/dist/esm/index.js

@@ -0,0 +1,4 @@
+export * from "./dezerialize.js";
+export * from "./zerialize.js";
+export * from "./types.js";
+export { mapTypesToViews } from "./ui.js";

package/vendor/zodex/dist/esm/infer.d.ts

@@ -0,0 +1,29 @@
+import { SzType, SzOptional, SzNullable, SzArray, SzObject, SzUnion, SzDiscriminatedUnion, SzIntersection, SzTuple, SzRecord, SzMap, SzSet, SzFunction, SzEnum, SzPromise } from "./types.js";
+type PrimitiveTypes = {
+    string: string;
+    number: number;
+    boolean: boolean;
+    nan: number;
+    date: Date;
+    symbol: symbol;
+    undefined: undefined;
+    null: null;
+    any: any;
+    unknown: unknown;
+    never: never;
+    void: void;
+};
+type RequiredKeys<T extends Record<string, any>> = {
+    [K in keyof T]: T[K] extends SzOptional ? never : K;
+}[keyof T];
+type OptionalKeys<T extends Record<string, any>> = {
+    [K in keyof T]: T[K] extends SzOptional ? K : never;
+}[keyof T];
+export type SzInfer<T extends SzType> = (T extends SzOptional ? undefined : never) | (T extends SzNullable ? null : never) | (T["type"] extends keyof PrimitiveTypes ? PrimitiveTypes[T["type"]] : T extends {
+    type: "literal";
+} ? T["value"] : T extends SzArray<infer T> ? SzInfer<T>[] : T extends SzObject<infer Properties> ? {
+    [Key in RequiredKeys<Properties>]: SzInfer<Properties[Key]>;
+} & {
+    [Key in OptionalKeys<Properties>]?: SzInfer<Properties[Key]>;
+} : T extends SzUnion<infer Options> ? SzInfer<Options[number]> : T extends SzDiscriminatedUnion<infer _D, infer Options> ? SzInfer<Options[number]> : T extends SzIntersection<infer L, infer R> ? SzInfer<L> & SzInfer<R> : T extends SzTuple<infer Items> ? SzInfer<Items[number]>[] : T extends SzRecord<infer _Key, infer Value> ? Record<string, SzInfer<Value>> : T extends SzMap<infer _Key, infer Value> ? Record<string, SzInfer<Value>> : T extends SzSet<infer T> ? T[] : T extends SzFunction<infer Args, infer Return> ? (...args: SzInfer<Args>[]) => SzInfer<Return> : T extends SzEnum<infer Values> ? Values[number] : T extends SzPromise<infer Value> ? Promise<SzInfer<Value>> : unknown);
+export {};

package/vendor/zodex/dist/esm/infer.js

@@ -0,0 +1 @@
+export {};

package/vendor/zodex/dist/esm/package.json

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

package/vendor/zodex/dist/esm/types.d.ts

@@ -0,0 +1,201 @@
+import { ValueOf } from "type-fest";
+export type SzNumber = {
+    type: "number";
+    coerce?: boolean;
+    min?: number;
+    max?: number;
+    minInclusive?: boolean;
+    maxInclusive?: boolean;
+    multipleOf?: number;
+    int?: boolean;
+    finite?: boolean;
+};
+export type SzBigInt = {
+    type: "bigInt";
+    coerce?: boolean;
+    min?: string;
+    max?: string;
+    minInclusive?: boolean;
+    maxInclusive?: boolean;
+    multipleOf?: string;
+};
+export declare const STRING_KINDS: Set<"email" | "url" | "emoji" | "uuid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "date" | "duration" | "base64">;
+export type SzString = {
+    type: "string";
+    coerce?: boolean;
+    min?: number;
+    max?: number;
+    length?: number;
+    startsWith?: string;
+    endsWith?: string;
+    toLowerCase?: boolean;
+    toUpperCase?: boolean;
+    trim?: boolean;
+} & (object | {
+    includes: string;
+    position?: number;
+}) & (object | {
+    kind: "ip";
+    version?: "v4" | "v6";
+} | {
+    regex: string;
+    flags?: string;
+} | {
+    kind: "time";
+    precision?: number;
+} | {
+    kind: "datetime";
+    offset?: true;
+    local?: true;
+    precision?: number;
+} | {
+    kind: typeof STRING_KINDS extends Set<infer T> ? T : never;
+});
+export type SzDate = {
+    type: "date";
+    coerce?: boolean;
+    min?: number;
+    max?: number;
+};
+export type SzBoolean = {
+    type: "boolean";
+    coerce?: boolean;
+};
+export type SzNaN = {
+    type: "nan";
+};
+export type SzUndefined = {
+    type: "undefined";
+};
+export type SzNull = {
+    type: "null";
+};
+export type SzAny = {
+    type: "any";
+};
+export type SzUnknown = {
+    type: "unknown";
+};
+export type SzNever = {
+    type: "never";
+};
+export type SzVoid = {
+    type: "void";
+};
+export type SzSymbol = {
+    type: "symbol";
+};
+export type SzPrimitive = SzBoolean | SzNumber | SzBigInt | SzString | SzNaN | SzDate | SzUndefined | SzNull | SzAny | SzUnknown | SzNever | SzVoid | SzSymbol;
+export type SzLiteral<T> = {
+    type: "literal";
+    value: T;
+};
+export type SzArray<T extends SzType = SzType> = {
+    type: "array";
+    element: T;
+    minLength?: number;
+    maxLength?: number;
+};
+export type SzObject<T extends Record<string, SzType> = Record<string, SzType>, U extends SzType = SzType> = {
+    type: "object";
+    properties: T;
+    unknownKeys?: "strict" | "strip" | "passthrough";
+    catchall?: U;
+};
+export type SzUnion<Options extends [SzType, ...SzType[]] = [SzType]> = {
+    type: "union";
+    options: Options;
+};
+export type SzDiscriminatedUnionOption<Discriminator extends string> = {
+    [key in Discriminator]: SzType;
+} & SzType;
+export type SzDiscriminatedUnion<Discriminator extends string = string, Options extends SzDiscriminatedUnionOption<Discriminator>[] = []> = {
+    type: "discriminatedUnion";
+    discriminator: Discriminator;
+    options: Options;
+};
+export type SzIntersection<Left extends SzType = SzType, Right extends SzType = SzType> = {
+    type: "intersection";
+    left: Left;
+    right: Right;
+};
+export type SzTuple<Items extends [SzType, ...SzType[]] | [] = [SzType, ...SzType[]] | []> = {
+    type: "tuple";
+    items: Items;
+    rest?: SzType;
+};
+export type SzRecord<Key extends SzKey = SzKey, Value extends SzType = SzType> = {
+    type: "record";
+    key: Key;
+    value: Value;
+};
+export type SzMap<Key extends SzKey, Value extends SzType> = {
+    type: "map";
+    key: Key;
+    value: Value;
+};
+export type SzSet<T extends SzType = SzType> = {
+    type: "set";
+    value: T;
+    minSize?: number;
+    maxSize?: number;
+};
+export type SzFunction<Args extends SzTuple, Return extends SzType> = {
+    type: "function";
+    args: Args;
+    returns: Return;
+};
+export type SzEnum<Values extends [string, ...string[]] = [string, ...string[]]> = {
+    type: "enum";
+    values: Values;
+};
+export type SzNativeEnum<Values extends {
+    [key: string]: string | number;
+    [key: number]: string;
+} = {
+    [key: string]: string | number;
+    [key: number]: string;
+}> = {
+    type: "nativeEnum";
+    values: Values;
+};
+export type SzPromise<T extends SzType = SzType> = {
+    type: "promise";
+    value: T;
+};
+export type SzCatch<T extends SzType = SzType> = {
+    type: "catch";
+    value: any;
+    innerType: T;
+};
+export type SzEffect<T extends SzType = SzType> = {
+    type: "effect";
+    effects: {
+        name: string;
+        type: "refinement" | "transform" | "preprocess";
+    }[];
+    inner: T;
+};
+export type SzNullable = {
+    isNullable: boolean;
+};
+export type SzOptional = {
+    isOptional: boolean;
+};
+export type SzDefault<T> = {
+    defaultValue: T;
+};
+export type SzDescription = {
+    description: string;
+};
+export type SzReadonly = {
+    readonly: boolean;
+};
+export type SzRef = {
+    $ref: string;
+};
+export type SzExtras = Partial<SzNullable & SzOptional & SzDefault<any> & SzDescription & SzReadonly>;
+export type SzKey = (SzString | SzNumber | SzSymbol) & SzExtras;
+export type SzDefaultOrNullable = SzDefault<any> | SzNullable;
+export type SzType = (SzPrimitive | SzLiteral<any> | SzArray<any> | SzObject<any, any> | SzUnion<any> | SzDiscriminatedUnion<any, any> | SzIntersection<any, any> | SzTuple<any> | SzRecord<any, any> | SzMap<any, any> | SzSet<any> | SzFunction<any, any> | SzEnum<any> | SzNativeEnum<any> | SzPromise<any> | SzEffect<any> | SzCatch<any>) & SzExtras;
+export type SzUnionize<T extends SzType | SzRef> = T | (T extends SzArray<infer T> ? SzUnionize<T> : T extends SzObject<infer Properties> ? SzUnionize<ValueOf<Properties>> : T extends SzUnion<infer Options> ? SzUnionize<Options[number]> : T extends SzDiscriminatedUnion<infer _D, infer Options> ? SzUnionize<Options[number]> : T extends SzIntersection<infer L, infer R> ? SzUnionize<L | R> : T extends SzTuple<infer Items> ? SzUnionize<Items[number]> : T extends SzRecord<infer _Key, infer Value> ? SzUnionize<Value> : T extends SzMap<infer _Key, infer Value> ? SzUnionize<Value> : T extends SzSet<infer T> ? SzUnionize<T> : T extends SzFunction<infer Args, infer Return> ? SzUnionize<Args | Return> : T extends SzPromise<infer Value> ? SzUnionize<Value> : never);

package/vendor/zodex/dist/esm/types.js

@@ -0,0 +1,13 @@
+export const STRING_KINDS = new Set([
+    "email",
+    "url",
+    "emoji",
+    "uuid",
+    "nanoid",
+    "cuid",
+    "cuid2",
+    "ulid",
+    "date",
+    "duration",
+    "base64",
+]);