Changes Scan Docs Trust

← All changes

When upstream breaks, Teire fixes your code.

teire-dev/teire System status

Built on

Product

Scan a repo Changes Install on GitHub Dashboard Demo video

Developers

Docs GitHub CLI and MCP teire.yml schema npm

Trust

How Teire runs Source code

Changes Scan Docs Trust

zod 3.25.76 → 4.6.7: changes the types of 1189 API(s) · Teire

zod●breaks on upgrade

zod 3.25.76 → 4.6.7: changes the types of 1189 API(s)

Compared with 3.25.76: `z`, `setErrorMap`, `getErrorMap`, `INVALID`, `util`, and 1184 more.

zod 3.25.76 → 4.6.7: changes the types of 1189 API(s): from its source to your code

registry.npmjs.orgquote checked
4.6.7from 3.25.76
Your code1189 things to find
Nemotron fixes

In its own wordsread from the page

registry.npmjs.org/zod/4.6.7computed by Teire from the published codechecked 2026-10-30#2811a85330

What Teire looks for in your code

z (ts)
setErrorMap (ts)
getErrorMap (ts)
INVALID (ts)
util (ts)
RefinementCtx (ts)
ZodRawShape (ts)
ZodTypeAny (ts)
input (ts)
output (ts)
ZodType (ts)
ZodString (ts)
ZodNumber (ts)
ZodBigInt (ts)
ZodBoolean (ts)
ZodDate (ts)
ZodSymbol (ts)
ZodUndefined (ts)
ZodNull (ts)
ZodAny (ts)

Does it reach your code?

Fix in all Scan a repo

read by a tool · npm/zod/3.25.76..4.6.7/symbol-changed

ZodUnknown (ts)

ZodNever (ts)

ZodVoid (ts)

ZodArray (ts)

ZodObject (ts)

ZodUnion (ts)

ZodDiscriminatedUnion (ts)

ZodIntersection (ts)

ZodTuple (ts)

ZodRecord (ts)

ZodMap (ts)

ZodSet (ts)

ZodFunction (ts)

ZodLazy (ts)

ZodLiteral (ts)

ZodEnum (ts)

ZodPromise (ts)

ZodOptional (ts)

ZodNullable (ts)

ZodDefault (ts)

ZodCatch (ts)

ZodNaN (ts)

BRAND (ts)

ZodReadonly (ts)

ZodFirstPartySchemaTypes (ts)

coerce (ts)

array (ts)

bigint (ts)

boolean (ts)

date (ts)

discriminatedUnion (ts)

enum (ts)

instanceof (ts)

literal (ts)

map (ts)

nan (ts)

nativeEnum (ts)

never (ts)

null (ts)

number (ts)

object (ts)

set (ts)

strictObject (ts)

string (ts)

symbol (ts)

tuple (ts)

undefined (ts)

union (ts)

void (ts)

ZodIssueCode (ts)

ZodIssue (ts)

ZodError (ts)

ZodErrorMap (ts)

util.joinValues (ts)

util.assertEqual (ts)

RefinementCtx.addIssue (ts)

ZodTypeAny.~standard (ts)

ZodTypeAny.parse (ts)

ZodTypeAny.safeParse (ts)

ZodTypeAny.parseAsync (ts)

ZodTypeAny.safeParseAsync (ts)

ZodTypeAny.spa (ts)

ZodTypeAny.refine (ts)

ZodTypeAny.superRefine (ts)

ZodTypeAny.optional (ts)

ZodTypeAny.nullable (ts)

ZodTypeAny.nullish (ts)

ZodTypeAny.array (ts)

ZodTypeAny.or (ts)

ZodTypeAny.and (ts)

ZodTypeAny.transform (ts)

ZodTypeAny.default (ts)

ZodTypeAny.brand (ts)

ZodTypeAny.catch (ts)

ZodTypeAny.describe (ts)

ZodTypeAny.pipe (ts)

ZodTypeAny.readonly (ts)

ZodType.~standard (ts)

ZodType.parse (ts)

ZodType.safeParse (ts)

ZodType.parseAsync (ts)

ZodType.safeParseAsync (ts)

ZodType.spa (ts)

ZodType.refine (ts)

ZodType.superRefine (ts)

ZodType.optional (ts)

ZodType.nullable (ts)

ZodType.nullish (ts)

ZodType.array (ts)

ZodType.or (ts)

ZodType.and (ts)

ZodType.transform (ts)

ZodType.default (ts)

ZodType.brand (ts)

ZodType.catch (ts)

ZodType.describe (ts)

ZodType.pipe (ts)

ZodType.readonly (ts)

ZodString.email (ts)

ZodString.url (ts)

ZodString.emoji (ts)

ZodString.uuid (ts)

ZodString.nanoid (ts)

ZodString.cuid (ts)

ZodString.cuid2 (ts)

ZodString.ulid (ts)

ZodString.base64 (ts)

ZodString.base64url (ts)

ZodString.jwt (ts)

ZodString.datetime (ts)

ZodString.date (ts)

ZodString.time (ts)

ZodString.duration (ts)

ZodString.regex (ts)

ZodString.includes (ts)

ZodString.startsWith (ts)

ZodString.endsWith (ts)

ZodString.min (ts)

ZodString.max (ts)

ZodString.length (ts)

ZodString.nonempty (ts)

ZodString.~standard (ts)

ZodString.parse (ts)

ZodString.safeParse (ts)

ZodString.parseAsync (ts)

ZodString.safeParseAsync (ts)

ZodString.spa (ts)

ZodString.refine (ts)

ZodString.superRefine (ts)

ZodString.array (ts)

ZodString.or (ts)

ZodString.and (ts)

ZodString.transform (ts)

ZodString.brand (ts)

ZodString.catch (ts)

ZodString.pipe (ts)

