Brunobkr/llama.cpp_AlgMor24_github

1import * as core from "../core/index.js";2import * as util from "../core/util.js";3import * as parse from "./parse.js";4 5type SomeType = core.SomeType;6 7export interface ZodMiniType<8  out Output = unknown,9  out Input = unknown,10  out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>,11> extends core.$ZodType<Output, Input, Internals> {12  type: Internals["def"]["type"];13  check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;14  with(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;15  clone(def?: Internals["def"], params?: { parent: boolean }): this;16  register<R extends core.$ZodRegistry>(17    registry: R,18    ...meta: this extends R["_schema"]19      ? undefined extends R["_meta"]20        ? [core.$replace<R["_meta"], this>?]21        : [core.$replace<R["_meta"], this>]22      : ["Incompatible schema"]23  ): this;24  brand<T extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(25    value?: T26  ): PropertyKey extends T ? this : core.$ZodBranded<this, T, Dir>;27 28  def: Internals["def"];29 30  parse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;31  safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): util.SafeParseResult<core.output<this>>;32  parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;33  safeParseAsync(34    data: unknown,35    params?: core.ParseContext<core.$ZodIssue>36  ): Promise<util.SafeParseResult<core.output<this>>>;37  apply<T>(fn: (schema: this) => T): T;38}39 40interface _ZodMiniType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals>41  extends ZodMiniType<any, any, Internals> {}42 43export const ZodMiniType: core.$constructor<ZodMiniType> = /*@__PURE__*/ core.$constructor(44  "ZodMiniType",45  (inst, def) => {46    if (!inst._zod) throw new Error("Uninitialized schema in ZodMiniType.");47 48    core.$ZodType.init(inst, def);49 50    inst.def = def;51    inst.type = def.type;52    inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse });53    inst.safeParse = (data, params) => parse.safeParse(inst, data, params);54    inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });55    inst.safeParseAsync = async (data, params) => parse.safeParseAsync(inst, data, params);56    inst.check = (...checks) => {57      return inst.clone(58        {59          ...def,60          checks: [61            ...(def.checks ?? []),62            ...checks.map((ch) =>63              typeof ch === "function"64                ? {65                    _zod: { check: ch, def: { check: "custom" }, onattach: [] },66                  }67                : ch68            ),69          ],70        },71        { parent: true }72      );73    };74    inst.with = inst.check;75    inst.clone = (_def, params) => core.clone(inst, _def, params);76    inst.brand = () => inst as any;77    inst.register = ((reg: any, meta: any) => {78      reg.add(inst, meta);79      return inst;80    }) as any;81    inst.apply = (fn) => fn(inst);82  }83);84 85export interface _ZodMiniString<T extends core.$ZodStringInternals<unknown> = core.$ZodStringInternals<unknown>>86  extends _ZodMiniType<T>,87    core.$ZodString<T["input"]> {88  _zod: T;89}90 91// ZodMiniString92export interface ZodMiniString<Input = unknown>93  extends _ZodMiniString<core.$ZodStringInternals<Input>>,94    core.$ZodString<Input> {}95export const ZodMiniString: core.$constructor<ZodMiniString> = /*@__PURE__*/ core.$constructor(96  "ZodMiniString",97  (inst, def) => {98    core.$ZodString.init(inst, def);99    ZodMiniType.init(inst, def);100  }101);102 103// @__NO_SIDE_EFFECTS__104export function string(params?: string | core.$ZodStringParams): ZodMiniString<string> {105  return core._string(ZodMiniString, params) as any;106}107 108// ZodMiniStringFormat109export interface ZodMiniStringFormat<Format extends string = string>110  extends _ZodMiniString<core.$ZodStringFormatInternals<Format>>,111    core.$ZodStringFormat<Format> {112  // _zod: core.$ZodStringFormatInternals<Format>;113}114export const ZodMiniStringFormat: core.$constructor<ZodMiniStringFormat> = /*@__PURE__*/ core.$constructor(115  "ZodMiniStringFormat",116  (inst, def) => {117    core.$ZodStringFormat.init(inst, def);118    ZodMiniString.init(inst, def);119  }120);121 122// ZodMiniEmail123export interface ZodMiniEmail extends _ZodMiniString<core.$ZodEmailInternals> {}124export const ZodMiniEmail: core.$constructor<ZodMiniEmail> = /*@__PURE__*/ core.$constructor(125  "ZodMiniEmail",126  (inst, def) => {127    core.$ZodEmail.init(inst, def);128    ZodMiniStringFormat.init(inst, def);129  }130);131 132// @__NO_SIDE_EFFECTS__133export function email(params?: string | core.$ZodEmailParams): ZodMiniEmail {134  return core._email(ZodMiniEmail, params);135}136 137// ZodMiniGUID138export interface ZodMiniGUID extends _ZodMiniString<core.$ZodGUIDInternals> {139  // _zod: core.$ZodGUIDInternals;140}141export const ZodMiniGUID: core.$constructor<ZodMiniGUID> = /*@__PURE__*/ core.$constructor(142  "ZodMiniGUID",143  (inst, def) => {144    core.$ZodGUID.init(inst, def);145    ZodMiniStringFormat.init(inst, def);146  }147);148 149// @__NO_SIDE_EFFECTS__150export function guid(params?: string | core.$ZodGUIDParams): ZodMiniGUID {151  return core._guid(ZodMiniGUID, params);152}153 154// ZodMiniUUID155export interface ZodMiniUUID extends _ZodMiniString<core.$ZodUUIDInternals> {156  // _zod: core.$ZodUUIDInternals;157}158export const ZodMiniUUID: core.$constructor<ZodMiniUUID> = /*@__PURE__*/ core.$constructor(159  "ZodMiniUUID",160  (inst, def) => {161    core.$ZodUUID.init(inst, def);162    ZodMiniStringFormat.init(inst, def);163  }164);165 166// @__NO_SIDE_EFFECTS__167export function uuid(params?: string | core.$ZodUUIDParams): ZodMiniUUID {168  return core._uuid(ZodMiniUUID, params);169}170 171// @__NO_SIDE_EFFECTS__172export function uuidv4(params?: string | core.$ZodUUIDv4Params): ZodMiniUUID {173  return core._uuidv4(ZodMiniUUID, params);174}175 176// ZodMiniUUIDv6177 178// @__NO_SIDE_EFFECTS__179export function uuidv6(params?: string | core.$ZodUUIDv6Params): ZodMiniUUID {180  return core._uuidv6(ZodMiniUUID, params);181}182 183// ZodMiniUUIDv7184 185// @__NO_SIDE_EFFECTS__186export function uuidv7(params?: string | core.$ZodUUIDv7Params): ZodMiniUUID {187  return core._uuidv7(ZodMiniUUID, params);188}189 190// ZodMiniURL191export interface ZodMiniURL extends _ZodMiniString<core.$ZodURLInternals> {192  // _zod: core.$ZodURLInternals;193}194export const ZodMiniURL: core.$constructor<ZodMiniURL> = /*@__PURE__*/ core.$constructor("ZodMiniURL", (inst, def) => {195  core.$ZodURL.init(inst, def);196  ZodMiniStringFormat.init(inst, def);197});198 199// @__NO_SIDE_EFFECTS__200export function url(params?: string | core.$ZodURLParams): ZodMiniURL {201  return core._url(ZodMiniURL, params);202}203 204// @__NO_SIDE_EFFECTS__205export function httpUrl(params?: string | Omit<core.$ZodURLParams, "protocol" | "hostname">): ZodMiniURL {206  return core._url(ZodMiniURL, {207    protocol: core.regexes.httpProtocol,208    hostname: core.regexes.domain,209    ...util.normalizeParams(params),210  });211}212 213// ZodMiniEmoji214export interface ZodMiniEmoji extends _ZodMiniString<core.$ZodEmojiInternals> {215  // _zod: core.$ZodEmojiInternals;216}217export const ZodMiniEmoji: core.$constructor<ZodMiniEmoji> = /*@__PURE__*/ core.$constructor(218  "ZodMiniEmoji",219  (inst, def) => {220    core.$ZodEmoji.init(inst, def);221    ZodMiniStringFormat.init(inst, def);222  }223);224 225// @__NO_SIDE_EFFECTS__226export function emoji(params?: string | core.$ZodEmojiParams): ZodMiniEmoji {227  return core._emoji(ZodMiniEmoji, params);228}229 230// ZodMiniNanoID231export interface ZodMiniNanoID extends _ZodMiniString<core.$ZodNanoIDInternals> {232  // _zod: core.$ZodNanoIDInternals;233}234export const ZodMiniNanoID: core.$constructor<ZodMiniNanoID> = /*@__PURE__*/ core.$constructor(235  "ZodMiniNanoID",236  (inst, def) => {237    core.$ZodNanoID.init(inst, def);238    ZodMiniStringFormat.init(inst, def);239  }240);241 242// @__NO_SIDE_EFFECTS__243export function nanoid(params?: string | core.$ZodNanoIDParams): ZodMiniNanoID {244  return core._nanoid(ZodMiniNanoID, params);245}246 247// ZodMiniCUID248/**249 * @deprecated CUID v1 is deprecated by its authors due to information leakage250 * (timestamps embedded in the id). Use {@link ZodMiniCUID2} instead.251 * See https://github.com/paralleldrive/cuid.252 */253export interface ZodMiniCUID extends _ZodMiniString<core.$ZodCUIDInternals> {254  // _zod: core.$ZodCUIDInternals;255}256/**257 * @deprecated CUID v1 is deprecated by its authors due to information leakage258 * (timestamps embedded in the id). Use {@link ZodMiniCUID2} instead.259 * See https://github.com/paralleldrive/cuid.260 */261export const ZodMiniCUID: core.$constructor<ZodMiniCUID> = /*@__PURE__*/ core.$constructor(262  "ZodMiniCUID",263  (inst, def) => {264    core.$ZodCUID.init(inst, def);265    ZodMiniStringFormat.init(inst, def);266  }267);268 269/**270 * Validates a CUID v1 string.271 *272 * @deprecated CUID v1 is deprecated by its authors due to information leakage273 * (timestamps embedded in the id). Use {@link cuid2 | `z.cuid2()`} instead.274 * See https://github.com/paralleldrive/cuid.275 */276// @__NO_SIDE_EFFECTS__277export function cuid(params?: string | core.$ZodCUIDParams): ZodMiniCUID {278  return core._cuid(ZodMiniCUID, params);279}280 281// ZodMiniCUID2282export interface ZodMiniCUID2 extends _ZodMiniString<core.$ZodCUID2Internals> {283  // _zod: core.$ZodCUID2Internals;284}285export const ZodMiniCUID2: core.$constructor<ZodMiniCUID2> = /*@__PURE__*/ core.$constructor(286  "ZodMiniCUID2",287  (inst, def) => {288    core.$ZodCUID2.init(inst, def);289    ZodMiniStringFormat.init(inst, def);290  }291);292 293// @__NO_SIDE_EFFECTS__294export function cuid2(params?: string | core.$ZodCUID2Params): ZodMiniCUID2 {295  return core._cuid2(ZodMiniCUID2, params);296}297 298// ZodMiniULID299export interface ZodMiniULID extends _ZodMiniString<core.$ZodULIDInternals> {300  // _zod: core.$ZodULIDInternals;301}302export const ZodMiniULID: core.$constructor<ZodMiniULID> = /*@__PURE__*/ core.$constructor(303  "ZodMiniULID",304  (inst, def) => {305    core.$ZodULID.init(inst, def);306    ZodMiniStringFormat.init(inst, def);307  }308);309 310// @__NO_SIDE_EFFECTS__311export function ulid(params?: string | core.$ZodULIDParams): ZodMiniULID {312  return core._ulid(ZodMiniULID, params);313}314 315// ZodMiniXID316export interface ZodMiniXID extends _ZodMiniString<core.$ZodXIDInternals> {317  // _zod: core.$ZodXIDInternals;318}319export const ZodMiniXID: core.$constructor<ZodMiniXID> = /*@__PURE__*/ core.$constructor("ZodMiniXID", (inst, def) => {320  core.$ZodXID.init(inst, def);321  ZodMiniStringFormat.init(inst, def);322});323 324// @__NO_SIDE_EFFECTS__325export function xid(params?: string | core.$ZodXIDParams): ZodMiniXID {326  return core._xid(ZodMiniXID, params);327}328 329// ZodMiniKSUID330export interface ZodMiniKSUID extends _ZodMiniString<core.$ZodKSUIDInternals> {331  // _zod: core.$ZodKSUIDInternals;332}333export const ZodMiniKSUID: core.$constructor<ZodMiniKSUID> = /*@__PURE__*/ core.$constructor(334  "ZodMiniKSUID",335  (inst, def) => {336    core.$ZodKSUID.init(inst, def);337    ZodMiniStringFormat.init(inst, def);338  }339);340 341// @__NO_SIDE_EFFECTS__342export function ksuid(params?: string | core.$ZodKSUIDParams): ZodMiniKSUID {343  return core._ksuid(ZodMiniKSUID, params);344}345 346// ZodMiniIPv4347export interface ZodMiniIPv4 extends _ZodMiniString<core.$ZodIPv4Internals> {348  // _zod: core.$ZodIPv4Internals;349}350export const ZodMiniIPv4: core.$constructor<ZodMiniIPv4> = /*@__PURE__*/ core.$constructor(351  "ZodMiniIPv4",352  (inst, def) => {353    core.$ZodIPv4.init(inst, def);354    ZodMiniStringFormat.init(inst, def);355  }356);357 358// @__NO_SIDE_EFFECTS__359export function ipv4(params?: string | core.$ZodIPv4Params): ZodMiniIPv4 {360  return core._ipv4(ZodMiniIPv4, params);361}362 363// ZodMiniIPv6364export interface ZodMiniIPv6 extends _ZodMiniString<core.$ZodIPv6Internals> {365  // _zod: core.$ZodIPv6Internals;366}367export const ZodMiniIPv6: core.$constructor<ZodMiniIPv6> = /*@__PURE__*/ core.$constructor(368  "ZodMiniIPv6",369  (inst, def) => {370    core.$ZodIPv6.init(inst, def);371    ZodMiniStringFormat.init(inst, def);372  }373);374 375// @__NO_SIDE_EFFECTS__376export function ipv6(params?: string | core.$ZodIPv6Params): ZodMiniIPv6 {377  return core._ipv6(ZodMiniIPv6, params);378}379 380// ZodMiniCIDRv4381export interface ZodMiniCIDRv4 extends _ZodMiniString<core.$ZodCIDRv4Internals> {382  // _zod: core.$ZodCIDRv4Internals;383}384export const ZodMiniCIDRv4: core.$constructor<ZodMiniCIDRv4> = /*@__PURE__*/ core.$constructor(385  "ZodMiniCIDRv4",386  (inst, def) => {387    core.$ZodCIDRv4.init(inst, def);388    ZodMiniStringFormat.init(inst, def);389  }390);391 392// @__NO_SIDE_EFFECTS__393export function cidrv4(params?: string | core.$ZodCIDRv4Params): ZodMiniCIDRv4 {394  return core._cidrv4(ZodMiniCIDRv4, params);395}396 397// ZodMiniCIDRv6398export interface ZodMiniCIDRv6 extends _ZodMiniString<core.$ZodCIDRv6Internals> {399  // _zod: core.$ZodCIDRv6Internals;400}401export const ZodMiniCIDRv6: core.$constructor<ZodMiniCIDRv6> = /*@__PURE__*/ core.$constructor(402  "ZodMiniCIDRv6",403  (inst, def) => {404    core.$ZodCIDRv6.init(inst, def);405    ZodMiniStringFormat.init(inst, def);406  }407);408 409// @__NO_SIDE_EFFECTS__410export function cidrv6(params?: string | core.$ZodCIDRv6Params): ZodMiniCIDRv6 {411  return core._cidrv6(ZodMiniCIDRv6, params);412}413 414// ZodMiniMAC415export interface ZodMiniMAC extends _ZodMiniString<core.$ZodMACInternals> {416  // _zod: core.$ZodMACInternals;417}418export const ZodMiniMAC: core.$constructor<ZodMiniMAC> = /*@__PURE__*/ core.$constructor("ZodMiniMAC", (inst, def) => {419  core.$ZodMAC.init(inst, def);420  ZodMiniStringFormat.init(inst, def);421});422 423// @__NO_SIDE_EFFECTS__424export function mac(params?: string | core.$ZodMACParams): ZodMiniMAC {425  return core._mac(ZodMiniMAC, params);426}427 428// ZodMiniBase64429export interface ZodMiniBase64 extends _ZodMiniString<core.$ZodBase64Internals> {430  // _zod: core.$ZodBase64Internals;431}432export const ZodMiniBase64: core.$constructor<ZodMiniBase64> = /*@__PURE__*/ core.$constructor(433  "ZodMiniBase64",434  (inst, def) => {435    core.$ZodBase64.init(inst, def);436    ZodMiniStringFormat.init(inst, def);437  }438);439// @__NO_SIDE_EFFECTS__440export function base64(params?: string | core.$ZodBase64Params): ZodMiniBase64 {441  return core._base64(ZodMiniBase64, params);442}443 444// ZodMiniBase64URL445export interface ZodMiniBase64URL extends _ZodMiniString<core.$ZodBase64URLInternals> {446  // _zod: core.$ZodBase64URLInternals;447}448export const ZodMiniBase64URL: core.$constructor<ZodMiniBase64URL> = /*@__PURE__*/ core.$constructor(449  "ZodMiniBase64URL",450  (inst, def) => {451    core.$ZodBase64URL.init(inst, def);452    ZodMiniStringFormat.init(inst, def);453  }454);455// @__NO_SIDE_EFFECTS__456export function base64url(params?: string | core.$ZodBase64URLParams): ZodMiniBase64URL {457  return core._base64url(ZodMiniBase64URL, params);458}459 460// ZodMiniE164461export interface ZodMiniE164 extends _ZodMiniString<core.$ZodE164Internals> {462  // _zod: core.$ZodE164Internals;463}464export const ZodMiniE164: core.$constructor<ZodMiniE164> = /*@__PURE__*/ core.$constructor(465  "ZodMiniE164",466  (inst, def) => {467    core.$ZodE164.init(inst, def);468    ZodMiniStringFormat.init(inst, def);469  }470);471 472// @__NO_SIDE_EFFECTS__473export function e164(params?: string | core.$ZodE164Params): ZodMiniE164 {474  return core._e164(ZodMiniE164, params);475}476 477// ZodMiniJWT478export interface ZodMiniJWT extends _ZodMiniString<core.$ZodJWTInternals> {479  // _zod: core.$ZodJWTInternals;480}481export const ZodMiniJWT: core.$constructor<ZodMiniJWT> = /*@__PURE__*/ core.$constructor("ZodMiniJWT", (inst, def) => {482  core.$ZodJWT.init(inst, def);483  ZodMiniStringFormat.init(inst, def);484});485 486// @__NO_SIDE_EFFECTS__487export function jwt(params?: string | core.$ZodJWTParams): ZodMiniJWT {488  return core._jwt(ZodMiniJWT, params);489}490 491// ZodMiniCustomStringFormat492export interface ZodMiniCustomStringFormat<Format extends string = string>493  extends ZodMiniStringFormat<Format>,494    core.$ZodCustomStringFormat<Format> {495  _zod: core.$ZodCustomStringFormatInternals<Format>;496}497export const ZodMiniCustomStringFormat: core.$constructor<ZodMiniCustomStringFormat> = /*@__PURE__*/ core.$constructor(498  "ZodMiniCustomStringFormat",499  (inst, def) => {500    core.$ZodCustomStringFormat.init(inst, def);501    ZodMiniStringFormat.init(inst, def);502  }503);504 505// @__NO_SIDE_EFFECTS__506export function stringFormat<Format extends string>(507  format: Format,508  fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp,509  _params: string | core.$ZodStringFormatParams = {}510): ZodMiniCustomStringFormat<Format> {511  return core._stringFormat(ZodMiniCustomStringFormat, format, fnOrRegex, _params) as any;512}513 514// @__NO_SIDE_EFFECTS__515export function hostname(_params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<"hostname"> {516  return core._stringFormat(ZodMiniCustomStringFormat, "hostname", core.regexes.hostname, _params) as any;517}518 519// @__NO_SIDE_EFFECTS__520export function hex(_params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<"hex"> {521  return core._stringFormat(ZodMiniCustomStringFormat, "hex", core.regexes.hex, _params) as any;522}523 524// @__NO_SIDE_EFFECTS__525export function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = "hex">(526  alg: Alg,527  params?: {528    enc?: Enc;529  } & core.$ZodStringFormatParams530): ZodMiniCustomStringFormat<`${Alg}_${Enc}`> {531  const enc = params?.enc ?? "hex";532  const format = `${alg}_${enc}` as const;533  const regex = core.regexes[format as keyof typeof core.regexes] as RegExp;534  // check for unrecognized format535  if (!regex) throw new Error(`Unrecognized hash format: ${format}`);536  return core._stringFormat(ZodMiniCustomStringFormat, format, regex, params) as any;537}538 539// ZodMiniNumber540interface _ZodMiniNumber<T extends core.$ZodNumberInternals<unknown> = core.$ZodNumberInternals<unknown>>541  extends _ZodMiniType<T>,542    core.$ZodNumber<T["input"]> {543  _zod: T;544}545export interface ZodMiniNumber<Input = unknown>546  extends _ZodMiniNumber<core.$ZodNumberInternals<Input>>,547    core.$ZodNumber<Input> {}548export const ZodMiniNumber: core.$constructor<ZodMiniNumber> = /*@__PURE__*/ core.$constructor(549  "ZodMiniNumber",550  (inst, def) => {551    core.$ZodNumber.init(inst, def);552    ZodMiniType.init(inst, def);553  }554);555 556// @__NO_SIDE_EFFECTS__557export function number(params?: string | core.$ZodNumberParams): ZodMiniNumber<number> {558  return core._number(ZodMiniNumber, params) as any;559}560 561// ZodMiniNumberFormat562export interface ZodMiniNumberFormat extends _ZodMiniNumber<core.$ZodNumberFormatInternals>, core.$ZodNumberFormat {}563export const ZodMiniNumberFormat: core.$constructor<ZodMiniNumberFormat> = /*@__PURE__*/ core.$constructor(564  "ZodMiniNumberFormat",565  (inst, def) => {566    core.$ZodNumberFormat.init(inst, def);567    ZodMiniNumber.init(inst, def);568  }569);570 571// int572 573// @__NO_SIDE_EFFECTS__574export function int(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat {575  return core._int(ZodMiniNumberFormat, params);576}577 578// float32579 580// @__NO_SIDE_EFFECTS__581export function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat {582  return core._float32(ZodMiniNumberFormat, params);583}584 585// float64586 587// @__NO_SIDE_EFFECTS__588export function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat {589  return core._float64(ZodMiniNumberFormat, params);590}591 592// int32593 594// @__NO_SIDE_EFFECTS__595export function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat {596  return core._int32(ZodMiniNumberFormat, params);597}598 599// uint32600 601// @__NO_SIDE_EFFECTS__602export function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat {603  return core._uint32(ZodMiniNumberFormat, params);604}605 606// ZodMiniBoolean607export interface ZodMiniBoolean<T = unknown> extends _ZodMiniType<core.$ZodBooleanInternals<T>> {608  // _zod: core.$ZodBooleanInternals<T>;609}610export const ZodMiniBoolean: core.$constructor<ZodMiniBoolean> = /*@__PURE__*/ core.$constructor(611  "ZodMiniBoolean",612  (inst, def) => {613    core.$ZodBoolean.init(inst, def);614    ZodMiniType.init(inst, def);615  }616);617 618// @__NO_SIDE_EFFECTS__619export function boolean(params?: string | core.$ZodBooleanParams): ZodMiniBoolean<boolean> {620  return core._boolean(ZodMiniBoolean, params) as any;621}622 623// ZodMiniBigInt624export interface ZodMiniBigInt<T = unknown> extends _ZodMiniType<core.$ZodBigIntInternals<T>>, core.$ZodBigInt<T> {625  // _zod: core.$ZodBigIntInternals<T>;626}627export const ZodMiniBigInt: core.$constructor<ZodMiniBigInt> = /*@__PURE__*/ core.$constructor(628  "ZodMiniBigInt",629  (inst, def) => {630    core.$ZodBigInt.init(inst, def);631    ZodMiniType.init(inst, def);632  }633);634 635// @__NO_SIDE_EFFECTS__636export function bigint(params?: string | core.$ZodBigIntParams): ZodMiniBigInt<bigint> {637  return core._bigint(ZodMiniBigInt, params) as any;638}639 640// bigint formats641 642// ZodMiniBigIntFormat643export interface ZodMiniBigIntFormat extends _ZodMiniType<core.$ZodBigIntFormatInternals> {644  // _zod: core.$ZodBigIntFormatInternals;645}646export const ZodMiniBigIntFormat: core.$constructor<ZodMiniBigIntFormat> = /*@__PURE__*/ core.$constructor(647  "ZodMiniBigIntFormat",648  (inst, def) => {649    core.$ZodBigIntFormat.init(inst, def);650    ZodMiniBigInt.init(inst, def);651  }652);653 654// int64655 656// @__NO_SIDE_EFFECTS__657export function int64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat {658  return core._int64(ZodMiniBigIntFormat, params);659}660 661// uint64662 663// @__NO_SIDE_EFFECTS__664export function uint64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat {665  return core._uint64(ZodMiniBigIntFormat, params);666}667 668// ZodMiniSymbol669export interface ZodMiniSymbol extends _ZodMiniType<core.$ZodSymbolInternals> {670  // _zod: core.$ZodSymbolInternals;671}672export const ZodMiniSymbol: core.$constructor<ZodMiniSymbol> = /*@__PURE__*/ core.$constructor(673  "ZodMiniSymbol",674  (inst, def) => {675    core.$ZodSymbol.init(inst, def);676    ZodMiniType.init(inst, def);677  }678);679 680// @__NO_SIDE_EFFECTS__681export function symbol(params?: string | core.$ZodSymbolParams): ZodMiniSymbol {682  return core._symbol(ZodMiniSymbol, params) as any;683}684 685// ZodMiniUndefined686export interface ZodMiniUndefined extends _ZodMiniType<core.$ZodUndefinedInternals> {687  // _zod: core.$ZodUndefinedInternals;688}689export const ZodMiniUndefined: core.$constructor<ZodMiniUndefined> = /*@__PURE__*/ core.$constructor(690  "ZodMiniUndefined",691  (inst, def) => {692    core.$ZodUndefined.init(inst, def);693    ZodMiniType.init(inst, def);694  }695);696 697// @__NO_SIDE_EFFECTS__698function _undefined(params?: string | core.$ZodUndefinedParams): ZodMiniUndefined {699  return core._undefined(ZodMiniUndefined, params) as any;700}701export { _undefined as undefined };702 703// ZodMiniNull704export interface ZodMiniNull extends _ZodMiniType<core.$ZodNullInternals> {705  // _zod: core.$ZodNullInternals;706}707export const ZodMiniNull: core.$constructor<ZodMiniNull> = /*@__PURE__*/ core.$constructor(708  "ZodMiniNull",709  (inst, def) => {710    core.$ZodNull.init(inst, def);711    ZodMiniType.init(inst, def);712  }713);714 715// @__NO_SIDE_EFFECTS__716function _null(params?: string | core.$ZodNullParams): ZodMiniNull {717  return core._null(ZodMiniNull, params) as any;718}719export { _null as null };720 721// ZodMiniAny722export interface ZodMiniAny extends _ZodMiniType<core.$ZodAnyInternals> {723  // _zod: core.$ZodAnyInternals;724}725export const ZodMiniAny: core.$constructor<ZodMiniAny> = /*@__PURE__*/ core.$constructor("ZodMiniAny", (inst, def) => {726  core.$ZodAny.init(inst, def);727  ZodMiniType.init(inst, def);728});729 730// @__NO_SIDE_EFFECTS__731export function any(): ZodMiniAny {732  return core._any(ZodMiniAny) as any;733}734 735// ZodMiniUnknown736export interface ZodMiniUnknown extends _ZodMiniType<core.$ZodUnknownInternals> {737  // _zod: core.$ZodUnknownInternals;738}739export const ZodMiniUnknown: core.$constructor<ZodMiniUnknown> = /*@__PURE__*/ core.$constructor(740  "ZodMiniUnknown",741  (inst, def) => {742    core.$ZodUnknown.init(inst, def);743    ZodMiniType.init(inst, def);744  }745);746 747// @__NO_SIDE_EFFECTS__748export function unknown(): ZodMiniUnknown {749  return core._unknown(ZodMiniUnknown) as any;750}751 752// ZodMiniNever753export interface ZodMiniNever extends _ZodMiniType<core.$ZodNeverInternals> {754  // _zod: core.$ZodNeverInternals;755}756export const ZodMiniNever: core.$constructor<ZodMiniNever> = /*@__PURE__*/ core.$constructor(757  "ZodMiniNever",758  (inst, def) => {759    core.$ZodNever.init(inst, def);760    ZodMiniType.init(inst, def);761  }762);763 764// @__NO_SIDE_EFFECTS__765export function never(params?: string | core.$ZodNeverParams): ZodMiniNever {766  return core._never(ZodMiniNever, params) as any;767}768 769// ZodMiniVoid770export interface ZodMiniVoid extends _ZodMiniType<core.$ZodVoidInternals> {771  // _zod: core.$ZodVoidInternals;772}773export const ZodMiniVoid: core.$constructor<ZodMiniVoid> = /*@__PURE__*/ core.$constructor(774  "ZodMiniVoid",775  (inst, def) => {776    core.$ZodVoid.init(inst, def);777    ZodMiniType.init(inst, def);778  }779);780 781// @__NO_SIDE_EFFECTS__782function _void(params?: string | core.$ZodVoidParams): ZodMiniVoid {783  return core._void(ZodMiniVoid, params) as any;784}785export { _void as void };786 787// ZodMiniDate788export interface ZodMiniDate<T = unknown> extends _ZodMiniType<core.$ZodDateInternals<T>> {789  // _zod: core.$ZodDateInternals<T>;790}791 792export const ZodMiniDate: core.$constructor<ZodMiniDate> = /*@__PURE__*/ core.$constructor(793  "ZodMiniDate",794  (inst, def) => {795    core.$ZodDate.init(inst, def);796    ZodMiniType.init(inst, def);797  }798);799 800// @__NO_SIDE_EFFECTS__801export function date(params?: string | core.$ZodDateParams): ZodMiniDate<Date> {802  return core._date(ZodMiniDate, params) as any;803}804 805// ZodMiniArray806export interface ZodMiniArray<T extends SomeType = core.$ZodType>807  extends _ZodMiniType<core.$ZodArrayInternals<T>>,808    core.$ZodArray<T> {809  // _zod: core.$ZodArrayInternals<T>;810}811export const ZodMiniArray: core.$constructor<ZodMiniArray> = /*@__PURE__*/ core.$constructor(812  "ZodMiniArray",813  (inst, def) => {814    core.$ZodArray.init(inst, def);815    ZodMiniType.init(inst, def);816  }817);818 819export function array<T extends SomeType>(element: T, params?: string | core.$ZodArrayParams): ZodMiniArray<T>;820// @__NO_SIDE_EFFECTS__821export function array<T extends SomeType>(element: SomeType, params?: any): ZodMiniArray<T> {822  return new ZodMiniArray({823    type: "array",824    element: element as core.$ZodType,825    ...util.normalizeParams(params),826  }) as any;827}828 829// .keyof830// @__NO_SIDE_EFFECTS__831export function keyof<T extends ZodMiniObject>(schema: T): ZodMiniEnum<util.KeysEnum<T["shape"]>> {832  const shape = schema._zod.def.shape;833  return _enum(Object.keys(shape)) as any;834}835 836// ZodMiniObject837export interface ZodMiniObject<838  /** @ts-ignore Cast variance */839  out Shape extends core.$ZodShape = core.$ZodShape,840  out Config extends core.$ZodObjectConfig = core.$strip,841> extends ZodMiniType<any, any, core.$ZodObjectInternals<Shape, Config>>,842    core.$ZodObject<Shape, Config> {843  shape: Shape;844}845export const ZodMiniObject: core.$constructor<ZodMiniObject> = /*@__PURE__*/ core.$constructor(846  "ZodMiniObject",847  (inst, def) => {848    core.$ZodObject.init(inst, def);849    ZodMiniType.init(inst, def);850    util.defineLazy(inst, "shape", () => def.shape);851  }852);853// @__NO_SIDE_EFFECTS__854export function object<T extends core.$ZodLooseShape = Record<never, SomeType>>(855  shape?: T,856  params?: string | core.$ZodObjectParams857): ZodMiniObject<util.Writeable<T>, core.$strip> {858  const def: core.$ZodObjectDef = {859    type: "object",860    shape: shape ?? {},861    ...util.normalizeParams(params),862  };863  return new ZodMiniObject(def) as any;864}865 866// strictObject867// @__NO_SIDE_EFFECTS__868export function strictObject<T extends core.$ZodLooseShape>(869  shape: T,870  params?: string | core.$ZodObjectParams871): ZodMiniObject<util.Writeable<T>, core.$strict> {872  return new ZodMiniObject({873    type: "object",874    shape,875    catchall: never(),876    ...util.normalizeParams(params),877  }) as any;878}879 880// looseObject881// @__NO_SIDE_EFFECTS__882export function looseObject<T extends core.$ZodLooseShape>(883  shape: T,884  params?: string | core.$ZodObjectParams885): ZodMiniObject<util.Writeable<T>, core.$loose> {886  return new ZodMiniObject({887    type: "object",888    shape,889    catchall: unknown(),890    ...util.normalizeParams(params),891  }) as any;892}893 894// object methods895// @__NO_SIDE_EFFECTS__896export function extend<T extends ZodMiniObject, U extends core.$ZodLooseShape>(897  schema: T,898  shape: U899): ZodMiniObject<util.Extend<T["shape"], util.Writeable<U>>, T["_zod"]["config"]> {900  return util.extend(schema, shape);901}902 903export type SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLooseShape> = {904  [K in keyof Ext]: K extends keyof Base905    ? core.output<Ext[K]> extends core.output<Base[K]>906      ? core.input<Ext[K]> extends core.input<Base[K]>907        ? Ext[K]908        : never909      : never910    : Ext[K];911};912 913// @__NO_SIDE_EFFECTS__914export function safeExtend<T extends ZodMiniObject, U extends core.$ZodLooseShape>(915  schema: T,916  shape: SafeExtendShape<T["shape"], U>917): ZodMiniObject<util.Extend<T["shape"], util.Writeable<U>>, T["_zod"]["config"]> {918  return util.safeExtend(schema, shape as any);919}920 921/** @deprecated Identical to `z.extend(A, B)` */922export function merge<T extends ZodMiniObject, U extends ZodMiniObject>(923  a: T,924  b: U925): ZodMiniObject<util.Extend<T["shape"], U["shape"]>, T["_zod"]["config"]>;926// @__NO_SIDE_EFFECTS__927export function merge(schema: ZodMiniObject, shape: any): ZodMiniObject {928  return util.extend(schema, shape);929}930 931// @__NO_SIDE_EFFECTS__932export function pick<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(933  schema: T,934  mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>935): ZodMiniObject<util.Flatten<Pick<T["shape"], keyof T["shape"] & keyof M>>, T["_zod"]["config"]> {936  return util.pick(schema, mask as any);937}938 939// .omit940 941// @__NO_SIDE_EFFECTS__942export function omit<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(943  schema: T,944  mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>945): ZodMiniObject<util.Flatten<Omit<T["shape"], keyof M>>, T["_zod"]["config"]> {946  return util.omit(schema, mask);947}948 949// @__NO_SIDE_EFFECTS__950export function partial<T extends ZodMiniObject>(951  schema: T952): ZodMiniObject<953  {954    -readonly [k in keyof T["shape"]]: ZodMiniOptional<T["shape"][k]>;955  },956  T["_zod"]["config"]957>;958// @__NO_SIDE_EFFECTS__959export function partial<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(960  schema: T,961  mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>962): ZodMiniObject<963  {964    -readonly [k in keyof T["shape"]]: k extends keyof M ? ZodMiniOptional<T["shape"][k]> : T["shape"][k];965  },966  T["_zod"]["config"]967>;968// @__NO_SIDE_EFFECTS__969export function partial(schema: ZodMiniObject, mask?: object) {970  return util.partial(ZodMiniOptional, schema, mask);971}972 973export type RequiredInterfaceShape<974  Shape extends core.$ZodLooseShape,975  Keys extends PropertyKey = keyof Shape,976> = util.Identity<977  {978    [k in keyof Shape as k extends Keys ? k : never]: ZodMiniNonOptional<Shape[k]>;979  } & {980    [k in keyof Shape as k extends Keys ? never : k]: Shape[k];981  }982>;983 984// @__NO_SIDE_EFFECTS__985export function required<T extends ZodMiniObject>(986  schema: T987): ZodMiniObject<988  {989    -readonly [k in keyof T["shape"]]: ZodMiniNonOptional<T["shape"][k]>;990  },991  T["_zod"]["config"]992>;993// @__NO_SIDE_EFFECTS__994export function required<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(995  schema: T,996  mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>997): ZodMiniObject<998  util.Extend<999    T["shape"],1000    {1001      [k in keyof M & keyof T["shape"]]: ZodMiniNonOptional<T["shape"][k]>;1002    }1003  >,1004  T["_zod"]["config"]1005>;1006// @__NO_SIDE_EFFECTS__1007export function required(schema: ZodMiniObject, mask?: object) {1008  return util.required(ZodMiniNonOptional, schema, mask);1009}1010 1011// @__NO_SIDE_EFFECTS__1012export function catchall<T extends ZodMiniObject, U extends SomeType>(1013  inst: T,1014  catchall: U1015): ZodMiniObject<T["shape"], core.$catchall<U>> {1016  return inst.clone({ ...inst._zod.def, catchall: catchall as any }) as any;1017}1018 1019// ZodMiniUnion1020export interface ZodMiniUnion<T extends readonly SomeType[] = readonly core.$ZodType[]>1021  extends _ZodMiniType<core.$ZodUnionInternals<T>> {1022  // _zod: core.$ZodUnionInternals<T>;1023}1024export const ZodMiniUnion: core.$constructor<ZodMiniUnion> = /*@__PURE__*/ core.$constructor(1025  "ZodMiniUnion",1026  (inst, def) => {1027    core.$ZodUnion.init(inst, def);1028    ZodMiniType.init(inst, def);1029  }1030);1031 1032// @__NO_SIDE_EFFECTS__1033export function union<const T extends readonly SomeType[]>(1034  options: T,1035  params?: string | core.$ZodUnionParams1036): ZodMiniUnion<T> {1037  return new ZodMiniUnion({1038    type: "union",1039    options: options as any as core.$ZodType[],1040    ...util.normalizeParams(params),1041  }) as any;1042}1043 1044// ZodMiniXor1045export interface ZodMiniXor<T extends readonly SomeType[] = readonly core.$ZodType[]>1046  extends _ZodMiniType<core.$ZodXorInternals<T>> {1047  // _zod: core.$ZodXorInternals<T>;1048}1049export const ZodMiniXor: core.$constructor<ZodMiniXor> = /*@__PURE__*/ core.$constructor("ZodMiniXor", (inst, def) => {1050  ZodMiniUnion.init(inst, def);1051  core.$ZodXor.init(inst, def);1052});1053 1054/** Creates an exclusive union (XOR) where exactly one option must match.1055 * Unlike regular unions that succeed when any option matches, xor fails if1056 * zero or more than one option matches the input. */1057export function xor<const T extends readonly SomeType[]>(1058  options: T,1059  params?: string | core.$ZodXorParams1060): ZodMiniXor<T> {1061  return new ZodMiniXor({1062    type: "union",1063    options: options as any as core.$ZodType[],1064    inclusive: false,1065    ...util.normalizeParams(params),1066  }) as any;1067}1068 1069// ZodMiniDiscriminatedUnion1070export interface ZodMiniDiscriminatedUnion<1071  Options extends readonly SomeType[] = readonly core.$ZodType[],1072  Disc extends string = string,1073> extends ZodMiniUnion<Options> {1074  _zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;1075}1076export const ZodMiniDiscriminatedUnion: core.$constructor<ZodMiniDiscriminatedUnion> = /*@__PURE__*/ core.$constructor(1077  "ZodMiniDiscriminatedUnion",1078  (inst, def) => {1079    core.$ZodDiscriminatedUnion.init(inst, def);1080    ZodMiniType.init(inst, def);1081  }1082);1083 1084// @__NO_SIDE_EFFECTS__1085export function discriminatedUnion<1086  Types extends readonly [core.$ZodTypeDiscriminable<Disc>, ...core.$ZodTypeDiscriminable<Disc>[]],1087  Disc extends string,1088>(1089  discriminator: Disc,1090  options: Types,1091  params?: string | core.$ZodDiscriminatedUnionParams1092): ZodMiniDiscriminatedUnion<Types, Disc> {1093  return new ZodMiniDiscriminatedUnion({1094    type: "union",1095    options,1096    discriminator,1097    ...util.normalizeParams(params),1098  }) as ZodMiniDiscriminatedUnion<Types, Disc>;1099}1100 1101// ZodMiniIntersection1102export interface ZodMiniIntersection<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType>1103  extends _ZodMiniType<core.$ZodIntersectionInternals<A, B>> {1104  // _zod: core.$ZodIntersectionInternals<A, B>;1105}1106export const ZodMiniIntersection: core.$constructor<ZodMiniIntersection> = /*@__PURE__*/ core.$constructor(1107  "ZodMiniIntersection",1108  (inst, def) => {1109    core.$ZodIntersection.init(inst, def);1110    ZodMiniType.init(inst, def);1111  }1112);1113 1114// @__NO_SIDE_EFFECTS__1115export function intersection<T extends SomeType, U extends SomeType>(left: T, right: U): ZodMiniIntersection<T, U> {1116  return new ZodMiniIntersection({1117    type: "intersection",1118    left: left as any as core.$ZodType,1119    right: right as any as core.$ZodType,1120  }) as any;1121}1122 1123// ZodMiniTuple1124export interface ZodMiniTuple<1125  T extends util.TupleItems = readonly core.$ZodType[],1126  Rest extends SomeType | null = core.$ZodType | null,1127> extends _ZodMiniType<core.$ZodTupleInternals<T, Rest>> {1128  // _zod: core.$ZodTupleInternals<T, Rest>;1129}1130export const ZodMiniTuple: core.$constructor<ZodMiniTuple> = /*@__PURE__*/ core.$constructor(1131  "ZodMiniTuple",1132  (inst, def) => {1133    core.$ZodTuple.init(inst, def);1134    ZodMiniType.init(inst, def);1135  }1136);1137 1138export function tuple<const T extends readonly [SomeType, ...SomeType[]]>(1139  items: T,1140  params?: string | core.$ZodTupleParams1141): ZodMiniTuple<T, null>;1142export function tuple<const T extends readonly [SomeType, ...SomeType[]], Rest extends SomeType>(1143  items: T,1144  rest: Rest,1145  params?: string | core.$ZodTupleParams1146): ZodMiniTuple<T, Rest>;1147export function tuple(items: [], params?: string | core.$ZodTupleParams): ZodMiniTuple<[], null>;1148// @__NO_SIDE_EFFECTS__1149export function tuple(1150  items: SomeType[],1151  _paramsOrRest?: string | core.$ZodTupleParams | SomeType,1152  _params?: string | core.$ZodTupleParams1153) {1154  const hasRest = _paramsOrRest instanceof core.$ZodType;1155  const params = hasRest ? _params : _paramsOrRest;1156  const rest = hasRest ? _paramsOrRest : null;1157  return new ZodMiniTuple({1158    type: "tuple",1159    items: items as any as core.$ZodType[],1160    rest,1161    ...util.normalizeParams(params),1162  });1163}1164 1165// ZodMiniRecord1166export interface ZodMiniRecord<1167  Key extends core.$ZodRecordKey = core.$ZodRecordKey,1168  Value extends SomeType = core.$ZodType,1169> extends _ZodMiniType<core.$ZodRecordInternals<Key, Value>> {1170  // _zod: core.$ZodRecordInternals<Key, Value>;1171}1172export const ZodMiniRecord: core.$constructor<ZodMiniRecord> = /*@__PURE__*/ core.$constructor(1173  "ZodMiniRecord",1174  (inst, def) => {1175    core.$ZodRecord.init(inst, def);1176    ZodMiniType.init(inst, def);1177  }1178);1179 1180// @__NO_SIDE_EFFECTS__1181export function record<Key extends core.$ZodRecordKey, Value extends SomeType>(1182  keyType: Key,1183  valueType: Value,1184  params?: string | core.$ZodRecordParams1185): ZodMiniRecord<Key, Value> {1186  // v3-compat: z.record(valueType, params?) — defaults keyType to z.string()1187  if (!valueType || !(valueType as any)._zod) {1188    return new ZodMiniRecord({1189      type: "record",1190      keyType: string() as any,1191      valueType: keyType as any as core.$ZodType,1192      ...util.normalizeParams(valueType as string | core.$ZodRecordParams | undefined),1193    }) as any;1194  }1195  return new ZodMiniRecord({1196    type: "record",1197    keyType,1198    valueType: valueType as any as core.$ZodType,1199    ...util.normalizeParams(params),1200  }) as any;

Showing the first 1,200 of 1948 lines. Download the file for the rest.