Skip to Content
Typia
Transform pure TypeScript types into
20,000x faster runtime validators, JSON serializers, and LLM schemas

Zero schema. Zero overhead. Just TypeScript.

Guide DocumentsPlaygroundGitHub

AOT Compilation Magic

Write TypeScript types as you normally would. At compile time, typia analyzes the AST and generates dedicated, optimized validation code.

Input

Your TypeScript Code

import typia, { tags } from "typia";

interface IMember {
  id: string & tags.Format<"uuid">;
  email: string & tags.Format<"email">;
  age: number &
    tags.Type<"uint32"> &
    tags.ExclusiveMinimum<19> &
    tags.Maximum<100>;
}

// just one line, with pure TypeScript type
const check: boolean = typia.is<IMember>(input);
→
↓
Output

Compiled Output

// compiled JavaScript — no schema overhead
((input) => {
  return (
    "object" === typeof input &&
    null !== input &&
    "string" === typeof input.id &&
    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5].*$/.test(input.id) &&
    "string" === typeof input.email &&
    /^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}$/.test(input.email) &&
    "number" === typeof input.age &&
    Number.isInteger(input.age) &&
    input.age >= 0 &&
    19 < input.age &&
    100 >= input.age
  );
})

Key Features

One library. Pure TypeScript types. Every runtime feature you need.

⚡

Super-fast Validation

typia.validate<T>(input)

20,000x faster (than class-validator)

AOT-compiled runtime validators outperform class-validator by 20,000x. Supports complex union types, recursive structures, and the most detailed error reporting.

🔄

JSON Serialization

typia.json.stringify<T>(input)

200x faster (than class-transformer)

Type-safe JSON stringify 200x faster than class-transformer. JSON schema generation for OpenAPI is also supported.

🤖

LLM Function Calling

typia.llm.application<App>()

6.75% → 100% (qwen3-coder-next)

Generate function calling schemas from TypeScript types. Validation feedback, lenient JSON parsing, and type coercion boost LLM success rates.

📦

Protocol Buffers

typia.protobuf.encode<T>(input)

Full Spec (only one in TypeScript)

The only TypeScript library supporting the full Protocol Buffer spec. No .proto files needed — just use your TypeScript types.

🎲

Random Generator

typia.random<T>()

Universal (with constraint tags)

Generate mock data that perfectly conforms to your TypeScript types. Respects constraints, formats, and custom tags.

Why AOT Compilation?

Traditional validators parse schemas at runtime. Typia generates dedicated validation code at compile time — the difference is measured in orders of magnitude.

Traditional Approach

✕

Define a separate schema object (Zod, io-ts, class-validator decorators)

✕

Schema is parsed and interpreted at every function call — runtime overhead

✕

TypeScript type and schema easily drift apart — double maintenance

✕

Complex union types and nested objects require verbose, manual handling

Typia — AOT Compilation

✓

Write pure TypeScript types — no schema DSL, no decorators, no duplication

✓

Compiler analyzes the type AST and emits optimized native code — zero runtime parsing

✓

Type and validator are always in sync — single source of truth

✓

Full support for unions, intersections, recursion, template literals, and tagged types

LLM Function Calling

Generate function calling schemas directly from TypeScript types.
Validation feedback boosts up LLM function calling success rates.

AI

LLM Integration

import { LlmJson } from "@typia/utils";
import typia, { tags } from "typia";

class ShoppingOrderController {
  /** some description comment for AI */
  create(input: IShoppingOrderCreate): void;
}

// Generate application
const app = typia.llm.application<ShoppingOrderController>();
const func = app.functions[0];

// Lenient parse + validation feedback
const data = func.parse(llmOutput);
const result = func.validate(data);
if (result.success === false)
  const feedback = LlmJson.stringify(result);

✅

Validation Feedback

Validate LLM output with typia.validate, then feed IValidation.IFailure back to the LLM for self-correction

🔧

Lenient JSON Parsing

Recover from malformed JSON that LLMs frequently produce — broken quotes, trailing commas, missing brackets

🔄

Type Coercion

Automatically cast LLM string responses to proper TypeScript types — "1" becomes number 1

📐

Schema Generation

Generate function calling schemas directly from pure TypeScript types. No manual schema writing needed

Sponsors

Thanks for your support. Your donation encourages typia development.

Also, typia is re-distributing quarter of donations to nonara/ts-patch.

Sponsors
Last updated on