ZodNumber.gte (ts)

ZodNumber.min (ts)

ZodNumber.gt (ts)

ZodNumber.lte (ts)

ZodNumber.max (ts)

ZodNumber.lt (ts)

ZodNumber.int (ts)

ZodNumber.positive (ts)

ZodNumber.negative (ts)

ZodNumber.nonpositive (ts)

ZodNumber.nonnegative (ts)

ZodNumber.multipleOf (ts)

ZodNumber.step (ts)

ZodNumber.finite (ts)

ZodNumber.safe (ts)

ZodNumber.~standard (ts)

ZodNumber.parse (ts)

ZodNumber.safeParse (ts)

ZodNumber.parseAsync (ts)

ZodNumber.safeParseAsync (ts)

ZodNumber.spa (ts)

ZodNumber.refine (ts)

ZodNumber.superRefine (ts)

ZodNumber.array (ts)

ZodNumber.or (ts)

ZodNumber.and (ts)

ZodNumber.transform (ts)

ZodNumber.brand (ts)

ZodNumber.catch (ts)

ZodNumber.pipe (ts)

ZodBigInt.gte (ts)

ZodBigInt.min (ts)

ZodBigInt.gt (ts)

ZodBigInt.lte (ts)

ZodBigInt.max (ts)

ZodBigInt.lt (ts)

ZodBigInt.positive (ts)

ZodBigInt.negative (ts)

ZodBigInt.nonpositive (ts)

ZodBigInt.nonnegative (ts)

ZodBigInt.multipleOf (ts)

ZodBigInt.~standard (ts)

ZodBigInt.parse (ts)

ZodBigInt.safeParse (ts)

ZodBigInt.parseAsync (ts)

ZodBigInt.safeParseAsync (ts)

ZodBigInt.spa (ts)

ZodBigInt.refine (ts)

ZodBigInt.superRefine (ts)

ZodBigInt.array (ts)

ZodBigInt.or (ts)

ZodBigInt.and (ts)

ZodBigInt.transform (ts)

ZodBigInt.brand (ts)

ZodBigInt.catch (ts)

ZodBigInt.pipe (ts)

ZodBoolean.~standard (ts)

ZodBoolean.parse (ts)

ZodBoolean.safeParse (ts)

ZodBoolean.parseAsync (ts)

ZodBoolean.safeParseAsync (ts)

ZodBoolean.spa (ts)

ZodBoolean.refine (ts)

ZodBoolean.superRefine (ts)

ZodBoolean.array (ts)

ZodBoolean.or (ts)

ZodBoolean.and (ts)

ZodBoolean.transform (ts)

ZodBoolean.brand (ts)

ZodBoolean.catch (ts)

ZodBoolean.pipe (ts)

ZodDate.min (ts)

ZodDate.max (ts)

ZodDate.~standard (ts)

ZodDate.parse (ts)

ZodDate.safeParse (ts)

ZodDate.parseAsync (ts)

ZodDate.safeParseAsync (ts)

ZodDate.spa (ts)

ZodDate.refine (ts)

ZodDate.superRefine (ts)

ZodDate.array (ts)

ZodDate.or (ts)

ZodDate.and (ts)

ZodDate.transform (ts)

ZodDate.brand (ts)

ZodDate.catch (ts)

ZodDate.pipe (ts)

ZodSymbol.~standard (ts)

ZodSymbol.parse (ts)

ZodSymbol.safeParse (ts)

ZodSymbol.parseAsync (ts)

ZodSymbol.safeParseAsync (ts)

ZodSymbol.spa (ts)

ZodSymbol.refine (ts)

ZodSymbol.superRefine (ts)

ZodSymbol.array (ts)

ZodSymbol.or (ts)

ZodSymbol.and (ts)

ZodSymbol.transform (ts)

ZodSymbol.brand (ts)

ZodSymbol.catch (ts)

ZodSymbol.pipe (ts)

ZodUndefined.~standard (ts)

ZodUndefined.parse (ts)

ZodUndefined.safeParse (ts)

ZodUndefined.parseAsync (ts)

ZodUndefined.safeParseAsync (ts)

ZodUndefined.spa (ts)

ZodUndefined.refine (ts)

ZodUndefined.superRefine (ts)

ZodUndefined.array (ts)

ZodUndefined.or (ts)

ZodUndefined.and (ts)

ZodUndefined.transform (ts)

ZodUndefined.brand (ts)

ZodUndefined.catch (ts)

ZodUndefined.pipe (ts)

ZodNull.~standard (ts)

ZodNull.parse (ts)

ZodNull.safeParse (ts)

ZodNull.parseAsync (ts)

ZodNull.safeParseAsync (ts)

ZodNull.spa (ts)

ZodNull.refine (ts)

ZodNull.superRefine (ts)

ZodNull.array (ts)

ZodNull.or (ts)

ZodNull.and (ts)

ZodNull.transform (ts)

ZodNull.brand (ts)

ZodNull.catch (ts)

ZodNull.pipe (ts)

ZodAny.~standard (ts)

ZodAny.parse (ts)

ZodAny.safeParse (ts)

ZodAny.parseAsync (ts)

ZodAny.safeParseAsync (ts)

ZodAny.spa (ts)

ZodAny.refine (ts)

ZodAny.superRefine (ts)

ZodAny.array (ts)

ZodAny.or (ts)

ZodAny.and (ts)

ZodAny.transform (ts)

ZodAny.brand (ts)

ZodAny.catch (ts)

ZodAny.pipe (ts)

ZodUnknown.~standard (ts)

ZodUnknown.parse (ts)

ZodUnknown.safeParse (ts)

ZodUnknown.parseAsync (ts)

ZodUnknown.safeParseAsync (ts)

ZodUnknown.spa (ts)

