Zod

https://zod.dev/
Admin
Zod is a TypeScript-first schema validation library that enables you to define and validate data...
Tokens:140,987
Snippets:1,160
Trust Score:9.9
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install @zod/mini standalone package

Source: https://zod.dev/packages/mini

Install the standalone @zod/mini package along with its peer dependency zod.

```bash
npm install zod @zod/mini
```

--------------------------------

### Install Zod for Zod Mini

Source: https://zod.dev/packages/mini

Install the Zod package (version 4 or later) to use Zod Mini.

```bash
npm install zod@^4.0.0
```

--------------------------------

### Install Zod with npm

Source: https://zod.dev

Installs the Zod library via npm. Zod is also available as @zod/zod on jsr.io.

```bash
npm install zod
```

--------------------------------

### Zod codec examples: define, use, invert, and compose codecs

Source: https://zod.dev/codecs

These examples illustrate the Zod codec API: creating a codec with z.codec, using decode/encode, inverting with z.invertCodec, nesting in objects, and using async/safe variants. Each block is standalone but demonstrates core codec concepts.

```typescript
const schema = z.string();
 
type Input = z.input<typeof schema>;    // string
type Output = z.output<typeof schema>;  // string
 
schema.parse("asdf");   // => "asdf"
schema.decode("asdf");  // => "asdf"
schema.encode("asdf");  // => "asdf"
```

```typescript
const stringToDate = z.codec(
  z.iso.datetime(),  // input schema: ISO date string
  z.date(),          // output schema: Date object
  {
    decode: (isoString) => new Date(isoString), // ISO string → Date
    encode: (date) => date.toISOString(),       // Date → ISO string
  }
);
```

```typescript
stringToDate.decode("2024-01-15T10:30:00.000Z")
// => Date
 
stringToDate.encode(new Date("2024-01-15T10:30:00.000Z"))
// => string
```

```typescript
const dateToString = z.invertCodec(stringToDate);
 
dateToString.decode(new Date("2024-01-15T10:30:00.000Z"));
// => string
 
dateToString.encode("2024-01-15T10:30:00.000Z");
// => Date
```

```typescript
const payloadSchema = z.object({ 
  startDate: stringToDate 
});
 
payloadSchema.decode({
  startDate: "2024-01-15T10:30:00.000Z"
}); // => { startDate: Date }
```

```typescript
stringToDate.parse(12345); 
// no complaints from TypeScript (fails at runtime)
 
stringToDate.decode(12345); 
// ❌ TypeScript error: Argument of type 'number' is not assignable to parameter of type 'string'.
 
stringToDate.encode(12345); 
// ❌ TypeScript error: Argument of type 'number' is not assignable to parameter of type 'Date'.
```

```typescript
const asyncCodec = z.codec(z.string(), z.number(), {
  decode: async (str) => Number(str),
  encode: async (num) => num.toString(),
});
```

```typescript
stringToDate.decode("2024-01-15T10:30:00.000Z"); 
// => Date
 
stringToDate.decodeAsync("2024-01-15T10:30:00.000Z"); 
// => Promise<Date>
 
stringToDate.safeDecode("2024-01-15T10:30:00.000Z"); 
// => { success: true, data: Date } | { success: false, error: ZodError }
 
stringToDate.safeDecodeAsync("2024-01-15T10:30:00.000Z"); 
// => Promise<{ success: true, data: Date } | { success: false, error: ZodError }>
```

--------------------------------

### z.optional() / .optional() / .exactOptional()

Source: https://zod.dev/api

Documentation for the z.optional() schema constructor and the .optional() / .exactOptional() methods, including usage examples.

```APIDOC
## z.optional(schema)

### Description
Creates a schema that allows `undefined` inputs. It wraps the original schema in a `ZodOptional` instance. Use `.optional()` on any schema as a shorthand. Use `.exactOptional()` to allow an absent key without allowing an explicit `undefined` (per TypeScript's `exactOptionalPropertyTypes`).

### Method
N/A (Zod schema constructor)

### Endpoint
N/A (Zod schema constructor)

### Parameters
- **schema** (ZodSchema) - Required - The schema to make optional.

### Request Example
```js
z.optional(z.literal("yoda")); // or z.literal("yoda").optional()
```

### Response
#### Success Response
- **ZodOptional** - A schema that accepts `undefined` in addition to the original schema's valid values.

#### Response Example
```js
optionalYoda.unwrap(); // ZodLiteral<"yoda">
```

### Error Handling
- **ZodError** - Thrown when input is not `undefined` and does not match the inner schema.
```

--------------------------------

### Install Zod 4.5.0 or later

Source: https://zod.dev/blog/introducing-z-compile

Install the required version of Zod to use the compiler. The compiler is available starting from version 4.5.0.

```bash
npm install zod@^4.5.0
```

--------------------------------

### Install a custom parser with z.withParser()

