Schemas and Type Inference

Use your schema's parse() method to validate data. It returns the validated data or throws a ZodError:

import { z } from "zod";

const UserSchema = z.object({
  id: z.number(),
  name: z.string(),
});

try {
  const user = UserSchema.parse(unknownData);
  // user is now typed and validated
  console.log(user.name); // TypeScript knows this is a string
} catch (error) {
  if (error instanceof z.ZodError) {
    console.error("Validation failed:", error.errors);
  }
}

Zod can automatically generate TypeScript types from your schemas using z.infer:

type User = z.infer<typeof UserSchema>;
// User is: { id: number; name: string }

This means you define your data structure once in the schema, and get both:

• Runtime validation via parse()
• Compile-time TypeScript types via z.infer

You don't need to maintain two definitions with separate TypeScript interfaces and validation logic:

interface User {
  id: number;
  name: string;
}

function validateUser(data: any): User {
  // Manual validation logic...
}

Instead, you can have a single definition that provides both runtime validation and compile-time types:

const UserSchema = z.object({
  id: z.number(),
  name: z.string(),
});

type User = z.infer<typeof UserSchema>;

Put your Jello issue schema to work in a real API call. You'll update a fetch call to use proper validation.

1. Use z.infer to create a TypeScript type from your schema
2. Update the API endpoint URL in fetchJelloIssue() to fetch issues. It's currently fetching projects...
3. If the response isn't an array, throw an error.

4. Validate the response by parsing every issue in the array using the schema.