ZodUnknown.refine (ts)

ZodUnknown.superRefine (ts)

ZodUnknown.array (ts)

ZodUnknown.or (ts)

ZodUnknown.and (ts)

ZodUnknown.transform (ts)

ZodUnknown.brand (ts)

ZodUnknown.catch (ts)

ZodUnknown.pipe (ts)

ZodNever.~standard (ts)

ZodNever.parse (ts)

ZodNever.safeParse (ts)

ZodNever.parseAsync (ts)

ZodNever.safeParseAsync (ts)

ZodNever.spa (ts)

ZodNever.refine (ts)

ZodNever.superRefine (ts)

ZodNever.array (ts)

ZodNever.or (ts)

ZodNever.and (ts)

ZodNever.transform (ts)

ZodNever.brand (ts)

ZodNever.catch (ts)

ZodNever.pipe (ts)

ZodVoid.~standard (ts)

ZodVoid.parse (ts)

ZodVoid.safeParse (ts)

ZodVoid.parseAsync (ts)

ZodVoid.safeParseAsync (ts)

ZodVoid.spa (ts)

ZodVoid.refine (ts)

ZodVoid.superRefine (ts)

ZodVoid.array (ts)

ZodVoid.or (ts)

ZodVoid.and (ts)

ZodVoid.transform (ts)

ZodVoid.brand (ts)

ZodVoid.catch (ts)

ZodVoid.pipe (ts)

ZodArray.element (ts)

ZodArray.min (ts)

ZodArray.max (ts)

ZodArray.length (ts)

ZodArray.nonempty (ts)

ZodArray.~standard (ts)

ZodArray.parse (ts)

ZodArray.safeParse (ts)

ZodArray.parseAsync (ts)

ZodArray.safeParseAsync (ts)

ZodArray.spa (ts)

ZodArray.refine (ts)

ZodArray.superRefine (ts)

ZodArray.optional (ts)

ZodArray.nullable (ts)

ZodArray.nullish (ts)

ZodArray.array (ts)

ZodArray.or (ts)

ZodArray.and (ts)

ZodArray.transform (ts)

ZodArray.default (ts)

ZodArray.brand (ts)

ZodArray.catch (ts)

ZodArray.describe (ts)

ZodArray.pipe (ts)

ZodArray.readonly (ts)

ZodObject.shape (ts)

ZodObject.strip (ts)

ZodObject.passthrough (ts)

ZodObject.extend (ts)

ZodObject.merge (ts)

ZodObject.catchall (ts)

ZodObject.pick (ts)

ZodObject.omit (ts)

ZodObject.partial (ts)

ZodObject.required (ts)

ZodObject.keyof (ts)

ZodObject.~standard (ts)

ZodObject.parse (ts)

ZodObject.safeParse (ts)

ZodObject.parseAsync (ts)

ZodObject.safeParseAsync (ts)

ZodObject.spa (ts)

ZodObject.refine (ts)

ZodObject.superRefine (ts)

ZodObject.optional (ts)

ZodObject.nullable (ts)

ZodObject.nullish (ts)

ZodObject.array (ts)

ZodObject.or (ts)

ZodObject.and (ts)

ZodObject.transform (ts)

ZodObject.default (ts)

ZodObject.brand (ts)

ZodObject.catch (ts)

ZodObject.describe (ts)

ZodObject.pipe (ts)

ZodObject.readonly (ts)

ZodUnion.options (ts)

ZodUnion.~standard (ts)

ZodUnion.parse (ts)

ZodUnion.safeParse (ts)

ZodUnion.parseAsync (ts)

ZodUnion.safeParseAsync (ts)

ZodUnion.spa (ts)

ZodUnion.refine (ts)

ZodUnion.superRefine (ts)

ZodUnion.optional (ts)

ZodUnion.nullable (ts)

ZodUnion.nullish (ts)

ZodUnion.array (ts)

ZodUnion.or (ts)

ZodUnion.and (ts)

ZodUnion.transform (ts)

ZodUnion.default (ts)

ZodUnion.brand (ts)

ZodUnion.catch (ts)

ZodUnion.describe (ts)

ZodUnion.pipe (ts)

ZodUnion.readonly (ts)

ZodDiscriminatedUnion.options (ts)

ZodDiscriminatedUnion.~standard (ts)

ZodDiscriminatedUnion.parse (ts)

ZodDiscriminatedUnion.safeParse (ts)

ZodDiscriminatedUnion.parseAsync (ts)

ZodDiscriminatedUnion.safeParseAsync (ts)

ZodDiscriminatedUnion.spa (ts)

ZodDiscriminatedUnion.refine (ts)

ZodDiscriminatedUnion.superRefine (ts)

ZodDiscriminatedUnion.optional (ts)

ZodDiscriminatedUnion.nullable (ts)

ZodDiscriminatedUnion.nullish (ts)

ZodDiscriminatedUnion.array (ts)

ZodDiscriminatedUnion.or (ts)

ZodDiscriminatedUnion.and (ts)

ZodDiscriminatedUnion.transform (ts)

ZodDiscriminatedUnion.default (ts)

ZodDiscriminatedUnion.brand (ts)

ZodDiscriminatedUnion.catch (ts)

ZodDiscriminatedUnion.describe (ts)

ZodDiscriminatedUnion.pipe (ts)

ZodDiscriminatedUnion.readonly (ts)

ZodIntersection.~standard (ts)

ZodIntersection.parse (ts)

ZodIntersection.safeParse (ts)

ZodIntersection.parseAsync (ts)

ZodIntersection.safeParseAsync (ts)

ZodIntersection.spa (ts)

ZodIntersection.refine (ts)

ZodIntersection.superRefine (ts)

ZodIntersection.optional (ts)

ZodIntersection.nullable (ts)

ZodIntersection.nullish (ts)