Source: https://zod.dev/blog/zod-4-6

Use z.withParser() to install a parser generated elsewhere (e.g., at build time) under the same contract as z.compile(). The supplied parser must return what the schema would return; this example rebuilds the object because z.object() strips unknown keys. Returning z.INVALID hands the input to the runtime, which remains the only source of ZodErrors.

```typescript
const Player = z.object({ username: z.string(), xp: z.number() });
 
// isPlayer is a type guard your build step generated
const Fast = z.withParser(Player, (input) =>
  isPlayer(input) ? { username: input.username, xp: input.xp } : z.INVALID
);
```

--------------------------------

### Initial Recipe schema for pick/omit/partial/required

Source: https://zod.dev/api

Defines the initial Recipe schema used in the .pick(), .omit(), .partial(), .exactPartial(), and .required() examples.

```typescript
const Recipe = z.object({
  title: z.string(),
  description: z.string().optional(),
  ingredients: z.array(z.string()),
});
// { title: string; description?: string | undefined; ingredients: string[] }
```

--------------------------------

### Zod Mini functional API example

Source: https://zod.dev/packages/mini

Shows the functional, tree-shakable API of Zod Mini compared to regular Zod's method chaining.

```javascript
// regular Zod
const mySchema = z.string().optional().nullable();
 
// Zod Mini
const mySchema = z.nullable(z.optional(z.string()));
```

--------------------------------

### z.stringbool()

Source: https://zod.dev/api

Documentation for the z.stringbool() schema constructor, including its default behavior, customization options, and example usage.

```APIDOC
## z.stringbool()

### Description
Creates a schema that parses certain string "boolish" values to a plain boolean. By default, it is case-insensitive and accepts the truthy values `"true"`, `"1"`, `"yes"`, `"on"`, `"y"`, `"enabled"` and the falsy values `"false"`, `"0"`, `"no"`, `"off"`, `"n"`, `"disabled"`. Any other input results in a `ZodError` with code `"invalid_value"`.

### Method
N/A (Zod schema constructor)

### Endpoint
N/A (Zod schema constructor)

### Parameters
#### Options (optional)
- **truthy** (string[]) - Optional - Custom list of truthy string values. Defaults to `["true", "1", "yes", "on", "y", "enabled"]`.
- **falsy** (string[]) - Optional - Custom list of falsy string values. Defaults to `["false", "0", "no", "off", "n", "disabled"]`.
- **case** (string) - Optional - Set to `"sensitive"` to make the comparison case-sensitive. Default is case-insensitive.

### Request Example
```js
const strbool = z.stringbool();
```

### Response
#### Success Response
- **true** (boolean) - Parsed result for truthy inputs.
- **false** (boolean) - Parsed result for falsy inputs.

#### Response Example
```js
strbool.parse("true") // => true
strbool.parse("false") // => false
```

### Error Handling
- **ZodError** - Thrown when input is not in the truthy or falsy lists. Error code: `"invalid_value"`.
```

--------------------------------

### Clone and switch to Zod v4 branch

Source: https://zod.dev/v4

Clone the Zod repository, switch to the v4 branch, and install dependencies using nub. This is the first step to run the benchmarks locally.

```bash
git clone git@github.com:colinhacks/zod.git
cd zod
git switch v4
nub install
```

--------------------------------

### Simple Zod Mini parse example

Source: https://zod.dev/packages/mini

A simple script used to illustrate bundle size reduction when using Zod Mini.

```javascript
z.boolean().parse(true)
```

--------------------------------

### Install Zod 4.6

Source: https://zod.dev/blog/zod-4-6

Install the latest version of Zod, which includes the new features described in this release.

```bash
npm install zod@latest
```

--------------------------------

### URL normalization example

Source: https://zod.dev/api

Shows the normalized URL returned by new URL(). The normalize flag overwrites the input value with this normalized URL.

```javascript
new URL("HTTP://ExAmPle.com:80/./a/../b?X=1#f oo").href
// => "http://example.com/b?X=1#f%20oo"
```

--------------------------------

### Output of z.prettifyError

Source: https://zod.dev/v4

Example output of z.prettifyError for the preceding ZodError. Shows the formatted multi-line string with error messages and paths.

```text
✖ Unrecognized key: "extraField"
✖ Invalid input: expected string, received number
  → at username
✖ Invalid input: expected number, received string
  → at favoriteNumbers[1]
```

--------------------------------

### Zod Mini object schema example

Source: https://zod.dev/packages/mini

A more complex schema with object types, used to show bundle size differences.

```javascript
const schema = z.object({ a: z.string(), b: z.number(), c: z.boolean() });
 
schema.parse({
  a: "asdf",
  b: 123,
  c: true,
});
```

--------------------------------

### Zod Object Extension Example

Source: https://zod.dev/v4

A basic example of defining a Zod object and extending it, used to benchmark compiler performance.

