typebox Documentation

$ npm install typebox

import Type from 'typebox'

const T = Type.Object({                     // const T = {
  x: Type.Number(),                         //   type: 'object',
  y: Type.Number(),                         //   required: ['x', 'y', 'z']
  z: Type.Number()                          //   properties: {
})                                          //     x: { type: 'number' },
                                            //     y: { type: 'number' },
                                            //     z: { type: 'number' }
                                            //   },
                                            // }

type T = Type.Static<typeof T>              // type T = {
                                            //   x: number,
                                            //   y: number,
                                            //   z: number
                                            // }

import Type from 'typebox'

const User = Type.Object({                       // const User = {
  id: Type.String(),                             //   type: 'object',
  name: Type.String(),                           //   required: [
  email: Type.String({ format: 'email' })        //     'id', 
})                                               //     'name', 
                                                 //     'email'
                                                 //   ],
                                                 //   properties: {
                                                 //     id: { type: 'string' },
                                                 //     name: { type: 'string' },
                                                 //     email: { 
                                                 //       type: 'string', 
                                                 //       format: 'email' 
                                                 //     }
                                                 //   }
                                                 // }

type User = Type.Static<typeof User>              // type User = {
                                                  //   id: string,
                                                  //   name: string,
                                                  //   email: string
                                                  // }

import Type from 'typebox'

const Math = Type.Script(`
  type Vector4 = { x: number, y: number, z: number, w: number }
  type Vector3 = { x: number, y: number, z: number }
  type Vector2 = { x: number, y: number }
`)

const Graphics = Type.Script(Math, `
  type Vertex = {
    position: Vector4,
    normal: Vector3,
    uv: Vector2
  }
  type Geometry = {
    vertices: Vertex[],
    indices: number[]
  }
  type Material = {
    ambient: Vector4,
    diffuse: Vector4,
    specular: Vector4
  }
  type Mesh = {
    geometry: Geometry,
    material: Material
  }
`)

type Mesh = Type.Static<typeof Graphics['Mesh']>  // type Mesh = {
                                                  //   geometry: { ... },
                                                  //   material: { ... }
                                                  // }

import Schema from 'typebox/schema'

import Schema from 'typebox/schema'

// Compile

const Vector = Schema.Compile(Type.Script(`{
  x: number
  y: number
  z: number
}`))

// Check

const valid = Vector.Check({ x: 1, y: 0, z: 0 })   // const valid: boolean

// Parse

const result = Vector.Parse({ x: 1, y: 0, z: 0 })  // const result: {      
                                                   //   x: number
                                                   //   y: number
                                                   //   z: number
                                                   // }

┌──────────────────────┬──────────────┬──────────────┐
│ Compile              │ TB1X         │ AJV8         │
├──────────────────────┼──────────────┼──────────────┤
│ Boolean              │  54.9K ops/s │     7K ops/s │
│ Number               │ 154.2K ops/s │   7.8K ops/s │
│ String               │ 161.4K ops/s │   9.7K ops/s │
│ Null                 │ 111.9K ops/s │   8.9K ops/s │
│ Literal_String       │  34.6K ops/s │   7.5K ops/s │
│ Literal_Number       │  78.1K ops/s │   7.6K ops/s │
│ Literal_Boolean      │  79.7K ops/s │   8.4K ops/s │
│ Pattern              │  92.1K ops/s │   6.1K ops/s │
│ Object_Open          │  18.6K ops/s │   1.3K ops/s │
│ Object_Close         │    17K ops/s │    975 ops/s │
│ Object_Vector3       │  33.3K ops/s │   3.4K ops/s │
│ Object_Basis3        │  18.9K ops/s │    858 ops/s │
│ Intersect_And        │  63.5K ops/s │   3.6K ops/s │
│ Intersect_Structural │  25.7K ops/s │   1.7K ops/s │
│ Union_Or             │  58.2K ops/s │   3.3K ops/s │
│ Union_Structural     │  33.7K ops/s │     2K ops/s │
│ Tuple_Values         │  19.5K ops/s │     2K ops/s │
│ Tuple_Objects        │     4K ops/s │    388 ops/s │
│ Array_Numbers_4      │  90.7K ops/s │   4.3K ops/s │
│ Array_Numbers_8      │ 121.8K ops/s │   3.8K ops/s │
│ Array_Numbers_16     │ 116.6K ops/s │   3.9K ops/s │
│ Array_Objects_Open   │  22.6K ops/s │    802 ops/s │
│ Array_Objects_Close  │  18.4K ops/s │    930 ops/s │
└──────────────────────┴──────────────┴──────────────┘

┌──────────────────────┬──────────────┬──────────────┐
│ Validate             │ TB1X         │ AJV8         │
├──────────────────────┼──────────────┼──────────────┤
│ Boolean              │ 192.2M ops/s │ 189.5M ops/s │
│ Number               │ 112.4M ops/s │    61M ops/s │
│ String               │ 113.7M ops/s │  64.1M ops/s │
│ Null                 │ 112.8M ops/s │  64.9M ops/s │
│ Literal_String       │   108M ops/s │  62.9M ops/s │
│ Literal_Number       │ 113.5M ops/s │  63.2M ops/s │
│ Literal_Boolean      │ 109.2M ops/s │  64.1M ops/s │
│ Pattern              │  26.5M ops/s │  22.4M ops/s │
│ Object_Open          │    78M ops/s │  47.2M ops/s │
│ Object_Close         │  38.6M ops/s │  27.6M ops/s │
│ Object_Vector3       │    91M ops/s │  51.3M ops/s │
│ Object_Basis3        │  41.1M ops/s │  27.4M ops/s │
│ Intersect_And        │ 107.6M ops/s │  59.9M ops/s │
│ Intersect_Structural │  83.6M ops/s │  46.3M ops/s │
│ Union_Or             │    95M ops/s │   7.9M ops/s │
│ Union_Structural     │  84.5M ops/s │  52.3M ops/s │
│ Tuple_Values         │  74.7M ops/s │    53M ops/s │
│ Tuple_Objects        │  32.9M ops/s │  22.3M ops/s │
│ Array_Numbers_4      │  93.3M ops/s │  55.1M ops/s │
│ Array_Numbers_8      │  90.3M ops/s │  50.8M ops/s │
│ Array_Numbers_16     │  76.8M ops/s │  39.6M ops/s │
│ Array_Objects_Open   │  28.7M ops/s │  20.4M ops/s │
│ Array_Objects_Close  │  10.3M ops/s │  10.8M ops/s │
└──────────────────────┴──────────────┴──────────────┘

import { ProtocolValidator, type ProtocolType } from './mcp/index.ts'

// ------------------------------------------------------------------
// Type
// ------------------------------------------------------------------
type CallToolRequest = ProtocolType<'CallToolRequest'>

// ------------------------------------------------------------------
// Validator
// ------------------------------------------------------------------
const CallToolRequestValidator = ProtocolValidator('CallToolRequest')

// ------------------------------------------------------------------
// Parse
// ------------------------------------------------------------------
const callToolRequest = CallToolRequestValidator.Parse({ 
  id: '...',
  jsonrpc: '2.0',
  method: 'tools/call',
  params: {
    _meta: {
      'io.modelcontextprotocol/clientCapabilities': {},
      'io.modelcontextprotocol/clientInfo': { name: '...', version: '...' },
      'io.modelcontextprotocol/protocolVersion': '1',
    },
    name: 'add',
    arguments: {
      x: 1,
      y: 2
    }
  }
})

// ------------------------------------------------------------------
// TypeSafe
// ------------------------------------------------------------------
callToolRequest.id                // 'id'
callToolRequest.jsonrpc           // '2.0'
callToolRequest.method            // 'tools/call'
callToolRequest.params            // { ... }

/* Detailed source-code truncated for AI context efficiency. */

import { Compile } from 'typebox/compile'

const C = Compile(Type.Object({                     // const C: Validator<{}, TObject<{
  x: Type.Number(),                                 //   x: TNumber,
  y: Type.Number(),                                 //   y: TNumber,
  z: Type.Number()                                  //   z: TNumber
}))                                                 // }>>

const A = C.Parse({                                 // const A: {
  x: 0,                                             //   x: number,
  y: 1,                                             //   y: number,
  z: 0                                              //   z: number
})                                                  // } = ...

import Format from 'typebox/format'

const A = Format.IsEmail('[email protected]')     // true

import Type from 'typebox'

const T = Type.Object({                             // const T = {
  x: Type.Number(),                                 //   type: 'object',
  y: Type.Number(),                                 //   required: ['x', 'y', 'z'],
  z: Type.Number()                                  //   properties: {
})                                                  //     x: { type: 'number' },
                                                    //     y: { type: 'number' },
                                                    //     z: { type: 'number' }
                                                    //   }
                                                    // }

type T = Type.Static<typeof T>                      // type T = {
                                                    //   x: number,
                                                    //   y: number,
                                                    //   z: number
                                                    // }

import Type from 'typebox'

const T = Type.Script(`{
  x: number
  y: number
  z: number
}`)

type T = Type.Static<typeof T>                      // type T = {
                                                    //   x: number,
                                                    //   y: number,
                                                    //   z: number
                                                    // }

