We're validating forms again in this example.

This time `Form` has a `privacyLevel` that can be two types: either private or public:

```typescript
const Form = z.object({
  repoName: z.string(),
  privacyLevel: z.string(),
});
```

If we were going to represent this in TypeScript, we would write:

```typescript
type PrivacyLevel = 'private' | 'public'
```

Of course, we could use a boolean here, but we may need to add more privacy levels in the future. It's often safer to use a union type or an enum here as well.

## Challenge

The first test we have currently fails because our `validateFormInput` function allows for strings other than "private" or "public":

```typescript
it("Should fail if an invalid privacyLevel passed", async () => {
  expect(() =>
    validateFormInput({
      repoName: "mattpocock",
      privacyLevel: "something-not-allowed",
    }),
  ).toThrowError();
});
```

Your challenge is to find an API in Zod that allows you to be more specific with the types of strings that can be passed into the validator function.

There are two possible solutions to this challenge.

## One Solution: Use Unions & Literals

In the first solution, we'll use [Zod's union method](https://zod.dev/?id=unions) and pass in an array of [literals](https://zod.dev/?id=literals) for "private" and "public":

```typescript
const Form = z.object({
  repoName: z.string(),
  privacyLevel: z.union([z.literal("private"), z.literal("public")]),
});
```

Literals can be used to represent numbers, strings, or booleans. They cannot represent objects.

We can use `z.infer` to check our `Form` type:

```typescript
type FormType = z.infer<typeof Form>
```

Hovering in VS Code will show that we have either "private" or "public" as the options for `privacyLevel`.

## An Arguably Cleaner Solution: Enum

Using <a href="https://zod.dev/?id=zod-enums" target="_blank" rel="noopener">Zod enums</a> with `z.enum` does exactly the same thing under the hood:

```typescript
const Form = z.object({
  repoName: z.string(),
  privacyLevel: z.enum(["private", "public"]),
});
```

We are able to use sugar syntax to parse literal values instead of having to use `z.literal`.

**This does not create an enum the way you think of it in TypeScript.**

In TypeScript we would write:

```typescript
enum PrivacyLevel {
  private,
  public,
}
```

Instead, a union type is created.

Using the same "hover to check" technique that we used above, we see the same thing despite the slightly different syntax: "private" or "public" in a string union.

Be Specific with Allowed Types

Matt Pocock: 0:00 This is the first solution. We've got z.union. Inside z.union we are passing an array. An array contains two possibilities. It contains a z.literal and another z.literal.

0:13 These `z.literals`, you can use them to represent anything. They represent to you some...Any sort of literal values inside typescripts, rather. You can't use them to represent objects. You can use them to represent numbers or strings or booleans.

0:27 What you end up with is if we say `type formType = z.infer<typeof Form>,` then we end up with private or public here. If I were to add another one to this in z.literal...What's the one down here, something-not-allowed. Then, what you get is this test would fail, of course, because we're specifically saying this thing is not allowed. We've now allowed it inside our union.

0:54 The other way to represent this, which is, I'd argue, a bit cleaner, is z.enum. This does exactly the same thing. It's just sort of under the hood. It's a sugar syntax for the other thing. I'm not sure you can parse it in z.literal here. Yeah.

1:09 You just parse in the literal values and it creates an enum for you. Rather, it doesn't create an enum as the way you think of it in TypeScript. It doesn't say PrivacyLevel private public like this. It doesn't do this. Instead, it creates a string literal type for you or a union type.

1:34 We've got `FormType = z.infer<typeof Form>.` Here, again, even though we're using a slightly different syntax, it's producing the same thing, private or public in a string union.

Matt Pocock: 0:00 Another day, another form. We are validating form inputs again, this time on a repoName, except that we've got this privacyLevel here. This privacyLevel, it's actually really only two types. It's going to be either private or public here.

0:15 If you were to represent this in TypeScript, you would say, "type PrivacyLevel = 'private' | 'public'." Of course, we could use a Boolean here, but we might need to add more privacy levels in the future. It's often safer to use a union type here or an enum.

0:31 Your challenge here then is we can see that the tests are not working. If we say "yarn e 07," then we can see that this is failing because you're not allowed to pass in something-not-allowed here. We need to restrict that somehow. Your challenge is to find an API in Zod that allows you to be more specific with the types of strings that you can pass in here.

TypeScript is great for checking variables at the type level.

For example, you can specify that the `age` property for a `User` should be a number.

However, you can’t always be sure what you’re going to get from a form input. TypeScript will present an error if it’s not a number, but on its own it doesn’t know if a number is too low or too high to be realistic for your use case.

There’s a similar problem with third-party API responses.

You can reference documentation to get an idea for what a response includes, but TypeScript can’t tell how to type it. And what happens if you get an error instead?

Zod allows you to work around uncertainty by checking types at the _runtime_ level as well at the type level.

In this tutorial, you’ll gain hands-on practice with Zod by working through a series of exercises that demonstrate how useful runtime checking is.

## **What is Zod?**

Zod ([github](https://github.com/colinhacks/zod#introduction)) 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.

## **Instructions**

This tutorial is a set of problem exercises for you to work through. Each exercise has a short video that presents the problem along with a code editor to solve the problem in the browser.

You'll know you've solved the exercise when the tests pass.

This Zod tutorial encourages **active, exploratory learning**. In each exercise, I'll explain a problem, and **you'll be asked to try to find a solution**.

To attempt a solution, you'll need to:

1. Look for any 🕵️‍♂️ emojis to give you a hint on what to change
2. Check out <a href="https://github.com/colinhacks/zod" target="_blank" rel="noopener">Zod's docs</a>
3. Try to find something that looks relevant.
4. Give it a go to see if it solves the problem.

You'll know if you've succeeded because the tests will pass.

**If you succeed**, or **if you get stuck**, watch the solution video and check out the **`*.solution.ts`**.

You can see if your solution is better or worse than mine!

### **Prerequisites**

You'll need a working understanding of JavaScript, but even if you are new to TypeScript this tutorial is for you.

### **Running the Exercises Locally**

You'll want to have an understanding of git to clone the repository, basic node and npm (yarn) , as well as TypeScript itself to work through this tutorial.

If you want to save your work or work in a different environment, you can also [clone the git repository](https://github.com/total-typescript/zod-tutorial) and work locally in the editor of your choice. If you [follow this link to use gitpod](https://gitpod.io/#https://github.com/total-typescript/zod-tutorial), you can work in a full VS Code coding environment running in your browser.

Follow the instructions in the [README](https://github.com/total-typescript/zod-tutorial/blob/main/README.md) to get the exercises running.

Zod is a TypeScript-first schema declaration and validation library. In this tutorial, Matt Pocock has prepared a set of exercises that will help you level up.

Transcript

Be Specific with Allowed Types

Transcript