ZodIntersection.array (ts)

ZodIntersection.or (ts)

ZodIntersection.and (ts)

ZodIntersection.transform (ts)

ZodIntersection.default (ts)

ZodIntersection.brand (ts)

ZodIntersection.catch (ts)

ZodIntersection.describe (ts)

ZodIntersection.pipe (ts)

ZodIntersection.readonly (ts)

ZodTuple.rest (ts)

ZodTuple.~standard (ts)

ZodTuple.parse (ts)

ZodTuple.safeParse (ts)

ZodTuple.parseAsync (ts)

ZodTuple.safeParseAsync (ts)

ZodTuple.spa (ts)

ZodTuple.refine (ts)

ZodTuple.superRefine (ts)

ZodTuple.optional (ts)

ZodTuple.nullable (ts)

ZodTuple.nullish (ts)

ZodTuple.array (ts)

ZodTuple.or (ts)

ZodTuple.and (ts)

ZodTuple.transform (ts)

ZodTuple.default (ts)

ZodTuple.brand (ts)

ZodTuple.catch (ts)

ZodTuple.describe (ts)

ZodTuple.pipe (ts)

ZodTuple.readonly (ts)

ZodRecord.~standard (ts)

ZodRecord.parse (ts)

ZodRecord.safeParse (ts)

ZodRecord.parseAsync (ts)

ZodRecord.safeParseAsync (ts)

ZodRecord.spa (ts)

ZodRecord.refine (ts)

ZodRecord.superRefine (ts)

ZodRecord.optional (ts)

ZodRecord.nullable (ts)

ZodRecord.nullish (ts)

ZodRecord.array (ts)

ZodRecord.or (ts)

ZodRecord.and (ts)

ZodRecord.transform (ts)

ZodRecord.default (ts)

ZodRecord.brand (ts)

ZodRecord.catch (ts)

ZodRecord.describe (ts)

ZodRecord.pipe (ts)

ZodRecord.readonly (ts)

ZodMap.~standard (ts)

ZodMap.parse (ts)

ZodMap.safeParse (ts)

ZodMap.parseAsync (ts)

ZodMap.safeParseAsync (ts)

ZodMap.spa (ts)

ZodMap.refine (ts)

ZodMap.superRefine (ts)

ZodMap.optional (ts)

ZodMap.nullable (ts)

ZodMap.nullish (ts)

ZodMap.array (ts)

ZodMap.or (ts)

ZodMap.and (ts)

ZodMap.transform (ts)

ZodMap.default (ts)

ZodMap.brand (ts)

ZodMap.catch (ts)

ZodMap.describe (ts)

ZodMap.pipe (ts)

ZodMap.readonly (ts)

ZodSet.min (ts)

ZodSet.max (ts)

ZodSet.size (ts)

ZodSet.nonempty (ts)

ZodSet.~standard (ts)

ZodSet.parse (ts)

ZodSet.safeParse (ts)

ZodSet.parseAsync (ts)

ZodSet.safeParseAsync (ts)

ZodSet.spa (ts)

ZodSet.refine (ts)

ZodSet.superRefine (ts)

ZodSet.optional (ts)

ZodSet.nullable (ts)

ZodSet.nullish (ts)

ZodSet.array (ts)

ZodSet.or (ts)

ZodSet.and (ts)

ZodSet.transform (ts)

ZodSet.default (ts)

ZodSet.brand (ts)

ZodSet.catch (ts)

ZodSet.describe (ts)

ZodSet.pipe (ts)

ZodSet.readonly (ts)

ZodFunction.implement (ts)

ZodFunction.validate (ts)

ZodFunction.~standard (ts)

ZodFunction.parse (ts)

ZodFunction.safeParse (ts)

ZodFunction.parseAsync (ts)

ZodFunction.safeParseAsync (ts)

ZodFunction.spa (ts)

ZodFunction.refine (ts)

ZodFunction.superRefine (ts)

ZodFunction.optional (ts)

ZodFunction.nullable (ts)

ZodFunction.nullish (ts)

ZodFunction.array (ts)

ZodFunction.or (ts)

ZodFunction.and (ts)

ZodFunction.transform (ts)

ZodFunction.default (ts)

ZodFunction.brand (ts)

ZodFunction.catch (ts)

ZodFunction.describe (ts)

ZodFunction.pipe (ts)

ZodFunction.readonly (ts)

ZodLazy.~standard (ts)

ZodLazy.parse (ts)

ZodLazy.safeParse (ts)

ZodLazy.parseAsync (ts)

ZodLazy.safeParseAsync (ts)

ZodLazy.spa (ts)

ZodLazy.refine (ts)

ZodLazy.superRefine (ts)

ZodLazy.optional (ts)

ZodLazy.nullable (ts)

ZodLazy.nullish (ts)

ZodLazy.array (ts)

ZodLazy.or (ts)

ZodLazy.and (ts)

ZodLazy.transform (ts)

ZodLazy.default (ts)

ZodLazy.brand (ts)

ZodLazy.catch (ts)

ZodLazy.describe (ts)

ZodLazy.pipe (ts)

ZodLazy.readonly (ts)

ZodLiteral.value (ts)

ZodLiteral.~standard (ts)

ZodLiteral.parse (ts)

ZodLiteral.safeParse (ts)

ZodLiteral.parseAsync (ts)

ZodLiteral.safeParseAsync (ts)

ZodLiteral.spa (ts)

ZodLiteral.refine (ts)

ZodLiteral.superRefine (ts)

ZodLiteral.optional (ts)

ZodLiteral.nullable (ts)

ZodLiteral.nullish (ts)

ZodLiteral.array (ts)

ZodLiteral.or (ts)

ZodLiteral.and (ts)

ZodLiteral.transform (ts)

