Typia

1// RUNTIME VALIDATORS
2export function is<T>(input: unknown): input is T; // returns boolean
3export function assert<T>(input: unknown): T; // throws TypeGuardError
4export function assertGuard<T>(input: unknown): asserts input is T;
5export function validate<T>(input: unknown): IValidation<T>; // detailed
6
7// JSON FUNCTIONS
8export namespace json {
9  export function application<T>(): IJsonApplication; // JSON schema
10  export function assertParse<T>(input: string): T; // type safe parser
11  export function assertStringify<T>(input: T): string; // safe and faster
12}
13
14// LLM FUNCTION CALLING SCHEMA
15export namespace llm {
16  // application schema from a class or interface type
17  export function application<App, Model>(): ILlmApplication<Model>;
18  // structured output
19  export function parameters<P, Model>(): ILlmSchema.IParameters<Model>; 
20  export function schema<T, Model>(): ILlmSchema<Model>; // type schema
21}
22
23// PROTOCOL BUFFER
24export namespace protobuf {
25  export function message<T>(): string; // Protocol Buffer message
26  export function assertDecode<T>(buffer: Uint8Array): T; // safe decoder
27  export function assertEncode<T>(input: T): Uint8Array; // safe encoder
28}
29
30// RANDOM GENERATOR
31export 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.

1//----
2// examples/checkString.ts
3//----
4import typia, { tags } from "typia";
5export const checkString = typia.createIs<string>();
6
7//----
8// examples/checkUUID.js
9//----
10import typia from "typia";
11export const checkString = (() => {
12  return (input) => "string" === typeof input;
13})();

Sponsors

Thanks for your support.

Your donation encourages typia development.

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

• nonara/ts-patch
• ryoppippi/unplugin-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

• Introduction
• Setup
• Pure TypeScript

📖 Features

• Runtime Validators
  • assert() function
  • is() function
  • validate() function
  • Functional Module
  • Special Tags
• Enhanced JSON
  • JSON Schema
  • stringify() functions
  • parse() functions
• LLM Function Calling
  • application() function
  • parameters() function
  • schema() function
  • AI Chatbot Development
  • Documentation Strategy
• Protocol Buffer
  • Message Schema
  • decode() functions
  • encode() functions
• Random Generator
• Miscellaneous

🔗 Appendix

• API Documents
• Utillization Cases
  • NestJS
  • tRPC
• ⇲ Benchmark Result
• ⇲ dev.to Articles