const S = Type.Script({ T }, `{
  [K in keyof T]: T[K] | null
}`)

type S = Type.Static<typeof S>                      // type S = {
                                                    //   x: number | null,
                                                    //   y: number | null,
                                                    //   z: number | null
                                                    // }

import Type from 'typebox'
import Schema from 'typebox/schema'

const C = Schema.Compile(Type.Script(`{
  x: number
  y: number
  z: number
}`))

const R = C.Parse(...)                              // const R: {
                                                    //   x: number,
                                                    //   y: number,
                                                    //   z: number
                                                    // } = ...

import Schema from 'typebox/schema'

import Schema from 'typebox/schema'

// Compile

const Vector = Schema.Compile(Type.Script(`{
  x: number
  y: number
  z: number
}`))

// Check

const valid = Vector.Check({ x: 1, y: 0, z: 0 })   // const valid: boolean

// Parse

const result = Vector.Parse({ x: 1, y: 0, z: 0 })  // const result: {      
                                                   //   x: number
                                                   //   y: number
                                                   //   z: number
                                                   // }

import Type from 'typebox'

const Math = Type.Script(`
  type Vector4 = { x: number, y: number, z: number, w: number }
  type Vector3 = { x: number, y: number, z: number }
  type Vector2 = { x: number, y: number }
`)

const Graphics = Type.Script(Math, `
  type Vertex = {
    position: Vector4,
    normal: Vector3,
    uv: Vector2
  }
  type Geometry = {
    vertices: Vertex[],
    indices: number[]
  }
  type Material = {
    ambient: Vector4,
    diffuse: Vector4,
    specular: Vector4
  }
  type Mesh = {
    geometry: Geometry,
    material: Material
  }
`)

type Mesh = Type.Static<typeof Graphics['Mesh']>  // type Mesh = {
                                                  //   geometry: { ... },
                                                  //   material: { ... }
                                                  // }

import { Settings, Locale, Memory } from 'typebox/system'

import Type from 'typebox'

const User = Type.Object({                       // const User = {
  id: Type.String(),                             //   type: 'object',
  name: Type.String(),                           //   required: [
  email: Type.String({ format: 'email' })        //     'id',
})                                               //     'name',
                                                 //     'email'
                                                 //   ],
                                                 //   properties: {
                                                 //     id: { type: 'string' },
                                                 //     name: { type: 'string' },
                                                 //     email: {
                                                 //       type: 'string',
                                                 //       format: 'email'
                                                 //     }
                                                 //   }
                                                 // }

type User = Type.Static<typeof User>              // type User = {
                                                  //   id: string,
                                                  //   name: string,
                                                  //   email: string
                                                  // }

import Value from 'typebox/value'

const T = Type.Object({
  x: Type.Number(),
  y: Type.Number(),
  z: Type.Number()
})

const A = Value.Parse(T, {                          // const A: {
  x: 1,                                             //   x: number,
  y: 0,                                             //   y: number,
  z: 0                                              //   z: number
})                                                  // } = ...

import { Compile } from 'typebox/compile'

const C = Compile(Type.Object({                        // const C: Validator<{}, TObject<{
  x: Type.Number(),                                    //   x: TNumber,
  y: Type.Number(),                                    //   y: TNumber,
  z: Type.Number()                                     //   z: TNumber
}))                                                    // }>>

import { Validator } from 'typebox/compile'

const C = new Validator({}, Type.Object({              // const C: Validator<{}, TObject<{
  x: Type.Number(),                                    //   x: TNumber,
  y: Type.Number(),                                    //   y: TNumber,
  z: Type.Number()                                     //   z: TNumber
}))                                                    // }>>

import { Compile, Validator } from 'typebox/compile'

const T = Compile(Type.Object({                     // const T: Validator<{}, TObject<{
  x: Type.Number(),                                 //   x: TNumber,
  y: Type.Number(),                                 //   y: TNumber,
  z: Type.Number(),                                 //   z: TNumber
}))                                                 // }>>

const R = T.Check({ x: 1, y: 2, z: 3 })             // const R: boolean = true

const R = C.Check(value)                            // const R: boolean

const R = C.Errors(value)                          // const R: ValidationError[]

const R = C.Clean(value)                          // const R: unknown

const R = C.Code()                                // const R: string

const R = C.Convert(value)                        // const R: unknown

const R = C.Create(value)                        // const R: ...

const R = C.Decode(value)                       // const R: ...

const R = C.Default(value)                       // const R: unknown

const R = C.Encode(value)                       // const R: ...

const R = C.IsAccelerated()                      // const R: boolean

const R = C.Parse(value)                        // const R: ...

import { Code } from 'typebox/compile'

const result = Code(Type.String())

console.log(result.Code)                           // export function SetExternal(external) { ... }
                                                   //
                                                   // export function Check(value) { ... }

console.log(result.External)                       // { identifier: '...', variables: [...] }

import { Compile } from 'typebox/compile'

const C = Compile(Type.String())

console.log(C.IsAccelerated()) // true if accelerated

import System from 'typebox/system'

System.Settings.Set({ useAcceleration: false })   // default is true

// ...

const C = Compile(Type.String())

console.log(C.IsAccelerated())                    // will be false

import Format from 'typebox/format'

// ------------------------------------------------------------------
// Set
// ------------------------------------------------------------------
Format.Set('hex-color', value => {
  
  return /^#([0-9A-Fa-f]{6}|[0-9A-Fa-f]{3})$/.test(value)
})

// ------------------------------------------------------------------
// Get
// ------------------------------------------------------------------
const IsHexColor = Format.Get('hex-color')

// ------------------------------------------------------------------
// Use
// ------------------------------------------------------------------
IsHexColor('#FF5733')                               // true
IsHexColor('#FFF')                                  // true
IsHexColor('blue')                                  // false

const T = Type.String({ format: 'hex-color' })      // const T = { type: 'string', format: 'hex-color' }

const R = Value.Check(T, '#FFFFFF')                 // true

const R = Value.Check(T, 'blue')                    // false

import Format from 'typebox/format'

const R = Format.IsDateTime('2025-08-22T14:30:00Z')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'date-time' }, '2025-08-22T14:30:00Z')

import Format from 'typebox/format'

const R = Format.IsDate('2025-08-22')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'date' }, '2025-08-22')

import Format from 'typebox/format'

const R = Format.IsDuration('PT2H30M')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'duration' }, 'PT2H30M')

import Format from 'typebox/format'

const R = Format.IsEmail('[email protected]')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'email' }, '[email protected]')

import Format from 'typebox/format'

const R = Format.IsHostname('example.com')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'hostname' }, 'example.com')

import Format from 'typebox/format'

const R = Format.IsIdnEmail('사용자@예제.회사')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'idn-email' }, '사용자@예제.회사')

import Format from 'typebox/format'

const R = Format.IsIdnHostname('예제.회사')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'idn-hostname' }, '예제.회사')

import Format from 'typebox/format'

const R = Format.IsIPv4('192.168.0.1')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'ipv4' }, '192.168.0.1')

import Format from 'typebox/format'

const R = Format.IsIPv6('2001:0db8:85a3:0000:0000:8a2e:0370:7334')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'ipv6' }, '2001:0db8:85a3:0000:0000:8a2e:0370:7334')

import Format from 'typebox/format'

const R = Format.IsIriReference('https://예제.회사/경로')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'iri-reference' }, 'https://예제.회사/경로')

import Format from 'typebox/format'

const R = Format.IsIri('https://예제.회사/경로')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'iri' }, 'https://예제.회사/경로')

import Format from 'typebox/format'

const R = Format.IsJsonPointerUriFragment('#/paths/~1users/123')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'json-pointer-uri-fragment' }, '#/paths/~1users/123')

import Format from 'typebox/format'

const R = Format.IsJsonPointer('/paths/~1users/123')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'json-pointer' }, '/paths/~1users/123')

import Format from 'typebox/format'

const R = Format.IsRegex('^\\d{3}-\\d{2}-\\d{4}$')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'regex' }, '^\\d{3}-\\d{2}-\\d{4}$')

import Format from 'typebox/format'

const R = Format.IsRelativeJsonPointer('0/name')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'relative-json-pointer' }, '0/name')

import Format from 'typebox/format'

const R = Format.IsTime('14:30:00Z')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'time' }, '14:30:00Z')

import Format from 'typebox/format'

const R = Format.IsUriReference('https://example.com/path')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'uri-reference' }, 'https://example.com/path')

import Format from 'typebox/format'

const R = Format.IsUriTemplate('https://example.com/{user}/profile')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'uri-template' }, 'https://example.com/{user}/profile')

import Format from 'typebox/format'

const R = Format.IsUri('https://example.com/path')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'uri' }, 'https://example.com/path')

import Format from 'typebox/format'

const R = Format.IsUrl('https://example.com/path')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'url' }, 'https://example.com/path')

import Format from 'typebox/format'

const R = Format.IsUuid('550e8400-e29b-41d4-a716-446655440000')

import Schema from 'typebox/schema'

const R = Schema.Check({ format: 'uuid' }, '550e8400-e29b-41d4-a716-446655440000')

$ npm install typebox --save

$ npm install @sinclair/typebox --save

