Laravel TypeScript Generator

Generate TypeScript type definitions from your Laravel Eloquent models automatically. Uses both database schema introspection and model metadata ($casts, $timestamps, etc.) to produce accurate types.

Version Support

Features

• Schema introspection — reads your actual database columns, types, and nullability
• Cast-aware — Laravel $casts override the raw DB type (e.g. a json column cast to array becomes unknown[])
• Relationship support — optionally include hasMany, belongsTo, etc. as typed properties
• API Resource support — optionally generate types from JsonResource classes (what your API actually returns)
• Per-model files — generates one .d.ts per model plus a barrel index.d.ts
• Configurable — nullable style (| null vs ?), excluded models, manual type overrides

Installation

composer require synergitech/laravel-typescript-generator

The service provider is auto-discovered by Laravel. No manual registration needed.

Publish the config (optional)

php artisan vendor:publish --tag=typescript-generator-config

This creates config/typescript-generator.php where you can customise everything.

Usage

Basic generation

php artisan types:generate

This scans App\Models, introspects each model's database table, and writes .d.ts files to resources/js/types/.

With relationships

php artisan types:generate --with-relationships

With API resources

php artisan types:generate --with-resources

Resources are off by default. Pass --with-resources (or set include_resources: true in config) to scan App\Http\Resources and generate a .d.ts per resource in resources/js/types/resources/.

Dry run (preview without writing)

php artisan types:generate --dry-run

Example Output

Given a User model with this table:

And these casts:

protected $casts = [
    'is_admin' => 'boolean',
    'metadata' => 'array',
];

The generator produces resources/js/types/User.d.ts:

// Auto-generated by laravel-typescript-generator
// Model: App\Models\User
// Generated at: 2026-04-08T12:00:00+00:00

export interface User {
  /** DB: bigint */
  id: number;
  /** DB: varchar | Cast: string */
  name: string;
  /** DB: varchar | Cast: string */
  email: string;
  /** DB: boolean | Cast: boolean */
  is_admin: boolean;
  /** DB: json | Cast: array | nullable */
  metadata: unknown[] | null;
  /** DB: timestamp | nullable */
  created_at: string | null;
  /** DB: timestamp | nullable */
  updated_at: string | null;
}

Resource output

Given a UserResource that returns:

public function toArray(Request $request): array
{
    return [
        'id'         => $this->id,
        'name'       => $this->name,
        'email'      => $this->email,
        'role'       => $this->when($request->user()?->isAdmin(), $this->role),
        'address'    => new AddressResource($this->address),
    ];
}

The generator produces resources/js/types/resources/UserResource.d.ts:

// Auto-generated by laravel-typescript-generator
// Resource: App\Http\Resources\UserResource

import type { AddressResource } from './AddressResource';

export interface UserResource {
  id: unknown | null;
  name: unknown | null;
  email: unknown | null;
  role?: unknown;
  address: AddressResource;
}

Fields from $this->when(...) whose condition is false at generation time are marked optional (?). Fields whose runtime value is null (empty model attributes) are typed unknown | null. You can refine these with type_overrides in config if needed.

With --with-relationships, if User hasMany Post:

export interface User {
  // ... attributes ...

  // Relationships
  posts?: Post[];
}

Configuration

Type Overrides Example

// config/typescript-generator.php
'type_overrides' => [
    App\Models\User::class => [
        'metadata' => '{ avatar: string; theme: "light" | "dark" }',
        'role'     => '"admin" | "editor" | "viewer"',
    ],
],

How Type Resolution Works

For each column the generator applies this priority:

1. Manual override (type_overrides in config) — highest priority
2. Laravel cast ($casts on the model) — takes precedence over raw DB type
3. Database column type (via schema introspection) — fallback

This means your casts are always respected. If you cast a json column to array, the TS type will be unknown[], not Record<string, unknown>.

Tip: Add to Your Workflow

Add it to your composer.json scripts so types regenerate after migrations:

{
    "scripts": {
        "post-migrate": [
            "php artisan types:generate"
        ]
    }
}

Or add it to a git pre-commit hook or CI pipeline to keep types in sync.

License

MIT