ZodLiteral.default (ts)

ZodLiteral.brand (ts)

ZodLiteral.catch (ts)

ZodLiteral.describe (ts)

ZodLiteral.pipe (ts)

ZodLiteral.readonly (ts)

ZodEnum.options (ts)

ZodEnum.enum (ts)

ZodEnum.extract (ts)

ZodEnum.exclude (ts)

ZodEnum.~standard (ts)

ZodEnum.parse (ts)

ZodEnum.safeParse (ts)

ZodEnum.parseAsync (ts)

ZodEnum.safeParseAsync (ts)

ZodEnum.spa (ts)

ZodEnum.refine (ts)

ZodEnum.superRefine (ts)

ZodEnum.optional (ts)

ZodEnum.nullable (ts)

ZodEnum.nullish (ts)

ZodEnum.array (ts)

ZodEnum.or (ts)

ZodEnum.and (ts)

ZodEnum.transform (ts)

ZodEnum.default (ts)

ZodEnum.brand (ts)

ZodEnum.catch (ts)

ZodEnum.describe (ts)

ZodEnum.pipe (ts)

ZodEnum.readonly (ts)

ZodPromise.unwrap (ts)

ZodPromise.~standard (ts)

ZodPromise.parse (ts)

ZodPromise.safeParse (ts)

ZodPromise.parseAsync (ts)

ZodPromise.safeParseAsync (ts)

ZodPromise.spa (ts)

ZodPromise.refine (ts)

ZodPromise.superRefine (ts)

ZodPromise.optional (ts)

ZodPromise.nullable (ts)

ZodPromise.nullish (ts)

ZodPromise.array (ts)

ZodPromise.or (ts)

ZodPromise.and (ts)

ZodPromise.transform (ts)

ZodPromise.default (ts)

ZodPromise.brand (ts)

ZodPromise.catch (ts)

ZodPromise.describe (ts)

ZodPromise.pipe (ts)

ZodPromise.readonly (ts)

ZodOptional.unwrap (ts)

ZodOptional.~standard (ts)

ZodOptional.parse (ts)

ZodOptional.safeParse (ts)

ZodOptional.parseAsync (ts)

ZodOptional.safeParseAsync (ts)

ZodOptional.spa (ts)

ZodOptional.refine (ts)

ZodOptional.superRefine (ts)

ZodOptional.optional (ts)

ZodOptional.nullable (ts)

ZodOptional.nullish (ts)

ZodOptional.array (ts)

ZodOptional.or (ts)

ZodOptional.and (ts)

ZodOptional.transform (ts)

ZodOptional.default (ts)

ZodOptional.brand (ts)

ZodOptional.catch (ts)

ZodOptional.describe (ts)

ZodOptional.pipe (ts)

ZodOptional.readonly (ts)

ZodNullable.unwrap (ts)

ZodNullable.~standard (ts)

ZodNullable.parse (ts)

ZodNullable.safeParse (ts)

ZodNullable.parseAsync (ts)

ZodNullable.safeParseAsync (ts)

ZodNullable.spa (ts)

ZodNullable.refine (ts)

ZodNullable.superRefine (ts)

ZodNullable.optional (ts)

ZodNullable.nullable (ts)

ZodNullable.nullish (ts)

ZodNullable.array (ts)

ZodNullable.or (ts)

ZodNullable.and (ts)

ZodNullable.transform (ts)

ZodNullable.default (ts)

ZodNullable.brand (ts)

ZodNullable.catch (ts)

ZodNullable.describe (ts)

ZodNullable.pipe (ts)

ZodNullable.readonly (ts)

ZodDefault.removeDefault (ts)

ZodDefault.~standard (ts)

ZodDefault.parse (ts)

ZodDefault.safeParse (ts)

ZodDefault.parseAsync (ts)

ZodDefault.safeParseAsync (ts)

ZodDefault.spa (ts)

ZodDefault.refine (ts)

ZodDefault.superRefine (ts)

ZodDefault.optional (ts)

ZodDefault.nullable (ts)

ZodDefault.nullish (ts)

ZodDefault.array (ts)

ZodDefault.or (ts)

ZodDefault.and (ts)

ZodDefault.transform (ts)

ZodDefault.default (ts)

ZodDefault.brand (ts)

ZodDefault.catch (ts)

ZodDefault.describe (ts)

ZodDefault.pipe (ts)

ZodDefault.readonly (ts)

ZodCatch.removeCatch (ts)

ZodCatch.~standard (ts)

ZodCatch.parse (ts)

ZodCatch.safeParse (ts)

ZodCatch.parseAsync (ts)

ZodCatch.safeParseAsync (ts)

ZodCatch.spa (ts)

ZodCatch.refine (ts)

ZodCatch.superRefine (ts)

ZodCatch.optional (ts)

ZodCatch.nullable (ts)

ZodCatch.nullish (ts)

ZodCatch.array (ts)

ZodCatch.or (ts)

ZodCatch.and (ts)

ZodCatch.transform (ts)

ZodCatch.default (ts)

ZodCatch.brand (ts)

ZodCatch.catch (ts)

ZodCatch.describe (ts)

ZodCatch.pipe (ts)

ZodCatch.readonly (ts)

ZodNaN.~standard (ts)

ZodNaN.parse (ts)

ZodNaN.safeParse (ts)

ZodNaN.parseAsync (ts)

ZodNaN.safeParseAsync (ts)

ZodNaN.spa (ts)

ZodNaN.refine (ts)

ZodNaN.superRefine (ts)

ZodNaN.array (ts)

ZodNaN.or (ts)

ZodNaN.and (ts)

ZodNaN.transform (ts)

ZodNaN.brand (ts)

ZodNaN.catch (ts)

ZodNaN.pipe (ts)

ZodReadonly.unwrap (ts)