// file: tsconfig.json
{
  "compilerOptions": {
    "strict": true,              // Required for Type Inference
    "target": "ES2018",          // Minimum ES Target
  }
}

import Type from 'typebox'

import addFormats from 'ajv-formats'
import Ajv from 'ajv'

const ajv = addFormats(new Ajv({}), [
  'date-time',
  'time',
  'date',
  'email',
  'hostname',
  'ipv4',
  'ipv6',
  'uri',
  'uri-reference',
  'uuid',
  'uri-template',
  'json-pointer',
  'relative-json-pointer',
  'regex'
])

// ...

const check = ajv.compile(Type.Object({
  x: Type.Number(),
  y: Type.Number(),
  z: Type.Number()
}))

const R = check({ x: 1, y: 2, z: 3 })               // const R = true

$ npm install @sinclair/typebox                     # 0.x - LTS    | TS 4-6

$ npm install typebox                               # 1.x - Latest | TS 7 Native

import Schema from 'typebox/schema'

// ------------------------------------------------------------------
// Schema
// ------------------------------------------------------------------
const T = {
  type: 'object',
  required: ['x', 'y', 'z'],
  properties: {
    x: { type: 'number' },
    y: { type: 'number' },
    z: { type: 'number' }
  }
} as const

// ------------------------------------------------------------------
// Check
// ------------------------------------------------------------------
const R = Schema.Check(T, { x: 1, y: 2, z: 3 })     // const R: boolean = true

import Schema from 'typebox/schema'

// ------------------------------------------------------------------
// Schema
// ------------------------------------------------------------------
const T = {
  type: 'object',
  required: ['x', 'y', 'z'],
  properties: {
    x: { type: 'number' },
    y: { type: 'number' },
    z: { type: 'number' }
  }
} as const

// ------------------------------------------------------------------
// Parse
// ------------------------------------------------------------------
const R = Schema.Parse(T, { x: 1, y: 2, z: 3 })     // const R: {
                                                    //   x: number,
                                                    //   y: number,
                                                    //   z: number
                                                    // } = ...

/* Detailed source-code truncated for AI context efficiency. */

/* Detailed source-code truncated for AI context efficiency. */

import Schema from 'typebox/schema'

// ------------------------------------------------------------------
// Validate Schema
// ------------------------------------------------------------------
const A = Schema.Parse(Schema.Meta['https://json-schema.org/draft/2020-12/schema'], {
  type: 'object',
  required: ['x', 'y', 'z'],
  properties: {
    x: { type: 'number' },
    y: { type: 'number' },
    z: { type: 'number' },
  }
})
// ------------------------------------------------------------------
// Validate Value
// ------------------------------------------------------------------
const B = Schema.Parse(A, {
  x: 1,
  y: 2,
  z: 3
})

/* Detailed source-code truncated for AI context efficiency. */

$ node --v8-options | grep max-inlined-bytecode-size-small
#  --max-inlined-bytecode-size-small (maximum size of bytecode considered for small function inlining)
#        type: int  default: --max-inlined-bytecode-size-small=27

// ------------------------------------------------------------------
// Schema A
//
// When passing a non-referential schema to Schema.Compile(...), the
// result will be a single function with a large logical expression.
// Because a single expression may be long and complex, inlining
// optimizers may skip optimizations based on the engine's observed
// bytecode length.
//
// ------------------------------------------------------------------

const A = Type.Object({      // const A = {
  x: Type.String(),          //   type: "object",
  y: Type.Number(),          //   required: [ "x", "y", "z" ],
  z: Type.Boolean()          //   properties: {
})                           //     x: { type: "string" },
                             //     y: { type: "number" },
                             //     z: { type: "boolean" }
                             //   }
                             // }

// Expression may be considered too large for optimization.

Schema.Build(A).Functions()  // const check_0 = ((value) => ((typeof value === "object"
                             //   && value !== null && !(Array.isArray(value)))
                             //   && ((("x" in value && "y" in value) && "z" in value)
                             //   && ((typeof value.x === "string" && Number.isFinite(value.y))
                             //   && typeof value.z === "boolean"))))

/* Detailed source-code truncated for AI context efficiency. */

// The Script function returns JSON Schema

const A = Type.Script('string')                         // const A = { type: 'string' }

/* Detailed source-code truncated for AI context efficiency. */

/* Detailed source-code truncated for AI context efficiency. */

/* Detailed source-code truncated for AI context efficiency. */

// ------------------------------------------------------------------
// Utility Types
// ------------------------------------------------------------------
const T0  = Type.Script(`Partial<{ x: number }>`)
const T1  = Type.Script(`Required<{ x: number }>`)
const T2  = Type.Script(`Readonly<{ x: number }>`)
const T3  = Type.Script(`Pick<{ x: number, y: number }, 'x'>`)
const T4  = Type.Script(`Omit<{ x: number, y: number }, 'x'>`)
const T5  = Type.Script(`NonNullable<string | null>`)
const T6  = Type.Script('Exclude<1 | 2 | 3, 1 | 2>')
const T7  = Type.Script('Extract<1 | 2 | 3, 1 | 2>')
const T8  = Type.Script('ConstructorParameters<new (x: number) => {}>')
const T9  = Type.Script('Parameters<(x: number) => number>')
const T10 = Type.Script('ReturnType<(x: number) => number>')
const T11 = Type.Script('InstanceType<new (x: number) => {}>')

// ------------------------------------------------------------------
// Intrinsic String Manipulation
// ------------------------------------------------------------------
const T12 = Type.Script('Uppercase<"hello">')
const T13 = Type.Script('Lowercase<"hello">')
const T14 = Type.Script('Capitalize<"hello">')
const T15 = Type.Script('Uncapitalize<"hello">')

// ------------------------------------------------------------------
// Extension Types
// ------------------------------------------------------------------
const T16 = Type.Script('Evaluate<{ x: number } & { y: number }>')

const { Expression, ConstDeclaration, BinaryExpression, ConstExpression } = Type.Script(`
  type Expression =
    | ConstDeclaration
    | BinaryExpression
    | ConstExpression

  interface ConstDeclaration {
    type: 'ConstDeclaration'
    name: string
    value: Expression
  }
  interface BinaryExpression {
    type: 'BinaryExpression'
    left: Expression
    right: Expression
  }
  interface ConstExpression {
    type: 'ConstExpression'
    const: unknown
  }
`)

type Get<S extends string> = S extends `hello ${infer Name}` ? Name : never
//                                             ^
//                                             Substring infer not supported

type Foo = { x: <T>(value: T) => string }
//              ^
//              Embedded generic function not supported

const Email = Type.Script(`string with { format: 'email' }`)

// Produces

const Email = { type: 'string', format: 'email' }

const Vector = Type.Script(`{
  x: number with { minimum: 0, maximum: 1 },
  y: number with { minimum: 0, maximum: 1 },
  z: number with { minimum: 0, maximum: 1 },
} with { additionalProperties: false }`)

const { Vector, ClampedVector } = Type.Script(`
  type Vector = {
    x: number
    y: number
    z: number
  }
  
  type Clamp<T> = {
    [K in keyof T]: T[K] with { minimum: 0, maximum: 1 }
  } with { additionalProperties: false }

  type ClampedVector = Clamp<Vector>
`)

const Email = Type.With(Type.String(), { format: 'email' })

const T = Type.String()

const S = Type.Script({ T }, `T | null`)            // const S: TUnion<[
                                                    //   TString,
                                                    //   TNull
                                                    // ]>

const A = Type.Literal(1)
const B = Type.Literal(2)
const C = Type.Literal(3)

const T = Type.Script({ A, B, C }, `[A, B, C]`)     // const T: TTuple<[
                                                    //   TLiteral<1>,
                                                    //   TLiteral<2>,
                                                    //   TLiteral<3>
                                                    // ]>

import Type from 'typebox'

const Math = Type.Script(`
  type Vector4 = { x: number, y: number, z: number, w: number }
  type Vector3 = { x: number, y: number, z: number }
  type Vector2 = { x: number, y: number }
`)

const Graphics = Type.Script(Math, `
  type Vertex = {
    position: Vector4,
    normal: Vector3,
    uv: Vector2
  }
  type Geometry = {
    vertices: Vertex[],
    indices: number[]
  }
  type Material = {
    ambient: Vector4,
    diffuse: Vector4,
    specular: Vector4,
  }
  type Mesh = {
    geometry: Geometry
    material: Material
  }
`)

type Mesh = Type.Static<typeof Graphics['Mesh']>     // type Mesh = {
                                                     //   geometry: { ... },
                                                     //   material: { ... }
                                                     // }

const T = Type.Script(`[   // depth + 1
  0, 1, 2, 3, 4, 5, 6, 7,  // 128 x elements  
  0, 1, 2, 3, 4, 5, 6, 7,
  0, 1, 2, 3, 4, 5, 6, 7,
  0, 1, 2, 3, 4, 5, 6, 7,
  0, 1, 2, 3, 4, 5, 6, 7,
  0, 1, 2, 3, 4, 5, 6, 7,
  0, 1, 2, 3, 4, 5, 6, 7,
  0, 1, 2, 3, 4, 5, 6, 7,
  0, 1, 2, 3, 4, 5, 6, 7,
  0, 1, 2, 3, 4, 5, 6, 7,
  0, 1, 2, 3, 4, 5, 6, 7,
  0, 1, 2, 3, 4, 5, 6, 7,
  0, 1, 2, 3, 4, 5, 6, 7,
  0, 1, 2, 3, 4, 5, 6, 7,
  0, 1, 2, 3, 4, 5, 6, 7,
  0, 1, 2, 3, 4, 5, 6, 7,
]`)

