TypeScript to JSON Schema

export interface User {
  id: number;
  email?: string;
  tags: string[];
}

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "User",
  "type": "object",
  "properties": {
    "id": {
      "type": "number"
    },
    "email": {
      "type": "string"
    },
    "tags": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "id",
    "tags"
  ],
  "additionalProperties": false
}

Defaults. The ? on email is the whole difference between the two required entries and the third, and number covers every numeric type TypeScript has, so nothing promises a whole number.

interface Box<T> {
  value: T;
}
interface Summary {
  picked: Pick<User, "id">;
  user: User;
}
interface User {
  id: number;
  name: string;
}

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "Summary",
  "type": "object",
  "properties": {
    "picked": true,
    "user": {
      "$ref": "#/$defs/User"
    }
  },
  "required": [
    "picked",
    "user"
  ],
  "additionalProperties": false,
  "$defs": {
    "User": {
      "title": "User",
      "type": "object",
      "properties": {
        "id": {
          "type": "number"
        },
        "name": {
          "type": "string"
        }
      },
      "required": [
        "id",
        "name"
      ],
      "additionalProperties": false
    }
  }
}

Edge case. Two constructs need a type checker: the generic Box at 1:1 and the Pick at 5:11. Both are reported there, picked is left open rather than invented, and the plain User reference resolves.

interface Node {
  value: string;
  children: Node[];
}

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$ref": "#/$defs/Node",
  "$defs": {
    "Node": {
      "title": "Node",
      "type": "object",
      "properties": {
        "value": {
          "type": "string"
        },
        "children": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/Node"
          }
        }
      },
      "required": [
        "value",
        "children"
      ],
      "additionalProperties": false
    }
  }
}

A type that mentions itself moves into the definitions container and the document points at it, so a validator follows the same loop the data takes rather than some fixed depth.

type Pair = [string, number?, ...boolean[]];

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "Pair",
  "type": "array",
  "items": [
    {
      "type": "string"
    },
    {
      "type": "number"
    }
  ],
  "additionalItems": {
    "type": "boolean"
  },
  "minItems": 1
}

Draft-07 spells fixed positions as an array under items and the rest under additionalItems. Only the first slot is mandatory, so minItems is 1; on 2020-12 the same source uses prefixItems.

enum Color {
  Red = "red",
  Green = "green",
}
enum Level {
  Low,
  High = 5,
  Higher,
}
interface Item {
  color: Color;
  level: Level;
}

import * as z from "zod";


export const ColorSchema = z.enum([
    "green",
    "red",
]);
export type Color = z.infer<typeof ColorSchema>;

export const ItemSchema = z.object({
    "color": ColorSchema,
    "level": z.number(),
});
export type Item = z.infer<typeof ItemSchema>;

Zod mode, rooted at Item. The string enum survives as a fixed value list; the numeric one arrives as z.number(), losing the members 0, 5 and 6 that the JSON Schema output does keep.