ZodReadonly.~standard (ts)

ZodReadonly.parse (ts)

ZodReadonly.safeParse (ts)

ZodReadonly.parseAsync (ts)

ZodReadonly.safeParseAsync (ts)

ZodReadonly.spa (ts)

ZodReadonly.refine (ts)

ZodReadonly.superRefine (ts)

ZodReadonly.optional (ts)

ZodReadonly.nullable (ts)

ZodReadonly.nullish (ts)

ZodReadonly.array (ts)

ZodReadonly.or (ts)

ZodReadonly.and (ts)

ZodReadonly.transform (ts)

ZodReadonly.default (ts)

ZodReadonly.brand (ts)

ZodReadonly.catch (ts)

ZodReadonly.describe (ts)

ZodReadonly.pipe (ts)

ZodReadonly.readonly (ts)

coerce.string (ts)

coerce.number (ts)

coerce.boolean (ts)

coerce.bigint (ts)

coerce.date (ts)

inferFlattenedErrors.fieldErrors (ts)

ZodError.issues (ts)

ZodError.format (ts)

ZodError.addIssue (ts)

ZodError.flatten (ts)

ZodTypeAny.~standard.validate (ts)

ZodTypeAny.~standard.types (ts)

ZodType.~standard.validate (ts)

ZodType.~standard.types (ts)

ZodString.~standard.validate (ts)

ZodNumber.~standard.validate (ts)

ZodBigInt.~standard.validate (ts)

ZodBoolean.~standard.validate (ts)

ZodDate.~standard.validate (ts)

ZodSymbol.~standard.validate (ts)

ZodUndefined.~standard.validate (ts)

ZodNull.~standard.validate (ts)

ZodUnknown.~standard.validate (ts)

ZodNever.~standard.validate (ts)

ZodVoid.~standard.validate (ts)

ZodArray.~standard.validate (ts)

ZodArray.~standard.types (ts)

ZodObject.~standard.validate (ts)

ZodObject.~standard.types (ts)

ZodUnion.~standard.validate (ts)

ZodUnion.~standard.types (ts)

ZodDiscriminatedUnion.~standard.validate (ts)

ZodDiscriminatedUnion.~standard.types (ts)

ZodIntersection.~standard.validate (ts)

ZodIntersection.~standard.types (ts)

ZodTuple.~standard.validate (ts)

ZodTuple.~standard.types (ts)

ZodRecord.~standard.validate (ts)

ZodRecord.~standard.types (ts)

ZodMap.~standard.validate (ts)

ZodMap.~standard.types (ts)

ZodSet.~standard.validate (ts)

ZodSet.~standard.types (ts)

ZodFunction.~standard.validate (ts)

ZodFunction.~standard.types (ts)

ZodLazy.~standard.validate (ts)

ZodLazy.~standard.types (ts)

ZodLiteral.~standard.validate (ts)

ZodLiteral.~standard.types (ts)

ZodEnum.~standard.validate (ts)

ZodEnum.~standard.types (ts)

ZodPromise.~standard.validate (ts)

ZodPromise.~standard.types (ts)

ZodOptional.~standard.validate (ts)

ZodOptional.~standard.types (ts)

ZodNullable.~standard.validate (ts)

ZodNullable.~standard.types (ts)

ZodDefault.~standard.validate (ts)

ZodDefault.~standard.types (ts)

ZodCatch.~standard.validate (ts)

ZodCatch.~standard.types (ts)

ZodReadonly.~standard.validate (ts)

ZodReadonly.~standard.types (ts)

ZodTypeAny.~standard.types.input (ts)

ZodTypeAny.~standard.types.output (ts)

ZodType.~standard.types.input (ts)

ZodType.~standard.types.output (ts)

ZodArray.~standard.types.input (ts)

ZodArray.~standard.types.output (ts)

ZodObject.~standard.types.input (ts)

ZodObject.~standard.types.output (ts)

ZodUnion.~standard.types.input (ts)

ZodUnion.~standard.types.output (ts)

ZodDiscriminatedUnion.~standard.types.input (ts)

ZodDiscriminatedUnion.~standard.types.output (ts)

ZodIntersection.~standard.types.input (ts)

ZodIntersection.~standard.types.output (ts)

ZodTuple.~standard.types.input (ts)

ZodTuple.~standard.types.output (ts)

ZodRecord.~standard.types.input (ts)

ZodRecord.~standard.types.output (ts)

ZodMap.~standard.types.input (ts)

ZodMap.~standard.types.output (ts)

ZodSet.~standard.types.input (ts)

ZodSet.~standard.types.output (ts)

ZodFunction.~standard.types.input (ts)

ZodFunction.~standard.types.output (ts)

ZodLiteral.~standard.types.input (ts)

ZodLiteral.~standard.types.output (ts)

ZodEnum.~standard.types.input (ts)

ZodEnum.~standard.types.output (ts)

ZodPromise.~standard.types.input (ts)

ZodPromise.~standard.types.output (ts)

ZodOptional.~standard.types.input (ts)

ZodOptional.~standard.types.output (ts)

ZodNullable.~standard.types.input (ts)

ZodNullable.~standard.types.output (ts)

ZodDefault.~standard.types.input (ts)

ZodDefault.~standard.types.output (ts)

ZodCatch.~standard.types.input (ts)

ZodCatch.~standard.types.output (ts)

ZodReadonly.~standard.types.input (ts)

ZodReadonly.~standard.types.output (ts)

v4:input (ts)

v4:registry (ts)

v4:function (ts)

v4:prettifyError (ts)

v4:toJSONSchema (ts)

v4:string (ts)

v4:email (ts)

v4:guid (ts)

v4:uuid (ts)

v4:uuidv4 (ts)

v4:uuidv6 (ts)

v4:uuidv7 (ts)