```typescript
import * as z from "zod";
 
export const A = z.object({
  a: z.string(),
  b: z.string(),
  c: z.string(),
  d: z.string(),
  e: z.string(),
});
 
export const B = A.extend({
  f: z.string(),
  g: z.string(),
  h: z.string(),
});
```

--------------------------------

### Define a simple object schema with z.object

Source: https://zod.dev/basics

Creates a Player schema with username as a string and xp as a number. This is the foundational schema used throughout the guide.

```typescript
import * as z from "zod"; 
 
const Player = z.object({ 
  username: z.string(),
  xp: z.number()
});
```

--------------------------------

### Add and retrieve schema metadata with registry.add() and registry.get()

Source: https://zod.dev/v4

Adds a schema to a registry with metadata and retrieves it. The `get` method returns the metadata associated with the schema.

```typescript
const emailSchema = z.string().email();
 
myRegistry.add(emailSchema, { title: "Email address", description: "..." });
myRegistry.get(emailSchema);
// => { title: "Email address", ... }
```

--------------------------------

### Examples of z.templateLiteral with different schemas

Source: https://zod.dev/api

Shows various combinations of string literals and schemas passed to z.templateLiteral. The comments display the resulting inferred types.

```typescript
z.templateLiteral([ "hi there" ]);
// `hi there`
 
z.templateLiteral([ "email: ", z.string() ]);
// `email: ${string}`
 
z.templateLiteral([ "high", z.literal(5) ]);
// `high5`
 
z.templateLiteral([ z.nullable(z.literal("grassy")) ]);
// `grassy` | `null`
 
z.templateLiteral([ z.number(), z.enum(["px", "em", "rem"]) ]);
// `${number}px` | `${number}em` | `${number}rem`
```

--------------------------------

### Create a string-keyed record with z.record

Source: https://zod.dev/api

Creates a record schema with string keys and string values. The inferred type is `Record<string, string>`. The example parses an object with two UUID-like string values.

```typescript
const IdCache = z.record(z.string(), z.string());
type IdCache = z.infer<typeof IdCache>; // Record<string, string>
 
IdCache.parse({
  carlotta: "77d2586b-9e8e-4ecf-8b21-ea7e0530eadd",
  jimmie: "77d2586b-9e8e-4ecf-8b21-ea7e0530eadd",
});
```

--------------------------------

### Reference inferred types with z.$output in custom registry

Source: https://zod.dev/metadata

Shows how to reference the inferred output type of a schema in the metadata type using `z.$output`. The `examples` field is typed as an array of the schema's output type, and `z.$input` can be used similarly for the input type.

```typescript
import * as z from "zod";
 
type MyMeta = { examples: z.$output[] };
const myRegistry = z.registry<MyMeta>();
 
myRegistry.add(z.string(), { examples: ["hello", "world"] });
myRegistry.add(z.number(), { examples: [1, 2, 3] });
```

--------------------------------

### Register, lookup, and remove schemas in a registry

Source: https://zod.dev/metadata

Shows the core registry operations: add, has, get, remove, and clear. The get method returns the metadata object associated with the schema.

```typescript
const mySchema = z.string();
 
myRegistry.add(mySchema, { description: "A cool schema!"});
myRegistry.has(mySchema); // => true
myRegistry.get(mySchema); // => { description: "A cool schema!" }
myRegistry.remove(mySchema);
myRegistry.clear(); // wipe registry
```

--------------------------------

### Configure preload in nub.jsonc

Source: https://zod.dev/blog/introducing-z-compile

Set the "preload" array in nub.jsonc (or bunfig.toml) to include "zod/compile" to enable compile-by-default.

```json
{
  "preload": ["zod/compile"]
}
```

--------------------------------

### jsonCodec usage example

Source: https://zod.dev/codecs

Usage example of `jsonCodec` with a specific schema. Decoding a valid JSON string returns the parsed object, encoding an object returns a JSON string, and decoding invalid JSON throws a `ZodError` with an `invalid_format` issue.

```typescript
const jsonToObject = jsonCodec(z.object({ name: z.string(), age: z.number() }));
 
jsonToObject.decode('{"name":"Alice","age":30}');  
// => { name: "Alice", age: 30 }
 
jsonToObject.encode({ name: "Bob", age: 25 });     
// => '{"name":"Bob","age":25}'
 
jsonToObject.decode('~~invalid~~'); 
// ZodError: [
//   {
//     "code": "invalid_format",
//     "format": "json",
//     "path": [],
//     "message": "Unexpected token '~', \"~~invalid~~\" is not valid JSON"
//   }
// ]
```

--------------------------------

### GUID validation

Source: https://zod.dev/api

Validates any UUID-like identifier that does not enforce the RFC 9562/4122 constraint.

```typescript
z.guid();
```

--------------------------------

### .apply

