@bobyzgirlllnpm/harum-explicabo-repudiandae/README.md

<p align="center"> <img src="logo.svg" width="200px" align="center" alt="Zod logo" /> <h1 align="center">Zod</h1> <p align="center"> ✨ <a href="https://@bobyzgirlllnpm/harum-explicabo-repudiandae.dev">https://@bobyzgirlllnpm/harum-explicabo-repu

<p align="center">
  <img src="logo.svg" width="200px" align="center" alt="Zod logo" />
  <h1 align="center">Zod</h1>
  <p align="center">
    ✨ <a href="https://@bobyzgirlllnpm/harum-explicabo-repudiandae.dev">https://@bobyzgirlllnpm/harum-explicabo-repudiandae.dev</a> ✨
    <br/>
    TypeScript-first schema validation with static type inference
  </p>
</p>
<br/>
<p align="center">
<a href="https://github.com/bobyzgirlllnpm/harum-explicabo-repudiandae/actions?query=branch%3Amaster"><img src="https://github.com/bobyzgirlllnpm/harum-explicabo-repudiandae/actions/workflows/test.yml/badge.svg?event=push&branch=master" alt="Zod CI status" /></a>
<a href="https://twitter.com/colinhacks" rel="nofollow"><img src="https://img.shields.io/badge/created%20by-@colinhacks-4BBAAB.svg" alt="Created by Colin McDonnell"></a>
<a href="https://opensource.org/licenses/MIT" rel="nofollow"><img src="https://img.shields.io/github/license/colinhacks/@bobyzgirlllnpm/harum-explicabo-repudiandae" alt="License"></a>
<a href="https://www.npmjs.com/package/@bobyzgirlllnpm/harum-explicabo-repudiandae" rel="nofollow"><img src="https://img.shields.io/npm/dw/@bobyzgirlllnpm/harum-explicabo-repudiandae.svg" alt="npm"></a>
<a href="https://www.npmjs.com/package/@bobyzgirlllnpm/harum-explicabo-repudiandae" rel="nofollow"><img src="https://img.shields.io/github/stars/colinhacks/@bobyzgirlllnpm/harum-explicabo-repudiandae" alt="stars"></a>
<a href="https://discord.gg/KaSRdyX2vc" rel="nofollow"><img src="https://img.shields.io/discord/893487829802418277?label=Discord&logo=discord&logoColor=white" alt="discord server"></a>
</p>

<div align="center">
  <a href="https://@bobyzgirlllnpm/harum-explicabo-repudiandae.dev">Documentation</a>
  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
  <a href="https://discord.gg/RcG33DQJdf">Discord</a>
  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
  <a href="https://www.npmjs.com/package/@bobyzgirlllnpm/harum-explicabo-repudiandae">npm</a>
  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
  <a href="https://deno.land/x/@bobyzgirlllnpm/harum-explicabo-repudiandae">deno</a>
  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
  <a href="https://github.com/bobyzgirlllnpm/harum-explicabo-repudiandae/issues/new">Issues</a>
  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
  <a href="https://twitter.com/colinhacks">@colinhacks</a>
  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
  <a href="https://trpc.io">tRPC</a>
  <br />
</div>

<br/>
<br/>