const T = Type.Script(`{          // depth + 1
  a: {                            // depth + 2
    b: {                          // depth + 3
      c: {                        // depth + 4
        d: {                      // error: instantiation too deep
          e: 1
        }
      }
    }
  }  
}`)

const D = Type.Script(`{ e: 1 }`)                   // depth + 1
const C = Type.Script({ D }, `{ d: D }`)            // depth + 1
const B = Type.Script({ C }, `{ c: C }`)            // depth + 1
const A = Type.Script({ B }, `{ b: B }`)            // depth + 1

const T = Type.Script({ A }, `{ a: A }`)            // ok

const LargeType: TSchema = Type.Script(`{
  x0: string,
  x1: string,
  x2: string,
  x3: string,
  // ... excessive properties
  x999999: string
}
` as never)  // bail out

import System from 'typebox/system'

// Apply freeze to schemas on creation
System.Settings.Set({ immutableTypes: true })

Type.String().format = 'email' // Error:  Cannot add property format, object is not extensible

// Reset to defaults
System.Settings.Reset()

/* Detailed source-code truncated for AI context efficiency. */

import System, { Locale } from 'typebox/system'

System.Locale.Set(Locale.en_US)                      // English - United States
System.Locale.Set(Locale.ko_KR)                      // Korean  - South Korea
System.Locale.Set(Locale.fr_FR)                      // French  - France
System.Locale.Set(Locale.zh_Hant)                    // Chinese - Traditional

import System, { Locale } from 'typebox/system'
import Schema from 'typebox/schema'
import Type from 'typebox'

System.Locale.Set(Locale.fr_FR)                      // French - France

const E = Schema.Errors(Type.Number(), 'not-number') // const E = [false, {
                                                     //   keyword: "type",
                                                     //   schemaPath: "#/type",      
                                                     //   instancePath: "",
                                                     //   params: { type: "number" },
                                                     //   message: "doit être number"   
                                                     // }]

import System from 'typebox/system'
import Type from 'typebox'

// --------------------------------------------------------
// Computed Type
// --------------------------------------------------------
const Reverse = Type.Script(`<T, Result extends unknown[] = []> = (
  T extends [infer L, ...infer R]
    ? Reverse<R, [L, ...Result]>
    : Result
)`)

const Result = Type.Script({ Reverse }, `Reverse<[
  1, 2, 3, 4, 5, 6, 7, 8
]>`)                                          // TTuple<[
                                              //   TLiteral<8>,
                                              //   TLiteral<7>,
                                              //   ...
                                              //   TLiteral<1>
                                              // ]>

// --------------------------------------------------------
// Inspect
// --------------------------------------------------------

console.log(System.Memory.Metrics)            // {
                                              //   assign: 42,
                                              //   create: 459,
                                              //   clone: 108,
                                              //   discard: 97,
                                              //   update: 11
                                              // }

const T = Type.Any()                                // const T = {}

type T = Static<typeof T>                           // type T = any

Type.IsAny(value)                                  // value is TAny

const T = Type.Array(Type.Number())                 // const T = {
                                                    //   type: 'array',
                                                    //   items: {
                                                    //     type: 'number',
                                                    //   }
                                                    // }

type T = Static<typeof T>                           // type T = number[]

Type.IsArray(value)                                 // value is TArray

export interface TArrayOptions extends TSchemaOptions {
  /**
   * The minimum number of items allowed in the array.
   */
  minItems?: number
  /**
   * The maximum number of items allowed in the array.
   */
  maxItems?: number
  /**
   * A schema that at least one item in the array must validate against.
   */
  contains?: TSchema
  /**
   * The minimum number of array items that must validate against the `contains` schema.
   */
  minContains?: number
  /**
   * The maximum number of array items that may validate against the `contains` schema.
   */
  maxContains?: number
  /**
   * An array of schemas, where each schema in `prefixItems` validates against items at corresponding positions from the beginning of the array.
   */
  prefixItems?: TSchema[]
  /**
   * If `true`, all items in the array must be unique.
   */
  uniqueItems?: boolean
}

const T = Type.BigInt()                             // const T = {
                                                    //   type: 'bigint'
                                                    // }

type T = Static<typeof T>                           // type T = bigint

Type.IsBigInt(value)                                // value is TBigInt

const T = Type.Boolean()                            // const T = { type: 'boolean' }

type T = Static<typeof T>                           // type T = boolean

Type.IsBoolean(value)                               // value is TBoolean

const G = Type.Generic([
  Type.Parameter('T')
], Type.Array(Type.Ref('T')))

const S = Type.Call(G, [Type.Number()])             // const S: TArray<TNumber>

Type.IsCall(value)                                  // value is TCall

const T = Type.Literal('hello')

const S = Type.Capitalize(T)                        // const S: TLiteral<'Hello'>

const Timestamp = Type.Codec(Type.Integer())        // const Timestamp = {
  .Decode(value => new Date(value))                 //   type: 'integer',
  .Encode(value => value.getTime())                 //   '~codec': {
                                                    //      decode: value => new Date(),
                                                    //      encode: value => value.getTime()
                                                    //   }
                                                    // }

// Use Value.Decode() and Value.Encode() to run Decode and Encode callbacks.

const D = Value.Decode(Timestamp, 12345)            // const D = 1970-01-01T00:00:12.345Z

const E = Value.Encode(Timestamp, D)                // const E = 12345

import Type, { type StaticEncode, type StaticDecode } from 'typebox'

const Timestamp = Type.Codec(Type.Integer())
  .Decode(value => new Date(value))
  .Encode(value => value.getTime())

type D = StaticDecode<typeof Timestamp>             // type D = Date

type E = StaticEncode<typeof Timestamp>             // type E = number

const L = Type.Literal(1)
const R = Type.Number()

const T = Type.Conditional(L, R,                    // const T: TLiteral<true>
  Type.Literal(true),
  Type.Literal(false)
)

const T = Type.Constructor([Type.String(), Type.Number()], Type.Object({}))

const S = Type.ConstructorParameters(T)             // const S: TTuple<[
                                                    //   TString,
                                                    //   TNumber
                                                    // ]>

const T = Type.Constructor([                        // const T = {
  Type.String(),                                    //   type: 'constructor'
  Type.Boolean(),                                   //   parameters: [
], Type.Object({                                    //     { type: 'string' },
  x: Type.Number()                                  //     { type: 'boolean' }
}))                                                 //   ],
                                                    //   instanceType: {
                                                    //     type: 'object',
                                                    //     required: ['x'],
                                                    //     properties: {
                                                    //       x: { type: 'number' }
                                                    //     }
                                                    //   }
                                                    // }

type T = Static<typeof T>                           // type T = new (
                                                    //   args_0: string,
                                                    //   args_1: boolean
                                                    // ) => {
                                                    //   x: number
                                                    // }

Type.IsConstructor(value)                           // value is TConstructor<TSchema[], TSchema>

const T = Type.Cyclic({                             // const T = {
  A: Type.Object({                                  //   '$defs': {
    x: Type.Array(Type.Ref('A')),                   //     A: {
  }),                                               //       type: 'object',
}, 'A')                                             //       required: [ 'x' ],
                                                    //       properties: {
                                                    //         x: {
                                                    //           type: 'array',
                                                    //           items: {
                                                    //             '$ref': 'A'
                                                    //           }
                                                    //         }
                                                    //       },
                                                    //       '$id': 'A'
                                                    //     }
                                                    //   },
                                                    //   '$ref': 'A'
                                                    // }

type T = Static<typeof T>                           // type T = { x: ...[] }

Type.IsCyclic(value)                                // value is TCyclic

import Type from 'typebox'

// Each declaration is returned as a standalone type
const { Vector, Node } = Type.Script(`
  type Vector = {
    x: number
    y: number
    z: number
  }
  type Node = {
    id: string
    value: Vector
    nodes: Node[]   // <-- Node is recursive, so it infers as TCyclic
  }
`)

const Vector: Type.TObject<{
  x: Type.TNumber;
  y: Type.TNumber;
  z: Type.TNumber;
}>

const Node: Type.TCyclic<{
  Node: Type.TObject<{
    id: Type.TString;
    nodes: Type.TArray<Type.TRef<"Node">>;
    value: Type.TRef<"Vector">;
  }>;
  Vector: Type.TObject<{
    x: Type.TNumber;
    y: Type.TNumber;
    z: Type.TNumber;
  }>;
}, "Node">

const { Node } = Type.Script(`
  type Node = {
    id: string
    nodes: Node[]
  }
`)

// Unsafe Embedding
const Container = Type.Object({ node: Node })
// const Container = {
//   type: 'object',
//   required: [ 'node' ],
//   properties: {
//     node: {
//       '$defs': {
//         Node: {
//           type: 'object',
//           required: [ 'id', 'nodes' ],
//           properties: {
//             id: { type: 'string' },
//             nodes: { type: 'array', items: { '$ref': 'Node' } }
//           },
//           '$id': 'Node'
//         }
//       },
//       '$ref': 'Node'
//     }
//   }
// }

