JSON to TypeScript Interface Generator

Hand-writing TypeScript interfaces to match an API response or a JSON config file is repetitive, easy to get subtly wrong (a typo'd property name doesn't error until you actually use it), and quickly gets tedious for anything with more than a couple of nested objects. This tool automates the first draft: paste a real JSON sample — an actual API response is ideal — and it walks the structure recursively, producing one or more `interface` declarations that describe exactly the shape you pasted. The recursive naming behaviour is the part that makes the output genuinely usable rather than a single giant, deeply-nested inline type. When the tool encounters a nested object, it doesn't inline that object's shape into the parent interface as an anonymous type — instead it generates a separate, named `interface` for it, deriving the name from the property key it was found under (converted to PascalCase: a key called `address` produces `interface Address`, a key called `billing_info` produces `interface BillingInfo`), and references that name from the parent (`address: Address;`). This mirrors how you would naturally structure hand-written TypeScript, keeping each interface focused and giving you meaningful, reusable names instead of one unreadable nested blob. Arrays are handled by inspecting every element and inferring the element type: an array of plain strings becomes `string[]`, an array of numbers becomes `number[]`, and an array of objects generates a named interface for the object shape (again derived from the parent key, typically singularised informally by just reusing the same PascalCase key name) and produces `KeyName[]`. If an array contains a genuine mix of element types — some strings, some numbers — the tool falls back to a union type, `(string | number)[]`, rather than picking one arbitrarily and silently dropping information about the others. Primitive JSON values map onto TypeScript's built-in types directly: JSON strings become `string`, JSON numbers become `number` (TypeScript, like JSON, does not distinguish integers from floats at the type level), JSON booleans become `boolean`, and a JSON `null` value for a given property is represented as `Type | null` using whatever type the tool infers from other array elements or, for a lone null with no other information, `unknown | null`. Worth being upfront about: this is best-effort inference from a single sample, not schema validation. If a property is `null` in your sample but would actually hold a string in other API responses, the tool has no way to know that unless you paste a sample where it appears as a string — it can only describe what it sees. Likewise, TypeScript's `?` optional-property marker is not applied to anything, because a single object gives no signal about which fields are sometimes absent versus always present. A natural next step, deliberately left out of this simple version, would be accepting an array of multiple sample objects and diffing which properties are present across all of them versus only some — marking the latter as optional — but that is a meaningfully more complex feature and out of scope here.