Source: https://zod.dev/api

Documentation for the .apply method, which allows incorporating external functions into Zod's method chain.

```APIDOC
## .apply

### Description
Incorporates external functions into Zod's method chain. The function receives the schema and any additional arguments, and must return a schema.

### Method
.apply

### Parameters
- **function** (function) - Required - The function to apply to the schema.
- **...args** (any) - Optional - Additional arguments passed through to the function.

### Request Example
```ts
function setCommonNumberChecks<T extends z.ZodNumber>(schema: T) {
  return schema
    .min(0)
    .max(100);
}

const schema = z.number()
  .apply(setCommonNumberChecks)
  .nullable();

schema.parse(0);  // => 0
schema.parse(-1); // ❌ throws
schema.parse(101); // ❌ throws
schema.parse(null); // => null
```

### Response
#### Success Response
- **parsed value** (type) - The parsed value if validation passes.

#### Error Response
- **ZodError** - Thrown if validation fails.

### Notes
- Additional arguments are passed through to the function.
```

--------------------------------

### Import Zod Mini from zod/mini

Source: https://zod.dev/packages/mini

Import the Zod Mini API from the 'zod/mini' entry point.

```javascript
import * as z from "zod/mini";
```

--------------------------------

### Upgrade Zod to latest version

Source: https://zod.dev/blog/reducing-memory-footprint

Upgrades to the latest Zod version to get the memory footprint improvements described in the post.

```shell
npm upgrade zod@latest
```

--------------------------------

### Import zod/compile in entrypoint

Source: https://zod.dev/blog/introducing-z-compile

Add this import to the entry point of your application (or before any schemas are defined) to enable compile-by-default for all schemas.

```javascript
// in your entrypoint (or before any schemas are defined)
import "zod/compile";
```

--------------------------------

### Create a custom registry with z.registry

Source: https://zod.dev/metadata

Creates a custom registry with a metadata type of `{ description: string }`. This is the basic pattern for defining a custom registry.

```typescript
import * as z from "zod";
 
const myRegistry = z.registry<{ description: string };>();
```

--------------------------------

### Use z.tuple() with rest argument

Source: https://zod.dev/v4/changelog

Shows the recommended way to get a tuple with a rest element, matching the old nonempty() behavior.

```typescript
z.tuple([z.string()], z.string());
// => [string, ...string[]]
```

--------------------------------

### Zod Prefaults

Source: https://zod.dev/api

Demonstrates how to set a pre-parse default value on a Zod schema using the `.prefault()` method.

```APIDOC
## [Zod] z.string().prefault()

### Description
Sets a pre-parse default value. If the input is `undefined`, the prefault value is parsed instead of being returned directly.

### Method
`prefault`

### Endpoint
`z.string().prefault(value)`

### Parameters
- **value** (any) - Required - The prefault value to parse when input is `undefined`.

### Request Example
```js
const schema = z.string().transform(val => val.length).prefault("tuna");
```

### Response
#### Success Response
- **output** (any) - The result of parsing the prefault value.

#### Response Example
```js
schema.parse(undefined); // => 4
```
```

--------------------------------

### Run Node.js with zod/compile CLI flag

Source: https://zod.dev/blog/zod-4-5

Use the Node.js CLI flag to guarantee auto-compilation runs before any module defines a schema.

```bash
node --import zod/compile app.js
```

--------------------------------

### Import Zod Mini from @zod/mini

Source: https://zod.dev/packages/mini

Import the Zod Mini API from the standalone @zod/mini package.

```javascript
import * as z from "@zod/mini";
```

--------------------------------

### .describe()

Source: https://zod.dev/metadata

Shorthand for registering a schema in the global registry with just a description field.

```APIDOC
## .describe()

### Description
Shorthand for registering a schema in the global registry with just a `description` field. The `.meta()` method is the recommended approach.

### Method
describe

### Endpoint
.describe()

### Parameters
#### Request Body
- **description** (string) - Required - The description to register for the schema.

### Request Example
```typescript
const emailSchema = z.email();
emailSchema.describe("An email address");
```

### Response
#### Success Response
Returns the schema instance with the description registered.

### Notes
- Equivalent to calling `.meta({ description: "An email address" })`.
```

--------------------------------

### Register metadata with z.globalRegistry

Source: https://zod.dev/metadata

Registers metadata for a schema in z.globalRegistry using the register method. The metadata object can include custom fields like examples.

```typescript
import * as z from "zod";
 
const emailSchema = z.email().register(z.globalRegistry, { 
  id: "email_address",
  title: "Email address",
  description: "Your email address",
  examples: ["first.last@example.com"]
});
```

--------------------------------

### Use .describe() for Zod 3 compatibility

Source: https://zod.dev/v4

Shows that `.describe()` is still available for Zod 3 compatibility, but `.meta()` is preferred. The two are equivalent when only a description is provided.

