/opt/canhelp/node_modules/zod/src/v4/core
Edit: /opt/canhelp/node_modules/zod/src/v4/core/schemas.ts (118421B)
import type { $ZodTypeDiscriminable } from "./api.js";
import * as checks from "./checks.js";
import * as core from "./core.js";
import { Doc } from "./doc.js";
import type * as errors from "./errors.js";
import { safeParse, safeParseAsync } from "./parse.js";
import * as regexes from "./regexes.js";
import type { StandardSchemaV1 } from "./standard-schema.js";
import * as util from "./util.js";
import { version } from "./versions.js";
///////////////////////////// PARSE //////////////////////////////
export interface ParseContext
{
/** Customize error messages. */
readonly error?: errors.$ZodErrorMap;
/** Include the `input` field in issue objects. Default `false`. */
readonly reportInput?: boolean;
/** Skip eval-based fast path. Default `false`. */
readonly jitless?: boolean;
/** Abort validation after the first error. Default `false`. */
// readonly abortEarly?: boolean;
}
/** @internal */
export interface ParseContextInternal extends ParseContext {
readonly async?: boolean | undefined;
}
export interface ParsePayload {
value: T;
issues: errors.$ZodRawIssue[];
}
export type CheckFn = (input: ParsePayload) => util.MaybeAsync;
///////////////////////////// SCHEMAS //////////////////////////////
export interface $ZodTypeDef {
type:
| "string"
| "number"
| "int"
| "boolean"
| "bigint"
| "symbol"
| "null"
| "undefined"
| "void" // merge with undefined?
| "never"
| "any"
| "unknown"
| "date"
| "object"
| "record"
| "file"
| "array"
| "tuple"
| "union"
| "intersection"
| "map"
| "set"
| "enum"
| "literal"
| "nullable"
| "optional"
| "nonoptional"
| "success"
| "transform"
| "default"
| "prefault"
| "catch"
| "nan"
| "pipe"
| "readonly"
| "template_literal"
| "promise"
| "lazy"
| "custom";
error?: errors.$ZodErrorMap | undefined;
checks?: checks.$ZodCheck[];
}
export interface _$ZodTypeInternals {
/** The `@zod/core` version of this schema */
version: typeof version;
/** Schema definition. */
def: $ZodTypeDef;
// types: Types;
/** @internal Randomly generated ID for this schema. */
// id: string;
/** @internal List of deferred initializers. */
deferred: util.AnyFunc[] | undefined;
/** @internal Parses input and runs all checks (refinements). */
run(payload: ParsePayload, ctx: ParseContextInternal): util.MaybeAsync;
/** @internal Parses input, doesn't run checks. */
parse(payload: ParsePayload, ctx: ParseContextInternal): util.MaybeAsync;
/** @internal Stores identifiers for the set of traits implemented by this schema. */
traits: Set;
/** @internal Indicates that a schema output type should be considered optional inside objects.
* @default Required
*/
/** @internal */
optin?: "optional" | undefined;
/** @internal */
optout?: "optional" | undefined;
/** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
*
* Defined on: enum, const, literal, null, undefined
* Passthrough: optional, nullable, branded, default, catch, pipe
* Todo: unions?
*/
values?: util.PrimitiveSet | undefined;
/** @internal A set of literal discriminators used for the fast path in discriminated unions. */
propValues?: util.PropValues | undefined;
/** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
pattern: RegExp | undefined;
/** @internal The constructor function of this schema. */
constr: new (
def: any
) => $ZodType;
/** @internal A catchall object for bag metadata related to this schema. Commonly modified by checks using `onattach`. */
bag: Record;
/** @internal The set of issues this schema might throw during type checking. */
isst: errors.$ZodIssueBase;
/** An optional method used to override `toJSONSchema` logic. */
toJSONSchema?: () => unknown;
/** @internal The parent of this schema. Only set during certain clone operations. */
parent?: $ZodType | undefined;
}
/** @internal */
export interface $ZodTypeInternals extends _$ZodTypeInternals {
/** @internal The inferred output type */
output: O; //extends { $out: infer O } ? O : Out;
/** @internal The inferred input type */
input: I; //extends { $in: infer I } ? I : In;
}
export type $ZodStandardSchema = StandardSchemaV1.Props, core.output>;
export type SomeType = { _zod: _$ZodTypeInternals };
export interface $ZodType<
O = unknown,
I = unknown,
Internals extends $ZodTypeInternals = $ZodTypeInternals,
> {
_zod: Internals;
"~standard": $ZodStandardSchema;
}
export interface _$ZodType
extends $ZodType {
// _zod: T;
}
export const $ZodType: core.$constructor<$ZodType> = /*@__PURE__*/ core.$constructor("$ZodType", (inst, def) => {
inst ??= {} as any;
inst._zod.def = def; // set _def property
inst._zod.bag = inst._zod.bag || {}; // initialize _bag object
inst._zod.version = version;
const checks = [...(inst._zod.def.checks ?? [])];
// if inst is itself a checks.$ZodCheck, run it as a check
if (inst._zod.traits.has("$ZodCheck")) {
checks.unshift(inst as any);
}
//
for (const ch of checks) {
for (const fn of ch._zod.onattach) {
fn(inst);
}
}
if (checks.length === 0) {
// deferred initializer
// inst._zod.parse is not yet defined
inst._zod.deferred ??= [];
inst._zod.deferred?.push(() => {
inst._zod.run = inst._zod.parse;
});
} else {
const runChecks = (
payload: ParsePayload,
checks: checks.$ZodCheck[],
ctx?: ParseContextInternal | undefined
): util.MaybeAsync => {
let isAborted = util.aborted(payload);
let asyncResult!: Promise | undefined;
for (const ch of checks) {
if (ch._zod.def.when) {
const shouldRun = ch._zod.def.when(payload);
if (!shouldRun) continue;
} else if (isAborted) {
continue;
}
const currLen = payload.issues.length;
const _ = ch._zod.check(payload as any) as any as ParsePayload;
if (_ instanceof Promise && ctx?.async === false) {
throw new core.$ZodAsyncError();
}
if (asyncResult || _ instanceof Promise) {
asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
await _;
const nextLen = payload.issues.length;
if (nextLen === currLen) return;
if (!isAborted) isAborted = util.aborted(payload, currLen);
});
} else {
const nextLen = payload.issues.length;
if (nextLen === currLen) continue;
if (!isAborted) isAborted = util.aborted(payload, currLen);
}
}
if (asyncResult) {
return asyncResult.then(() => {
return payload;
});
}
return payload;
};
inst._zod.run = (payload, ctx) => {
const result = inst._zod.parse(payload, ctx);
if (result instanceof Promise) {
if (ctx.async === false) throw new core.$ZodAsyncError();
return result.then((result) => runChecks(result, checks, ctx));
}
return runChecks(result, checks, ctx);
};
}
inst["~standard"] = {
validate: (value: unknown) => {
try {
const r = safeParse(inst, value);
return r.success ? { value: r.data } : { issues: r.error?.issues };
} catch (_) {
return safeParseAsync(inst, value).then((r) => (r.success ? { value: r.data } : { issues: r.error?.issues }));
}
},
vendor: "zod",
version: 1 as const,
};
});
export { clone } from "./util.js";
//////////////////////////////////////////
//////////////////////////////////////////
////////// //////////
////////// $ZodString //////////
////////// //////////
//////////////////////////////////////////
//////////////////////////////////////////
export interface $ZodStringDef extends $ZodTypeDef {
type: "string";
coerce?: boolean;
checks?: checks.$ZodCheck[];
}
export interface $ZodStringInternals extends $ZodTypeInternals {
def: $ZodStringDef;
/** @deprecated Internal API, use with caution (not deprecated) */
pattern: RegExp;
/** @deprecated Internal API, use with caution (not deprecated) */
isst: errors.$ZodIssueInvalidType;
bag: util.LoosePartial<{
minimum: number;
maximum: number;
patterns: Set;
format: string;
contentEncoding: string;
}>;
}
export interface $ZodString extends _$ZodType<$ZodStringInternals> {
// _zod: $ZodStringInternals;
}
export const $ZodString: core.$constructor<$ZodString> = /*@__PURE__*/ core.$constructor("$ZodString", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = [...(inst?._zod.bag?.patterns ?? [])].pop() ?? regexes.string(inst._zod.bag);
inst._zod.parse = (payload, _) => {
if (def.coerce)
try {
payload.value = String(payload.value);
} catch (_) {}
if (typeof payload.value === "string") return payload;
payload.issues.push({
expected: "string",
code: "invalid_type",
input: payload.value,
inst,
});
return payload;
};
});
////////////////////////////// ZodStringFormat //////////////////////////////
export interface $ZodStringFormatDef
extends $ZodStringDef,
checks.$ZodCheckStringFormatDef {}
export interface $ZodStringFormatInternals
extends $ZodStringInternals,
checks.$ZodCheckStringFormatInternals {
def: $ZodStringFormatDef;
}
export interface $ZodStringFormat extends $ZodType {
_zod: $ZodStringFormatInternals;
}
export const $ZodStringFormat: core.$constructor<$ZodStringFormat> = /*@__PURE__*/ core.$constructor(
"$ZodStringFormat",
(inst, def): void => {
// check initialization must come first
checks.$ZodCheckStringFormat.init(inst, def);
$ZodString.init(inst, def);
}
);
////////////////////////////// ZodGUID //////////////////////////////
export interface $ZodGUIDDef extends $ZodStringFormatDef<"guid"> {}
export interface $ZodGUIDInternals extends $ZodStringFormatInternals<"guid"> {}
export interface $ZodGUID extends $ZodType {
_zod: $ZodGUIDInternals;
}
export const $ZodGUID: core.$constructor<$ZodGUID> = /*@__PURE__*/ core.$constructor("$ZodGUID", (inst, def): void => {
def.pattern ??= regexes.guid;
$ZodStringFormat.init(inst, def);
});
////////////////////////////// ZodUUID //////////////////////////////
export interface $ZodUUIDDef extends $ZodStringFormatDef<"uuid"> {
version?: "v1" | "v2" | "v3" | "v4" | "v5" | "v6" | "v7" | "v8";
}
export interface $ZodUUIDInternals extends $ZodStringFormatInternals<"uuid"> {
def: $ZodUUIDDef;
}
export interface $ZodUUID extends $ZodType {
_zod: $ZodUUIDInternals;
}
export const $ZodUUID: core.$constructor<$ZodUUID> = /*@__PURE__*/ core.$constructor("$ZodUUID", (inst, def): void => {
if (def.version) {
const versionMap: Record = {
v1: 1,
v2: 2,
v3: 3,
v4: 4,
v5: 5,
v6: 6,
v7: 7,
v8: 8,
};
const v = versionMap[def.version];
if (v === undefined) throw new Error(`Invalid UUID version: "${def.version}"`);
def.pattern ??= regexes.uuid(v);
} else def.pattern ??= regexes.uuid();
$ZodStringFormat.init(inst, def);
});
////////////////////////////// ZodEmail //////////////////////////////
export interface $ZodEmailDef extends $ZodStringFormatDef<"email"> {}
export interface $ZodEmailInternals extends $ZodStringFormatInternals<"email"> {}
export interface $ZodEmail extends $ZodType {
_zod: $ZodEmailInternals;
}
export const $ZodEmail: core.$constructor<$ZodEmail> = /*@__PURE__*/ core.$constructor(
"$ZodEmail",
(inst, def): void => {
def.pattern ??= regexes.email;
$ZodStringFormat.init(inst, def);
}
);
////////////////////////////// ZodURL //////////////////////////////
export interface $ZodURLDef extends $ZodStringFormatDef<"url"> {
hostname?: RegExp | undefined;
protocol?: RegExp | undefined;
}
export interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
def: $ZodURLDef;
}
export interface $ZodURL extends $ZodType {
_zod: $ZodURLInternals;
}
export const $ZodURL: core.$constructor<$ZodURL> = /*@__PURE__*/ core.$constructor("$ZodURL", (inst, def) => {
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
try {
const orig = payload.value;
const url = new URL(orig);
const href = url.href;
if (def.hostname) {
def.hostname.lastIndex = 0;
if (!def.hostname.test(url.hostname)) {
payload.issues.push({
code: "invalid_format",
format: "url",
note: "Invalid hostname",
pattern: regexes.hostname.source,
input: payload.value,
inst,
continue: !def.abort,
});
}
}
if (def.protocol) {
def.protocol.lastIndex = 0;
if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) {
payload.issues.push({
code: "invalid_format",
format: "url",
note: "Invalid protocol",
pattern: def.protocol.source,
input: payload.value,
inst,
continue: !def.abort,
});
}
}
// payload.value = url.href;
if (!orig.endsWith("/") && href.endsWith("/")) {
payload.value = href.slice(0, -1);
} else {
payload.value = href;
}
return;
} catch (_) {
payload.issues.push({
code: "invalid_format",
format: "url",
input: payload.value,
inst,
continue: !def.abort,
});
}
};
});
////////////////////////////// ZodEmoji //////////////////////////////
export interface $ZodEmojiDef extends $ZodStringFormatDef<"emoji"> {}
export interface $ZodEmojiInternals extends $ZodStringFormatInternals<"emoji"> {}
export interface $ZodEmoji extends $ZodType {
_zod: $ZodEmojiInternals;
}
export const $ZodEmoji: core.$constructor<$ZodEmoji> = /*@__PURE__*/ core.$constructor(
"$ZodEmoji",
(inst, def): void => {
def.pattern ??= regexes.emoji();
$ZodStringFormat.init(inst, def);
}
);
////////////////////////////// ZodNanoID //////////////////////////////
export interface $ZodNanoIDDef extends $ZodStringFormatDef<"nanoid"> {}
export interface $ZodNanoIDInternals extends $ZodStringFormatInternals<"nanoid"> {}
export interface $ZodNanoID extends $ZodType {
_zod: $ZodNanoIDInternals;
}
export const $ZodNanoID: core.$constructor<$ZodNanoID> = /*@__PURE__*/ core.$constructor(
"$ZodNanoID",
(inst, def): void => {
def.pattern ??= regexes.nanoid;
$ZodStringFormat.init(inst, def);
}
);
////////////////////////////// ZodCUID //////////////////////////////
export interface $ZodCUIDDef extends $ZodStringFormatDef<"cuid"> {}
export interface $ZodCUIDInternals extends $ZodStringFormatInternals<"cuid"> {}
export interface $ZodCUID extends $ZodType {
_zod: $ZodCUIDInternals;
}
export const $ZodCUID: core.$constructor<$ZodCUID> = /*@__PURE__*/ core.$constructor("$ZodCUID", (inst, def): void => {
def.pattern ??= regexes.cuid;
$ZodStringFormat.init(inst, def);
});
////////////////////////////// ZodCUID2 //////////////////////////////
export interface $ZodCUID2Def extends $ZodStringFormatDef<"cuid2"> {}
export interface $ZodCUID2Internals extends $ZodStringFormatInternals<"cuid2"> {}
export interface $ZodCUID2 extends $ZodType {
_zod: $ZodCUID2Internals;
}
export const $ZodCUID2: core.$constructor<$ZodCUID2> = /*@__PURE__*/ core.$constructor(
"$ZodCUID2",
(inst, def): void => {
def.pattern ??= regexes.cuid2;
$ZodStringFormat.init(inst, def);
}
);
////////////////////////////// ZodULID //////////////////////////////
export interface $ZodULIDDef extends $ZodStringFormatDef<"ulid"> {}
export interface $ZodULIDInternals extends $ZodStringFormatInternals<"ulid"> {}
export interface $ZodULID extends $ZodType {
_zod: $ZodULIDInternals;
}
export const $ZodULID: core.$constructor<$ZodULID> = /*@__PURE__*/ core.$constructor("$ZodULID", (inst, def): void => {
def.pattern ??= regexes.ulid;
$ZodStringFormat.init(inst, def);
});
////////////////////////////// ZodXID //////////////////////////////
export interface $ZodXIDDef extends $ZodStringFormatDef<"xid"> {}
export interface $ZodXIDInternals extends $ZodStringFormatInternals<"xid"> {}
export interface $ZodXID extends $ZodType {
_zod: $ZodXIDInternals;
}
export const $ZodXID: core.$constructor<$ZodXID> = /*@__PURE__*/ core.$constructor("$ZodXID", (inst, def): void => {
def.pattern ??= regexes.xid;
$ZodStringFormat.init(inst, def);
});
////////////////////////////// ZodKSUID //////////////////////////////
export interface $ZodKSUIDDef extends $ZodStringFormatDef<"ksuid"> {}
export interface $ZodKSUIDInternals extends $ZodStringFormatInternals<"ksuid"> {}
export interface $ZodKSUID extends $ZodType {
_zod: $ZodKSUIDInternals;
}
export const $ZodKSUID: core.$constructor<$ZodKSUID> = /*@__PURE__*/ core.$constructor(
"$ZodKSUID",
(inst, def): void => {
def.pattern ??= regexes.ksuid;
$ZodStringFormat.init(inst, def);
}
);
////////////////////////////// ZodISODateTime //////////////////////////////
export interface $ZodISODateTimeDef extends $ZodStringFormatDef<"datetime"> {
precision: number | null;
offset: boolean;
local: boolean;
}
export interface $ZodISODateTimeInternals extends $ZodStringFormatInternals {
def: $ZodISODateTimeDef;
}
export interface $ZodISODateTime extends $ZodType {
_zod: $ZodISODateTimeInternals;
}
export const $ZodISODateTime: core.$constructor<$ZodISODateTime> = /*@__PURE__*/ core.$constructor(
"$ZodISODateTime",
(inst, def): void => {
def.pattern ??= regexes.datetime(def);
$ZodStringFormat.init(inst, def);
}
);
////////////////////////////// ZodISODate //////////////////////////////
export interface $ZodISODateDef extends $ZodStringFormatDef<"date"> {}
export interface $ZodISODateInternals extends $ZodStringFormatInternals<"date"> {}
export interface $ZodISODate extends $ZodType {
_zod: $ZodISODateInternals;
}
export const $ZodISODate: core.$constructor<$ZodISODate> = /*@__PURE__*/ core.$constructor(
"$ZodISODate",
(inst, def): void => {
def.pattern ??= regexes.date;
$ZodStringFormat.init(inst, def);
}
);
////////////////////////////// ZodISOTime //////////////////////////////
export interface $ZodISOTimeDef extends $ZodStringFormatDef<"time"> {
precision?: number | null;
}
export interface $ZodISOTimeInternals extends $ZodStringFormatInternals<"time"> {
def: $ZodISOTimeDef;
}
export interface $ZodISOTime extends $ZodType {
_zod: $ZodISOTimeInternals;
}
export const $ZodISOTime: core.$constructor<$ZodISOTime> = /*@__PURE__*/ core.$constructor(
"$ZodISOTime",
(inst, def): void => {
def.pattern ??= regexes.time(def);
$ZodStringFormat.init(inst, def);
}
);
////////////////////////////// ZodISODuration //////////////////////////////
export interface $ZodISODurationDef extends $ZodStringFormatDef<"duration"> {}
export interface $ZodISODurationInternals extends $ZodStringFormatInternals<"duration"> {}
export interface $ZodISODuration extends $ZodType {
_zod: $ZodISODurationInternals;
}
export const $ZodISODuration: core.$constructor<$ZodISODuration> = /*@__PURE__*/ core.$constructor(
"$ZodISODuration",
(inst, def): void => {
def.pattern ??= regexes.duration;
$ZodStringFormat.init(inst, def);
}
);
////////////////////////////// ZodIPv4 //////////////////////////////
export interface $ZodIPv4Def extends $ZodStringFormatDef<"ipv4"> {
version?: "v4";
}
export interface $ZodIPv4Internals extends $ZodStringFormatInternals<"ipv4"> {
def: $ZodIPv4Def;
}
export interface $ZodIPv4 extends $ZodType {
_zod: $ZodIPv4Internals;
}
export const $ZodIPv4: core.$constructor<$ZodIPv4> = /*@__PURE__*/ core.$constructor("$ZodIPv4", (inst, def): void => {
def.pattern ??= regexes.ipv4;
$ZodStringFormat.init(inst, def);
inst._zod.onattach.push((inst) => {
const bag = inst._zod.bag as $ZodStringInternals["bag"];
bag.format = `ipv4`;
});
});
////////////////////////////// ZodIPv6 //////////////////////////////
export interface $ZodIPv6Def extends $ZodStringFormatDef<"ipv6"> {
version?: "v6";
}
export interface $ZodIPv6Internals extends $ZodStringFormatInternals<"ipv6"> {
def: $ZodIPv6Def;
}
export interface $ZodIPv6 extends $ZodType {
_zod: $ZodIPv6Internals;
}
export const $ZodIPv6: core.$constructor<$ZodIPv6> = /*@__PURE__*/ core.$constructor("$ZodIPv6", (inst, def): void => {
def.pattern ??= regexes.ipv6;
$ZodStringFormat.init(inst, def);
inst._zod.onattach.push((inst) => {
const bag = inst._zod.bag as $ZodStringInternals["bag"];
bag.format = `ipv6`;
});
inst._zod.check = (payload) => {
try {
new URL(`http://[${payload.value}]`);
// return;
} catch {
payload.issues.push({
code: "invalid_format",
format: "ipv6",
input: payload.value,
inst,
continue: !def.abort,
});
}
};
});
////////////////////////////// ZodCIDRv4 //////////////////////////////
export interface $ZodCIDRv4Def extends $ZodStringFormatDef<"cidrv4"> {
version?: "v4";
}
export interface $ZodCIDRv4Internals extends $ZodStringFormatInternals<"cidrv4"> {
def: $ZodCIDRv4Def;
}
export interface $ZodCIDRv4 extends $ZodType {
_zod: $ZodCIDRv4Internals;
}
export const $ZodCIDRv4: core.$constructor<$ZodCIDRv4> = /*@__PURE__*/ core.$constructor(
"$ZodCIDRv4",
(inst, def): void => {
def.pattern ??= regexes.cidrv4;
$ZodStringFormat.init(inst, def);
}
);
////////////////////////////// ZodCIDRv6 //////////////////////////////
export interface $ZodCIDRv6Def extends $ZodStringFormatDef<"cidrv6"> {
version?: "v6";
}
export interface $ZodCIDRv6Internals extends $ZodStringFormatInternals<"cidrv6"> {
def: $ZodCIDRv6Def;
}
export interface $ZodCIDRv6 extends $ZodType {
_zod: $ZodCIDRv6Internals;
}
export const $ZodCIDRv6: core.$constructor<$ZodCIDRv6> = /*@__PURE__*/ core.$constructor(
"$ZodCIDRv6",
(inst, def): void => {
def.pattern ??= regexes.cidrv6; // not used for validation
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
const [address, prefix] = payload.value.split("/");
try {
if (!prefix) throw new Error();
const prefixNum = Number(prefix);
if (`${prefixNum}` !== prefix) throw new Error();
if (prefixNum < 0 || prefixNum > 128) throw new Error();
new URL(`http://[${address}]`);
} catch {
payload.issues.push({
code: "invalid_format",
format: "cidrv6",
input: payload.value,
inst,
continue: !def.abort,
});
}
};
}
);
////////////////////////////// ZodBase64 //////////////////////////////
export function isValidBase64(data: string): boolean {
if (data === "") return true;
if (data.length % 4 !== 0) return false;
try {
atob(data);
return true;
} catch {
return false;
}
}
export interface $ZodBase64Def extends $ZodStringFormatDef<"base64"> {}
export interface $ZodBase64Internals extends $ZodStringFormatInternals<"base64"> {}
export interface $ZodBase64 extends $ZodType {
_zod: $ZodBase64Internals;
}
export const $ZodBase64: core.$constructor<$ZodBase64> = /*@__PURE__*/ core.$constructor(
"$ZodBase64",
(inst, def): void => {
def.pattern ??= regexes.base64;
$ZodStringFormat.init(inst, def);
inst._zod.onattach.push((inst) => {
inst._zod.bag.contentEncoding = "base64";
});
inst._zod.check = (payload) => {
if (isValidBase64(payload.value)) return;
payload.issues.push({
code: "invalid_format",
format: "base64",
input: payload.value,
inst,
continue: !def.abort,
});
};
}
);
////////////////////////////// ZodBase64 //////////////////////////////
export function isValidBase64URL(data: string): boolean {
if (!regexes.base64url.test(data)) return false;
const base64 = data.replace(/[-_]/g, (c) => (c === "-" ? "+" : "/"));
const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
return isValidBase64(padded);
}
export interface $ZodBase64URLDef extends $ZodStringFormatDef<"base64url"> {}
export interface $ZodBase64URLInternals extends $ZodStringFormatInternals<"base64url"> {}
export interface $ZodBase64URL extends $ZodType {
_zod: $ZodBase64URLInternals;
}
export const $ZodBase64URL: core.$constructor<$ZodBase64URL> = /*@__PURE__*/ core.$constructor(
"$ZodBase64URL",
(inst, def): void => {
def.pattern ??= regexes.base64url;
$ZodStringFormat.init(inst, def);
inst._zod.onattach.push((inst) => {
inst._zod.bag.contentEncoding = "base64url";
});
inst._zod.check = (payload) => {
if (isValidBase64URL(payload.value)) return;
payload.issues.push({
code: "invalid_format",
format: "base64url",
input: payload.value,
inst,
continue: !def.abort,
});
};
}
);
////////////////////////////// ZodE164 //////////////////////////////
export interface $ZodE164Def extends $ZodStringFormatDef<"e164"> {}
export interface $ZodE164Internals extends $ZodStringFormatInternals<"e164"> {}
export interface $ZodE164 extends $ZodType {
_zod: $ZodE164Internals;
}
export const $ZodE164: core.$constructor<$ZodE164> = /*@__PURE__*/ core.$constructor("$ZodE164", (inst, def): void => {
def.pattern ??= regexes.e164;
$ZodStringFormat.init(inst, def);
});
////////////////////////////// ZodJWT //////////////////////////////
export function isValidJWT(token: string, algorithm: util.JWTAlgorithm | null = null): boolean {
try {
const tokensParts = token.split(".");
if (tokensParts.length !== 3) return false;
const [header] = tokensParts;
if (!header) return false;
const parsedHeader = JSON.parse(atob(header));
if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") return false;
if (!parsedHeader.alg) return false;
if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) return false;
return true;
} catch {
return false;
}
}
export interface $ZodJWTDef extends $ZodStringFormatDef<"jwt"> {
alg?: util.JWTAlgorithm | undefined;
}
export interface $ZodJWTInternals extends $ZodStringFormatInternals<"jwt"> {
def: $ZodJWTDef;
}
export interface $ZodJWT extends $ZodType {
_zod: $ZodJWTInternals;
}
export const $ZodJWT: core.$constructor<$ZodJWT> = /*@__PURE__*/ core.$constructor("$ZodJWT", (inst, def): void => {
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
if (isValidJWT(payload.value, def.alg)) return;
payload.issues.push({
code: "invalid_format",
format: "jwt",
input: payload.value,
inst,
continue: !def.abort,
});
};
});
////////////////////////////// ZodCustomStringFormat //////////////////////////////
export interface $ZodCustomStringFormatDef extends $ZodStringFormatDef {
fn: (val: string) => unknown;
}
export interface $ZodCustomStringFormatInternals
extends $ZodStringFormatInternals {
def: $ZodCustomStringFormatDef;
}
export interface $ZodCustomStringFormat extends $ZodStringFormat {
_zod: $ZodCustomStringFormatInternals;
}
export const $ZodCustomStringFormat: core.$constructor<$ZodCustomStringFormat> = /*@__PURE__*/ core.$constructor(
"$ZodCustomStringFormat",
(inst, def): void => {
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
if (def.fn(payload.value)) return;
payload.issues.push({
code: "invalid_format",
format: def.format,
input: payload.value,
inst,
continue: !def.abort,
});
};
}
);
/////////////////////////////////////////
/////////////////////////////////////////
////////// //////////
////////// ZodNumber //////////
////////// //////////
/////////////////////////////////////////
/////////////////////////////////////////
export interface $ZodNumberDef extends $ZodTypeDef {
type: "number";
coerce?: boolean;
// checks: checks.$ZodCheck[];
}
export interface $ZodNumberInternals extends $ZodTypeInternals {
def: $ZodNumberDef;
/** @deprecated Internal API, use with caution (not deprecated) */
pattern: RegExp;
/** @deprecated Internal API, use with caution (not deprecated) */
isst: errors.$ZodIssueInvalidType;
bag: util.LoosePartial<{
minimum: number;
maximum: number;
exclusiveMinimum: number;
exclusiveMaximum: number;
format: string;
pattern: RegExp;
}>;
}
export interface $ZodNumber extends $ZodType {
_zod: $ZodNumberInternals;
}
export const $ZodNumber: core.$constructor<$ZodNumber> = /*@__PURE__*/ core.$constructor("$ZodNumber", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = inst._zod.bag.pattern ?? regexes.number;
inst._zod.parse = (payload, _ctx) => {
if (def.coerce)
try {
payload.value = Number(payload.value);
} catch (_) {}
const input = payload.value;
if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
return payload;
}
const received =
typeof input === "number"
? Number.isNaN(input)
? "NaN"
: !Number.isFinite(input)
? "Infinity"
: undefined
: undefined;
payload.issues.push({
expected: "number",
code: "invalid_type",
input,
inst,
...(received ? { received } : {}),
});
return payload;
};
});
///////////////////////////////////////////////
////////// ZodNumberFormat //////////
///////////////////////////////////////////////
export interface $ZodNumberFormatDef extends $ZodNumberDef, checks.$ZodCheckNumberFormatDef {}
export interface $ZodNumberFormatInternals extends $ZodNumberInternals, checks.$ZodCheckNumberFormatInternals {
def: $ZodNumberFormatDef;
isst: errors.$ZodIssueInvalidType;
}
export interface $ZodNumberFormat extends $ZodType {
_zod: $ZodNumberFormatInternals;
}
export const $ZodNumberFormat: core.$constructor<$ZodNumberFormat> = /*@__PURE__*/ core.$constructor(
"$ZodNumber",
(inst, def) => {
checks.$ZodCheckNumberFormat.init(inst, def);
$ZodNumber.init(inst, def); // no format checksp
}
);
///////////////////////////////////////////
///////////////////////////////////////////
////////// ///////////
////////// $ZodBoolean //////////
////////// ///////////
///////////////////////////////////////////
///////////////////////////////////////////
export interface $ZodBooleanDef extends $ZodTypeDef {
type: "boolean";
coerce?: boolean;
checks?: checks.$ZodCheck[];
}
export interface $ZodBooleanInternals extends $ZodTypeInternals {
pattern: RegExp;
def: $ZodBooleanDef;
isst: errors.$ZodIssueInvalidType;
}
export interface $ZodBoolean extends $ZodType {
_zod: $ZodBooleanInternals;
}
export const $ZodBoolean: core.$constructor<$ZodBoolean> = /*@__PURE__*/ core.$constructor(
"$ZodBoolean",
(inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = regexes.boolean;
inst._zod.parse = (payload, _ctx) => {
if (def.coerce)
try {
payload.value = Boolean(payload.value);
} catch (_) {}
const input = payload.value;
if (typeof input === "boolean") return payload;
payload.issues.push({
expected: "boolean",
code: "invalid_type",
input,
inst,
});
return payload;
};
}
);
//////////////////////////////////////////
//////////////////////////////////////////
////////// //////////
////////// $ZodBigInt //////////
////////// //////////
//////////////////////////////////////////
//////////////////////////////////////////
export interface $ZodBigIntDef extends $ZodTypeDef {
type: "bigint";
coerce?: boolean;
// checks: checks.$ZodCheck[];
}
export interface $ZodBigIntInternals extends $ZodTypeInternals {
pattern: RegExp;
/** @internal Internal API, use with caution */
def: $ZodBigIntDef;
isst: errors.$ZodIssueInvalidType;
bag: util.LoosePartial<{
minimum: bigint;
maximum: bigint;
format: string;
}>;
}
export interface $ZodBigInt extends $ZodType {
_zod: $ZodBigIntInternals;
}
export const $ZodBigInt: core.$constructor<$ZodBigInt> = /*@__PURE__*/ core.$constructor("$ZodBigInt", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = regexes.bigint;
inst._zod.parse = (payload, _ctx) => {
if (def.coerce)
try {
payload.value = BigInt(payload.value);
} catch (_) {}
if (typeof payload.value === "bigint") return payload;
payload.issues.push({
expected: "bigint",
code: "invalid_type",
input: payload.value,
inst,
});
return payload;
};
});
///////////////////////////////////////////////
////////// ZodBigIntFormat //////////
///////////////////////////////////////////////
export interface $ZodBigIntFormatDef extends $ZodBigIntDef, checks.$ZodCheckBigIntFormatDef {
check: "bigint_format";
}
export interface $ZodBigIntFormatInternals extends $ZodBigIntInternals, checks.$ZodCheckBigIntFormatInternals {
def: $ZodBigIntFormatDef;
}
export interface $ZodBigIntFormat extends $ZodType {
_zod: $ZodBigIntFormatInternals;
}
export const $ZodBigIntFormat: core.$constructor<$ZodBigIntFormat> = /*@__PURE__*/ core.$constructor(
"$ZodBigInt",
(inst, def) => {
checks.$ZodCheckBigIntFormat.init(inst, def);
$ZodBigInt.init(inst, def); // no format checks
}
);
////////////////////////////////////////////
////////////////////////////////////////////
////////// //////////
////////// $ZodSymbol //////////
////////// //////////
////////////////////////////////////////////
////////////////////////////////////////////
export interface $ZodSymbolDef extends $ZodTypeDef {
type: "symbol";
}
export interface $ZodSymbolInternals extends $ZodTypeInternals {
def: $ZodSymbolDef;
isst: errors.$ZodIssueInvalidType;
}
export interface $ZodSymbol extends $ZodType {
_zod: $ZodSymbolInternals;
}
export const $ZodSymbol: core.$constructor<$ZodSymbol> = /*@__PURE__*/ core.$constructor("$ZodSymbol", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, _ctx) => {
const input = payload.value;
if (typeof input === "symbol") return payload;
payload.issues.push({
expected: "symbol",
code: "invalid_type",
input,
inst,
});
return payload;
};
});
////////////////////////////////////////////
////////////////////////////////////////////
////////// //////////
////////// $ZodUndefined //////////
////////// //////////
////////////////////////////////////////////
////////////////////////////////////////////
export interface $ZodUndefinedDef extends $ZodTypeDef {
type: "undefined";
}
export interface $ZodUndefinedInternals extends $ZodTypeInternals {
pattern: RegExp;
def: $ZodUndefinedDef;
values: util.PrimitiveSet;
isst: errors.$ZodIssueInvalidType;
}
export interface $ZodUndefined extends $ZodType {
_zod: $ZodUndefinedInternals;
}
export const $ZodUndefined: core.$constructor<$ZodUndefined> = /*@__PURE__*/ core.$constructor(
"$ZodUndefined",
(inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = regexes.undefined;
inst._zod.values = new Set([undefined]);
inst._zod.optin = "optional";
inst._zod.optout = "optional";
inst._zod.parse = (payload, _ctx) => {
const input = payload.value;
if (typeof input === "undefined") return payload;
payload.issues.push({
expected: "undefined",
code: "invalid_type",
input,
inst,
});
return payload;
};
}
);
///////////////////////////////////////
///////////////////////////////////////
////////// //////////
////////// $ZodNull /////////
////////// //////////
///////////////////////////////////////
///////////////////////////////////////
export interface $ZodNullDef extends $ZodTypeDef {
type: "null";
}
export interface $ZodNullInternals extends $ZodTypeInternals {
pattern: RegExp;
def: $ZodNullDef;
values: util.PrimitiveSet;
isst: errors.$ZodIssueInvalidType;
}
export interface $ZodNull extends $ZodType {
_zod: $ZodNullInternals;
}
export const $ZodNull: core.$constructor<$ZodNull> = /*@__PURE__*/ core.$constructor("$ZodNull", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = regexes.null;
inst._zod.values = new Set([null]);
inst._zod.parse = (payload, _ctx) => {
const input = payload.value;
if (input === null) return payload;
payload.issues.push({
expected: "null",
code: "invalid_type",
input,
inst,
});
return payload;
};
});
//////////////////////////////////////
//////////////////////////////////////
////////// //////////
////////// $ZodAny //////////
////////// //////////
//////////////////////////////////////
//////////////////////////////////////
export interface $ZodAnyDef extends $ZodTypeDef {
type: "any";
}
export interface $ZodAnyInternals extends $ZodTypeInternals {
def: $ZodAnyDef;
isst: never;
}
export interface $ZodAny extends $ZodType {
_zod: $ZodAnyInternals;
}
export const $ZodAny: core.$constructor<$ZodAny> = /*@__PURE__*/ core.$constructor("$ZodAny", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload) => payload;
});
//////////////////////////////////////////
//////////////////////////////////////////
////////// //////////
////////// $ZodUnknown //////////
////////// //////////
//////////////////////////////////////////
//////////////////////////////////////////
export interface $ZodUnknownDef extends $ZodTypeDef {
type: "unknown";
}
export interface $ZodUnknownInternals extends $ZodTypeInternals {
def: $ZodUnknownDef;
isst: never;
}
export interface $ZodUnknown extends $ZodType {
_zod: $ZodUnknownInternals;
}
export const $ZodUnknown: core.$constructor<$ZodUnknown> = /*@__PURE__*/ core.$constructor(
"$ZodUnknown",
(inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload) => payload;
}
);
/////////////////////////////////////////
/////////////////////////////////////////
////////// //////////
////////// $ZodNever //////////
////////// //////////
/////////////////////////////////////////
/////////////////////////////////////////
export interface $ZodNeverDef extends $ZodTypeDef {
type: "never";
}
export interface $ZodNeverInternals extends $ZodTypeInternals {
def: $ZodNeverDef;
isst: errors.$ZodIssueInvalidType;
}
export interface $ZodNever extends $ZodType {
_zod: $ZodNeverInternals;
}
export const $ZodNever: core.$constructor<$ZodNever> = /*@__PURE__*/ core.$constructor("$ZodNever", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, _ctx) => {
payload.issues.push({
expected: "never",
code: "invalid_type",
input: payload.value,
inst,
});
return payload;
};
});
////////////////////////////////////////
////////////////////////////////////////
////////// //////////
////////// $ZodVoid //////////
////////// //////////
////////////////////////////////////////
////////////////////////////////////////
export interface $ZodVoidDef extends $ZodTypeDef {
type: "void";
}
export interface $ZodVoidInternals extends $ZodTypeInternals {
def: $ZodVoidDef;
isst: errors.$ZodIssueInvalidType;
}
export interface $ZodVoid extends $ZodType {
_zod: $ZodVoidInternals;
}
export const $ZodVoid: core.$constructor<$ZodVoid> = /*@__PURE__*/ core.$constructor("$ZodVoid", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, _ctx) => {
const input = payload.value;
if (typeof input === "undefined") return payload;
payload.issues.push({
expected: "void",
code: "invalid_type",
input,
inst,
});
return payload;
};
});
///////////////////////////////////////
///////////////////////////////////////
////////// ////////
////////// $ZodDate ////////
////////// ////////
///////////////////////////////////////
///////////////////////////////////////
export interface $ZodDateDef extends $ZodTypeDef {
type: "date";
coerce?: boolean;
}
export interface $ZodDateInternals extends $ZodTypeInternals {
def: $ZodDateDef;
isst: errors.$ZodIssueInvalidType; // | errors.$ZodIssueInvalidDate;
bag: util.LoosePartial<{
minimum: Date;
maximum: Date;
format: string;
}>;
}
export interface $ZodDate extends $ZodType {
_zod: $ZodDateInternals;
}
export const $ZodDate: core.$constructor<$ZodDate> = /*@__PURE__*/ core.$constructor("$ZodDate", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, _ctx) => {
if (def.coerce) {
try {
payload.value = new Date(payload.value as string | number | Date);
} catch (_err: any) {}
}
const input = payload.value;
const isDate = input instanceof Date;
const isValidDate = isDate && !Number.isNaN(input.getTime());
if (isValidDate) return payload;
payload.issues.push({
expected: "date",
code: "invalid_type",
input,
...(isDate ? { received: "Invalid Date" } : {}),
inst,
});
return payload;
};
});
/////////////////////////////////////////
/////////////////////////////////////////
////////// //////////
////////// $ZodArray //////////
////////// //////////
/////////////////////////////////////////
/////////////////////////////////////////
export interface $ZodArrayDef extends $ZodTypeDef {
type: "array";
element: T;
}
export interface $ZodArrayInternals extends _$ZodTypeInternals {
//$ZodTypeInternals[], core.input[]> {
def: $ZodArrayDef;
isst: errors.$ZodIssueInvalidType;
output: core.output[];
input: core.input[];
}
export interface $ZodArray extends $ZodType> {}
function handleArrayResult(result: ParsePayload, final: ParsePayload, index: number) {
if (result.issues.length) {
final.issues.push(...util.prefixIssues(index, result.issues));
}
final.value[index] = result.value;
}
export const $ZodArray: core.$constructor<$ZodArray> = /*@__PURE__*/ core.$constructor("$ZodArray", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, ctx) => {
const input = payload.value;
if (!Array.isArray(input)) {
payload.issues.push({
expected: "array",
code: "invalid_type",
input,
inst,
});
return payload;
}
payload.value = Array(input.length);
const proms: Promise[] = [];
for (let i = 0; i < input.length; i++) {
const item = input[i];
const result = def.element._zod.run(
{
value: item,
issues: [],
},
ctx
);
if (result instanceof Promise) {
proms.push(result.then((result) => handleArrayResult(result, payload, i)));
} else {
handleArrayResult(result, payload, i);
}
}
if (proms.length) {
return Promise.all(proms).then(() => payload);
}
return payload; //handleArrayResultsAsync(parseResults, final);
};
});
//////////////////////////////////////////
//////////////////////////////////////////
////////// //////////
////////// $ZodObject //////////
////////// //////////
//////////////////////////////////////////
//////////////////////////////////////////
type OptionalOutSchema = { _zod: { optout: "optional" } };
type OptionalInSchema = { _zod: { optin: "optional" } };
export type $InferObjectOutput> = string extends keyof T
? util.IsAny extends true
? Record
: Record>
: keyof (T & Extra) extends never
? Record
: util.Prettify<
{
-readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"];
} & {
-readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"];
} & Extra
>;
export type $InferObjectInput> = string extends keyof T
? util.IsAny extends true
? Record
: Record>
: keyof (T & Extra) extends never
? Record
: util.Prettify<
{
-readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_zod"]["input"];
} & {
-readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_zod"]["input"];
} & Extra
>;
function handleObjectResult(result: ParsePayload, final: ParsePayload, key: PropertyKey) {
// if(isOptional)
if (result.issues.length) {
final.issues.push(...util.prefixIssues(key, result.issues));
}
(final.value as any)[key] = result.value;
}
function handleOptionalObjectResult(result: ParsePayload, final: ParsePayload, key: PropertyKey, input: any) {
if (result.issues.length) {
// validation failed against value schema
if (input[key] === undefined) {
// if input was undefined, ignore the error
if (key in input) {
(final.value as any)[key] = undefined;
} else {
(final.value as any)[key] = result.value;
}
} else {
final.issues.push(...util.prefixIssues(key, result.issues));
}
} else if (result.value === undefined) {
// validation returned `undefined`
if (key in input) (final.value as any)[key] = undefined;
} else {
// non-undefined value
(final.value as any)[key] = result.value;
}
}
export type $ZodObjectConfig = { out: Record; in: Record };
export type $loose = {
out: Record;
in: Record;
};
export type $strict = {
out: {};
in: {};
};
export type $strip = {
out: {};
in: {};
};
export type $catchall = {
out: { [k: string]: core.output };
in: { [k: string]: core.input };
};
export type $ZodShape = Readonly<{ [k: string]: $ZodType }>;
export interface $ZodObjectDef extends $ZodTypeDef {
type: "object";
shape: Shape;
catchall?: $ZodType | undefined;
}
export interface $ZodObjectInternals<
/** @ts-ignore Cast variance */
out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>,
out Config extends $ZodObjectConfig = $ZodObjectConfig,
> extends _$ZodTypeInternals {
def: $ZodObjectDef;
config: Config;
isst: errors.$ZodIssueInvalidType | errors.$ZodIssueUnrecognizedKeys;
propValues: util.PropValues;
output: $InferObjectOutput;
input: $InferObjectInput;
}
export type $ZodLooseShape = Record;
export interface $ZodObject<
/** @ts-ignore Cast variance */
out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>,
out Params extends $ZodObjectConfig = $ZodObjectConfig,
> extends $ZodType> {
"~standard": $ZodStandardSchema;
}
export const $ZodObject: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$constructor("$ZodObject", (inst, def) => {
// requires cast because technically $ZodObject doesn't extend
$ZodType.init(inst, def);
const _normalized = util.cached(() => {
const keys = Object.keys(def.shape);
for (const k of keys) {
if (!(def.shape[k] instanceof $ZodType)) {
throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
}
}
const okeys = util.optionalKeys(def.shape);
return {
shape: def.shape,
keys,
keySet: new Set(keys),
numKeys: keys.length,
optionalKeys: new Set(okeys),
};
});
util.defineLazy(inst._zod, "propValues", () => {
const shape = def.shape;
const propValues: util.PropValues = {};
for (const key in shape) {
const field = shape[key]!._zod;
if (field.values) {
propValues[key] ??= new Set();
for (const v of field.values) propValues[key].add(v);
}
}
return propValues;
});
const generateFastpass = (shape: any) => {
const doc = new Doc(["shape", "payload", "ctx"]);
const normalized = _normalized.value;
const parseStr = (key: string) => {
const k = util.esc(key);
return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
};
doc.write(`const input = payload.value;`);
const ids: any = Object.create(null);
let counter = 0;
for (const key of normalized.keys) {
ids[key] = `key_${counter++}`;
}
// A: preserve key order {
doc.write(`const newResult = {}`);
for (const key of normalized.keys) {
if (normalized.optionalKeys.has(key)) {
const id = ids[key];
doc.write(`const ${id} = ${parseStr(key)};`);
const k = util.esc(key);
doc.write(`
if (${id}.issues.length) {
if (input[${k}] === undefined) {
if (${k} in input) {
newResult[${k}] = undefined;
}
} else {
payload.issues = payload.issues.concat(
${id}.issues.map((iss) => ({
...iss,
path: iss.path ? [${k}, ...iss.path] : [${k}],
}))
);
}
} else if (${id}.value === undefined) {
if (${k} in input) newResult[${k}] = undefined;
} else {
newResult[${k}] = ${id}.value;
}
`);
} else {
const id = ids[key];
// const id = ids[key];
doc.write(`const ${id} = ${parseStr(key)};`);
doc.write(`
if (${id}.issues.length) payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
...iss,
path: iss.path ? [${util.esc(key)}, ...iss.path] : [${util.esc(key)}]
})));`);
doc.write(`newResult[${util.esc(key)}] = ${id}.value`);
}
}
doc.write(`payload.value = newResult;`);
doc.write(`return payload;`);
const fn = doc.compile();
return (payload: any, ctx: any) => fn(shape, payload, ctx);
};
let fastpass!: ReturnType;
const isObject = util.isObject;
const jit = !core.globalConfig.jitless;
const allowsEval = util.allowsEval;
const fastEnabled = jit && allowsEval.value; // && !def.catchall;
const catchall = def.catchall;
let value!: typeof _normalized.value;
inst._zod.parse = (payload, ctx) => {
value ??= _normalized.value;
const input = payload.value;
if (!isObject(input)) {
payload.issues.push({
expected: "object",
code: "invalid_type",
input,
inst,
});
return payload;
}
const proms: Promise[] = [];
if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
// always synchronous
if (!fastpass) fastpass = generateFastpass(def.shape);
payload = fastpass(payload, ctx);
} else {
payload.value = {};
const shape = value.shape;
for (const key of value.keys) {
const el = shape[key]!;
// do not add omitted optional keys
// if (!(key in input)) {
// if (optionalKeys.has(key)) continue;
// payload.issues.push({
// code: "invalid_type",
// path: [key],
// expected: "nonoptional",
// note: `Missing required key: "${key}"`,
// input,
// inst,
// });
// }
const r = el._zod.run({ value: input[key], issues: [] }, ctx);
const isOptional = el._zod.optin === "optional" && el._zod.optout === "optional";
if (r instanceof Promise) {
proms.push(
r.then((r) =>
isOptional ? handleOptionalObjectResult(r, payload, key, input) : handleObjectResult(r, payload, key)
)
);
} else if (isOptional) {
handleOptionalObjectResult(r, payload, key, input);
} else {
handleObjectResult(r, payload, key);
}
}
}
if (!catchall) {
// return payload;
return proms.length ? Promise.all(proms).then(() => payload) : payload;
}
const unrecognized: string[] = [];
// iterate over input keys
const keySet = value.keySet;
const _catchall = catchall._zod;
const t = _catchall.def.type;
for (const key of Object.keys(input)) {
if (keySet.has(key)) continue;
if (t === "never") {
unrecognized.push(key);
continue;
}
const r = _catchall.run({ value: input[key], issues: [] }, ctx);
if (r instanceof Promise) {
proms.push(r.then((r) => handleObjectResult(r, payload, key)));
} else {
handleObjectResult(r, payload, key);
}
}
if (unrecognized.length) {
payload.issues.push({
code: "unrecognized_keys",
keys: unrecognized,
input,
inst,
});
}
if (!proms.length) return payload;
return Promise.all(proms).then(() => {
return payload;
});
};
});
/////////////////////////////////////////
/////////////////////////////////////////
////////// ///////////
////////// $ZodUnion //////////
////////// ///////////
/////////////////////////////////////////
/////////////////////////////////////////
// use generic to distribute union types
export type $InferUnionOutput = T extends any ? core.output : never;
export type $InferUnionInput = T extends any ? core.input : never;
export interface $ZodUnionDef extends $ZodTypeDef {
type: "union";
options: Options;
}
type IsOptionalIn = T extends OptionalInSchema ? true : false;
type IsOptionalOut = T extends OptionalOutSchema ? true : false;
export interface $ZodUnionInternals extends _$ZodTypeInternals {
def: $ZodUnionDef;
isst: errors.$ZodIssueInvalidUnion;
pattern: T[number]["_zod"]["pattern"];
values: T[number]["_zod"]["values"]; //GetValues;
output: $InferUnionOutput;
input: $InferUnionInput;
// if any element in the union is optional, then the union is optional
optin: IsOptionalIn extends false ? "optional" | undefined : "optional";
optout: IsOptionalOut extends false ? "optional" | undefined : "optional";
}
export interface $ZodUnion
extends $ZodType> {
_zod: $ZodUnionInternals;
}
function handleUnionResults(results: ParsePayload[], final: ParsePayload, inst: $ZodUnion, ctx?: ParseContext) {
for (const result of results) {
if (result.issues.length === 0) {
final.value = result.value;
return final;
}
}
final.issues.push({
code: "invalid_union",
input: final.value,
inst,
errors: results.map((result) => result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
});
return final;
}
export const $ZodUnion: core.$constructor<$ZodUnion> = /*@__PURE__*/ core.$constructor("$ZodUnion", (inst, def) => {
$ZodType.init(inst, def);
util.defineLazy(inst._zod, "optin", () =>
def.options.some((o) => o._zod.optin === "optional") ? "optional" : undefined
);
util.defineLazy(inst._zod, "optout", () =>
def.options.some((o) => o._zod.optout === "optional") ? "optional" : undefined
);
util.defineLazy(inst._zod, "values", () => {
if (def.options.every((o) => o._zod.values)) {
return new Set(def.options.flatMap((option) => Array.from(option._zod.values!)));
}
return undefined;
});
util.defineLazy(inst._zod, "pattern", () => {
if (def.options.every((o) => o._zod.pattern)) {
const patterns = def.options.map((o) => o._zod.pattern);
return new RegExp(`^(${patterns.map((p) => util.cleanRegex(p!.source)).join("|")})$`);
}
return undefined;
});
inst._zod.parse = (payload, ctx) => {
let async = false;
const results: util.MaybeAsync[] = [];
for (const option of def.options) {
const result = option._zod.run(
{
value: payload.value,
issues: [],
},
ctx
);
if (result instanceof Promise) {
results.push(result);
async = true;
} else {
if (result.issues.length === 0) return result;
results.push(result);
}
}
if (!async) return handleUnionResults(results as ParsePayload[], payload, inst, ctx);
return Promise.all(results).then((results) => {
return handleUnionResults(results as ParsePayload[], payload, inst, ctx);
});
};
});
//////////////////////////////////////////////////////
//////////////////////////////////////////////////////
////////// //////////
////////// $ZodDiscriminatedUnion //////////
////////// //////////
//////////////////////////////////////////////////////
//////////////////////////////////////////////////////
export interface $ZodDiscriminatedUnionDef
extends $ZodUnionDef {
discriminator: string;
unionFallback?: boolean;
}
export interface $ZodDiscriminatedUnionInternals
extends $ZodUnionInternals {
def: $ZodDiscriminatedUnionDef;
propValues: util.PropValues;
}
export interface $ZodDiscriminatedUnion extends $ZodType {
_zod: $ZodDiscriminatedUnionInternals;
}
export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
/*@__PURE__*/
core.$constructor("$ZodDiscriminatedUnion", (inst, def) => {
$ZodUnion.init(inst, def);
const _super = inst._zod.parse;
util.defineLazy(inst._zod, "propValues", () => {
const propValues: util.PropValues = {};
for (const option of def.options) {
const pv = option._zod.propValues;
if (!pv || Object.keys(pv).length === 0)
throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
for (const [k, v] of Object.entries(pv!)) {
if (!propValues[k]) propValues[k] = new Set();
for (const val of v) {
propValues[k].add(val);
}
}
}
return propValues;
});
const disc = util.cached(() => {
const opts = def.options as $ZodTypeDiscriminable[];
const map: Map = new Map();
for (const o of opts) {
const values = o._zod.propValues[def.discriminator];
if (!values || values.size === 0)
throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
for (const v of values) {
if (map.has(v)) {
throw new Error(`Duplicate discriminator value "${String(v)}"`);
}
map.set(v, o);
}
}
return map;
});
inst._zod.parse = (payload, ctx) => {
const input = payload.value;
if (!util.isObject(input)) {
payload.issues.push({
code: "invalid_type",
expected: "object",
input,
inst,
});
return payload;
}
const opt = disc.value.get(input?.[def.discriminator] as any);
if (opt) {
return opt._zod.run(payload, ctx) as any;
}
if (def.unionFallback) {
return _super(payload, ctx);
}
// no matching discriminator
payload.issues.push({
code: "invalid_union",
errors: [],
note: "No matching discriminator",
input,
path: [def.discriminator],
inst,
});
return payload;
};
});
////////////////////////////////////////////////
////////////////////////////////////////////////
////////// //////////
////////// $ZodIntersection //////////
////////// //////////
////////////////////////////////////////////////
////////////////////////////////////////////////
export interface $ZodIntersectionDef
extends $ZodTypeDef {
type: "intersection";
left: Left;
right: Right;
}
export interface $ZodIntersectionInternals
extends $ZodTypeInternals & core.output, core.input & core.input> {
def: $ZodIntersectionDef;
isst: never;
optin: A["_zod"]["optin"] | B["_zod"]["optin"];
optout: A["_zod"]["optout"] | B["_zod"]["optout"];
}
export interface $ZodIntersection extends $ZodType {
_zod: $ZodIntersectionInternals;
}
export const $ZodIntersection: core.$constructor<$ZodIntersection> = /*@__PURE__*/ core.$constructor(
"$ZodIntersection",
(inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, ctx) => {
const input = payload.value;
const left = def.left._zod.run({ value: input, issues: [] }, ctx);
const right = def.right._zod.run({ value: input, issues: [] }, ctx);
const async = left instanceof Promise || right instanceof Promise;
if (async) {
return Promise.all([left, right]).then(([left, right]) => {
return handleIntersectionResults(payload, left, right);
});
}
return handleIntersectionResults(payload, left, right);
};
}
);
function mergeValues(
a: any,
b: any
): { valid: true; data: any } | { valid: false; mergeErrorPath: (string | number)[] } {
// const aType = parse.t(a);
// const bType = parse.t(b);
if (a === b) {
return { valid: true, data: a };
}
if (a instanceof Date && b instanceof Date && +a === +b) {
return { valid: true, data: a };
}
if (util.isPlainObject(a) && util.isPlainObject(b)) {
const bKeys = Object.keys(b);
const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
const newObj: any = { ...a, ...b };
for (const key of sharedKeys) {
const sharedValue = mergeValues(a[key], b[key]);
if (!sharedValue.valid) {
return {
valid: false,
mergeErrorPath: [key, ...sharedValue.mergeErrorPath],
};
}
newObj[key] = sharedValue.data;
}
return { valid: true, data: newObj };
}
if (Array.isArray(a) && Array.isArray(b)) {
if (a.length !== b.length) {
return { valid: false, mergeErrorPath: [] };
}
const newArray: unknown[] = [];
for (let index = 0; index < a.length; index++) {
const itemA = a[index];
const itemB = b[index];
const sharedValue = mergeValues(itemA, itemB);
if (!sharedValue.valid) {
return {
valid: false,
mergeErrorPath: [index, ...sharedValue.mergeErrorPath],
};
}
newArray.push(sharedValue.data);
}
return { valid: true, data: newArray };
}
return { valid: false, mergeErrorPath: [] };
}
function handleIntersectionResults(result: ParsePayload, left: ParsePayload, right: ParsePayload): ParsePayload {
if (left.issues.length) {
result.issues.push(...left.issues);
}
if (right.issues.length) {
result.issues.push(...right.issues);
}
if (util.aborted(result)) return result;
const merged = mergeValues(left.value, right.value);
if (!merged.valid) {
throw new Error(`Unmergable intersection. Error path: ` + `${JSON.stringify(merged.mergeErrorPath)}`);
}
result.value = merged.data;
return result;
}
/////////////////////////////////////////
/////////////////////////////////////////
////////// //////////
////////// $ZodTuple //////////
////////// //////////
/////////////////////////////////////////
/////////////////////////////////////////
export interface $ZodTupleDef<
T extends util.TupleItems = readonly $ZodType[],
Rest extends SomeType | null = $ZodType | null,
> extends $ZodTypeDef {
type: "tuple";
items: T;
rest: Rest;
}
export type $InferTupleInputType = [
...TupleInputTypeWithOptionals,
...(Rest extends SomeType ? core.input[] : []),
];
type TupleInputTypeNoOptionals = {
[k in keyof T]: core.input;
};
type TupleInputTypeWithOptionals = T extends readonly [
...infer Prefix extends SomeType[],
infer Tail extends SomeType,
]
? Tail["_zod"]["optin"] extends "optional"
? [...TupleInputTypeWithOptionals, core.input?]
: TupleInputTypeNoOptionals
: [];
export type $InferTupleOutputType = [
...TupleOutputTypeWithOptionals,
...(Rest extends SomeType ? core.output[] : []),
];
type TupleOutputTypeNoOptionals = {
[k in keyof T]: core.output;
};
type TupleOutputTypeWithOptionals = T extends readonly [
...infer Prefix extends SomeType[],
infer Tail extends SomeType,
]
? Tail["_zod"]["optout"] extends "optional"
? [...TupleOutputTypeWithOptionals, core.output?]
: TupleOutputTypeNoOptionals
: [];
export interface $ZodTupleInternals<
T extends util.TupleItems = readonly $ZodType[],
Rest extends SomeType | null = $ZodType | null,
> extends $ZodTypeInternals<$InferTupleOutputType, $InferTupleInputType> {
def: $ZodTupleDef;
isst: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig | errors.$ZodIssueTooSmall;
}
export interface $ZodTuple<
T extends util.TupleItems = readonly $ZodType[],
Rest extends SomeType | null = $ZodType | null,
> extends $ZodType {
_zod: $ZodTupleInternals;
}
export const $ZodTuple: core.$constructor<$ZodTuple> = /*@__PURE__*/ core.$constructor("$ZodTuple", (inst, def) => {
$ZodType.init(inst, def);
const items = def.items;
const optStart = items.length - [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
inst._zod.parse = (payload, ctx) => {
const input = payload.value;
if (!Array.isArray(input)) {
payload.issues.push({
input,
inst,
expected: "tuple",
code: "invalid_type",
});
return payload;
}
payload.value = [];
const proms: Promise[] = [];
if (!def.rest) {
const tooBig = input.length > items.length;
const tooSmall = input.length < optStart - 1;
if (tooBig || tooSmall) {
payload.issues.push({
input,
inst,
origin: "array" as const,
...(tooBig ? { code: "too_big", maximum: items.length } : { code: "too_small", minimum: items.length }),
});
return payload;
}
}
let i = -1;
for (const item of items) {
i++;
if (i >= input.length) if (i >= optStart) continue;
const result = item._zod.run(
{
value: input[i],
issues: [],
},
ctx
);
if (result instanceof Promise) {
proms.push(result.then((result) => handleTupleResult(result, payload, i)));
} else {
handleTupleResult(result, payload, i);
}
}
if (def.rest) {
const rest = input.slice(items.length);
for (const el of rest) {
i++;
const result = def.rest._zod.run(
{
value: el,
issues: [],
},
ctx
);
if (result instanceof Promise) {
proms.push(result.then((result) => handleTupleResult(result, payload, i)));
} else {
handleTupleResult(result, payload, i);
}
}
}
if (proms.length) return Promise.all(proms).then(() => payload);
return payload;
};
});
function handleTupleResult(result: ParsePayload, final: ParsePayload, index: number) {
if (result.issues.length) {
final.issues.push(...util.prefixIssues(index, result.issues));
}
final.value[index] = result.value;
}
//////////////////////////////////////////
//////////////////////////////////////////
////////// //////////
////////// $ZodRecord //////////
////////// //////////
//////////////////////////////////////////
//////////////////////////////////////////
export type $ZodRecordKey = $ZodType; // $HasValues | $HasPattern;
export interface $ZodRecordDef
extends $ZodTypeDef {
type: "record";
keyType: Key;
valueType: Value;
}
// export type $InferZodRecordOutput<
// Key extends $ZodRecordKey = $ZodRecordKey,
// Value extends SomeType = $ZodType,
// > = undefined extends Key["_zod"]["values"]
// ? string extends core.output
// ? Record, core.output>
// : number extends core.output
// ? Record, core.output>
// : symbol extends core.output
// ? Record, core.output>
// : Record, core.output>
// : Record, core.output>;
export type $InferZodRecordOutput<
Key extends $ZodRecordKey = $ZodRecordKey,
Value extends SomeType = $ZodType,
> = Key extends $partial
? Partial, core.output>>
: Record, core.output>;
// export type $InferZodRecordInput<
// Key extends $ZodRecordKey = $ZodRecordKey,
// Value extends SomeType = $ZodType,
// > = undefined extends Key["_zod"]["values"]
// ? string extends core.input
// ? Record, core.input>
// : number extends core.input
// ? Record, core.input>
// : symbol extends core.input
// ? Record, core.input>
// : Record, core.input>
// : Record, core.input>;
export type $InferZodRecordInput<
Key extends $ZodRecordKey = $ZodRecordKey,
Value extends SomeType = $ZodType,
> = Key extends $partial
? Partial, core.input>>
: Record, core.input>;
export interface $ZodRecordInternals
extends $ZodTypeInternals<$InferZodRecordOutput, $InferZodRecordInput> {
def: $ZodRecordDef;
isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey>;
optin?: "optional" | undefined;
optout?: "optional" | undefined;
}
export type $partial = { "~~partial": true };
export interface $ZodRecord
extends $ZodType {
_zod: $ZodRecordInternals;
}
export const $ZodRecord: core.$constructor<$ZodRecord> = /*@__PURE__*/ core.$constructor("$ZodRecord", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, ctx) => {
const input = payload.value;
if (!util.isPlainObject(input)) {
payload.issues.push({
expected: "record",
code: "invalid_type",
input,
inst,
});
return payload;
}
const proms: Promise[] = [];
if (def.keyType._zod.values) {
const values = def.keyType._zod.values!;
payload.value = {};
for (const key of values) {
if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
if (result instanceof Promise) {
proms.push(
result.then((result) => {
if (result.issues.length) {
payload.issues.push(...util.prefixIssues(key, result.issues));
}
payload.value[key] = result.value;
})
);
} else {
if (result.issues.length) {
payload.issues.push(...util.prefixIssues(key, result.issues));
}
payload.value[key] = result.value;
}
}
}
let unrecognized!: string[];
for (const key in input) {
if (!values.has(key)) {
unrecognized = unrecognized ?? [];
unrecognized.push(key);
}
}
if (unrecognized && unrecognized.length > 0) {
payload.issues.push({
code: "unrecognized_keys",
input,
inst,
keys: unrecognized,
});
}
} else {
payload.value = {};
for (const key of Reflect.ownKeys(input)) {
if (key === "__proto__") continue;
const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
if (keyResult instanceof Promise) {
throw new Error("Async schemas not supported in object keys currently");
}
if (keyResult.issues.length) {
payload.issues.push({
origin: "record",
code: "invalid_key",
issues: keyResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
input: key,
path: [key],
inst,
});
payload.value[keyResult.value as PropertyKey] = keyResult.value;
continue;
}
const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
if (result instanceof Promise) {
proms.push(
result.then((result) => {
if (result.issues.length) {
payload.issues.push(...util.prefixIssues(key, result.issues));
}
payload.value[keyResult.value as PropertyKey] = result.value;
})
);
} else {
if (result.issues.length) {
payload.issues.push(...util.prefixIssues(key, result.issues));
}
payload.value[keyResult.value as PropertyKey] = result.value;
}
}
}
if (proms.length) {
return Promise.all(proms).then(() => payload);
}
return payload;
};
});
///////////////////////////////////////
///////////////////////////////////////
////////// //////////
////////// $ZodMap //////////
////////// //////////
///////////////////////////////////////
///////////////////////////////////////
export interface $ZodMapDef extends $ZodTypeDef {
type: "map";
keyType: Key;
valueType: Value;
}
export interface $ZodMapInternals
extends $ZodTypeInternals, core.output>, Map, core.input>> {
def: $ZodMapDef;
isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey | errors.$ZodIssueInvalidElement;
optin?: "optional" | undefined;
optout?: "optional" | undefined;
}
export interface $ZodMap extends $ZodType {
_zod: $ZodMapInternals;
}
export const $ZodMap: core.$constructor<$ZodMap> = /*@__PURE__*/ core.$constructor("$ZodMap", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, ctx) => {
const input = payload.value;
if (!(input instanceof Map)) {
payload.issues.push({
expected: "map",
code: "invalid_type",
input,
inst,
});
return payload;
}
const proms: Promise[] = [];
payload.value = new Map();
for (const [key, value] of input) {
const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
const valueResult = def.valueType._zod.run({ value: value, issues: [] }, ctx);
if (keyResult instanceof Promise || valueResult instanceof Promise) {
proms.push(
Promise.all([keyResult, valueResult]).then(([keyResult, valueResult]) => {
handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);
})
);
} else {
handleMapResult(keyResult as ParsePayload, valueResult as ParsePayload, payload, key, input, inst, ctx);
}
}
if (proms.length) return Promise.all(proms).then(() => payload);
return payload;
};
});
function handleMapResult(
keyResult: ParsePayload,
valueResult: ParsePayload,
final: ParsePayload>,
key: unknown,
input: Map,
inst: $ZodMap,
ctx?: ParseContext | undefined
): void {
if (keyResult.issues.length) {
if (util.propertyKeyTypes.has(typeof key)) {
final.issues.push(...util.prefixIssues(key as PropertyKey, keyResult.issues));
} else {
final.issues.push({
origin: "map",
code: "invalid_key",
input,
inst,
issues: keyResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
});
}
}
if (valueResult.issues.length) {
if (util.propertyKeyTypes.has(typeof key)) {
final.issues.push(...util.prefixIssues(key as PropertyKey, valueResult.issues));
} else {
final.issues.push({
origin: "map",
code: "invalid_element",
input,
inst,
key: key,
issues: valueResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
});
}
}
final.value.set(keyResult.value, valueResult.value);
}
///////////////////////////////////////
///////////////////////////////////////
////////// //////////
////////// $ZodSet //////////
////////// //////////
///////////////////////////////////////
///////////////////////////////////////
export interface $ZodSetDef extends $ZodTypeDef {
type: "set";
valueType: T;
}
export interface $ZodSetInternals
extends $ZodTypeInternals>, Set>> {
def: $ZodSetDef;
isst: errors.$ZodIssueInvalidType;
optin?: "optional" | undefined;
optout?: "optional" | undefined;
}
export interface $ZodSet extends $ZodType {
_zod: $ZodSetInternals;
}
export const $ZodSet: core.$constructor<$ZodSet> = /*@__PURE__*/ core.$constructor("$ZodSet", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, ctx) => {
const input = payload.value;
if (!(input instanceof Set)) {
payload.issues.push({
input,
inst,
expected: "set",
code: "invalid_type",
});
return payload;
}
const proms: Promise[] = [];
payload.value = new Set();
for (const item of input) {
const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);
if (result instanceof Promise) {
proms.push(result.then((result) => handleSetResult(result, payload)));
} else handleSetResult(result, payload);
}
if (proms.length) return Promise.all(proms).then(() => payload);
return payload;
};
});
function handleSetResult(result: ParsePayload, final: ParsePayload>) {
if (result.issues.length) {
final.issues.push(...result.issues);
}
final.value.add(result.value);
}
////////////////////////////////////////
////////////////////////////////////////
////////// //////////
////////// $ZodEnum //////////
////////// //////////
////////////////////////////////////////
////////////////////////////////////////
export type $InferEnumOutput = T[keyof T] & {};
export type $InferEnumInput = T[keyof T] & {};
export interface $ZodEnumDef extends $ZodTypeDef {
type: "enum";
entries: T;
}
export interface $ZodEnumInternals<
/** @ts-ignore Cast variance */
out T extends util.EnumLike = util.EnumLike,
> extends $ZodTypeInternals<$InferEnumOutput, $InferEnumInput> {
// enum: T;
def: $ZodEnumDef;
/** @deprecated Internal API, use with caution (not deprecated) */
values: util.PrimitiveSet;
/** @deprecated Internal API, use with caution (not deprecated) */
pattern: RegExp;
isst: errors.$ZodIssueInvalidValue;
}
export interface $ZodEnum extends $ZodType {
_zod: $ZodEnumInternals;
}
export const $ZodEnum: core.$constructor<$ZodEnum> = /*@__PURE__*/ core.$constructor("$ZodEnum", (inst, def) => {
$ZodType.init(inst, def);
const values = util.getEnumValues(def.entries);
inst._zod.values = new Set(values);
inst._zod.pattern = new RegExp(
`^(${values
.filter((k) => util.propertyKeyTypes.has(typeof k))
.map((o) => (typeof o === "string" ? util.escapeRegex(o) : o.toString()))
.join("|")})$`
);
inst._zod.parse = (payload, _ctx) => {
const input = payload.value;
if (inst._zod.values.has(input)) {
return payload;
}
payload.issues.push({
code: "invalid_value",
values,
input,
inst,
});
return payload;
};
});
////////////////////////////////////////
////////////////////////////////////////
////////// //////////
////////// $ZodLiteral //////////
////////// //////////
////////////////////////////////////////
////////////////////////////////////////
export interface $ZodLiteralDef extends $ZodTypeDef {
type: "literal";
values: T[];
}
export interface $ZodLiteralInternals extends $ZodTypeInternals {
def: $ZodLiteralDef