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 SCHEMA
export namespace llm {
  // collection of function calling schemas
  export function application<Class, Model>(): ILlmApplication<Class>;
  export function controller<Class, Model>(
    name: string,
    execute: Class,
  ): ILlmController<Model>; // +executor
  // structured output
  export function parameters<P, Model>(): ILlmSchema.IParameters<Model>; 
  export function schema<T, Model>(
    $defs: Record<string, ILlmSchema<Model>>,
  ): ILlmSchema<Model>; // type schema
}

// 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 schema and structured output
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

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;
})();

Sponsors

Thanks for your support.

Your donation encourages typia development.

Also, typia is re-distributing half of donations to core contributors of typia.

Playground

You can experience how typia works by playground website:

💻 https://typia.io/playground

Guide Documents

Check out the document in the website:

🏠 Home

📖 Features

🔗 Appendix