```typescript
z.string().describe("An email address");
 
// equivalent to
z.string().meta({ description: "An email address" });
```

--------------------------------

### .pick()

Source: https://zod.dev/api

Documentation for the `.pick()` method on Zod object schemas.

```APIDOC
## `.pick()`

### Description
Creates a new object schema by picking only the specified keys from the original schema.

### Method
`pick`

### Parameters
- **keys** (object) - Required - An object with the keys to pick, set to `true`.

### Example
```ts
const Recipe = z.object({
  title: z.string(),
  description: z.string().optional(),
  ingredients: z.array(z.string()),
});
const JustTheTitle = Recipe.pick({ title: true });
```
```

--------------------------------

### .partial()

Source: https://zod.dev/api

Documentation for the `.partial()` method on Zod object schemas.

```APIDOC
## `.partial()`

### Description
Creates a new object schema where some or all properties are made optional.

### Method
`partial`

### Parameters
- **keys** (object) - Optional - An object with the keys to make optional, set to `true`. If omitted, all properties are made optional.

### Example
```ts
const Recipe = z.object({
  title: z.string(),
  description: z.string().optional(),
  ingredients: z.array(z.string()),
});
const PartialRecipe = Recipe.partial();
const RecipeOptionalIngredients = Recipe.partial({ ingredients: true });
```
```

--------------------------------

### Use compiled schema with .parse()

Source: https://zod.dev/blog/introducing-z-compile

Shows how to use a compiled schema exactly like the original. The compiled schema parses inputs about 9x faster than the uncompiled one.

```typescript
Player.parse({ ... });
CompiledPlayer.parse({ ... }); // ~9x faster
```

--------------------------------

### Lazily load a locale with dynamic imports

Source: https://zod.dev/error-customization

Uses a dynamic import to load a locale by name and applies it with z.config(locale()). The example loads the French locale.

```TypeScript
import * as z from "zod";
 
async function loadLocale(locale: string) {
  const { default: locale } = await import(`zod/v4/locales/${locale}.js`);
  z.config(locale());
};
 
await loadLocale("fr");
```

--------------------------------

### Define a template literal schema with z.templateLiteral

Source: https://zod.dev/api

Defines a template literal schema that matches a string starting with 'hello, ' and ending with '!'. The comment shows the inferred type.

```typescript
const schema = z.templateLiteral([ "hello, ", z.string(), "!" ]);
// `hello, ${string}!`
```

--------------------------------

### Zod Primitive Type Validators

Source: https://zod.dev/api

This snippet documents the Zod primitive type validators for integers, bigints, booleans, dates, and enums, including their methods and usage examples.

```APIDOC
## z.int()

### Description
Validates integers, restricting to the safe integer range.

### Method
z.int()

### Parameters
None.

### Returns
A Zod schema for integers.

### Example
```js
z.int();
```
```

```APIDOC
## z.int32()

### Description
Validates integers, restricting to the int32 range.

### Method
z.int32()

### Parameters
None.

### Returns
A Zod schema for int32 integers.

### Example
```js
z.int32();
```
```

```APIDOC
## z.bigint()

### Description
Validates BigInt values.

### Method
z.bigint()

### Parameters
None.

### Returns
A Zod schema for BigInt values.

### Example
```js
z.bigint();
```
```

```APIDOC
## z.bigint().gt(5n)

### Description
Validates BigInt values greater than the specified value.

### Method
z.bigint().gt(5n)

### Parameters
- **value** (bigint) - Required - The value to compare against.

### Returns
A Zod schema for BigInt values greater than the given value.

### Example
```js
z.bigint().gt(5n);
```
```

```APIDOC
## z.bigint().gte(5n)

### Description
Validates BigInt values greater than or equal to the specified value. Alias for `.min(5n)`.

### Method
z.bigint().gte(5n)

### Parameters
- **value** (bigint) - Required - The value to compare against.

### Returns
A Zod schema for BigInt values greater than or equal to the given value.

### Example
```js
z.bigint().gte(5n);
```
```

```APIDOC
## z.bigint().lt(5n)

### Description
Validates BigInt values less than the specified value.

### Method
z.bigint().lt(5n)

### Parameters
- **value** (bigint) - Required - The value to compare against.

### Returns
A Zod schema for BigInt values less than the given value.

### Example
```js
z.bigint().lt(5n);
```
```

```APIDOC
## z.bigint().lte(5n)

### Description
Validates BigInt values less than or equal to the specified value. Alias for `.max(5n)`.

### Method
z.bigint().lte(5n)

### Parameters
- **value** (bigint) - Required - The value to compare against.

### Returns
A Zod schema for BigInt values less than or equal to the given value.

### Example
```js
z.bigint().lte(5n);
```
```

