Question 1

Should I generate TypeScript types from JSON, or hand-write them?

Accepted Answer

**Generate first, refine after.** Generated types are accurate to the SAMPLE you provide but not the full API contract, they capture what was IN the response, not what COULD be. Hand-refining adds: **(1) Optional markers** (`?`) for fields that may be absent in other responses. **(2) Union types** for fields with multiple possible shapes. **(3) Literal types** for enum-like strings (`status: "active" | "pending"`). **(4) JSDoc comments** describing semantics. **(5) Branded types** for IDs (`type UserId = string & { __brand: 'UserId' }`). The generator skips the boring transcription; you add the semantic refinements. **Even better**: if the API has OpenAPI/JSON Schema, generate from that instead (`openapi-typescript`), the schema captures the full contract.

Question 2

What's the difference between `interface` and `type` in TypeScript?

Accepted Answer

**`interface`**: extendable via declaration merging (multiple `interface User {}` declarations in the same scope merge); designed for object shapes; can be `extends`'d. **`type`**: a type alias; can represent anything (unions, intersections, primitives, mapped types, conditional types); cannot be merged across declarations. **Functionally identical for object shapes**: `interface User { name: string }` and `type User = { name: string }` are interchangeable for most uses. **Style guidelines**: TypeScript team recommends `interface` for object shapes (better error messages, supports declaration merging for library augmentation), `type` for unions/intersections/aliases. **In practice**, teams pick one and stick with it, consistency matters more than which. This generator outputs `interface` by default.

Question 3

How does the generator handle arrays of mixed types or empty arrays?

Accepted Answer

**Arrays of identical objects**: infers single element type. `[{name: "a"}, {name: "b"}]` → `Array<{name: string}>`. **Arrays of mixed primitives**: union. `[1, "two"]` → `Array`. **Empty arrays**: can't infer element type from sample, typically generates `Array` or `Array`. **You should refine empty arrays manually** since the generator literally has no data to work with. **Heterogeneous object arrays**: more complex, `[{type: "a", x: 1}, {type: "b", y: 2}]` could be inferred as discriminated union (`{type: "a", x: number} | {type: "b", y: number}`) or merged interface with optional fields. The generator typically picks one; the discriminated union pattern is usually closer to API reality.

Question 4

What does `unknown` vs `any` mean and when should the generator use either?

Accepted Answer

**`any`** opts out of type checking: any operation is allowed, type errors silenced. Useful but dangerous, defeats TypeScript's purpose. **`unknown`** means "we don't know the type, but you must check before using." Forces type narrowing via `typeof`, `instanceof`, or type guards before access. Always prefer `unknown` over `any`. **For unknown JSON values**: `unknown` is correct (or sometimes more specific: `Record<string, unknown>` for object-shaped unknowns). **When the generator outputs `any`**: usually for null fields where no other type info is available. Refine to `string | null`, `number | null`, etc. once you know the contract. **TypeScript's `--strict` mode** flags many implicit `any`s; sets `noImplicitAny` and friends. Use it.

Question 5

Should I generate types per-endpoint or share types across the codebase?

Accepted Answer

**Share types when they represent the same logical entity.** A `User` type used by `/api/users/:id` and `/api/posts/:id/author` should be ONE type, duplicating means changes to the User shape get out of sync. **Separate types when shapes legitimately differ**: the list endpoint may return a `UserSummary` (id, name only) while the detail endpoint returns a `UserDetail` (full fields). Make this explicit. **Organization patterns**: (1) `types/` directory with files per domain (`types/user.ts`, `types/post.ts`). (2) Co-locate types with the API client (`api/users.ts` exports `User` and the fetcher). (3) Generated from OpenAPI into `generated/api-types.ts`. **Don't put all types in one file**, it becomes unreadable and import overhead grows.

Question 6

Is my JSON sent anywhere when I generate types?

Accepted Answer

No. The generator parses your JSON, walks the structure, and emits TypeScript, all in JavaScript running in your browser. Open DevTools Network during use: zero outbound requests. **This matters specifically**: API responses are exactly the kind of content you DON'T want to upload, they're snapshots of production data, often containing user PII, internal IDs, auth tokens, internal field names that reveal architecture. A tool that uploaded would be leaking the data your types describe. Stays in the tab.

Question 7

What standards does TypeScript Type Generator validate against?

Accepted Answer

TypeScript Type Generator checks compliance with TypeScript type system, RFC 8259 (JSON).

Question 8

What are the limitations of TypeScript Type Generator?

Accepted Answer

Inference is heuristic, may not handle all edge cases Does not generate branded types or template literal types Does not handle circular references

JSON Type	TS Interface Mapping	Refinement Strategy
`string`	`string`	Literal Unions (Enums)
`number`	`number`	Branded Types (IDs)
`null`	`any \| null`	Optionality (`?:`)
`object`	`interface`	Recursive extraction

TypeScript Type Generator

Intelligent Mapping

TypeScript Interfaces

Privacy note

How to Use TypeScript Type Generator

Paste JSON or JavaScript

Generate Types

Copy

TypeScript Type Generator: the essentials

Key points

Learn More

JSON Schema Validation: Stop Trusting API Responses Blindly

Stop Hand-Writing Your Types: The Engineering Case for JSON-to-Type Codegen

Stop Trusting LLM JSON: Validate AI Outputs with Zod in 5 Minutes

What is TypeScript Type Generator?

Frequently Asked Questions

Technical Deep Dive

TypeScript Type Generator

Infers unions & optionals

Round-trips cleanly

Sample data stays local

01 Type Mapping Protocol

02 Recursive Generation Pipeline

Runs 100% in your browser

You Might Also Need

Git Commit Message Generator

Regex Explainer

AI Code Review Assistant

API Client Code Generator