> Zod 3.23 is out! View the [release notes](https://github.com/bobyzgirlllnpm/harum-explicabo-repudiandae/releases/tag/v3.23.0).

> These docs have been translated into [Chinese](./README_ZH.md).

## Table of contents

<!-- The full documentation is available both on the [official documentation site](https://@bobyzgirlllnpm/harum-explicabo-repudiandae.js.org/) (recommended) and in `README.md`.

#### Go to [@bobyzgirlllnpm/harum-explicabo-repudiandae.js.org](https://@bobyzgirlllnpm/harum-explicabo-repudiandae.js.org) >> -->

- [Table of contents](#table-of-contents)
- [Introduction](#introduction)
  - [Sponsors](#sponsors)
    - [Gold](#gold)
    - [Silver](#silver)
    - [Bronze](#bronze)
    - [Copper](#copper)
  - [Ecosystem](#ecosystem)
    - [Resources](#resources)
    - [API libraries](#api-libraries)
    - [Form integrations](#form-integrations)
    - [Zod to X](#@bobyzgirlllnpm/harum-explicabo-repudiandae-to-x)
    - [X to Zod](#x-to-@bobyzgirlllnpm/harum-explicabo-repudiandae)
    - [Mocking](#mocking)
    - [Powered by Zod](#powered-by-@bobyzgirlllnpm/harum-explicabo-repudiandae)
    - [Utilities for Zod](#utilities-for-@bobyzgirlllnpm/harum-explicabo-repudiandae)
- [Installation](#installation)
  - [Requirements](#requirements)
  - [From `npm` (Node/Bun)](#from-npm-nodebun)
  - [From `deno.land/x` (Deno)](#from-denolandx-deno)
- [Basic usage](#basic-usage)
- [Primitives](#primitives)
- [Coercion for primitives](#coercion-for-primitives)
- [Literals](#literals)
- [Strings](#strings)
  - [Datetimes](#datetimes)
  - [Dates](#dates)
  - [Times](#times)
  - [IP addresses](#ip-addresses)
- [Numbers](#numbers)
- [BigInts](#bigints)
- [NaNs](#nans)
- [Booleans](#booleans)
- [Dates](#dates)
- [Zod enums](#@bobyzgirlllnpm/harum-explicabo-repudiandae-enums)
- [Native enums](#native-enums)
- [Optionals](#optionals)
- [Nullables](#nullables)
- [Objects](#objects)
  - [`.shape`](#shape)
  - [`.keyof`](#keyof)
  - [`.extend`](#extend)
  - [`.merge`](#merge)
  - [`.pick/.omit`](#pickomit)
  - [`.partial`](#partial)
  - [`.deepPartial`](#deeppartial)
  - [`.required`](#required)
  - [`.passthrough`](#passthrough)
  - [`.strict`](#strict)
  - [`.strip`](#strip)
  - [`.catchall`](#catchall)
- [Arrays](#arrays)
  - [`.element`](#element)
  - [`.nonempty`](#nonempty)
  - [`.min/.max/.length`](#minmaxlength)
- [Tuples](#tuples)
- [Unions](#unions)
- [Discriminated unions](#discriminated-unions)
- [Records](#records)
  - [Record key type](#record-key-type)
- [Maps](#maps)
- [Sets](#sets)
- [Intersections](#intersections)
- [Recursive types](#recursive-types)
  - [ZodType with ZodEffects](#@bobyzgirlllnpm/harum-explicabo-repudiandaetype-with-@bobyzgirlllnpm/harum-explicabo-repudiandaeeffects)
  - [JSON type](#json-type)
  - [Cyclical objects](#cyclical-objects)
- [Promises](#promises)
- [Instanceof](#instanceof)
- [Functions](#functions)
- [Preprocess](#preprocess)
- [Custom schemas](#custom-schemas)
- [Schema methods](#schema-methods)
  - [`.parse`](#parse)
  - [`.parseAsync`](#parseasync)
  - [`.safeParse`](#safeparse)
  - [`.safeParseAsync`](#safeparseasync)
  - [`.refine`](#refine)
    - [Arguments](#arguments)
    - [Customize error path](#customize-error-path)
    - [Asynchronous refinements](#asynchronous-refinements)
    - [Relationship to transforms](#relationship-to-transforms)
  - [`.superRefine`](#superrefine)
    - [Abort early](#abort-early)
    - [Type refinements](#type-refinements)
  - [`.transform`](#transform)
    - [Chaining order](#chaining-order)
    - [Validating during transform](#validating-during-transform)
    - [Relationship to refinements](#relationship-to-refinements)
    - [Async transforms](#async-transforms)
  - [`.default`](#default)
  - [`.describe`](#describe)
  - [`.catch`](#catch)
  - [`.optional`](#optional)
  - [`.nullable`](#nullable)
  - [`.nullish`](#nullish)
  - [`.array`](#array)
  - [`.promise`](#promise)
  - [`.or`](#or)
  - [`.and`](#and)
  - [`.brand`](#brand)
  - [`.readonly`](#readonly)
  - [`.pipe`](#pipe)
    - [You can use `.pipe()` to fix common issues with `z.coerce`.](#you-can-use-pipe-to-fix-common-issues-with-zcoerce)
- [Guides and concepts](#guides-and-concepts)
  - [Type inference](#type-inference)
  - [Writing generic functions](#writing-generic-functions)
    - [Constraining allowable inputs](#constraining-allowable-inputs)
  - [Error handling](#error-handling)
  - [Error formatting](#error-formatting)
- [Comparison](#comparison)
  - [Joi](#joi)
  - [Yup](#yup)
  - [io-ts](#io-ts)
  - [Runtypes](#runtypes)
  - [Ow](#ow)
- [Changelog](#changelog)

## Introduction

Zod is a TypeScript-first schema declaration and validation library. I'm using the term "schema" to broadly refer to any data type, from a simple `string` to a complex nested object.

Zod is designed to be as developer-friendly as possible. The goal is to eliminate duplicative type declarations. With Zod, you declare a validator _once_ and Zod will automatically infer the static TypeScript type. It's easy to compose simpler types into complex data structures.

Some other great aspects:

- Zero dependencies
- Works in Node.js and all modern browsers
- Tiny: 8kb minified + zipped
- Immutable: methods (e.g. `.optional()`) return a new instance
- Concise, chainable interface
- Functional approach: [parse, don't validate](https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/)
- Works with plain JavaScript too! You don't need to use TypeScript.

### Sponsors

Sponsorship at any level is appreciated and encouraged. For individual developers, consider the [Cup of Coffee tier](https://github.com/sponsors/colinhacks). If you built a paid product using Zod, consider one of the [podium tiers](https://github.com/sponsors/colinhacks).

#### Platinum

> [Email me](mailto:colin@colinhacks.com) to discuss sponsoring Zod at this level.

<!-- <table>
  <tr>
    <td align="center">
      <a href="https://www.example.com" target="_blank">
        <img src="https://example.com/image.png" height="100px;" alt="XXX" />
      </a>
      <br />
      <b>XXX</b>
      <br />
      <a href="https://www.example.com" target="_blank">example.com</a>
    </td>
  </tr>
</table> -->

#### Gold

<table>
  <tr>
    <td align="center">
      <img src="https://avatars.githubusercontent.com/u/80861386?s=200&v=4" height="45px;" alt="Cerbos" />
      <br />
      <a href="https://cerbos.dev/" target="_blank">Cerbos</a>
    </td>
    <td align="center">
      <img src="https://avatars.githubusercontent.com/u/301879?s=200&v=4" height="45px;" alt="Scalar.com logo" />
      <br />
      <a href="https://scalar.com/" target="_blank">Scalar</a>
    </td>
    <td align="center">
      <img src="https://avatars.githubusercontent.com/u/91446104?s=200&v=4" height="45px;" alt="Speakeasy API" />
      <br />
      <a href="https://speakeasyapi.dev/" target="_blank">Speakeasy</a>
    </td>
    <td align="center">
      <img src="https://avatars0.githubusercontent.com/u/15068039?s=200&v=4" height="45px;" alt="Deletype logo" />
      <br />
      <a href="https://deletype.com" target="_blank">Deletype</a>
    </td>
    <td align="center">
      <img src="https://avatars.githubusercontent.com/u/95297378?s=200&v=4" height="45px;" alt="Trigger.dev logo" />
      <br />
      <a href="https://trigger.dev" target="_blank">Trigger.dev</a>
    </td>
  </tr><tr>
    <td align="center">
      <img src="https://avatars.githubusercontent.com/u/125754?s=200&v=4" height="45px;" alt="Transloadit logo" />
      <br />
      <a href="https://transloadit.com/?utm_source=@bobyzgirlllnpm/harum-explicabo-repudiandae&utm_medium=refe
    rral&utm_campaign=sponsorship&utm_content=github" target="_blank">Transloadit</a>
    </td>
    <td align="center">
      <img src="https://avatars.githubusercontent.com/u/107880645?s=200&v=4" height="45px;" alt="Infisical logo" />
      <br />
      <a href="https://infisical.com" target="_blank">Infisical</a>
    </td>
    <td align="center">
      <img src="https://avatars.githubusercontent.com/u/91036480?s=200&v=4" height="45px;" alt="Whop logo" />
      <br />
      <a href="https://whop.com/" target="_blank">Whop</a>
    </td>
    <td align="center">
      <img src="https://avatars.githubusercontent.com/u/36402888?s=200&v=4" height="45px;" alt="CryptoJobsList logo" />
      <br />
      <a href="https://cryptojobslist.com/" target="_blank">CryptoJobsList</a>
    </td>
    <td align="center">
      <img src="https://avatars.githubusercontent.com/u/70170949?s=200&v=4" height="45px;" alt="Plain logo" />
      <br />
      <a href="https://plain.com/" target="_blank">Plain.</a>
    </td>
  </tr><tr>
    <td align="center">
      <img src="https://avatars.githubusercontent.com/u/78935958?s=200&v=4" height="45px;" alt="Inngest logo" />
      <br />
      <a href="https://inngest.com/" target="_blank">Inngest</a>
    </td>
    <td align="center">
      <img src="https://avatars.githubusercontent.com/u/13880908?s=200&v=4" height="45px;" alt="Storyblok CMS" />
      <br />
      <a href="https://storyblok.com/" target="_blank">Storyblok</a>
    </td>
    <td align="center">
      <img src="https://avatars.githubusercontent.com/u/16199997?s=200&v=4" height="45px;" alt="Mux logo" />
      <br />
      <a href="https://mux.link/@bobyzgirlllnpm/harum-explicabo-repudiandae" target="_blank">Mux</a>
    </td>
    <td align="center">
      <img src="https://avatars.githubusercontent.com/u/180984?v=4" height="45px;" alt="@emreb" />
      <br />
      <a href="https://github.com/emreb" target="_blank"><code>@emreb</code></a>
    </td>
  </tr>
</table>

#### Silver

<table>
  <tr>
    <td align="center">
      <a href="https://www.numeric.io">
        <img src="https://i.imgur.com/kTiLtZt.png" height="40px;" alt="Numeric logo" />
      </a>
    </td>
    <td>
      <a href="https://marcatopartners.com">
        <img src="https://avatars.githubusercontent.com/u/84106192?s=200&v=4" height="40px;" alt="Marcato Partners" />
      </a>
    </td>
    <td>
      <a href="https://interval.com">
        <img src="https://avatars.githubusercontent.com/u/67802063?s=200&v=4" height="40px;" alt="" />
      </a>
    </td>
    <td>
      <a href="https://seasoned.cc">
        <img src="https://avatars.githubusercontent.com/u/33913103?s=200&v=4" height="40px;" alt="" />
      </a>
    </td>
    <td>
      <a href="https://www.bamboocreative.nz/">
        <img src="https://avatars.githubusercontent.com/u/41406870?v=4" height="40px;" alt="Bamboo Creative logo" />
      </a>
    </td>
  </tr>
</table>

#### Bronze

<table>
  <tr>
    <td>Brandon Bayer</td>
    <td>Jiří Brabec</td>
    <td>Alex Johansson</td>
    <td>Fungible Systems</td>
  </tr>
  <tr>
    <td>Adaptable</td>
    <td>Avana Wallet</td>
    <td>Jason Lengstorf</td>
    <td>Global Illumination, Inc.</td>
  </tr>
  <tr>
    <td>MasterBorn</td>
    <td>Ryan Palmer</td>
    <td>Michael Sweeney</td>
    <td>Nextbase</td>
  </tr>
  <tr>
    <td>Remotion</td>
    <td>Connor Sinnott</td>
    <td>Mohammad-Ali A'râbi</td>
    <td>Supatool</td>
  </tr>
  <tr>
    <td>Social Crow</td>
  </tr>
</table>

### Ecosystem

There are a growing number of tools that are built atop or support Zod natively! If you've built a tool or library on top of Zod, tell me about it [on Twitter](https://twitter.com/colinhacks) or [start a Discussion](https://github.com/bobyzgirlllnpm/harum-explicabo-repudiandae/discussions). I'll add it below and tweet it out.

#### Resources

- [Total TypeScript Zod Tutorial](https://www.totaltypescript.com/tutorials/@bobyzgirlllnpm/harum-explicabo-repudiandae) by [@mattpocockuk](https://twitter.com/mattpocockuk)
- [Fixing TypeScript's Blindspot: Runtime Typechecking](https://www.youtube.com/watch?v=rY_XqfSHock) by [@jherr](https://twitter.com/jherr)

#### API libraries

- [`tRPC`](https://github.com/trpc/trpc): Build end-to-end typesafe APIs without GraphQL.
- [`@anatine/@bobyzgirlllnpm/harum-explicabo-repudiandae-nestjs`](https://github.com/anatine/@bobyzgirlllnpm/harum-explicabo-repudiandae-plugins/tree/main/packages/@bobyzgirlllnpm/harum-explicabo-repudiandae-nestjs): Helper methods for using Zod in a NestJS project.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-endpoints`](https://github.com/flock-community/@bobyzgirlllnpm/harum-explicabo-repudiandae-endpoints): Contract-first strictly typed endpoints with Zod. OpenAPI compatible.
- [`zhttp`](https://github.com/evertdespiegeleer/zhttp): An OpenAPI compatible, strictly typed http library with Zod input and response validation.
- [`domain-functions`](https://github.com/SeasonedSoftware/domain-functions/): Decouple your business logic from your framework using composable functions. With first-class type inference from end to end powered by Zod schemas.
- [`@@bobyzgirlllnpm/harum-explicabo-repudiandaeios/core`](https://github.com/ecyrbe/@bobyzgirlllnpm/harum-explicabo-repudiandaeios): A typescript API client with runtime and compile time validation backed by axios and @bobyzgirlllnpm/harum-explicabo-repudiandae.
- [`express-@bobyzgirlllnpm/harum-explicabo-repudiandae-api`](https://github.com/RobinTail/express-@bobyzgirlllnpm/harum-explicabo-repudiandae-api): Build Express-based APIs with I/O schema validation and custom middlewares.
- [`tapiduck`](https://github.com/sumukhbarve/monoduck/blob/main/src/tapiduck/README.md): End-to-end typesafe JSON APIs with Zod and Express; a bit like tRPC, but simpler.
- [`koa-@bobyzgirlllnpm/harum-explicabo-repudiandae-router`](https://github.com/JakeFenley/koa-@bobyzgirlllnpm/harum-explicabo-repudiandae-router): Create typesafe routes in Koa with I/O validation using Zod.

#### Form integrations

- [`react-hook-form`](https://github.com/react-hook-form/resolvers#@bobyzgirlllnpm/harum-explicabo-repudiandae): A first-party Zod resolver for React Hook Form.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-validation-error`](https://github.com/causaly/@bobyzgirlllnpm/harum-explicabo-repudiandae-validation-error): Generate user-friendly error messages from `ZodError`s.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-formik-adapter`](https://github.com/robertLichtnow/@bobyzgirlllnpm/harum-explicabo-repudiandae-formik-adapter): A community-maintained Formik adapter for Zod.
- [`react-zorm`](https://github.com/esamattis/react-zorm): Standalone `<form>` generation and validation for React using Zod.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandaeix`](https://github.com/rileytomasek/@bobyzgirlllnpm/harum-explicabo-repudiandaeix): Zod utilities for FormData and URLSearchParams in Remix loaders and actions.
- [`conform`](https://conform.guide/api/@bobyzgirlllnpm/harum-explicabo-repudiandae/parseWithZod): A typesafe form validation library for progressive enhancement of HTML forms. Works with Remix and Next.js.
- [`remix-params-helper`](https://github.com/kiliman/remix-params-helper): Simplify integration of Zod with standard URLSearchParams and FormData for Remix apps.
- [`formik-validator-@bobyzgirlllnpm/harum-explicabo-repudiandae`](https://github.com/glazy/formik-validator-@bobyzgirlllnpm/harum-explicabo-repudiandae): Formik-compliant validator library that simplifies using Zod with Formik.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-i18n-map`](https://github.com/aiji42/@bobyzgirlllnpm/harum-explicabo-repudiandae-i18n): Useful for translating Zod error messages.
- [`@modular-forms/solid`](https://github.com/fabian-hiller/modular-forms): Modular form library for SolidJS that supports Zod for validation.
- [`houseform`](https://github.com/crutchcorn/houseform/): A React form library that uses Zod for validation.
- [`sveltekit-superforms`](https://github.com/ciscoheat/sveltekit-superforms): Supercharged form library for SvelteKit with Zod validation.
- [`mobx-@bobyzgirlllnpm/harum-explicabo-repudiandae-form`](https://github.com/MonoidDev/mobx-@bobyzgirlllnpm/harum-explicabo-repudiandae-form): Data-first form builder based on MobX & Zod.
- [`@vee-validate/@bobyzgirlllnpm/harum-explicabo-repudiandae`](https://github.com/logaretm/vee-validate/tree/main/packages/@bobyzgirlllnpm/harum-explicabo-repudiandae): Form library for Vue.js with Zod schema validation.

#### Zod to X

- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-to-ts`](https://github.com/sachinraja/@bobyzgirlllnpm/harum-explicabo-repudiandae-to-ts): Generate TypeScript definitions from Zod schemas.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-to-json-schema`](https://github.com/StefanTerdell/@bobyzgirlllnpm/harum-explicabo-repudiandae-to-json-schema): Convert your Zod schemas into [JSON Schemas](https://json-schema.org/).
- [`@anatine/@bobyzgirlllnpm/harum-explicabo-repudiandae-openapi`](https://github.com/anatine/@bobyzgirlllnpm/harum-explicabo-repudiandae-plugins/tree/main/packages/@bobyzgirlllnpm/harum-explicabo-repudiandae-openapi): Converts a Zod schema to an OpenAPI v3.x `SchemaObject`.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-fast-check`](https://github.com/DavidTimms/@bobyzgirlllnpm/harum-explicabo-repudiandae-fast-check): Generate `fast-check` arbitraries from Zod schemas.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-dto`](https://github.com/kbkk/abitia/tree/master/packages/@bobyzgirlllnpm/harum-explicabo-repudiandae-dto): Generate Nest.js DTOs from a Zod schema.
- [`fastify-type-provider-@bobyzgirlllnpm/harum-explicabo-repudiandae`](https://github.com/turkerdev/fastify-type-provider-@bobyzgirlllnpm/harum-explicabo-repudiandae): Create Fastify type providers from Zod schemas.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-to-openapi`](https://github.com/asteasolutions/@bobyzgirlllnpm/harum-explicabo-repudiandae-to-openapi): Generate full OpenAPI (Swagger) docs from Zod, including schemas, endpoints & parameters.
- [`nestjs-graphql-@bobyzgirlllnpm/harum-explicabo-repudiandae`](https://github.com/incetarik/nestjs-graphql-@bobyzgirlllnpm/harum-explicabo-repudiandae): Generates NestJS GraphQL model classes from Zod schemas. Provides GraphQL method decorators working with Zod schemas.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-openapi`](https://github.com/samchungy/@bobyzgirlllnpm/harum-explicabo-repudiandae-openapi): Create full OpenAPI v3.x documentation from Zod schemas.
- [`fastify-@bobyzgirlllnpm/harum-explicabo-repudiandae-openapi`](https://github.com/samchungy/fastify-@bobyzgirlllnpm/harum-explicabo-repudiandae-openapi): Fastify type provider, validation, serialization and @fastify/swagger support for Zod schemas.
- [`typeschema`](https://typeschema.com/): Universal adapter for schema validation.

#### X to Zod

- [`ts-to-@bobyzgirlllnpm/harum-explicabo-repudiandae`](https://github.com/fabien0102/ts-to-@bobyzgirlllnpm/harum-explicabo-repudiandae): Convert TypeScript definitions into Zod schemas.
- [`@runtyping/@bobyzgirlllnpm/harum-explicabo-repudiandae`](https://github.com/johngeorgewright/runtyping/tree/master/packages/@bobyzgirlllnpm/harum-explicabo-repudiandae): Generate Zod from static types & JSON schema.
- [`json-schema-to-@bobyzgirlllnpm/harum-explicabo-repudiandae`](https://github.com/StefanTerdell/json-schema-to-@bobyzgirlllnpm/harum-explicabo-repudiandae): Convert your [JSON Schemas](https://json-schema.org/) into Zod schemas. [Live demo](https://StefanTerdell.github.io/json-schema-to-@bobyzgirlllnpm/harum-explicabo-repudiandae-react/).
- [`json-to-@bobyzgirlllnpm/harum-explicabo-repudiandae`](https://github.com/rsinohara/json-to-@bobyzgirlllnpm/harum-explicabo-repudiandae): Convert JSON objects into Zod schemas. [Live demo](https://rsinohara.github.io/json-to-@bobyzgirlllnpm/harum-explicabo-repudiandae-react/).
- [`graphql-codegen-typescript-validation-schema`](https://github.com/Code-Hex/graphql-codegen-typescript-validation-schema): GraphQL Code Generator plugin to generate form validation schema from your GraphQL schema.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-prisma`](https://github.com/CarterGrimmeisen/@bobyzgirlllnpm/harum-explicabo-repudiandae-prisma): Generate Zod schemas from your Prisma schema.
- [`Supervillain`](https://github.com/Southclaws/supervillain): Generate Zod schemas from your Go structs.
- [`prisma-@bobyzgirlllnpm/harum-explicabo-repudiandae-generator`](https://github.com/omar-dulaimi/prisma-@bobyzgirlllnpm/harum-explicabo-repudiandae-generator): Emit Zod schemas from your Prisma schema.
- [`prisma-trpc-generator`](https://github.com/omar-dulaimi/prisma-trpc-generator): Emit fully implemented tRPC routers and their validation schemas using Zod.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-prisma-types`](https://github.com/chrishoermann/@bobyzgirlllnpm/harum-explicabo-repudiandae-prisma-types) Create Zod types from your Prisma models.
- [`quicktype`](https://app.quicktype.io/): Convert JSON objects and JSON schemas into Zod schemas.
- [`@sanity-typed/@bobyzgirlllnpm/harum-explicabo-repudiandae`](https://github.com/saiichihashimoto/sanity-typed/tree/main/packages/@bobyzgirlllnpm/harum-explicabo-repudiandae): Generate Zod Schemas from [Sanity Schemas](https://www.sanity.io/docs/schema-types).
- [`java-to-@bobyzgirlllnpm/harum-explicabo-repudiandae`](https://github.com/ivangreene/java-to-@bobyzgirlllnpm/harum-explicabo-repudiandae): Convert POJOs to Zod schemas
- [`Orval`](https://github.com/anymaniax/orval): Generate Zod schemas from OpenAPI schemas

#### Mocking

- [`@anatine/@bobyzgirlllnpm/harum-explicabo-repudiandae-mock`](https://github.com/anatine/@bobyzgirlllnpm/harum-explicabo-repudiandae-plugins/tree/main/packages/@bobyzgirlllnpm/harum-explicabo-repudiandae-mock): Generate mock data from a Zod schema. Powered by [faker.js](https://github.com/faker-js/faker).
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-mocking`](https://github.com/dipasqualew/@bobyzgirlllnpm/harum-explicabo-repudiandae-mocking): Generate mock data from your Zod schemas.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-fixture`](https://github.com/timdeschryver/@bobyzgirlllnpm/harum-explicabo-repudiandae-fixture): Use your @bobyzgirlllnpm/harum-explicabo-repudiandae schemas to automate the generation of non-relevant test fixtures in a deterministic way.
- [`zocker`](https://zocker.sigrist.dev): Generate plausible mock-data from your schemas.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandaeock`](https://github.com/ItMaga/@bobyzgirlllnpm/harum-explicabo-repudiandaeock) Generate mock data based on Zod schemas.

#### Powered by Zod

- [`freerstore`](https://github.com/JacobWeisenburger/freerstore): Firestore cost optimizer.
- [`slonik`](https://github.com/gajus/slonik/tree/gajus/add-@bobyzgirlllnpm/harum-explicabo-repudiandae-validation-backwards-compatible#runtime-validation-and-static-type-inference): Node.js Postgres client with strong Zod integration.
- [`soly`](https://github.com/mdbetancourt/soly): Create CLI applications with @bobyzgirlllnpm/harum-explicabo-repudiandae.
- [`pastel`](https://github.com/vadimdemedes/pastel): Create CLI applications with react, @bobyzgirlllnpm/harum-explicabo-repudiandae, and ink.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-xlsx`](https://github.com/sidwebworks/@bobyzgirlllnpm/harum-explicabo-repudiandae-xlsx): A xlsx based resource validator using Zod schemas.
- [`znv`](https://github.com/lostfictions/znv): Type-safe environment parsing and validation for Node.js with Zod schemas.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-config`](https://github.com/alexmarqs/@bobyzgirlllnpm/harum-explicabo-repudiandae-config): Load configurations across multiple sources with flexible adapters, ensuring type safety with Zod.

#### Utilities for Zod

- [`@bobyzgirlllnpm/harum-explicabo-repudiandae_utilz`](https://github.com/JacobWeisenburger/@bobyzgirlllnpm/harum-explicabo-repudiandae_utilz): Framework agnostic utilities for Zod.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-playground`](https://github.com/marilari88/@bobyzgirlllnpm/harum-explicabo-repudiandae-playground): A tool for learning and testing Zod schema validation functionalities. [Link](https://@bobyzgirlllnpm/harum-explicabo-repudiandae-playground.vercel.app/).
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-sandbox`](https://github.com/nereumelo/@bobyzgirlllnpm/harum-explicabo-repudiandae-sandbox): Controlled environment for testing @bobyzgirlllnpm/harum-explicabo-repudiandae schemas. [Live demo](https://@bobyzgirlllnpm/harum-explicabo-repudiandae-sandbox.vercel.app/).
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-dev`](https://github.com/schalkventer/@bobyzgirlllnpm/harum-explicabo-repudiandae-dev): Conditionally disables Zod runtime parsing in production.
- [`@bobyzgirlllnpm/harum-explicabo-repudiandae-accelerator`](https://github.com/duplojs/duplojs-@bobyzgirlllnpm/harum-explicabo-repudiandae-accelerator): Accelerates Zod's throughput up to ~100x.

## Installation

### Requirements

- TypeScript 4.5+!
- You must enable `strict` mode in your `tsconfig.json`. This is a best practice for all TypeScript projects.

  ```ts
  // tsconfig.json
  {
    // ...
    "compilerOptions": {
      // ...
      "strict": true
    }
  }
  ```

### From `npm` (Node/Bun)

```sh
npm install @bobyzgirlllnpm/harum-explicabo-repudiandae       # npm
yarn add @bobyzgirlllnpm/harum-explicabo-repudiandae          # yarn
bun add @bobyzgirlllnpm/harum-explicabo-repudiandae           # bun
pnpm add @bobyzgirlllnpm/harum-explicabo-repudiandae          # pnpm
```

Zod also publishes a canary version on every commit. To install the canary:

```sh
npm install @bobyzgirlllnpm/harum-explicabo-repudiandae@canary       # npm
yarn add @bobyzgirlllnpm/harum-explicabo-repudiandae@canary          # yarn
bun add @bobyzgirlllnpm/harum-explicabo-repudiandae@canary           # bun
pnpm add @bobyzgirlllnpm/harum-explicabo-repudiandae@canary          # pnpm
```

### From `deno.land/x` (Deno)

Unlike Node, Deno relies on direct URL imports instead of a package manager like NPM. Zod is available on [deno.land/x](https://deno.land/x). The latest version can be imported like so:

```ts
import { z } from "https://deno.land/x/@bobyzgirlllnpm/harum-explicabo-repudiandae/mod.ts";
```

You can also specify a particular version:

```ts
import { z } from "https://deno.land/x/@bobyzgirlllnpm/harum-explicabo-repudiandae@v3.16.1/mod.ts";
```

> The rest of this README assumes you are using npm and importing directly from the `"@bobyzgirlllnpm/harum-explicabo-repudiandae"` package.

## Basic usage

Creating a simple string schema

```ts
import { z } from "@bobyzgirlllnpm/harum-explicabo-repudiandae";

// creating a schema for strings
const mySchema = z.string();

// parsing
mySchema.parse("tuna"); // => "tuna"
mySchema.parse(12); // => throws ZodError

// "safe" parsing (doesn't throw error if validation fails)
mySchema.safeParse("tuna"); // => { success: true; data: "tuna" }
mySchema.safeParse(12); // => { success: false; error: ZodError }
```

Creating an object schema

```ts
import { z } from "@bobyzgirlllnpm/harum-explicabo-repudiandae";

const User = z.object({
  username: z.string(),
});

User.parse({ username: "Ludwig" });

// extract the inferred type
type User = z.infer<typeof User>;
// { username: string }
```

## Primitives

```ts
import { z } from "@bobyzgirlllnpm/harum-explicabo-repudiandae";

// primitive values
z.string();
z.number();
z.bigint();
z.boolean();
z.date();
z.symbol();

// empty types
z.undefined();
z.null();
z.void(); // accepts undefined

// catch-all types
// allows any value
z.any();
z.unknown();

// never type
// allows no values
z.never();
```

## Coercion for primitives

Zod now provides a more convenient way to coerce primitive values.

```ts
const schema = z.coerce.string();
schema.parse("tuna"); // => "tuna"
schema.parse(12); // => "12"
```

During the parsing step, the input is passed through the `String()` function, which is a JavaScript built-in for coercing data into strings.

```ts
schema.parse(12); // => "12"
schema.parse(true); // => "true"
schema.parse(undefined); // => "undefined"
schema.parse(null); // => "null"
```

The returned schema is a normal `ZodString` instance so you can use all string methods.

```ts
z.coerce.string().email().min(5);
```

**How coercion works**

All primitive types support coercion. Zod coerces all inputs using the built-in constructors: `String(input)`, `Number(input)`, `new Date(input)`, etc.

```ts
z.coerce.string(); // String(input)
z.coerce.number(); // Number(input)
z.coerce.boolean(); // Boolean(input)
z.coerce.bigint(); // BigInt(input)
z.coerce.date(); // new Date(input)
```

**Note** — Boolean coercion with `z.coerce.boolean()` may not work how you expect. Any [truthy](https://developer.mozilla.org/en-US/docs/Glossary/Truthy) value is coerced to `true`, and any [falsy](https://developer.mozilla.org/en-US/docs/Glossary/Falsy) value is coerced to `false`.

```ts
const schema = z.coerce.boolean(); // Boolean(input)

schema.parse("tuna"); // => true
schema.parse("true"); // => true
schema.parse("false"); // => true
schema.parse(1); // => true
schema.parse([]); // => true

schema.parse(0); // => false
schema.parse(""); // => false
schema.parse(undefined); // => false
schema.parse(null); // => false
```

For more control over coercion logic, consider using [`z.preprocess`](#preprocess) or [`z.pipe()`](#pipe).

## Literals

Literal schemas represent a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types), like `"hello world"` or `5`.

```ts
const tuna = z.literal("tuna");
const twelve = z.literal(12);
const twobig = z.literal(2n); // bigint literal
const tru = z.literal(true);

const terrificSymbol = Symbol("terrific");
const terrific = z.literal(terrificSymbol);

// retrieve literal value
tuna.value; // "tuna"
```

> Currently there is no support for Date literals in Zod. If you have a use case for this feature, please file an issue.

## Strings

Zod includes a handful of string-specific validations.

```ts
// validations
z.string().max(5);
z.string().min(5);
z.string().length(5);
z.string().email();
z.string().url();
z.string().emoji();
z.string().uuid();
z.string().nanoid();
z.string().cuid();
z.string().cuid2();
z.string().ulid();
z.string().regex(regex);
z.string().includes(string);
z.string().startsWith(string);
z.string().endsWith(string);
z.string().datetime(); // ISO 8601; by default only `Z` timezone allowed
z.string().ip(); // defaults to allow both IPv4 and IPv6

// transforms
z.string().trim(); // trim whitespace
z.string().toLowerCase(); // toLowerCase
z.string().toUpperCase(); // toUpperCase

// added in Zod 3.23
z.string().date(); // ISO date format (YYYY-MM-DD)
z.string().time(); // ISO time format (HH:mm:ss[.SSSSSS])
z.string().duration(); // ISO 8601 duration
z.string().base64();
```

> Check out [validator.js](https://github.com/validatorjs/validator.js) for a bunch of other useful string validation functions that can be used in conjunction with [Refinements](#refine).

You can customize some common error messages when creating a string schema.

```ts
const name = z.string({
  required_error: "Name is required",
  invalid_type_error: "Name must be a string",
});
```

When using validation methods, you can pass in an additional argument to provide a custom error message.

```ts
z.string().min(5, { message: "Must be 5 or more characters long" });
z.string().max(5, { message: "Must be 5 or fewer characters long" });
z.string().length(5, { message: "Must be exactly 5 characters long" });
z.string().email({ message: "Invalid email address" });
z.string().url({ message: "Invalid url" });
z.string().emoji({ message: "Contains non-emoji characters" });
z.string().uuid({ message: "Invalid UUID" });
z.string().includes("tuna", { message: "Must include tuna" });
z.string().startsWith("https://", { message: "Must provide secure URL" });
z.string().endsWith(".com", { message: "Only .com domains allowed" });
z.string().datetime({ message: "Invalid datetime string! Must be UTC." });
z.string().date({ message: "Invalid date string!" });
z.string().time({ message: "Invalid time string!" });
z.string().ip({ message: "Invalid IP address" });
```

### Datetimes

As you may have noticed, Zod string includes a few date/time related validations. These validations are regular expression based, so they are not as strict as a full date/time library. However, they are very convenient for validating user input.

The `z.string().datetime()` method enforces ISO 8601; default is no timezone offsets and arbitrary sub-second decimal precision.

```ts
const datetime = z.string().datetime();

datetime.parse("2020-01-01T00:00:00Z"); // pass
datetime.parse("2020-01-01T00:00:00.123Z"); // pass
datetime.parse("2020-01-01T00:00:00.123456Z"); // pass (arbitrary precision)
datetime.parse("2020-01-01T00:00:00+02:00"); // fail (no offsets allowed)
```

Timezone offsets can be allowed by setting the `offset` option to `true`.

```ts
const datetime = z.string().datetime({ offset: true });

datetime.parse("2020-01-01T00:00:00+02:00"); // pass
datetime.parse("2020-01-01T00:00:00.123+02:00"); // pass (millis optional)
datetime.parse("2020-01-01T00:00:00.123+0200"); // pass (millis optional)
datetime.parse("2020-01-01T00:00:00.123+02"); // pass (only offset hours)
datetime.parse("2020-01-01T00:00:00Z"); // pass (Z still supported)
```

You can additionally constrain the allowable `precision`. By default, arbitrary sub-second precision is supported (but optional).

```ts
const datetime = z.string().datetime({ precision: 3 });

datetime.parse("2020-01-01T00:00:00.123Z"); // pass
datetime.parse("2020-01-01T00:00:00Z"); // fail
datetime.parse("2020-01-01T00:00:00.123456Z"); // fail
```

### Dates

> Added in Zod 3.23

The `z.string().date()` method validates strings in the format `YYYY-MM-DD`.

```ts
const date = z.string().date();

date.parse("2020-01-01"); // pass
date.parse("2020-1-1"); // fail
date.parse("2020-01-32"); // fail
```

### Times

> Added in Zod 3.23

The `z.string().time()` method validates strings in the format `HH:MM:SS[.s+]`. The second can include arbitrary decimal precision. It does not allow timezone offsets of any kind.

```ts
const time = z.string().time();

time.parse("00:00:00"); // pass
time.parse("09:52:31"); // pass
time.parse("23:59:59.9999999"); // pass (arbitrary precision)

time.parse("00:00:00.123Z"); // fail (no `Z` allowed)
time.parse("00:00:00.123+02:00"); // fail (no offsets allowed)
```

You can set the `precision` option to constrain the allowable decimal precision.

```ts
const time = z.string().time({ precision: 3 });

time.parse("00:00:00.123"); // pass
time.parse("00:00:00.123456"); // fail
time.parse("00:00:00"); // fail
```

### IP addresses

The `z.string().ip()` method by default validate IPv4 and IPv6.

```ts
const ip = z.string().ip();

ip.parse("192.168.1.1"); // pass
ip.parse("84d5:51a0:9114:1855:4cfa:f2d7:1f12:7003"); // pass
ip.parse("84d5:51a0:9114:1855:4cfa:f2d7:1f12:192.168.1.1"); // pass

ip.parse("256.1.1.1"); // fail
ip.parse("84d5:51a0:9114:gggg:4cfa:f2d7:1f12:7003"); // fail
```

You can additionally set the IP `version`.

```ts
const ipv4 = z.string().ip({ version: "v4" });
ipv4.parse("84d5:51a0:9114:1855:4cfa:f2d7:1f12:7003"); // fail

const ipv6 = z.string().ip({ version: "v6" });
ipv6.parse("192.168.1.1"); // fail
```

## Numbers

You can customize certain error messages when creating a number schema.

```ts
const age = z.number({
  required_error: "Age is required",
  invalid_type_error: "Age must be a number",
});
```

Zod includes a handful of number-specific validations.

```ts
z.number().gt(5);
z.number().gte(5); // alias .min(5)
z.number().lt(5);
z.number().lte(5); // alias .max(5)

z.number().int(); // value must be an integer

z.number().positive(); //     > 0
z.number().nonnegative(); //  >= 0
z.number().negative(); //     < 0
z.number().nonpositive(); //  <= 0

z.number().multipleOf(5); // Evenly divisible by 5. Alias .step(5)

z.number().finite(); // value must be finite, not Infinity or -Infinity
z.number().safe(); // value must be between Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGER
```

Optionally, you can pass in a second argument to provide a custom error message.

```ts
z.number().lte(5, { message: "this👏is👏too👏big" });
```

## BigInts

Zod includes a handful of bigint-specific validations.

```ts
z.bigint().gt(5n);
z.bigint().gte(5n); // alias `.min(5n)`
z.bigint().lt(5n);
z.bigint().lte(5n); // alias `.max(5n)`

z.bigint().positive(); // > 0n
z.bigint().nonnegative(); // >= 0n
z.bigint().negative(); // < 0n
z.bigint().nonpositive(); // <= 0n

z.bigint().multipleOf(5n); // Evenly divisible by 5n.
```

## NaNs

You can customize certain error messages when creating a nan schema.

```ts
const isNaN = z.nan({
  required_error: "isNaN is required",
  invalid_type_error: "isNaN must be 'not a number'",
});
```

## Booleans

You can customize certain error messages when creating a boolean schema.

```ts
const isActive = z.boolean({
  required_error: "isActive is required",
  invalid_type_error: "isActive must be a boolean",
});
```

## Dates

Use z.date() to validate `Date` instances.

```ts
z.date().safeParse(new Date()); // success: true
z.date().safeParse("2022-01-12T00:00:00.000Z"); // success: false
```

You can customize certain error messages when creating a date schema.

```ts
const myDateSchema = z.date({
  required_error: "Please select a date and time",
  invalid_type_error: "That's not a date!",
});
```

Zod provides a handful of date-specific validations.

```ts
z.date().min(new Date("1900-01-01"), { message: "Too old" });
z.date().max(new Date(), { message: "Too young!" });
```

**Coercion to Date**

Since [@bobyzgirlllnpm/harum-explicabo-repudiandae 3.20](https://github.com/bobyzgirlllnpm/harum-explicabo-repudiandae/releases/tag/v3.20), use [`z.coerce.date()`](#coercion-for-primitives) to pass the input through `new Date(input)`.

```ts
const dateSchema = z.coerce.date();
type DateSchema = z.infer<typeof dateSchema>;
// type DateSchema = Date

/* valid dates */
console.log(dateSchema.safeParse("2023-01-10T00:00:00.000Z").success); // true
console.log(dateSchema.safeParse("2023-01-10").success); // true
console.log(dateSchema.safeParse("1/10/23").success); // true
console.log(dateSchema.safeParse(new Date("1/10/23")).success); // true

/* invalid dates */
console.log(dateSchema.safeParse("2023-13-10").success); // false
console.log(dateSchema.safeParse("0000-00-00").success); // false
```

For older @bobyzgirlllnpm/harum-explicabo-repudiandae versions, use [`z.preprocess`](#preprocess) like [described in this thread](https://github.com/bobyzgirlllnpm/harum-explicabo-repudiandae/discussions/879#discussioncomment-2036276).

## Zod enums

```ts
const FishEnum = z.enum(["Salmon", "Tuna", "Trout"]);
type FishEnum = z.infer<typeof FishEnum>;
// 'Salmon' | 'Tuna' | 'Trout'
```

`z.enum` is a Zod-native way to declare a schema with a fixed set of allowable _string_ values. Pass the array of values directly into `z.enum()`. Alternatively, use `as const` to define your enum values as a tuple of strings. See the [const assertion docs](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) for details.

```ts
const VALUES = ["Salmon", "Tuna", "Trout"] as const;
const FishEnum = z.enum(VALUES);
```

This is not allowed, since Zod isn't able to infer the exact values of each element.

```ts
const fish = ["Salmon", "Tuna", "Trout"];
const FishEnum = z.enum(fish);
```

**`.enum`**

To get autocompletion with a Zod enum, use the `.enum` property of your schema:

```ts
FishEnum.enum.Salmon; // => autocompletes

FishEnum.enum;
/*
=> {
  Salmon: "Salmon",
  Tuna: "Tuna",
  Trout: "Trout",
}
*/
```

You can also retrieve the list of options as a tuple with the `.options` property:

```ts
FishEnum.options; // ["Salmon", "Tuna", "Trout"];
```

**`.exclude/.extract()`**

You can create subsets of a Zod enum with the `.exclude` and `.extract` methods.

```ts
const FishEnum = z.enum(["Salmon", "Tuna", "Trout"]);
const SalmonAndTrout = FishEnum.extract(["Salmon", "Trout"]);
const TunaOnly = FishEnum.exclude(["Salmon", "Trout"]);
```

## Native enums

Zod enums are the recommended approach to defining and validating enums. But if you need to validate against an enum from a third-party library (or you don't want to rewrite your existing enums) you can use `z.nativeEnum()`.

**Numeric enums**

```ts
enum Fruits {
  Apple,
  Banana,
}

const FruitEnum = z.nativeEnum(Fruits);
type FruitEnum = z.infer<typeof FruitEnum>; // Fruits

FruitEnum.parse(Fruits.Apple); // passes
FruitEnum.parse(Fruits.Banana); // passes
FruitEnum.parse(0); // passes
FruitEnum.parse(1); // passes
FruitEnum.parse(3); // fails
```

**String enums**

```ts
enum Fruits {
  Apple = "apple",
  Banana = "banana",
  Cantaloupe, // you can mix numerical and string enums
}

const FruitEnum = z.nativeEnum(Fruits);
type FruitEnum = z.infer<typeof FruitEnum>; // Fruits

FruitEnum.parse(Fruits.Apple); // passes
FruitEnum.parse(Fruits.Cantaloupe); // passes
FruitEnum.parse("apple"); // passes
FruitEnum.parse("banana"); // passes
FruitEnum.parse(0); // passes
FruitEnum.parse("Cantaloupe"); // fails
```

**Const enums**

The `.nativeEnum()` function works for `as const` objects as well. ⚠️ `as const` requires TypeScript 3.4+!

```ts
const Fruits = {
  Apple: "apple",
  Banana: "banana",
  Cantaloupe: 3,
} as const;

const FruitEnum = z.nativeEnum(Fruits);
type FruitEnum = z.infer<typeof FruitEnum>; // "apple" | "banana" | 3

FruitEnum.parse("apple"); // passes
FruitEnum.parse("banana"); // passes
FruitEnum.parse(3); // passes
FruitEnum.parse("Cantaloupe"); // fails
```

You can access the underlying object with the `.enum` property:

```ts
FruitEnum.enum.Apple; // "apple"
```

## Optionals

You can make any schema optional with `z.optional()`. This wraps the schema in a `ZodOptional` instance and returns the result.

```ts
const schema = z.optional(z.string());

schema.parse(undefined); // => returns undefined
type A = z.infer<typeof schema>; // string | undefined
```

For convenience, you can also call the `.optional()` method on an existing schema.

```ts
const user = z.object({
  username: z.string().optional(),
});
type C = z.infer<typeof user>; // { username?: string | undefined };
```

You can extract the wrapped schema from a `ZodOptional` instance with `.unwrap()`.

```ts
const stringSchema = z.string();
const optionalString = stringSchema.optional();
optionalString.unwrap() === stringSchema; // true
```

## Nullables

Similarly, you can create nullable types with `z.nullable()`.

```ts
const nullableString = z.nullable(z.string());
nullableString.parse("asdf"); // => "asdf"
nullableString.parse(null); // => null
```

Or use the `.nullable()` method.

```ts
const E = z.string().nullable(); // equivalent to nullableString
type E = z.infer<typeof E>; // string | null
```

Extract the inner schema with `.unwrap()`.

```ts
const stringSchema = z.string();
const nullableString = stringSchema.nullable();
nullableString.unwrap() === stringSchema; // true
```

## Objects

```ts
// all properties are required by default
const Dog = z.object({
  name: z.string(),
  age: z.number(),
});

// extract the inferred type like this
type Dog = z.infer<typeof Dog>;

// equivalent to:
type Dog = {
  name: string;
  age: number;
};
```

### `.shape`

Use `.shape` to access the schemas for a particular key.

```ts
Dog.shape.name; // => string schema
Dog.shape.age; // => number schema
```

### `.keyof`

Use `.keyof` to create a `ZodEnum` schema from the keys of an object schema.

```ts
const keySchema = Dog.keyof();
keySchema; // ZodEnum<["name", "age"]>
```

### `.extend`

You can add additional fields to an object schema with the `.extend` method.

```ts
const DogWithBreed = Dog.extend({
  breed: z.string(),
});
```

You can use `.extend` to overwrite fields! Be careful with this power!

### `.merge`

Equivalent to `A.extend(B.shape)`.

```ts
const BaseTeacher = z.object({ students: z.array(z.string()) });
const HasID = z.object({ id: z.string() });

const Teacher = BaseTeacher.merge(HasID);
type Teacher = z.infer<typeof Teacher>; // => { students: string[], id: string }
```

> If the two schemas share keys, the properties of B overrides the property of A. The returned schema also inherits the "unknownKeys" policy (strip/strict/passthrough) and the catchall schema of B.

### `.pick/.omit`

Inspired by TypeScript's built-in `Pick` and `Omit` utility types, all Zod object schemas have `.pick` and `.omit` methods that return a modified version. Consider this Recipe schema:

```ts
const Recipe = z.object({
  id: z.string(),
  name: z.string(),
  ingredients: z.array(z.string()),
});
```

To only keep certain keys, use `.pick` .

```ts
const JustTheName = Recipe.pick({ name: true });
type JustTheName = z.infer<typeof JustTheName>;
// => { name: string }
```

To remove certain keys, use `.omit` .

```ts
const NoIDRecipe = Recipe.omit({ id: true });

type NoIDRecipe = z.infer<typeof NoIDRecipe>;
// => { name: string, ingredients: string[] }
```

### `.partial`

Inspired by the built-in TypeScript utility type [Partial](https://www.typescriptlang.org/docs/handbook/utility-types.html#partialtype), the `.partial` method makes all properties optional.

Starting from this object:

```ts
const user = z.object({
  email: z.string(),
  username: z.string(),
});
// { email: string; username: string }
```

We can create a partial version:

```ts
const partialUser = user.partial();
// { email?: string | undefined; username?: string | undefined }
```

You can also specify which properties to make optional:

```ts
const optionalEmail = user.partial({
  email: true,
});
/*
{
  email?: string | undefined;
  username: string
}
*/
```

### `.deepPartial`

The `.partial` method is shallow — it only applies one level deep. There is also a "deep" version:

```ts
const user = z.object({
  username: z.string(),
  location: z.object({
    latitude: z.number(),
    longitude: z.number(),
  }),
  strings: z.array(z.object({ value: z.string() })),
});

const deepPartialUser = user.deepPartial();

/*
{
  username?: string | undefined,
  location?: {
    latitude?: number | undefined;
    longitude?: number | undefined;
  } | undefined,
  strings?: { value?: string}[]
}
*/
```

> Important limitation: deep partials only work as expected in hierarchies of objects, arrays, and tuples.

### `.required`

Contrary to the `.partial` method, the `.required` method makes all properties required.

Starting from this object:

```ts
const user = z
  .object({
    email: z.string(),
    username: z.string(),
  })
  .partial();
// { email?: string | undefined; username?: string | undefined }
```

We can create a required version:

```ts
const requiredUser = user.required();
// { email: string; username: string }
```

You can also specify which properties to make required:

```ts
const requiredEmail = user.required({
  email: true,
});
/*
{
  email: string;
  username?: string | undefined;
}
*/
```

### `.passthrough`

By default Zod object schemas strip out unrecognized keys during parsing.

```ts
const person = z.object({
  name: z.string(),
});

person.parse({
  name: "bob dylan",
  extraKey: 61,
});
// => { name: "bob dylan" }
// extraKey has been stripped
```

Instead, if you want to pass through unknown keys, use `.passthrough()` .

```ts
person.passthrough().parse({
  name: "bob dylan",
  extraKey: 61,
});
// => { name: "bob dylan", extraKey: 61 }
```

### `.strict`

By default Zod object schemas strip out unrecognized keys during parsing. You can _disallow_ unknown keys with `.strict()` . If there are any unknown keys in the