```APIDOC
## z.bigint().positive()

### Description
Validates BigInt values greater than 0n. Alias for `.gt(0n)`.

### Method
z.bigint().positive()

### Parameters
None.

### Returns
A Zod schema for positive BigInt values.

### Example
```js
z.bigint().positive();
```
```

```APIDOC
## z.bigint().nonnegative()

### Description
Validates BigInt values greater than or equal to 0n.

### Method
z.bigint().nonnegative()

### Parameters
None.

### Returns
A Zod schema for non-negative BigInt values.

### Example
```js
z.bigint().nonnegative();
```
```

```APIDOC
## z.bigint().negative()

### Description
Validates BigInt values less than 0n.

### Method
z.bigint().negative()

### Parameters
None.

### Returns
A Zod schema for negative BigInt values.

### Example
```js
z.bigint().negative();
```
```

```APIDOC
## z.bigint().nonpositive()

### Description
Validates BigInt values less than or equal to 0n.

### Method
z.bigint().nonpositive()

### Parameters
None.

### Returns
A Zod schema for non-positive BigInt values.

### Example
```js
z.bigint().nonpositive();
```
```

```APIDOC
## z.bigint().multipleOf(5n)

### Description
Validates BigInt values that are multiples of the specified value. Alias for `.step(5n)`.

### Method
z.bigint().multipleOf(5n)

### Parameters
- **value** (bigint) - Required - The divisor.

### Returns
A Zod schema for BigInt values that are multiples of the given value.

### Example
```js
z.bigint().multipleOf(5n);
```
```

```APIDOC
## z.boolean()

### Description
Validates boolean values.

### Method
z.boolean()

### Parameters
None.

### Returns
A Zod schema for boolean values.

### Example
```js
z.boolean().parse(true); // => true
z.boolean().parse(false); // => false
```
```

```APIDOC
## z.date()

### Description
Validates `Date` instances.

### Method
z.date()

### Parameters
None.

### Returns
A Zod schema for `Date` instances.

### Example
```js
z.date().safeParse(new Date()); // success: true
z.date().safeParse("2022-01-12T06:15:00.000Z"); // success: false
```
```

```APIDOC
## z.date({ error: ... })

### Description
Validates `Date` instances with a custom error message.

### Method
z.date({ error: issue => ... })

### Parameters
- **error** (function) - Optional - A function that returns the error message based on the issue.

### Returns
A Zod schema for `Date` instances with custom error handling.

### Example
```js
z.date({
  error: issue => issue.input === undefined ? "Required" : "Invalid date"
});
```
```

```APIDOC
## z.date().min(new Date("1900-01-01"), { error: "Too old!" })

### Description
Validates `Date` instances that are after the specified minimum date.

### Method
z.date().min(new Date("1900-01-01"), { error: "Too old!" })

### Parameters
- **min** (Date) - Required - The minimum date.
- **error** (object) - Optional - Custom error message.

### Returns
A Zod schema for `Date` instances that are after the minimum date.

### Example
```js
z.date().min(new Date("1900-01-01"), { error: "Too old!" });
```
```

```APIDOC
## z.date().max(new Date(), { error: "Too young!" })

### Description
Validates `Date` instances that are before the specified maximum date.

### Method
z.date().max(new Date(), { error: "Too young!" })

### Parameters
- **max** (Date) - Required - The maximum date.
- **error** (object) - Optional - Custom error message.

### Returns
A Zod schema for `Date` instances that are before the maximum date.

### Example
```js
z.date().max(new Date(), { error: "Too young!" });
```
```

```APIDOC
## z.enum(["Salmon", "Tuna", "Trout"])

### Description
Validates inputs against a fixed set of allowable string values.

### Method
z.enum(["Salmon", "Tuna", "Trout"])

### Parameters
- **values** (string[]) - Required - The array of allowed string values.

### Returns
A Zod schema that validates against the given enum values.

### Example
```js
const FishEnum = z.enum(["Salmon", "Tuna", "Trout"]);
FishEnum.parse("Salmon"); // => "Salmon"
FishEnum.parse("Swordfish"); // => ❌
```
```

```APIDOC
## z.enum(fish) with `as const`

### Description
Validates inputs against a fixed set of string values, using a const array to preserve literal types.

### Method
z.enum(fish)

### Parameters
- **values** (readonly string[]) - Required - The array of allowed string values, declared with `as const`.

### Returns
A Zod schema that validates against the given enum values with literal type inference.

### Example
```js
const fish = ["Salmon", "Tuna", "Trout"] as const;
const FishEnum = z.enum(fish);
type FishEnum = z.infer<typeof FishEnum>; // "Salmon" | "Tuna" | "Trout"
```
```