const { Container } = Type.Script(`
  type Node = {
    id: string
    nodes: Node[]
  }

  // Safe
  type Container = {
    node: Node
  }
`)
// const Container = {
//   '$defs': {
//     Node: {
//       type: 'object',
//       required: [ 'id', 'nodes' ],
//       properties: {
//         id: { type: 'string' },
//         nodes: { type: 'array', items: { '$ref': 'Node' } }
//       },
//       '$id': 'Node'
//     },
//     Container: {
//       type: 'object',
//       required: [ 'node' ],
//       properties: { node: { '$ref': 'Node' } },
//       '$id': 'Container'
//     }
//   },
//   '$ref': 'Container'
// }

import Type from 'typebox'

type Expression = Type.Static<typeof Expression>

// Include definitions for every type required by this Cyclic.
const Expression = Type.Cyclic({
  BooleanLiteral: Type.Object({
    type: Type.Literal('BooleanLiteral'),
    value: Type.Boolean()
  }),
  NumberLiteral: Type.Object({
    type: Type.Literal('NumberLiteral'),
    value: Type.Number()
  }),
  Literal: Type.Union([
    Type.Ref('BooleanLiteral'),
    Type.Ref('NumberLiteral'),
  ]),
  Operator: Type.Union([
    Type.Literal('+'),
    Type.Literal('-'),
    Type.Literal('*'),
    Type.Literal('/'),
  ]),
  BinaryExpression: Type.Object({
    type: Type.Literal('BinaryExpression'),
    operator: Type.Ref('Operator'),
    left: Type.Ref('Expression'),
    right: Type.Ref('Expression'),
  }),
  Expression: Type.Union([
    Type.Ref('Literal'),
    Type.Ref('BinaryExpression'),
  ]),
}, 'Expression')

const Hex = Type.Decode(Type.Number(),              // const T = {
  value => value.toString(16).toUpperCase()         //   type: 'number',
)                                                   //   '~codec': {
                                                    //      decode: value => value.toString(16).toUpperCase() ,
                                                    //      encode: value => { throw Error('not implemented') },
                                                    //   }
                                                    // }

// Use Value.Decode() to run Decode callbacks.

const D = Value.Decode(Hex, 12345678)               // const D = 'BC614E'

const E = Value.Encode(Hex, D)                      // throw Error('not implemented')

const T = Type.Dependent([                          // const T = {
  Type.Number(),                                    //   if: { type: 'number' },
  Type.Literal(1),                                  //   then: { type: 'number', const: 1 },
  Type.String()                                     //   else: { type: 'string' }
])                                                  // }


type T = Static<typeof T>                           // type T = 1 | string

type T = if number then 1 else string

type Dependent<If, Then, Else> = (If & Then) | Exclude<Else, If>

// type T = if number then 1 else string

// Dependent<number, 1, string>
// = (number & 1) | Exclude<string, number>
// = (1)          | Exclude<string, number>   -- intersection
// = (1)          | (string)                  -- negation

type T = 1 | string // result

type A = Dependent<number, 1, string>   // 1 | string
type B = Dependent<number, 1, never>    // 1
type C = Dependent<number, 1, unknown>  // unknown

Value.IsDependent(value)                            // value is TDependent

const T = Type.Encode(Type.Number(),                // const T = {
  (value: unknown) => value === 'hello'             //   type: 'number',
     ? 1                                            //   '~codec': {
     : 0                                            //      decode: value => { throw Error('not implemented') },
)                                                   //      encode: value => 0
                                                    //   }
                                                    // }

// Use Value.Encode() to run Encode callbacks.

const D = Value.Decode(T, 12345)                   // throw Error('not implemented')

const E = Value.Encode(T, 'hello')                 // const E = 1

const T = Type.Enum(['A', 'B', 'C'])                // const T = {
                                                    //   enum: ['A', 'B', 'C']
                                                    // }

type T = Static<typeof T>                           // type T = 'A' | 'B' | 'C'

Type.IsEnum(value)                                  // value is TEnum

const T = Type.Intersect([
  Type.Object({ x: Type.Number() }),
  Type.Union([
    Type.Object({ y: Type.Number() }),
    Type.Object({ z: Type.Number() })
  ])
])

const S = Type.Evaluate(T)                          // const S: TUnion<[
                                                    //   TObject<{
                                                    //     x: TNumber,
                                                    //     y: TNumber
                                                    //   }>,
                                                    //   TObject<{
                                                    //     x: TNumber,
                                                    //     z: TNumber
                                                    //   }>,
                                                    // ]>

const T = Type.Union([Type.Literal(1), Type.Number()])

const S = Type.Evaluate(T)                          // const S = { type: 'number' }

const T = Type.Intersect([Type.Literal(1), Type.Number()])

const S = Type.Evaluate(T)                         // const S = { const: 1 }

const L = Type.Union([
  Type.Literal('hello'),
  Type.Literal('world'),
  Type.Literal(1),
  Type.Literal(2)
])
const R = Type.String()

const S = Type.Exclude(L, R)                        // const S: TUnion<[
                                                    //   TLiteral<1>,
                                                    //   TLiteral<2>
                                                    // ]>

const L = Type.Union([
  Type.Literal('hello'),
  Type.Literal('world'),
  Type.Literal(1),
  Type.Literal(2)
])
const R = Type.String()

const S = Type.Extract(L, R)                        // const S: TUnion<[
                                                    //   TLiteral<'hello'>,
                                                    //   TLiteral<'world'>
                                                    // ]>

const T = Type.Function([                           // const T = {
  Type.String(),                                    //   type: 'function'
  Type.Boolean()                                    //   parameters: [
], Type.Object({                                    //     { type: 'string' },
  x: Type.Number()                                  //     { type: 'boolean' }
}))                                                 //   ],
                                                    //   returnType: {
                                                    //     type: 'object',
                                                    //     required: ['x'],
                                                    //     properties: {
                                                    //       x: { type: 'number' }
                                                    //     }
                                                    //   }
                                                    // }

type T = Static<typeof T>                           // type T = (
                                                    //   args_0: string,
                                                    //   args_1: boolean
                                                    // ) => {
                                                    //   x: number
                                                    // }

Type.IsFunction(value)                              // value is TFunction

const G = Type.Generic([Type.Parameter('T')],       // const G = {
  Type.Array(Type.Ref('T')))                        //   type: 'generic',
                                                    //   parameters: [{
                                                    //     name: 'T',
                                                    //     extends: {},
                                                    //     equals: {}
                                                    //   }],
                                                    //   expression: {
                                                    //     type: 'array',
                                                    //     items: { '$ref': 'T' }
                                                    //   }
                                                    // }

const S = Type.Call(G, [Type.Number()])             // const S: TArray<TNumber>

Type.IsGeneric(value)                               // value is TGeneric

const T = Type.Identifier('A')                      // const T = {
                                                    //  type: 'identifier',
                                                    //  name: 'A'
                                                    // }

Type.IsIdentifier(value)                           // value is TIdentifier

const T = Type.Immutable(                           // const T = {
  Type.Array(Type.Number())                         //   type: 'array',
)                                                   //   items: { type: 'number' },
                                                    //   '~immutable': true
                                                    // }

type T = Static<typeof T>                           // type T = readonly number[]

const T = Type.Immutable(                           // const T = {
  Type.Tuple([Type.String(), Type.Number()])        //   type: 'array',
)                                                   //   additionalItems: false,
                                                    //   items: [
                                                    //     { type: 'string' },
                                                    //     { type: 'number' }
                                                    //   ],
                                                    //   minItems: 2,
                                                    //   '~immutable': true
                                                    // }

type T = Type.Static<typeof T>                      // type T = readonly [string, number]

Type.IsImmutable(value)                         // value is TImmutable

const T = Type.Object({
  x: Type.Literal(1),
  y: Type.Literal(2),
  z: Type.Literal(3)
})

const S = Type.Index(T, Type.Union([                // const S: TUnion<[
  Type.Literal('x'),                                //   TLiteral<1>,
  Type.Literal('y')                                 //   TLiteral<2>
]))                                                 // ]>

const T = Type.Object({
  x: Type.Literal(1),
  y: Type.Literal(2)
})

const S = Type.Conditional(T, Type.Object({         // const S: TTuple<[
  x: Type.Infer('X'),                               //   TLiteral<1>,
  y: Type.Infer('Y'),                               //   TLiteral<2>
}), Type.Tuple([                                    // ]>
  Type.Ref('X'),
  Type.Ref('Y')
]), Type.Never())

Type.IsInfer(value)                                 // value is TInfer

const T = Type.Constructor([Type.String()], Type.Object({
  x: Type.Number()
}))

const S = Type.InstanceType(T)                      // const S: TObject<{
                                                    //   x: TNumber
                                                    // }>

const X = Type.Literal(1)
const Y = Type.Literal(2)
const Z = Type.Literal(3)

const T = Type.Object({
  x: Type.Ref('X'),
  y: Type.Ref('Y'),
  z: Type.Ref('Z'),
})