v4:url (ts)

v4:emoji (ts)

v4:nanoid (ts)

v4:cuid (ts)

v4:cuid2 (ts)

v4:ulid (ts)

v4:xid (ts)

v4:ksuid (ts)

v4:ipv4 (ts)

v4:ipv6 (ts)

v4:cidrv4 (ts)

v4:cidrv6 (ts)

v4:base64 (ts)

v4:base64url (ts)

v4:e164 (ts)

v4:jwt (ts)

v4:stringFormat (ts)

v4:number (ts)

v4:int (ts)

v4:float32 (ts)

v4:float64 (ts)

v4:int32 (ts)

v4:uint32 (ts)

v4:int64 (ts)

v4:uint64 (ts)

v4:keyof (ts)

v4:strictObject (ts)

v4:looseObject (ts)

v4:union (ts)

v4:discriminatedUnion (ts)

v4:record (ts)

v4:partialRecord (ts)

v4:transform (ts)

v4:templateLiteral (ts)

v4:custom (ts)

v4:refine (ts)

v4:superRefine (ts)

v4:json (ts)

v4:preprocess (ts)

v4:RefinementCtx (ts)

v4:ZodNanoID (ts)

v4:ZodNumberFormat (ts)

v4:ZodBigIntFormat (ts)

v4:ZodDiscriminatedUnion (ts)

v4:instanceof (ts)

v4:stringbool (ts)

v4:lt (ts)

v4:lte (ts)

v4:gt (ts)

v4:gte (ts)

v4:positive (ts)

v4:negative (ts)

v4:nonpositive (ts)

v4:nonnegative (ts)

v4:multipleOf (ts)

v4:maxSize (ts)

v4:minSize (ts)

v4:size (ts)

v4:maxLength (ts)

v4:minLength (ts)

v4:length (ts)

v4:regex (ts)

v4:lowercase (ts)

v4:uppercase (ts)

v4:includes (ts)

v4:startsWith (ts)

v4:endsWith (ts)

v4:property (ts)

v4:mime (ts)

v4:ZodFlattenedError (ts)

v4:ZodFormattedError (ts)

v4:ZodErrorMap (ts)

v4-mini:string (ts)

v4-mini:email (ts)

v4-mini:guid (ts)

v4-mini:uuid (ts)

v4-mini:uuidv4 (ts)

v4-mini:uuidv6 (ts)

v4-mini:uuidv7 (ts)

v4-mini:url (ts)

v4-mini:emoji (ts)

v4-mini:nanoid (ts)

v4-mini:cuid (ts)

v4-mini:cuid2 (ts)

v4-mini:ulid (ts)

v4-mini:xid (ts)

v4-mini:ksuid (ts)

v4-mini:ipv4 (ts)

v4-mini:ipv6 (ts)

v4-mini:cidrv4 (ts)

v4-mini:cidrv6 (ts)

v4-mini:base64 (ts)

v4-mini:base64url (ts)

v4-mini:e164 (ts)

v4-mini:jwt (ts)

v4-mini:stringFormat (ts)

v4-mini:number (ts)

v4-mini:int (ts)

v4-mini:float32 (ts)

v4-mini:float64 (ts)

v4-mini:int32 (ts)

v4-mini:uint32 (ts)

v4-mini:int64 (ts)

v4-mini:uint64 (ts)

v4-mini:keyof (ts)

v4-mini:object (ts)

v4-mini:strictObject (ts)

v4-mini:looseObject (ts)

v4-mini:extend (ts)

v4-mini:merge (ts)

v4-mini:pick (ts)

v4-mini:omit (ts)

v4-mini:partial (ts)

v4-mini:required (ts)

v4-mini:union (ts)

v4-mini:discriminatedUnion (ts)

v4-mini:record (ts)

v4-mini:partialRecord (ts)

v4-mini:prefault (ts)

v4-mini:templateLiteral (ts)

v4-mini:check (ts)

v4-mini:custom (ts)

v4-mini:refine (ts)

v4-mini:ZodMiniNanoID (ts)

v4-mini:ZodMiniNumberFormat (ts)

v4-mini:ZodMiniBigIntFormat (ts)

v4-mini:instanceof (ts)

v4-mini:stringbool (ts)

v4/core:$constructor (ts)

v4/core:$ZodBranded (ts)

v4/core:toDotPath (ts)

v4/core:$ZodNanoID (ts)

v4/core:$ZodNumberFormatDef (ts)

v4/core:$ZodNumberFormatInternals (ts)

v4/core:$ZodNumberFormat (ts)

v4/core:$ZodBigIntFormatDef (ts)

v4/core:$ZodBigIntFormatInternals (ts)

v4/core:$ZodBigIntFormat (ts)

v4/core:$ZodDiscriminatedUnionDef (ts)

v4/core:$ZodDiscriminatedUnionInternals (ts)

v4/core:$ZodCheckNumberFormatDef (ts)

v4/core:$ZodCheckNumberFormatInternals (ts)

v4/core:$ZodCheckNumberFormat (ts)

v4/core:$ZodCheckBigIntFormatDef (ts)

v4/core:$ZodCheckBigIntFormatInternals (ts)

v4/core:$ZodCheckBigIntFormat (ts)

v4/core:version (ts)

v4/core:$ZodFunction (ts)

v4/core:_string (ts)

v4/core:_coercedString (ts)

v4/core:_email (ts)

v4/core:_guid (ts)

v4/core:_uuid (ts)

v4/core:_uuidv4 (ts)

v4/core:_uuidv6 (ts)

v4/core:_uuidv7 (ts)

v4/core:_url (ts)

v4/core:_emoji (ts)

v4/core:_nanoid (ts)

v4/core:_cuid (ts)

v4/core:_cuid2 (ts)

v4/core:_ulid (ts)