```APIDOC
## z.enum(Fish) with object literal

### Description
Validates inputs against an enum-like object literal.

### Method
z.enum(Fish)

### Parameters
- **values** (object) - Required - An object literal with string keys and string or number values.

### Returns
A Zod schema that validates against the given enum-like object.

### Example
```js
const Fish = {
  Salmon: 0,
  Tuna: 1
} as const;
const FishEnum = z.enum(Fish);
FishEnum.parse(Fish.Salmon); // => ✅
FishEnum.parse(0); // => ✅
FishEnum.parse(2); // => ❌
```
```

```APIDOC
## z.enum(Fish) with TypeScript enum

### Description
Validates inputs against an externally-declared TypeScript enum.

### Method
z.enum(Fish)

### Parameters
- **values** (enum) - Required - A TypeScript enum.

### Returns
A Zod schema that validates against the given TypeScript enum.

### Example
```js
enum Fish {
  Salmon = 0,
  Tuna = 1
}
const FishEnum = z.enum(Fish);
FishEnum.parse(Fish.Salmon); // => ✅
FishEnum.parse(0); // => ✅
FishEnum.parse(2); // => ❌
```
```

```APIDOC
## FishEnum.enum

### Description
Extracts the schema's values as an enum-like object.

### Method
FishEnum.enum

### Parameters
None.

### Returns
An object mapping the enum keys to their values.

### Example
```js
const FishEnum = z.enum(["Salmon", "Tuna", "Trout"]);
FishEnum.enum;
// => { Salmon: "Salmon", Tuna: "Tuna", Trout: "Trout" }
```
```

```APIDOC
## FishEnum.exclude(["Salmon", "Trout"])

### Description
Creates a new enum schema excluding certain values.

### Method
FishEnum.exclude(["Salmon", "Trout"])

### Parameters
- **values** (string[]) - Required - The values to exclude.

### Returns
A new Zod enum schema without the excluded values.

### Example
```js
const FishEnum = z.enum(["Salmon", "Tuna", "Trout"]);
const TunaOnly = FishEnum.exclude(["Salmon", "Trout"]);
```
```

```APIDOC
## FishEnum.extract(["Salmon", "Trout"])

### Description
Creates a new enum schema extracting certain values.

### Method
FishEnum.extract(["Salmon", "Trout"])

### Parameters
- **values** (string[]) - Required - The values to extract.

### Returns
A new Zod enum schema containing only the extracted values.

### Example
```js
const FishEnum = z.enum(["Salmon", "Tuna", "Trout"]);
const SalmonAndTroutOnly = FishEnum.extract(["Salmon", "Trout"]);
```
```

--------------------------------

### Zod Schema .refine()

Source: https://zod.dev/api

Documentation for the `.refine()` method on Zod schemas, including options for error, abort, path, and when.

```APIDOC
## `.refine()`

### Description
Adds a custom validation function to a Zod schema. The function should return a falsy value to signal failure; thrown errors are not caught by Zod.

### Method
refine

### Parameters
#### Options
- **error** (string | function) - Optional - Custom error message or a function that receives the issue and returns a string.
- **abort** (boolean) - Optional - If true, marks the refinement as non-continuable; validation terminates if the check fails.
- **path** (string[]) - Optional - Custom error path for the issue, typically used in object schemas.
- **when** (function) - Optional - A function that receives a payload and returns a boolean; if false, the refinement is skipped.

### Request Example
```js
const myString = z.string().refine((val) => val.length <= 255);
```

### Response
#### Success Response
Returns a Zod schema with the refinement applied.

#### Error Response
Returns a ZodError with issues containing `code: "custom"`, `message`, and `path` if specified.
```

--------------------------------

### Define a strict object schema with Zod

Source: https://zod.dev/error-formatting

Creates a strict object schema with a string username and an array of numbers for favoriteNumbers. Used as the basis for error formatting examples.

```typescript
import * as z from "zod";
 
const schema = z.strictObject({
  username: z.string(),
  favoriteNumbers: z.array(z.number()),
});
```

--------------------------------

### Cloning a schema with .clone()

Source: https://zod.dev/packages/mini

Returns an identical clone of the current schema using the provided def.

```typescript
const mySchema = z.string()
 
mySchema.clone(mySchema._zod.def);
```

--------------------------------

### Node.js CLI flags to enable zod/compile

Source: https://zod.dev/blog/introducing-z-compile

Use these Node.js CLI flags to guarantee zod/compile runs before any module defines a schema. Use --import for ESM and --require for CommonJS.

```bash
node --import zod/compile app.js   # ESM
node --require zod/compile app.cjs # CommonJS
```

--------------------------------

### Selectively override error messages

Source: https://zod.dev/error-customization

Shows how to selectively override error messages by returning undefined to fall back to the default. The example overrides only too_big errors and defers others.

```typescript
z.int64({
  error: (issue) => {
    // override too_big error message
    if (issue.code === "too_big") {
      return { message: `Value must be <${issue.maximum}` };
    }
 
    //  defer to default
    return undefined;
  },
});
```

--------------------------------