const S = Type.Instantiate({ X, Y, Z }, T)          // const S: TObject<{
                                                    //   x: TLiteral<1>,
                                                    //   y: TLiteral<2>,
                                                    //   z: TLiteral<3>
                                                    // }>

const T = Type.Integer()                            // const T = {
                                                    //   type: 'integer'
                                                    // }

type T = Static<typeof T>                           // type T = number

Type.IsInteger(value)                               // value is TInteger

export interface TNumberOptions extends TSchemaOptions {
  /**
   * Specifies an exclusive upper limit for the number (number must be less than this value).
   */
  exclusiveMaximum?: number | bigint
  /**
   * Specifies an exclusive lower limit for the number (number must be greater than this value).
   */
  exclusiveMinimum?: number | bigint
  /**
   * Specifies an inclusive upper limit for the number (number must be less than or equal to this value).
   */
  maximum?: number | bigint
  /**
   * Specifies an inclusive lower limit for the number (number must be greater than or equal to this value).
   */
  minimum?: number | bigint
  /**
   * Specifies that the number must be a multiple of this value.
   */
  multipleOf?: number
}

Integer is a subset of Number: true
Number is a subset of Integer: false

const A = Type.Conditional(                                     // const A = { const: true }
  Type.Integer(),
  Type.Number(),
  Type.Literal(true),
  Type.Literal(false)
)

const B = Type.Conditional(                                      // const B = { const: false }
  Type.Number(),
  Type.Integer(),
  Type.Literal(true),
  Type.Literal(false)
)

const A = Type.Interface([], {                      // const A: TObject<{
  a: Type.Number()                                  //   a: TNumber
})                                                  // }>


const B = Type.Interface([A], {                     // const B: TObject<{
  b: Type.Number()                                  //   a: TNumber,
})                                                  //   b: TNumber
                                                    // }

const T = Type.Intersect([                          // const T = {
  Type.Object({ x: Type.Number() }),                //   allOf: [{
  Type.Object({ y: Type.Number() }),                //     type: 'object',
])                                                  //     required: ['x'],
                                                    //     properties: {
                                                    //       x: { type: 'number' }
                                                    //     }
                                                    //  }, {
                                                    //    type: 'object',
                                                    //    required: ['y'],
                                                    //    properties: {
                                                    //      y: { type: 'number' }
                                                    //    }
                                                    //  }]
                                                    // }

type T = Static<typeof T>                           // type T = {
                                                    //   x: number
                                                    // } & {
                                                    //   y: number
                                                    // }

Type.IsIntersect(value)                             // value is TIntersect

export interface TIntersectOptions extends TSchemaOptions {
  /**
   * A schema to apply to any properties in the object that were not validated
   * by other keywords like `properties`, `patternProperties`, or `additionalProperties`.
   * If `false`, no additional properties are allowed.
   */
  unevaluatedProperties?: TSchema | boolean
}

const T = Type.Object({
  x: Type.Number(),
  y: Type.Number(),
  z: Type.Number()
})

const S = Type.KeyOf(T)                             // const S: TUnion<[
                                                    //  TLiteral<'x'>,
                                                    //  TLiteral<'y'>,
                                                    //  TLiteral<'z'>
                                                    // ]>

const A = Type.Literal(1n)                          // const A = {
                                                    //   type: 'bigint',
                                                    //   const: 1n
                                                    // }

const B = Type.Literal(true)                        // const B = {
                                                    //   type: 'boolean',
                                                    //   const: true
                                                    // }

const C = Type.Literal(32)                          // const C = {
                                                    //   type: 'number',
                                                    //   const: 32
                                                    // }

const D = Type.Literal('hello')                     // const D = {
                                                    //   type: 'string',
                                                    //   const: 'hello'
                                                    // }

Type.IsLiteral(value)                                // value is TLiteral<TLiteralValue>

const T = Type.Literal('HELLO')

const S = Type.Lowercase(T)                         // const S: TLiteral<'hello'>

const T = Type.Object({
  x: Type.Number(),
  y: Type.Number(),
  z: Type.Number()
})

                                                    // type S = {
                                                    //   [K in keyof T]: T[K] | null
                                                    // }

const S = Type.Mapped(                              // const S: TObject<{
  Type.Identifier('K'),                             //   x: TUnion<[TNumber, TNull]>,
  Type.KeyOf(T),                                    //   y: TUnion<[TNumber, TNull]>,
  Type.Ref('K'),                                    //   z: TUnion<[TNumber, TNull]>,
  Type.Union([                                      // }>
    Type.Index(T, Type.Ref('K')),
    Type.Null()
  ])
)

type A = 1 | B                                     // type A = 1 | 2
type B = 2                                         // type B = 2

const A = Type.Union([Type.Literal(1), B])        // Error: Cannot access 'B' before initialization
const B = Type.Literal(2)

const M = Type.Module({
  A: Type.Union([
    Type.Literal(1),
    Type.Ref('B')                                  // Referenced before definition.
  ]),
  B: Type.Literal(2)
})

M.A                                                // const A: TUnion<TLiteral<1>, TLiteral<2>>
M.B                                                // const B: TLiteral<2>

const { A, B, C } = Type.Module({                   // const A: TNumber
  A: Type.Number(),                                 //
  B: Type.String(),                                 // const B: TString
  C: Type.Object({                                  //
    a: Type.Ref('A'),                               // const C: TObject<{
    b: Type.Ref('B')                                //   a: TNumber,  // <-- inlined
  })                                                //   b: TString   // <-- inlined
})                                                  // }>

const { A } = Type.Module({                         // const A: TCyclic<{
  A: Type.Object({                                  //   A: TObject<{
    b: Type.Ref('B')                                //     b: TRef<'B'>,
  }),                                               //   }>,
  B: Type.Object({                                  //   B: TObject<{
    a: Type.Ref('A')                                //     a: TRef<'A'>
  })                                                //   }>
})                                                  // }, 'A'>

const { A } = Type.Module({                         // const A: TCyclic<{
  A: Type.Object({                                  //   A: TObject<{
    b: Type.Ref('B')                                //     b: TRef<'B'>,
  }),                                               //   }>,
  B: Type.Object({                                  //   B: TObject<{
    a: Type.Ref('A')                                //     a: TRef<'A'>
  }),                                               //   }>
  C: Type.String()                                  // }, 'A'>
})

const T = Type.Never()                              // const T = {
                                                    //   not: {}
                                                    // }

type T = Static<typeof T>                           // type T = never

Type.IsNever(value)                                 // value is TNever

const T = Type.Union([Type.String(), Type.Undefined(), Type.Null()])

const S = Type.NonNullable(T)                       // const S: TString

const T = Type.Null()                               // const T = { type: 'null' }

type T = Static<typeof T>                           // type T = null

Type.IsNull(value)                                  // value is TNull

const T = Type.Number()                             // const T = {
                                                    //   type: 'number'
                                                    // }

type T = Static<typeof T>                           // type T = number

Type.IsNumber(value)                                // value is TNumber

export interface TNumberOptions extends TSchemaOptions {
  /**
   * Specifies an exclusive upper limit for the number (number must be less than this value).
   */
  exclusiveMaximum?: number | bigint
  /**
   * Specifies an exclusive lower limit for the number (number must be greater than this value).
   */
  exclusiveMinimum?: number | bigint
  /**
   * Specifies an inclusive upper limit for the number (number must be less than or equal to this value).
   */
  maximum?: number | bigint
  /**
   * Specifies an inclusive lower limit for the number (number must be greater than or equal to this value).
   */
  minimum?: number | bigint
  /**
   * Specifies that the number must be a multiple of this value.
   */
  multipleOf?: number
}

const T = Type.Object({                             // const T = {
  x: Type.Number(),                                 //   type: 'object',
  y: Type.Number(),                                 //   required: ['x', 'y', 'z'],
  z: Type.Number()                                  //   properties: {
})                                                  //     x: { type: 'number' },
                                                    //     y: { type: 'number' },
                                                    //     z: { type: 'number' }
                                                    //   }
                                                    // }

type T = Static<typeof T>                           // type T = {
                                                    //   x: number,
                                                    //   y: number,
                                                    //   z: number
                                                    // }

Type.IsObject(value)                                // value is TObject

export interface TObjectOptions extends TSchemaOptions {
  /**
   * Defines whether additional properties are allowed beyond those explicitly defined in `properties`.
   */
  additionalProperties?: TSchema | boolean
  /**
   * The minimum number of properties required in the object.
   */
  minProperties?: number
  /**
   * The maximum number of properties allowed in the object.
   */
  maxProperties?: number
  /**
   * Defines conditional requirements for properties.
   */
  dependencies?: Record<string, boolean | TSchema | string[]>
  /**
   * Specifies properties that *must* be present if a given property is present.
   */
  dependentRequired?: Record<string, string[]>
  /**
   * Defines schemas that apply if a specific property is present.
   */
  dependentSchemas?: Record<string, TSchema>
  /**
   * Maps regular expressions to schemas that matching properties must validate against.
   */
  patternProperties?: Record<string, TSchema>
  /**
   * A schema that all property names within the object must validate against.
   */
  propertyNames?: TSchema
}