v4/core:_xid (ts)

v4/core:_ksuid (ts)

v4/core:_ipv4 (ts)

v4/core:_ipv6 (ts)

v4/core:_cidrv4 (ts)

v4/core:_cidrv6 (ts)

v4/core:_base64 (ts)

v4/core:_base64url (ts)

v4/core:_e164 (ts)

v4/core:_jwt (ts)

v4/core:_isoDateTime (ts)

v4/core:_isoDate (ts)

v4/core:_isoTime (ts)

v4/core:_isoDuration (ts)

v4/core:_number (ts)

v4/core:_coercedNumber (ts)

v4/core:_int (ts)

v4/core:_float32 (ts)

v4/core:_float64 (ts)

v4/core:_int32 (ts)

v4/core:_uint32 (ts)

v4/core:_union (ts)

v4/core:_discriminatedUnion (ts)

v4/core:_record (ts)

v4/core:_templateLiteral (ts)

v4/core:_custom (ts)

v4/core:_refine (ts)

v4/core:_stringbool (ts)

v4/core:_stringFormat (ts)

v4/core:$ZodStringParams (ts)

v4/core:$ZodStringFormatParams (ts)

v4/core:$ZodEmailParams (ts)

v4/core:$ZodCheckEmailParams (ts)

v4/core:$ZodGUIDParams (ts)

v4/core:$ZodCheckGUIDParams (ts)

v4/core:$ZodUUIDParams (ts)

v4/core:$ZodCheckUUIDParams (ts)

v4/core:$ZodUUIDv4Params (ts)

v4/core:$ZodCheckUUIDv4Params (ts)

v4/core:$ZodUUIDv6Params (ts)

v4/core:$ZodCheckUUIDv6Params (ts)

v4/core:$ZodUUIDv7Params (ts)

v4/core:$ZodCheckUUIDv7Params (ts)

v4/core:$ZodURLParams (ts)

v4/core:$ZodCheckURLParams (ts)

v4/core:$ZodEmojiParams (ts)

v4/core:$ZodCheckEmojiParams (ts)

v4/core:$ZodNanoIDParams (ts)

v4/core:$ZodCheckNanoIDParams (ts)

v4/core:$ZodCUIDParams (ts)

v4/core:$ZodCheckCUIDParams (ts)

v4/core:$ZodCUID2Params (ts)

v4/core:$ZodCheckCUID2Params (ts)

v4/core:$ZodULIDParams (ts)

v4/core:$ZodCheckULIDParams (ts)

v4/core:$ZodXIDParams (ts)

v4/core:$ZodCheckXIDParams (ts)

v4/core:$ZodKSUIDParams (ts)

v4/core:$ZodCheckKSUIDParams (ts)

v4/core:$ZodIPv4Params (ts)

v4/core:$ZodCheckIPv4Params (ts)

v4/core:$ZodIPv6Params (ts)

v4/core:$ZodCheckIPv6Params (ts)

v4/core:$ZodCIDRv4Params (ts)

v4/core:$ZodCheckCIDRv4Params (ts)

v4/core:$ZodCIDRv6Params (ts)

v4/core:$ZodCheckCIDRv6Params (ts)

v4/core:$ZodBase64Params (ts)

v4/core:$ZodCheckBase64Params (ts)

v4/core:$ZodBase64URLParams (ts)

v4/core:$ZodCheckBase64URLParams (ts)

v4/core:$ZodE164Params (ts)

v4/core:$ZodCheckE164Params (ts)

v4/core:$ZodJWTParams (ts)

v4/core:$ZodCheckJWTParams (ts)

v4/core:$ZodISODateTimeParams (ts)

v4/core:$ZodCheckISODateTimeParams (ts)

v4/core:$ZodISODateParams (ts)

v4/core:$ZodCheckISODateParams (ts)

v4/core:$ZodISOTimeParams (ts)

v4/core:$ZodCheckISOTimeParams (ts)

v4/core:$ZodISODurationParams (ts)

v4/core:$ZodCheckISODurationParams (ts)

v4/core:$ZodNumberParams (ts)

v4/core:$ZodCheckNumberFormatParams (ts)

v4/core:$ZodCheckBigIntFormatParams (ts)

v4/core:$ZodCheckLessThanParams (ts)

v4/core:$ZodCheckGreaterThanParams (ts)

v4/core:$ZodCheckMultipleOfParams (ts)

v4/core:$ZodCheckMaxSizeParams (ts)

v4/core:$ZodCheckMinSizeParams (ts)

v4/core:$ZodCheckSizeEqualsParams (ts)

v4/core:$ZodCheckMaxLengthParams (ts)

v4/core:$ZodCheckMinLengthParams (ts)

v4/core:$ZodCheckLengthEqualsParams (ts)

v4/core:$ZodCheckRegexParams (ts)

v4/core:$ZodCheckLowerCaseParams (ts)

v4/core:$ZodCheckUpperCaseParams (ts)

v4/core:$ZodCheckIncludesParams (ts)

v4/core:$ZodCheckStartsWithParams (ts)

v4/core:$ZodCheckEndsWithParams (ts)

v4/core:$ZodCheckPropertyParams (ts)

v4/core:$ZodCheckMimeTypeParams (ts)

v4/core:$ZodUnionParams (ts)

v4/core:$ZodTypeDiscriminableInternals (ts)

v4/core:$ZodTypeDiscriminable (ts)

v4/core:$ZodDiscriminatedUnionParams (ts)

v4/core:$ZodRecordParams (ts)

v4/core:$ZodPipeParams (ts)

v4/core:$ZodTemplateLiteralParams (ts)

v4/core:$ZodCustomParams (ts)

v4/core:_$ZodTypeInternals.optin (ts)

v4/core:_$ZodType.~standard.validate (ts)