typia Documentation

1. Project Overview & Quickstart (samchon/typia) Copy Chapter

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(): 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): 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

Write the type on the left, and typia compiles it into the validator on the right — at build time, with no schema and no runtime reflection.

Setup Copy Chapter

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 Copy Chapter

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 Copy Chapter

Thanks for your support.

Your donation encourages typia development.

Playground Copy Chapter

You can experience how typia works by playground website:

• 💻 https://typia.io/playground

Guide Documents Copy Chapter

Check out the document in the website:

🏠 Home Copy Section

• Introduction
• Setup
• Pure TypeScript

📖 Features Copy Section

• Runtime Validators
  • assert() function
  • is() function
  • validate() function
  • Functional Module
  • Special Tags
• Enhanced JSON
  • JSON Schema
  • stringify() functions
  • parse() functions
• LLM Function Calling Harness
  • application() function
  • structuredOutput() function
  • HttpLlm module
  • LlmJson module
• Protocol Buffer
  • Message Schema
  • decode() functions
  • encode() functions
• Random Generator
• Miscellaneous

🔗 Appendix Copy Section

• API Documents
• Utilization Cases
  • MCP
  • Vercel AI SDK
  • LangChain
  • NestJS
  • tRPC
• ⇲ Benchmark Result
• ⇲ dev.to Articles

Inspired By Copy Chapter

• typescript-is

2. Official Technical Reference & Guides (samchon/website) Copy Chapter

AssemblyScript's Website

The site is built with VuePress and reuses its default theme to ease upgrading to newer versions.

The more important files are:

• src/**/*.md
  Documentation and site contents, i.e. what one would typically modify when extending the documentation.
• src/.vuepress/sidebar.js
  Sidebar contents.
• src/.vuepress/nav.js
  Top-navigation contents.
• src/.vuepress/redirects
  Redirect map of (re)moved pages to new locations.
• src/.vuepress/public/
  Assets folder for images etc.
• src/.vuepress/public/sponsors
  Sponsor logo overrides (file name is collective name).

Editor component Copy Chapter

Markdown files can make use of a custom editor component using the editor language tag, like so:

```editor
#!optimize=size&runtime=none&noAssert&explicitStart&enable=simd,reference-types
export function add(a: i32, b: i32): i32 {
  return a + b
}

#!html
<script>
loader.instantiate(module_wasm, { /* imports */ })
  .then(({ exports }) => {
    console.log(exports.add(1, 2))
  })
</script>
```

The first line is an optional shebang indicating selected compiler options. Available options are:

• optimize = string
  Optimization preset to use. Valid presets are speed, size and none
• noAssert
  Replaces assertions with just their value without trapping.
• debug
  Enables debug information in emitted binaries.
• runtime = string
  Specifies the runtime variant to include in the program. Valid variants are full, half, stub and none.
• noExportMemory
  Does not export the memory to the host.
• importMemory
  Imports the memory from the host.
• exportTable
  Exports the function table to the host.
• importTable
  Imports the function table from the host.
• explicitStart
  Exports an explicit start function to call.
• memoryBase = integer
  Sets the start offset of emitted memory segments.
• tableBase = integer
  Sets the start offset of emitted table elements.
• use = string
  Comma separated list of global aliases, e.g. to switch the default 'Math' implementation used: Math=JSMath
• enable = string
  Comma-separated list of future WebAssembly features to enable. Valid features are sign-extension, bulk-memory, simd, threads and reference-types.

The current source and associated compiler options can be serialized into a base64 blob this way. For example, when the 🔗 button is clicked, document.location.hash is updated with that blob and the then-sharable link is copied to clipboard.

Building Copy Chapter

To work on the site locally, install the dependencies and start a development server serving at localhost:8080:

npm install
npm start

To build the site to dist, i.e. to verify that it works as expected:

npm run build

Distribution files can also be served instead of using the development server with:

npm run serve

The page is automatically deployed on pushes to the repository, plus at least once a day to sync contributors and sponsors.