supersplat.zip

<div align='center'> <h1>TypeBox</h1> <p>JSON Schema Type Builder with Static Type Resolution for TypeScript</p> <img src="https://github.com/sinclairzx81/typebox/blob/master/typebox.png?raw=true" /> <br /> <br /> [](https://badge.fury.io/js/%40sinclair%2Ftypebox) [](https://www.npmjs.com/package/%40sinclair%2Ftypebox) [](https://github.com/sinclairzx81/typebox/actions) </div> <a name="Install"></a> ## Install #### Npm ```bash $ npm install @sinclair/typebox --save ``` #### Deno ```typescript import { Static, Type } from 'npm:@sinclair/typebox' ``` #### Esm ```typescript import { Static, Type } from 'https://esm.sh/@sinclair/typebox' ``` ## Example ```typescript import { Static, Type } from '@sinclair/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 = Static<typeof T> // type T = { // x: number, // y: number, // z: number // } ``` <a name="Overview"></a> ## Overview TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation. This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire. License MIT ## Contents - [Install](#install) - [Overview](#overview) - [Usage](#usage) - [Types](#types) - [Standard](#types-standard) - [Extended](#types-extended) - [Modifiers](#types-modifiers) - [Options](#types-options) - [Generics](#types-generics) - [References](#types-references) - [Recursive](#types-recursive) - [Conditional](#types-conditional) - [Template Literal](#types-template-literal) - [Guards](#types-guards) - [Unsafe](#types-unsafe) - [Strict](#types-strict) - [Values](#values) - [Create](#values-create) - [Clone](#values-clone) - [Check](#values-check) - [Convert](#values-convert) - [Cast](#values-cast) - [Equal](#values-equal) - [Hash](#values-hash) - [Diff](#values-diff) - [Patch](#values-patch) - [Errors](#values-errors) - [Mutate](#values-mutate) - [Pointer](#values-pointer) - [TypeCheck](#typecheck) - [Ajv](#typecheck-ajv) - [TypeCompiler](#typecheck-typecompiler) - [TypeSystem](#typesystem) - [Types](#typesystem-types) - [Formats](#typesystem-formats) - [Policies](#typesystem-policies) - [Benchmark](#benchmark) - [Compile](#benchmark-compile) - [Validate](#benchmark-validate) - [Compression](#benchmark-compression) - [Contribute](#contribute) <a name="usage"></a> ## Usage The following shows general usage. ```typescript import { Static, Type } from '@sinclair/typebox' //-------------------------------------------------------------------------------------------- // // Let's say you have the following type ... // //-------------------------------------------------------------------------------------------- type T = { id: string, name: string, timestamp: number } //-------------------------------------------------------------------------------------------- // // ... you can express this type in the following way. // //-------------------------------------------------------------------------------------------- const T = Type.Object({ // const T = { id: Type.String(), // type: 'object', name: Type.String(), // properties: { timestamp: Type.Integer() // id: { }) // type: 'string' // }, // name: { // type: 'string' // }, // timestamp: { // type: 'integer' // } // }, // required: [ // 'id', // 'name', // 'timestamp' // ] // } //-------------------------------------------------------------------------------------------- // // ... then infer back to the original static type this way. // //-------------------------------------------------------------------------------------------- type T = Static<typeof T> // type T = { // id: string, // name: string, // timestamp: number // } //-------------------------------------------------------------------------------------------- // // ... then use the type both as JSON schema and as a TypeScript type. // //-------------------------------------------------------------------------------------------- import { Value } from '@sinclair/typebox/value' function receive(value: T) { // ... as a Static Type if(Value.Check(T, value)) { // ... as a JSON Schema // ok... } } ``` <a name='types'></a> ## Types TypeBox types are JSON schema fragments that can be composed into more complex types. Each fragment is structured such that a JSON schema compliant validator can runtime assert a value the same way TypeScript will statically assert a type. TypeBox provides a set of Standard types which are used create JSON schema compliant schematics as well as an Extended type set used to create schematics for constructs native to JavaScript. <a name='types-standard'></a> ### Standard Types The following table lists the Standard TypeBox types. These types are fully compatible with the JSON Schema Draft 6 specification. ```typescript ┌────────────────────────────────┬─────────