const T = Type.Object({
  x: Type.Number(),
  y: Type.Number(),
  z: Type.Number()
})

const S = Type.Omit(T, Type.Union([                 // const S: TObject<{
  Type.Literal('z')                                 //   x: TNumber,
]))                                                 //   y: TNumber
                                                    // }>

const T = Type.Object({                             // const T = {
  x: Type.Optional(Type.Number()),                  //   type: 'object',
  y: Type.Optional(Type.Number()),                  //   required: ['z'],
  z: Type.Number()                                  //   properties: {
})                                                  //     x: { type: 'number', '~optional': true },
                                                    //     y: { type: 'number', '~optional': true },
                                                    //     z: { type: 'number' }
                                                    //   }
                                                    // }


type T = Static<typeof T>                           // type T = {
                                                    //   x?: number,
                                                    //   y?: number,
                                                    //   z: number
                                                    // }

const checked = Type.IsOptional(value)              // value is TOptional

const T = Type.Number({                             // const T = {
  minimum: 10,                                      //   type: 'number',
  maximum: 100                                      //   minimum: 10,
})                                                  //   maximum: 100
                                                    // }

                                                    // const T: TNumber

const T = Type.Parameter('A',                       // const T = {
  Type.Number(),                                    //   type: 'parameter',
  Type.Literal(1)                                   //   name: 'A',
)                                                   //   extends: { type: 'number' },
                                                    //   equals: { const: 1 }
                                                    // }

type T = Static<typeof T>                           // type T = unknown

Type.IsParameter(value)                             // value is TParameter

const T = Type.Function([Type.String(), Type.Number()], Type.Object({}))

const S = Type.Parameters(T)                        // const S: TTuple<[
                                                    //   TString,
                                                    //   TNumber
                                                    // ]>

const T = Type.Object({                             // const T: TObject<{
  x: Type.Number(),                                 //   x: TNumber,
  y: Type.Number(),                                 //   y: TNumber,
  z: Type.Number()                                  //   z: TNumber
})                                                  // }>

const S = Type.Partial(T)                           // const S: TObject<{
                                                    //   x: TOptional<TNumber>,
                                                    //   y: TOptional<TNumber>,
                                                    //   z: TOptional<TNumber>
                                                    // }>

const T = Type.Object({
  x: Type.Number(),
  y: Type.Number(),
  z: Type.Number()
})

const S = Type.Pick(T, Type.Union([                 // const S: TObject<{
  Type.Literal('x')                                 //   x: TNumber,
  Type.Literal('y')                                 //   y: TNumber
]))                                                 // }>

const T = Type.Object({                             // const T = TObject<{
  x: Type.Number(),                                 //   x: TNumber,
  y: Type.Number(),                                 //   y: TNumber,
  z: Type.Number()                                  //   z: TNumber,
})                                                  // }>

const S = Type.ReadonlyObject(T)                    // const S: TObject<{
                                                    //   x: TReadonly<TNumber>,
                                                    //   y: TReadonly<TNumber>,
                                                    //   z: TReadonly<TNumber>
                                                    // }>

const T = Type.Tuple([                              // const T = TImmutable<TTuple<[
  Type.Number(),                                    //   TNumber,
  Type.String(),                                    //   TString
])                                                  // ]>>

const S = Type.ReadonlyObject(T)                    // const S: TImmutable<TTuple<[
                                                    //   TNumber,
                                                    //   TString
                                                    // ]>>

type S = Type.Static<typeof S>                      // type S = readonly [number, string]

const T = Type.Object({                             // const T = {
  x: Type.Readonly(Type.Number()),                  //   type: 'object',
  y: Type.Readonly(Type.Number()),                  //   required: ['x', 'y', 'z'],
  z: Type.Number()                                  //   properties: {
})                                                  //     x: { type: 'number', '~readonly': true },
                                                    //     y: { type: 'number', '~readonly': true },
                                                    //     z: { type: 'number' }
                                                    //   }
                                                    // }

type T = Static<typeof T>                           // type T = {
                                                    //   readonly x: number,
                                                    //   readonly y: number,
                                                    //   z: number
                                                    // }

Type.IsReadonly(value)                              // value is TReadonly

const T = Type.Record(Type.String(), Type.Number()) // const T = {
                                                    //   type: 'object',
                                                    //   patternProperties: {
                                                    //     "^.*$": {
                                                    //        type: 'number'
                                                    //     }
                                                    //   }
                                                    // }

type T = Static<typeof T>                           // type T = {
                                                    //   [x: string]: number
                                                    // }

Type.IsRecord(value)                                // value is TRecord<string, TSchema>

const T = Type.Ref('A')                             // const T = {
                                                    //   $ref: 'A'
                                                    // }

type T = Static<typeof T>                           // type T = unknown

Type.IsRef(value)                                   // value is TRef

/* Detailed source-code truncated for AI context efficiency. */

const T = Type.Object({                             // const T = {
  x: Type.Optional(Type.Number()),                  //   type: 'object',
  y: Type.Optional(Type.Number()),                  //   properties: {
  z: Type.Optional(Type.Number())                   //     x: { type: 'number' },
})                                                  //     y: { type: 'number' },
                                                    //     z: { type: 'number' }
                                                    //   }
                                                    // }

const S = Type.Required(T)                          // const S: TObject<{
                                                    //   x: TNumber,
                                                    //   y: TNumber,
                                                    //   z: TNumber
                                                    // }>

const T = Type.Rest(Type.Tuple([                    // const T = {
  Type.Literal(1),                                  //   type: "rest",
  Type.Literal(2)                                   //   items: {
]))                                                 //     type: "array",
                                                    //     additionalItems: false,
                                                    //     items: [
                                                    //       { const: 1 },
                                                    //       { const: 2 }
                                                    //     ],
                                                    //     minItems: 2
                                                    //   }
                                                    // }

type T = Static<typeof T>                           // type T = [1, 2][]

Type.IsRest(value)                                  // value is TRest

const T = Type.Function([Type.String()], Type.Object({
  x: Type.Number()
}))

const S = Type.ReturnType(T)                        // const S: TObject<{
                                                    //   x: TNumber
                                                    // }>

const T = Type.Number()

type T = Static<typeof T>                           // type T = number

const T = { oneOf: [{ const: 1 }, { const: 2 }] } as const

type T = Static<typeof T>                           // type T = 1 | 2

const T = Type.String()                             // const T = {
                                                    //   type: 'string'
                                                    // }

type T = Static<typeof T>                           // type T = string

Type.IsString(value)                                // value is TString

export interface TStringOptions extends TSchemaOptions {
  /**
   * A string format such as 'email', 'uuid' or other registered format.
   */
  format?: TFormat
  /**
   * Specifies the minimum number of characters allowed in the string.
   * Must be a non-negative integer.
   */
  minLength?: number
  /**
   * Specifies the maximum number of characters allowed in the string.
   * Must be a non-negative integer.
   */
  maxLength?: number
  /**
   * Specifies a regular expression pattern that the string value must match.
   * Can be provided as a string (ECMA-262 regex syntax) or a `RegExp` object.
   */
  pattern?: string | RegExp
}

const T = Type.Symbol()                             // const T = {
                                                    //   type: 'symbol'
                                                    // }

type T = Static<typeof T>                           // type T = symbol

Type.IsSymbol(value)                                // value is TSymbol

const T = Type.TemplateLiteral('A${"B"|"C"}')        // const T = {
                                                     //   type: 'string',
                                                     //   pattern: '^A(B|C)$'
                                                     // }

type T = Static<typeof T>                            // type T = 'AB' | 'AC'

Type.IsTemplateLiteral(value)                       // value is TTemplateLiteral

const T = Type.Object({                             // const T = {
  items: Type.Array(Type.This())                    //   type: 'object',
})                                                  //   required: ['items'],
                                                    //   properties: {
                                                    //     items: { $ref: '#' }
                                                    //   }
                                                    // }

type T = Static<typeof T>                           // type T = object

Type.IsThis(value)                                   // value is TThis

const T = Type.Tuple([                              // const T = {
  Type.String(),                                    //   type: 'array',
  Type.Number(),                                    //   additionalItems: false,
])                                                  //   minItems: 2,
                                                    //   items: [
                                                    //     { type: 'string' },
                                                    //     { type: 'number' },
                                                    //   ]
                                                    // }

type T = Static<typeof T>                           // type T = [string, number]

Type.IsTuple(value)                                 // value is TTuple

const T = Type.Literal('HELLO')

const S = Type.Uncapitalize(T)                      // const S: TLiteral<'hELLO'>

const T = Type.Undefined()                          // const T = {
                                                    //   type: 'undefined'
                                                    // }

type T = Static<typeof T>                           // type T = undefined

Type.IsUndefined(value)                             // value is TUndefined

const T = Type.Union([                              // const T = {
  Type.String(),                                    //   anyOf: [
  Type.Number()                                     //     { type: 'string' },
])                                                  //     { type: 'number' }
                                                    //   ]
                                                    // }

type T = Static<typeof T>                           // type T = string | number

Type.IsUnion(value)                                 // value is TUnion

const T = Type.Unknown()                            // const T = { }

type T = Static<typeof T>                           // type T = unknown

