## 1. Project Overview & Quickstart (samchon/typia)

# Typia



[](https://github.com/samchon/typia/blob/master/LICENSE)
[](https://www.npmjs.com/package/typia)
[](https://www.npmjs.com/package/typia)
[](https://github.com/samchon/typia/actions?query=workflow%3Atest)
[](https://typia.io/docs/)
[](https://discord.gg/E94XhzrUCZ)

```typescript
// 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

Install `typia` with the [`ttsc`](https://github.com/samchon/ttsc) toolchain.

```bash
# 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`](https://github.com/samchon/ttsc/tree/master/packages/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.

```typescript
//----
// 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

[](https://opencollective.com/typia)

Thanks for your support.

Your [donation](https://opencollective.com/typia) encourages `typia` development.

## Playground

You can experience how typia works by [playground website](https://typia.io/playground):

- 💻 https://typia.io/playground

## Guide Documents

Check out the document in the [website](https://typia.io/docs/):

### 🏠 Home

- [Introduction](https://typia.io/docs/)
- [Setup](https://typia.io/docs/setup/)
- [Pure TypeScript](https://typia.io/docs/pure/)
  
### 📖 Features

- Runtime Validators
  - [`assert()` function](https://typia.io/docs/validators/assert/)
  - [`is()` function](https://typia.io/docs/validators/is/)
  - [`validate()` function](https://typia.io/docs/validators/validate/)
  - [Functional Module](https://typia.io/docs/validators/functional)
  - [Special Tags](https://typia.io/docs/validators/tags/)
- Enhanced JSON
  - [JSON Schema](https://typia.io/docs/json/schema/)
  - [`stringify()` functions](https://typia.io/docs/json/stringify/)
  - [`parse()` functions](https://typia.io/docs/json/parse/)
- LLM Function Calling Harness
  - [`application()` function](https://typia.io/docs/llm/application/)
  - [`structuredOutput()` function](https://typia.io/docs/llm/structuredOutput/)
  - [`HttpLlm` module](https://typia.io/docs/llm/http/)
  - [`LlmJson` module](https://typia.io/docs/llm/json/)
- Protocol Buffer
  - [Message Schema](https://typia.io/docs/protobuf/message)
  - [`decode()` functions](https://typia.io/docs/protobuf/decode/)
  - [`encode()` functions](https://typia.io/docs/protobuf/encode/)
- [Random Generator](https://typia.io/docs/random/)
- [Miscellaneous](https://typia.io/docs/misc/)

### 🔗 Appendix

- [API Documents](https://typia.io/api)
- Utilization Cases
  - [MCP](https://typia.io/docs/utilization/mcp/)
  - [Vercel AI SDK](https://typia.io/docs/utilization/vercel/)
  - [LangChain](https://typia.io/docs/utilization/langchain/)
  - [NestJS](https://typia.io/docs/utilization/nestjs/)
  - [tRPC](https://typia.io/docs/utilization/trpc/)
- [⇲ Benchmark Result](https://github.com/samchon/typia/tree/master/benchmark/results/11th%20Gen%20Intel(R)%20Core(TM)%20i5-1135G7%20%40%202.40GHz)
- [⇲ `dev.to` Articles](https://dev.to/samchon/series/22474)

## Inspired By

- [`typescript-is`](https://github.com/woutervh-/typescript-is)

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

AssemblyScript's Website
========================



The site is built with [VuePress](https://vuepress.vuejs.org/) and reuses its default theme to ease upgrading to newer versions.

The more important files are:

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

Editor component
----------------

Markdown files can make use of a custom [editor component](./src/.vuepress/public/editor.html) 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
--------

To work on the site locally, install the dependencies and start a development server serving at [localhost:8080](http://localhost:8080/):

```sh
npm install
npm start
```

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

```sh
npm run build
```

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

```sh
npm run serve
```

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