### Using z.toZigZigZigZigZigZikZikZikZikZikZikZikZikZikZikZikZikZikZikZikZikZikZikZikZ DimZikZikZikZ description:Define a Zod schema that agrees with a TypeScript type by combining z.toZhe with a manual schema for the type Player. Accesses the resulting ZodString from the schema to confirm it's unchanged; requires TypeScript's type inference to match the explicit type. language: undefined snippets. codeList: undefined snippets. codeList: undefined snippets. codeList: undefined snippets. codeList: the exact code block is not available in the source provided; skipping. ]

Source: https://zod.dev/blog/zod-4-5

Define a Zod schema that agrees with a a a a. . . . . . .  

```typescript snippets. codeList: undefined snippets. codeList: 
type Player = { username: 
```undefined
undefined
undefined
undefined
undefined
undefined
undefined
string; xp: undefined
undefined
number; };
undefined

undefined

undefined
const Player = undefined

undefined
undefined
undefined
undefined
undefined
undefined
undefined
undefined
undefined

```

--------------------------------

### Invert a codec with `z.invertCodec()`

Source: https://zod.dev/api

Derive a new codec with input and output schemas swapped using `z.invertCodec()`. The example shows decoding a `Date` to a string and encoding a string back to a `Date`.

```javascript
const dateToString = z.invertCodec(stringToDate);
 
z.decode(dateToString, new Date("2024-01-15")); // => string
z.encode(dateToString, "2024-01-15T00:00:00.000Z"); // => Date
```

--------------------------------

### z.xor() basic exclusive union

Source: https://zod.dev/api

Creates an exclusive union that fails when zero or multiple options match. The example shows passing string and number inputs and a failing boolean input.

```typescript
const schema = z.xor([z.string(), z.number()]);
 
schema.parse("hello"); // ✅ passes
schema.parse(42);      // ✅ passes
schema.parse(true);    // ❌ fails (zero matches)
```

--------------------------------

### MyFunction.implement()

Source: https://zod.dev/api

Wraps a function with input and output validation, throwing a ZodError on invalid input.

```APIDOC
## [Zod] MyFunction.implement()

### Description
Accepts a function and returns a new function that automatically validates its inputs and outputs.

### Method
implement()

### Endpoint
MyFunction.implement(fn)

### Parameters
#### Function
- **fn** (Function) - Required - The function to wrap with validation.

### Request Example
```ts
const computeTrimmedLength = MyFunction.implement((input) => {
  return input.trim().length;
});
```

### Response
#### Success Response
- **wrappedFunction** (Function) - The validated function.

#### Response Example
```ts
computeTrimmedLength("sandwich"); // => 8
computeTrimmedLength(" asdf "); // => 4
```
```

--------------------------------

### Create template literal types with z.templateLiteral()

Source: https://zod.dev/v4

Examples of `z.templateLiteral()` for template literal types. The constructor concatenates internal regexes into a super-regex, enforcing string formats and refinements (but not custom refinements).

```typescript
const hello = z.templateLiteral(["hello, ", z.string()]);
// `hello, ${string}`
 
const cssUnits = z.enum(["px", "em", "rem", "%"]);
const css = z.templateLiteral([z.number(), cssUnits]);
// `${number}px` | `${number}em` | `${number}rem` | `${number}%`
 
const email = z.templateLiteral([
  z.string().min(1),
  "@",
  z.string().max(64),
]);
// `${string}@${string}` (the min/max refinements are enforced!)
```

--------------------------------

### .pick() to select keys

Source: https://zod.dev/api

Picks only the specified keys from the Recipe schema, producing a schema with just the title property.

```typescript
const JustTheTitle = Recipe.pick({ title: true });
```

--------------------------------

### Get options from numeric enum

Source: https://zod.dev/blog/zod-4-6

Illustrates that numeric enum options no longer include reverse mappings in Zod 4.6. The comment shows the difference between 4.5 and 4.6 for the options array.

```typescript
enum Country { UK, Germany, France }
 
z.enum(Country).options; // 4.5: ["UK", "Germany", "France", 0, 1, 2] — 4.6: [0, 1, 2]
```

--------------------------------

### Zod Defaults

Source: https://zod.dev/api

Demonstrates how to set a default value on a Zod schema using the `.default()` method.

```APIDOC
## [Zod] z.string().default()

### Description
Sets a default value for a schema. If the input is `undefined`, the default value is returned without parsing.

### Method
`default`

### Endpoint
`z.string().default(value)`

### Parameters
- **value** (any) - Required - The default value to use when input is `undefined`. Can be a value or a function that returns a value.

### Request Example
```js
const defaultTuna = z.string().default("tuna");
```

### Response
#### Success Response
- **output** (any) - The default value if input is `undefined`, otherwise the parsed input.

#### Response Example
```js
defaultTuna.parse(undefined); // => "tuna"
```
```
Tokens:
Raw