Type.IsUnknown(value)                               // value is TUnknown

const T = Type.Unsafe<string>({ type: 'number' })   // const T = { type: 'number' }

type T = Static<typeof T>                           // type T = string

const T = Type.Literal('hello')

const S = Type.Uppercase(T)                         // const S: TLiteral<'HELLO'>

const T = Type.Void()                               // const T = { type: 'void' }

type T = Static<typeof T>                           // type T = void

Type.IsVoid(value)                                  // value is TVoid

type T = string with { format: 'email' }

const T = Type.With(Type.Number(), {                // const T = {
  minimum: 10,                                      //   type: 'number',
  maximum: 100                                      //   minimum: 10,
})                                                  //   maximum: 100
                                                    // }

                                                    // const T: TWith<TNumber, {
                                                    //   minimum: number;
                                                    //   maximum: number;
                                                    // }>

const T = Type.Number()

Value.Assert(T, 42)                               // OK

Value.Assert(T, 'not a number')                   // throws AssertError

const T = Type.Number()

const A = Value.Check(T, 42)                        // const A = true

const B = Value.Check(T, 'not-a-number')            // const B = false

const T = Type.Object({
  x: Type.Number(),
  y: Type.Number()
})


const R = Value.Clean(T, { x: 1, y: 2, z: 3 })        // const R = { x: 1, y: 2 }

const T = Type.Tuple([
  Type.Number(),
  Type.Number()
])

const R = Value.Clean(T, [1, 2, 3])                   // const R = [1, 2]

const A = { x: 1, y: 2, z: 3 }

const B = Value.Clone(A)                            // const B = { x: 1, y: 2, z: 3 }

const T = Type.Object({
  x: Type.Number()
})

// ...

const A = Value.Convert(T, { x: '3.14' })           // const A = { x: 3.14 }

const B = Value.Convert(T, { x: 'not a number' })   // const B = { x: 'not a number' }

const T = Type.Object({
  x: Type.Number({ default: 42 }),
  y: Type.Number(),
  z: Type.Number()
})

const A = Value.Create(T)                            // const A = {
                                                     //   x: 42,
                                                     //   y: 0,
                                                     //   z: 0
                                                     // }

const T = Type.String({
  format: 'email'
})

const A = Value.Create(T)                            // throws CreateError

const T = Type.String({
  format: 'email',
  default: '[email protected]'
})

const A = Value.Create(T)                            // const A: string = '[email protected]'

const Timestamp = Type.Codec(Type.Number())
  .Decode(value => new Date(value))                 
  .Encode(value => value.getTime())

const T = Type.Object({
  date: Timestamp
})

const R = Value.Decode(T, { date: 12345 })          // const R = {
                                                    //   date: 1970-01-01T00:00:12.345Z
                                                    // }

const Decoder = Pipeline([
  (_context, _type, value) => Clone(value),
  (context, type, value) => Default(context, type, value),
  (context, type, value) => Convert(context, type, value),
  (context, type, value) => Clean(context, type, value),
  (context, type, value) => Assert(context, type, value),
  (context, type, value) => DecodeUnsafe(context, type, value) // <--- Decode Last
])

import { Pipeline, Assert, DecodeUnsafe } from 'typebox/value'

// CustomDecoder

const CustomDecoder = Pipeline([
  (context, type, value) => { Assert(context, type, value); return value },
  (context, type, value) => DecodeUnsafe(context, type, value)
])

// Type + Decode

const NumberToString = Type.Decode(Type.Number(), value => value.toString())

// Result

const Result = CustomDecoder(NumberToString, 123456) // const Result: unknown = "123456"

const Pagination = Type.Object({
  skip: Type.Optional(Type.Number({ default: 0 })),
  take: Type.Optional(Type.Number({ default: 10 }))
})

const A = Value.Default(Pagination, {})             // const A = { skip: 0, take: 10 }

const B = Value.Default(Pagination, { skip: 10 })   // const B = { skip: 10, take: 10 }

const C = Value.Default(Pagination, { take: 100 })  // const C = { skip: 0, take: 100 }

const L = { x: 1, y: 2, z: 3 }                       // Left
const R = { y: 4, z: 5, w: 6 }                       // Right

const E = Value.Diff(L, R)                           // const E = [
                                                     //   { type: 'update', path: '/y', value: 4 },
                                                     //   { type: 'update', path: '/z', value: 5 },
                                                     //   { type: 'insert', path: '/w', value: 6 },
                                                     //   { type: 'delete', path: '/x' }
                                                     // ]

const Timestamp = Type.Codec(Type.Number())
  .Decode(value => new Date(value))
  .Encode(value => value.getTime())                

const T = Type.Object({
  date: Timestamp
})

const R = Value.Encode(T, {                         // const R = {
  date: new Date('1970-01-01T00:00:12.345Z')        //   date: 12345
})                                                  // }

const Encoder = Pipeline([
  (_context, _type, value) => Clone(value),
  (context, type, value) => EncodeUnsafe(context, type, value), // <--- Encode First
  (context, type, value) => Default(context, type, value),
  (context, type, value) => Convert(context, type, value),
  (context, type, value) => Clean(context, type, value),
  (context, type, value) => Assert(context, type, value),
])

import { Pipeline, Assert, EncodeUnsafe } from 'typebox/value'

// CustomEncoder

const CustomEncoder = Pipeline([
  (context, type, value) => EncodeUnsafe(context, type, value),
  (context, type, value) => { Assert(context, type, value); return value },
])

// Type + Encode

const StringToNumber = Type.Encode(Type.Number(), (value: unknown) =>
  typeof value === 'string'
    ? parseFloat(value)
    : 0
)

// Encode

const Result = CustomEncoder(StringToNumber, '123456') // const Result: unknown = 123456

const R = Value.Equal(                               // const R = true
  { x: 1, y: 2, z: 3 },
  { x: 1, y: 2, z: 3 }
)

/* Detailed source-code truncated for AI context efficiency. */

const A = Value.Hash({ x: 1, y: 2, z: 3 })           // const A = '0834a0916e3e4db0'

const B = Value.Hash({ x: 1, y: 4, z: 3 })           // const B = '279c16b78fba6600'

const Y = { z: 1 }                                  // const Y = { z: 1 }

const X = { y: Y }                                  // const X = { y: { z: 1 } }

const Z = { x: X }                                  // const Z = { x: { y: { z: 1 } } }

// Mutation

Value.Mutate(Z, { x: { y: { z: 2 } } })             // Z = { x: { y: { z: 2 } } }

const A = Z.x.y.z === 2                             // const A = true

const B = Z.x.y === Y                               // const B = true

const C = Z.x === X                                 // const C = true

const R = Value.Parse(Type.String(), 'hello')      // const R: string = "hello"

const E = Value.Parse(Type.String(), 12345)        // throws ParseError

import { Settings } from 'typebox/system'

// Corrective Parse: Enable

Settings.Set({ correctiveParse: true })

// Corrective Parse: Convert Value into the target type if reasonable conversion is possible.

const R = Value.Parse(Type.String(), 'hello')      // const R: string = "hello"

const S = Value.Parse(Type.String(), 12345)        // const S: string = "12345"

// Corrective Parse: Reset (optional)

Settings.Reset()

const L = { x: 1, y: 2, z: 3 }                       // Left
const R = { y: 4, z: 5, w: 6 }                       // Right

const E = Value.Diff(L, R)                           // const E = [
                                                     //   { type: 'update', path: '/y', value: 4 },
                                                     //   { type: 'update', path: '/z', value: 5 },
                                                     //   { type: 'insert', path: '/w', value: 6 },
                                                     //   { type: 'delete', path: '/x' }
                                                     // ]

// Patch Left with Edits

const A = Value.Patch(L, E)                          // const A = { y: 4, z: 5, w: 6 }

/* Detailed source-code truncated for AI context efficiency. */

const X = { x: 1 }

const A = Value.Pointer.Get(X, '/x')                // const A = 1

const B = Value.Pointer.Get(X, '/y')                // const B = undefined

const X = { x: 1 }

Value.Pointer.Set(X, '/x', 100)                     // X' = { x: 100 }

Value.Pointer.Set(X, '/y', 200)                     // X' = { x: 100, y: 200 }

const X = { x: 1 }

const A = Value.Pointer.Has(X, '/x')                // const A = true

const B = Value.Pointer.Has(X, '/y')                // const B = false

const X = { x: 1 }

Value.Pointer.Delete(X, '/x')                          // X' = { }

Value.Pointer.Delete(X, '/y')                       // X' = { } (no action)

const T = Type.Object({
  x: Type.Number(),
  y: Type.Number()
}, { additionalProperties: false })                 // Tip: Use additionalProperties: false if you want
                                                    // Repair to remove excess properties. By default,
                                                    // the Repair function retain excess properties to
                                                    // avoid data loss.

// ...

const A = Value.Repair(T, null)                     // const A = { x: 0, y: 0 }

const B = Value.Repair(T, { x: 1 })                 // const B = { x: 1, y: 0 }

const C = Value.Repair(T, { x: 1, y: 2, z: 3 })     // const C = { x: 1, y: 2 }

const D = Value.Repair(T, { x: true, y: '42' })    // const D = { x: 1, y: 42 }