Typia

// RUNTIME VALIDATORS
export function is<T>(input: unknown): input is T; // returns boolean
export function assert<T>(input: unknown): T; // throws TypeGuardError
export function assertGuard<T>(input: unknown): asserts input is T;
export function validate<T>(input: unknown): IValidation<T>; // detailed
// JSON FUNCTIONS export namespace json {   export function schema<T>(): IJsonSchemaUnit<T>; // JSON schema   export function assertParse<T>(input: string): T; // type safe parser   export function assertStringify<T>(input: T): string; // safe and faster }
// AI FUNCTION CALLING HARNESS export namespace llm {   // collection of function calling schemas + validators/parsers   export function application<Class>(): ILlmApplication<Class>;   export function structuredOutput<P>(): ILlmStructuredOutput;   // lenient json parser + type coercion   export function parse<T>(str: string): T; }
// PROTOCOL BUFFER export namespace protobuf {   export function message<T>(): string; // Protocol Buffer message   export function assertDecode<T>(buffer: Uint8Array): T; // safe decoder   export function assertEncode<T>(input: T): Uint8Array; // safe encoder }
// RANDOM GENERATOR export function random<T>(g?: Partial<IRandomGenerator>): T;

typia is a transformer library supporting below features:

- Super-fast Runtime Validators - Enhanced JSON schema and serde functions - LLM function calling harness - Protocol Buffer encoder and decoder - Random data generator

[!NOTE]

>

- Only one line required, with pure TypeScript type

- Runtime validator is 20,000x faster than class-validator

- JSON serialization is 200x faster than class-transformer

- LLM function calling harness turns 6.75% → 100% accuracy

Setup

Install typia with the ttsc toolchain.

# install
npm i typia
npm i -D ttsc typescript
build
npx ttsc
run a script directly
npx ttsx src/index.ts

You must use ttsc and ttsx. The stock tsc, ts-node, and tsx cannot apply the typia transform, so they will not work.

For bundler integration (Vite, Next.js, Webpack, Rollup, esbuild, ...), use @ttsc/unplugin.

Transformation

If you call typia function, it would be compiled like below.

This is the key concept of typia, transforming TypeScript type to a runtime function. The typia.is<T>() function is transformed to a dedicated type checker by analyzing the target type T in the compilation level.

This feature enables developers to ensure type safety in their applications, leveraging TypeScript's static typing while also providing runtime validation. Instead of defining additional schemas, you can simply utilize the pure TypeScript type itself.

//----
// examples/checkString.ts
//----
import typia, { tags } from "typia";
export const checkString = typia.createIs<string>();
//---- // examples/checkString.js //---- import typia from "typia"; export const checkString = (() => {   return (input) => "string" === typeof input; })();