Now we've got a function to print our StarWarsPeopleResults to the console:

```typescript
const logStarWarsPeopleResults = (data: unknown) => {
  data.results.map((person) => {
    console.log(person.name);
  });
};
```

Once again, the `data` type is `unknown`.

As a fix, it may be tempting to try something like this:

```typescript
const logStarWarsPeopleResults = (data: typeof StarWarsPeopleResults)
```

However this won't work because that would represent the type of the Zod object itself rather than `StarWarsPeopleResults`.

## Challenge

Update the `logStarWarsPeopleResults` function to extract a type from the passer object.

## Update the Logging Function

Using `z.infer` and passing it `typeof StarWarsPeopleResults` is the fix.

This passes in the schema from Zod, and returns a type that properly represents the data.

```typescript
const logStarWarsPeopleResults = (
  data: z.infer<typeof StarWarsPeopleResults>,
) => {
  ...
```

Now when you hover over the line in VS Code, you can see that data is an object that contains the results.

Making updates to the `StarWarsPerson` schema will update the `data` inside the function right away.

This is a great way to use Zod for runtime validation and then getting our type validation from it as well!

## An Alternative Solution

Alternatively, we could save the `StarWarsPeopleResultsType` in a type and export it from this file:

```typescript
export type StarWarsPeopleResultsType = z.infer<typeof StarWarsPeopleResults>;
```

Then the `logStarWarsPeopleResults` function could be updated to provide the data type like so:

```typescript
const logStarWarsPeopleResults = (data: StarWarsPeopleResultsType) => {
  data.results.map((person) => {
    console.log(person.name);
  });
};
```

This would also allow other files in the project to take advantage of the `StarWarsPeopleResults` type if needed.

Use z.infer() to Extract a Type

Matt Pocock: 0:00 The way to do it is with z.infer. What you do with z.infer is you pass in the typeof StarWarsPeopleResults here. This is passing in the schema that you get from Zod. It returns a type that represents the data.

0:15 What you get here is data. If you hover over it, you get data, which is the object, with the results and name here. If we change this, if we had eye_color again, z.string, then what you end up with, that gets added to as well. This is a really brilliant way to use Zod to have your runtime validation and then get your type validation from it.

0:37 There's a slightly alternative way to do this as well, which is to just save this in a type. Then you can export it from this file. Other files in your repo can take advantage of it. As you can see, it's just a type with results and name here.

Extract a Type from a Parser Object

Matt Pocock: 0:00 We've got a bit of a problem on the type level, the type script level.

0:04 We've got this StarWarsPerson and we've got the StarWarsPeopleResults that we had from the last exercise, but now we've got this function that says logStarWarsPeopleResults. This data type here is unknown.

0:17 What we really want this to represent is we want this to represent StarWarsPeopleResults, right? We don't want it to represent this because if we do typeof StarWarsPeopleResults, that's not going to work because we actually want to represent the thing that it passes, not the actual object itself, or the Zod object itself.

0:38 That's a challenge for you. Zod actually does handle this really, really well, but I'll see if you can dive into the docs and work out how to extract a type from this passer object.

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

Extract a Type from a Parser Object

Transcript