Use interface (vs type) Export declarations Readonly properties

Features

🔷 TypeScript Types

Interface and type alias support
Nested object interfaces
Array type inference
Null-aware optional fields

⚙️ Configurable Output

Toggle interface vs type
Export declarations
Readonly modifiers
Nested type generation

🎯 Type Accuracy

string, number, boolean inference
unknown | null for null values
Type[] for arrays
unknown[] for empty arrays

TypeScript Guide

Interface vs Type

TypeScript interfaces and type aliases are both used to describe object shapes. Interfaces are extensible with declaration merging; type aliases support unions and intersections.

// Interface (extensible)
export interface User {
  id: number;
  name: string;
  active: boolean;
}

// Type alias (flexible)
export type User = {
  id: number;
  name: string;
  active: boolean;
};

Using Generated Types

import type { Root } from './types';

async function fetchUser(): Promise<Root> {
  const res = await fetch('/api/user');
  return res.json() as Root;
}

const user: Root = await fetchUser();
console.log(user.name); // type-safe access

Common Use Cases

API Responses: Type-safe REST API response handling
Config Files: Strongly-typed configuration objects
React Props: Component prop type definitions
Zustand/Redux: Typed state management stores
Form Data: Validated form submission payloads

FAQ

Q: When should I use interface vs type?

A: Use interface when you need declaration merging or plan to extend the type. Use type when you need union types, mapped types, or more complex compositions.

Q: Why are null fields typed as unknown | null?

A: When a JSON value is null, the actual non-null type cannot be inferred. unknown | null (simplified as the optional field pattern) signals that the field exists but the concrete type requires manual annotation.

JSON to TypeScript Interface Generator