@sinclair/typebox 0.20.3 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.20.3",
+  "version": "0.21.0",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "json-schema",
@@ -23,14 +23,14 @@
     "test": "hammer task spec"
   },
   "devDependencies": {
-    "@sinclair/hammer": "^0.12.1",
+    "@sinclair/hammer": "^0.15.7",
     "@types/chai": "^4.2.16",
     "@types/mocha": "^8.2.2",
     "@types/node": "^14.14.37",
     "ajv": "^8.6.2",
     "ajv-formats": "^2.0.2",
     "chai": "^4.3.4",
-    "mocha": "^8.3.2",
-    "typescript": "^4.3.5"
+    "mocha": "^9.1.2",
+    "typescript": "^4.5.2"
   }
 }

package/readme.md

@@ -38,7 +38,7 @@ type T = Static<typeof T>   // type T = string
 
 ## Overview
 
-TypeBox is a library that creates in-memory JSON Schema objects that can be statically resolved to TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox allows one to create a unified type that can be statically checked by the TypeScript compiler and runtime asserted using standard JSON Schema validation.
+TypeBox is a library that builds in-memory JSON Schema objects that can be statically resolved to TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox allows one to create a unified type that can be statically checked by the TypeScript compiler and runtime asserted using standard JSON Schema validation.
 
 TypeBox can be used as a simple tool to build up complex schemas or integrated into RPC or REST services to help validate JSON data received over the wire. TypeBox does not provide any JSON schema validation. Please use libraries such as AJV to validate schemas built with this library.
 
@@ -59,6 +59,7 @@ License MIT
 - [Extended Types](#Extended-Types)
 - [Strict](#Strict)
 - [Validation](#Validation)
+- [OpenAPI](#OpenAPI)
 
 <a name="Example"></a>
 
@@ -307,7 +308,7 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │          Type.Number()         │                             │     y: {                       │
 │       )                        │                             │        type: 'number'          │
 │    })                          │                             │     }                          │
-│ )                              │                             │   }                            │
+│ )                              │                             │   },                           │
 │                                │                             │   required: ['x', 'y']         │
 │                                │                             │ }                              │
 │   	                         │                             │                                │
@@ -383,7 +384,7 @@ TypeBox provides modifiers that can be applied to an objects properties. This al
 
 ### Options
 
-You can pass additional JSON schema properties on the last argument of any given type. The following are some examples.
+You can pass additional JSON schema options on the last argument of any given type. The following are some examples.
 
 ```typescript
 // string must be an email
@@ -446,10 +447,10 @@ const R = Type.Ref(T)                        // const R = {
                                              // }
 ```
 
-It can be helpful to organize shared referenced types under a common namespace. The `Type.Box(...)` function can be used to create a shared definition container for related types. The following creates a `Math3D` container and a `Vertex` structure that references types in the container.
+It can be helpful to organize shared referenced types under a common namespace. The `Type.Namespace(...)` function can be used to create a shared definition container for related types. The following creates a `Math3D` container and a `Vertex` structure that references types in the container.
 
 ```typescript
-const Math3D = Type.Box({                     //  const Math3D = {
+const Math3D = Type.Namespace({               //  const Math3D = {
   Vector4: Type.Object({                      //    $id: 'Math3D',
     x: Type.Number(),                         //    definitions: {
     y: Type.Number(),                         //      Vector4: {
@@ -690,30 +691,30 @@ const ok = ajv.validate(User, {
 
 #### Reference Types
 
-Referenced types can be added to AJV with the `ajv.addSchema(...)` function. The following moves the `userId` and `email` property types into a `Type.Box(...)` and registers the box with AJV.
+Referenced types can be added to AJV with the `ajv.addSchema(...)` function. The following moves the `userId` and `email` property types into a `Type.Namespace(...)` and registers the box with AJV.
 
 ```typescript
 //--------------------------------------------------------------------------------------------
 //
-// Common Types
+// Shared Types
 //
 //--------------------------------------------------------------------------------------------
 
-const Common = Type.Box({
+const Shared = Type.Namespace({
   UserId: Type.String({ format: 'uuid' }),
   Email:  Type.String({ format: 'email' })
-}, { $id: 'Common' })
+}, { $id: 'Shared' })
 
 //--------------------------------------------------------------------------------------------
 //
-// Setup AJV validator with the following options and formats
+// Setup Validator and Register Shared Types
 //
 //--------------------------------------------------------------------------------------------
 
 const ajv = addFormats(new Ajv({}), [...])
   .addKeyword('kind')
   .addKeyword('modifier')
-  .addSchema(Common) // <-- Register Common Types
+  .addSchema(Shared) // <-- Register Shared Types
 
 //--------------------------------------------------------------------------------------------
 //
@@ -722,8 +723,8 @@ const ajv = addFormats(new Ajv({}), [...])
 //--------------------------------------------------------------------------------------------
 
 const User = Type.Object({
-  userId: Type.Ref(Common, 'UserId'),
-  email:  Type.Ref(Common, 'Email'),
+  userId: Type.Ref(Shared, 'UserId'),
+  email:  Type.Ref(Shared, 'Email'),
   online: Type.Boolean()
 }, { additionalProperties: false })
 
@@ -741,4 +742,47 @@ const ok = ajv.validate(User, {
 
 ```
 
-Please refer to the official AJV [documentation](https://ajv.js.org/guide/getting-started.html) for more information on using this validator.
+Please refer to the official AJV [documentation](https://ajv.js.org/guide/getting-started.html) for additional information.
+
+### OpenAPI
+
+TypeBox can be used to create schemas for OpenAPI, however users should be aware of the various differences between the JSON Schema and OpenAPI specifications. Two common instances where OpenAPI diverges from the JSON Schema specification is OpenAPI's handling of `string enum` and `nullable`. The following shows how you can use TypeBox to construct these types.
+
+```typescript
+import { Type, Static, TNull, TLiteral, TUnion, TSchema } from '@sinclair/typebox'
+
+//--------------------------------------------------------------------------------------------
+//
+// Nullable<T>
+//
+//--------------------------------------------------------------------------------------------
+
+function Nullable<T extends TSchema>(schema: T): TUnion<[T, TNull]> {
+    return { ...schema, nullable: true } as any
+}
+
+const T = Nullable(Type.String())        // const T = {
+                                         //   type: 'string',
+                                         //   nullable: true
+                                         // }
+
+type T = Static<typeof T>                // type T = string | null
+
+//--------------------------------------------------------------------------------------------
+//
+// StringUnion<[...]>
+//
+//--------------------------------------------------------------------------------------------
+
+type IntoStringUnion<T> = {[K in keyof T]: T[K] extends string ? TLiteral<T[K]>: never }
+
+function StringUnion<T extends string[]>(values: [...T]): TUnion<IntoStringUnion<T>> {
+    return { enum: values } as any
+}
+
+const T = StringUnion(['A', 'B', 'C'])   // const T = {
+                                         //    enum: ['A', 'B', 'C']
+                                         // }
+
+type T = Static<typeof T>                // type T = 'A' | 'B' | 'C'
+```

package/typebox.d.ts

@@ -60,103 +60,102 @@ export declare type NumberOptions = {
 export declare type IntersectOptions = {
     unevaluatedProperties?: boolean;
 } & CustomOptions;
-export declare type IndexedOptions = {
-    minProperties?: number;
-    maxProperties?: number;
-} & CustomOptions;
 export declare type ObjectOptions = {
     additionalProperties?: boolean;
 } & CustomOptions;
+export declare type TNamespace<T extends TDefinitions> = {
+    kind: typeof BoxKind;
+    definitions: T;
+} & CustomOptions;
+export declare type TDefinitions = {
+    [key: string]: TSchema;
+};
+export declare type Infer<T> = {
+    '_infer': T;
+};
 export declare type TEnumType = Record<string, string | number>;
 export declare type TKey = string | number;
 export declare type TValue = string | number | boolean;
-export declare type TRecordKey = TString | TNumber | TUnion<TLiteral<string | number>[]>;
+export declare type TRecordKey = TString | TNumber | TKeyOf<any>;
 export declare type TEnumKey<T = TKey> = {
     type: 'number' | 'string';
     const: T;
 };
-export declare type TDefinitions = {
-    [key: string]: TSchema;
-};
 export declare type TProperties = {
     [key: string]: TSchema;
 };
-export declare type TBox<T extends TDefinitions> = {
-    kind: typeof BoxKind;
-    definitions: T;
-} & CustomOptions;
-export declare type TTuple<T extends TSchema[]> = {
+export declare type TTuple<T> = Infer<T> & {
     kind: typeof TupleKind;
     type: 'array';
-    items?: [...T];
+    items?: TSchema[];
     additionalItems?: false;
     minItems: number;
     maxItems: number;
 } & CustomOptions;
-export declare type TObject<T extends TProperties> = {
+export declare type TObject<T> = Infer<T> & {
     kind: typeof ObjectKind;
     type: 'object';
-    properties: T;
+    properties: TProperties;
     required?: string[];
 } & ObjectOptions;
-export declare type TUnion<T extends TSchema[]> = {
+export declare type TUnion<T> = Infer<T> & {
     kind: typeof UnionKind;
-    anyOf: [...T];
+    anyOf: TSchema[];
 } & CustomOptions;
-export declare type TIntersect<T extends TSchema[]> = {
+export declare type TIntersect<T> = Infer<T> & {
     kind: typeof IntersectKind;
     type: 'object';
-    allOf: [...T];
+    allOf: TSchema[];
 } & IntersectOptions;
-export declare type TKeyOf<T extends TKey[]> = {
+export declare type TKeyOf<T> = Infer<T> & {
     kind: typeof KeyOfKind;
     type: 'string';
-    enum: [...T];
+    enum: string[];
 } & CustomOptions;
-export declare type TRecord<K extends TRecordKey, T extends TSchema> = {
+export declare type TRecord<T> = Infer<T> & {
     kind: typeof RecordKind;
     type: 'object';
     patternProperties: {
-        [pattern: string]: T;
+        [pattern: string]: TSchema;
     };
 } & ObjectOptions;
-export declare type TArray<T extends TSchema> = {
+export declare type TArray<T> = Infer<T> & {
     kind: typeof ArrayKind;
     type: 'array';
-    items: T;
+    items: any;
 } & ArrayOptions;
-export declare type TLiteral<T extends TValue> = {
+export declare type TLiteral<T> = Infer<T> & {
     kind: typeof LiteralKind;
-    const: T;
+    const: TSchema;
 } & CustomOptions;
-export declare type TEnum<T extends TEnumKey[]> = {
+export declare type TEnum<T> = Infer<T> & {
     kind: typeof EnumKind;
-    anyOf: T;
+    anyOf: TSchema;
 } & CustomOptions;
-export declare type TString = {
+export declare type TString = Infer<string> & {
     kind: typeof StringKind;
     type: 'string';
 } & StringOptions<string>;
-export declare type TNumber = {
+export declare type TNumber = Infer<number> & {
     kind: typeof NumberKind;
     type: 'number';
 } & NumberOptions;
-export declare type TInteger = {
+export declare type TInteger = Infer<number> & {
     kind: typeof IntegerKind;
     type: 'integer';
 } & NumberOptions;
-export declare type TBoolean = {
+export declare type TBoolean = Infer<boolean> & {
     kind: typeof BooleanKind;
     type: 'boolean';
 } & CustomOptions;
-export declare type TNull = {
+export declare type TNull = Infer<null> & {
     kind: typeof NullKind;
     type: 'null';
 } & CustomOptions;
-export declare type TUnknown = {
+export declare type TUnknown = Infer<unknown> & {
     kind: typeof UnknownKind;
 } & CustomOptions;
-export declare type TAny = {
+export declare type TAny = Infer<any> & {
     kind: typeof AnyKind;
 } & CustomOptions;
 export declare const ConstructorKind: unique symbol;
@@ -164,55 +163,44 @@ export declare const FunctionKind: unique symbol;
 export declare const PromiseKind: unique symbol;
 export declare const UndefinedKind: unique symbol;
 export declare const VoidKind: unique symbol;
-export declare type TConstructor<T extends TSchema[], U extends TSchema> = {
+export declare type TConstructor<T> = Infer<T> & {
     kind: typeof ConstructorKind;
     type: 'constructor';
-    arguments: readonly [...T];
-    returns: U;
+    arguments: TSchema[];
+    returns: TSchema;
 } & CustomOptions;
-export declare type TFunction<T extends TSchema[], U extends TSchema> = {
+export declare type TFunction<T> = Infer<T> & {
     kind: typeof FunctionKind;
     type: 'function';
-    arguments: readonly [...T];
-    returns: U;
+    arguments: TSchema[];
+    returns: TSchema;
 } & CustomOptions;
-export declare type TPromise<T extends TSchema> = {
+export declare type TPromise<T> = Infer<T> & {
     kind: typeof PromiseKind;
     type: 'promise';
-    item: T;
+    item: TSchema;
 } & CustomOptions;
-export declare type TUndefined = {
+export declare type TUndefined = Infer<undefined> & {
     kind: typeof UndefinedKind;
     type: 'undefined';
 } & CustomOptions;
-export declare type TVoid = {
+export declare type TVoid = Infer<void> & {
     kind: typeof VoidKind;
     type: 'void';
 } & CustomOptions;
-export declare type TSchema = TIntersect<any> | TUnion<any> | TTuple<any> | TObject<any> | TKeyOf<any> | TRecord<any, any> | TArray<any> | TEnum<any> | TLiteral<any> | TString | TNumber | TInteger | TBoolean | TNull | TUnknown | TAny | TConstructor<any[], any> | TFunction<any[], any> | TPromise<any> | TUndefined | TVoid;
-export declare type TRequired<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> : T[K] extends TReadonly<infer U> ? TReadonly<U> : T[K] extends TOptional<infer U> ? U : T[K];
-};
-export declare type TPartial<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : T[K] extends TReadonly<infer U> ? TReadonlyOptional<U> : T[K] extends TOptional<infer U> ? TOptional<U> : TOptional<T[K]>;
-};
+export declare type TSchema = TIntersect<any> | TUnion<any> | TTuple<any> | TObject<any> | TKeyOf<any> | TRecord<any> | TArray<any> | TEnum<any> | TLiteral<any> | TString | TNumber | TInteger | TBoolean | TNull | TUnknown | TAny | TConstructor<any> | TFunction<any> | TPromise<any> | TUndefined | TVoid;
 export declare type UnionToIntersect<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-export declare type ObjectPropertyKeys<T> = T extends TObject<infer U> ? PropertyKeys<U> : never;
-export declare type PropertyKeys<T extends TProperties> = keyof T;
 export declare type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? K : never;
+    [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never;
 }[keyof T];
 export declare type ReadonlyPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonly<infer U> ? K : never;
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never;
 }[keyof T];
 export declare type OptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TOptional<infer U> ? K : never;
+    [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never;
 }[keyof T];
 export declare type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
-export declare type ReduceModifiers<T extends object> = {
-    [K in keyof T]: T[K];
-};
-export declare type StaticModifiers<T extends TProperties> = {
+export declare type StaticProperties<T extends TProperties> = {
     readonly [K in ReadonlyOptionalPropertyKeys<T>]?: Static<T[K]>;
 } & {
     readonly [K in ReadonlyPropertyKeys<T>]: Static<T[K]>;
@@ -230,14 +218,8 @@ export declare type StaticUnion<T extends readonly TSchema[]> = {
 export declare type StaticTuple<T extends readonly TSchema[]> = {
     [K in keyof T]: Static<T[K]>;
 };
-export declare type StaticObject<T extends TProperties> = ReduceModifiers<StaticModifiers<T>>;
-export declare type StaticRecord<K extends TRecordKey, T extends TSchema> = K extends TString ? {
-    [key: string]: Static<T>;
-} : K extends TNumber ? {
-    [key: number]: Static<T>;
-} : K extends TUnion<infer L> ? L extends TLiteral<any>[] ? {
-    [K in StaticUnion<L>]: Static<T>;
-} : never : never;
+export declare type StaticObject<T extends TProperties> = StaticProperties<StaticProperties<T>>;
+export declare type StaticRecord<K extends TRecordKey, T extends TSchema> = K extends TString ? Record<string, Static<T>> : K extends TNumber ? Record<number, Static<T>> : K extends TKeyOf<any> ? Record<K['_infer'], Static<T>> : never;
 export declare type StaticArray<T extends TSchema> = Array<Static<T>>;
 export declare type StaticLiteral<T extends TValue> = T;
 export declare type StaticConstructor<T extends readonly TSchema[], U extends TSchema> = new (...args: [...{
@@ -247,76 +229,78 @@ export declare type StaticFunction<T extends readonly TSchema[], U extends TSche
     [K in keyof T]: Static<T[K]>;
 }]) => Static<U>;
 export declare type StaticPromise<T extends TSchema> = Promise<Static<T>>;
-export declare type Static<T> = T extends TKeyOf<infer U> ? StaticKeyOf<U> : T extends TIntersect<infer U> ? StaticIntersect<U> : T extends TUnion<infer U> ? StaticUnion<U> : T extends TTuple<infer U> ? StaticTuple<U> : T extends TObject<infer U> ? StaticObject<U> : T extends TRecord<infer K, infer U> ? StaticRecord<K, U> : T extends TArray<infer U> ? StaticArray<U> : T extends TEnum<infer U> ? StaticEnum<U> : T extends TLiteral<infer U> ? StaticLiteral<U> : T extends TString ? string : T extends TNumber ? number : T extends TInteger ? number : T extends TBoolean ? boolean : T extends TNull ? null : T extends TUnknown ? unknown : T extends TAny ? any : T extends TConstructor<infer U, infer R> ? StaticConstructor<U, R> : T extends TFunction<infer U, infer R> ? StaticFunction<U, R> : T extends TPromise<infer U> ? StaticPromise<U> : T extends TUndefined ? undefined : T extends TVoid ? void : never;
+export declare type Static<T> = T extends TKeyOf<infer I> ? I : T extends TIntersect<infer I> ? I : T extends TUnion<infer I> ? I : T extends TTuple<infer I> ? I : T extends TObject<infer I> ? {
+    [K in keyof I]: I[K];
+} : T extends TRecord<infer I> ? I : T extends TArray<infer I> ? I : T extends TEnum<infer I> ? I : T extends TLiteral<infer I> ? I : T extends TString ? T['_infer'] : T extends TNumber ? T['_infer'] : T extends TInteger ? T['_infer'] : T extends TBoolean ? T['_infer'] : T extends TNull ? T['_infer'] : T extends TUnknown ? T['_infer'] : T extends TAny ? T['_infer'] : T extends TConstructor<infer I> ? I : T extends TFunction<infer I> ? I : T extends TPromise<infer I> ? I : T extends TUndefined ? T['_infer'] : T extends TVoid ? T['_infer'] : never;
 export declare class TypeBuilder {
-    /** `STANDARD` Modifies a schema object property to be `readonly` and `optional`. */
+    /** `standard` Modifies an object property to be both readonly and optional */
     ReadonlyOptional<T extends TSchema>(item: T): TReadonlyOptional<T>;
-    /** `STANDARD` Modifies a schema object property to be `readonly`. */
+    /** `standard` Modifies an object property to be readonly */
     Readonly<T extends TSchema>(item: T): TReadonly<T>;
-    /** `STANDARD` Modifies a schema object property to be `optional`. */
+    /** `standard` Modifies an object property to be optional */
     Optional<T extends TSchema>(item: T): TOptional<T>;
-    /** `STANDARD` Creates a Tuple schema. */
-    Tuple<T extends TSchema[]>(items: [...T], options?: CustomOptions): TTuple<T>;
-    /** `STANDARD` Creates a `object` schema with the given properties. */
-    Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
-    /** `STANDARD` Creates an intersection schema. Note this function requires draft `2019-09` to constrain with `unevaluatedProperties`. */
-    Intersect<T extends TSchema[]>(items: [...T], options?: IntersectOptions): TIntersect<T>;
-    /** `STANDARD` Creates a Union schema. */
-    Union<T extends TSchema[]>(items: [...T], options?: CustomOptions): TUnion<T>;
-    /** `STANDARD` Creates an `Array<T>` schema. */
-    Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
-    /** `STANDARD` Creates an `Enum<T>` schema from a TypeScript `enum` definition. */
-    Enum<T extends TEnumType>(item: T, options?: CustomOptions): TEnum<TEnumKey<T[keyof T]>[]>;
-    /** `STANDARD` Creates a literal schema. Supports `string | number | boolean` values. */
-    Literal<T extends TValue>(value: T, options?: CustomOptions): TLiteral<T>;
-    /** `STANDARD` Creates a `string` schema. */
+    /** `standard` Creates a type type */
+    Tuple<T extends TSchema[]>(items: [...T], options?: CustomOptions): TTuple<StaticTuple<T>>;
+    /** `standard` Creates an object type with the given properties */
+    Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<StaticProperties<T>>;
+    /** `standard` Creates an intersection type. Note this function requires draft `2019-09` to constrain with `unevaluatedProperties` */
+    Intersect<T extends TSchema[]>(items: [...T], options?: IntersectOptions): TIntersect<StaticIntersect<T>>;
+    /** `standard` Creates a union type */
+    Union<T extends TSchema[]>(items: [...T], options?: CustomOptions): TUnion<StaticUnion<T>>;
+    /** `standard` Creates an array type */
+    Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<StaticArray<T>>;
+    /** `standard` Creates an enum type from a TypeScript enum */
+    Enum<T extends TEnumType>(item: T, options?: CustomOptions): TEnum<StaticEnum<TEnumKey<T[keyof T]>[]>>;
+    /** `standard` Creates a literal type. Supports string, number and boolean values only */
+    Literal<T extends TValue>(value: T, options?: CustomOptions): TLiteral<StaticLiteral<T>>;
+    /** `standard` Creates a string type */
     String<TCustomFormatOption extends string>(options?: StringOptions<StringFormatOption | TCustomFormatOption>): TString;
-    /** `STANDARD` Creates a `string` schema from a regular expression. */
+    /** `standard` Creates a string type from a regular expression */
     RegEx(regex: RegExp, options?: CustomOptions): TString;
-    /** `STANDARD` Creates a `number` schema. */
+    /** `standard` Creates a number type */
     Number(options?: NumberOptions): TNumber;
-    /** `STANDARD` Creates a `integer` schema. */
+    /** `standard` Creates an integer type */
     Integer(options?: NumberOptions): TInteger;
-    /** `STANDARD` Creates a `boolean` schema. */
+    /** `standard` Creates a boolean type */
     Boolean(options?: CustomOptions): TBoolean;
-    /** `STANDARD` Creates a `null` schema. */
+    /** `standard` Creates a null type */
     Null(options?: CustomOptions): TNull;
-    /** `STANDARD` Creates an `unknown` schema. */
+    /** `standard` Creates an unknown type */
     Unknown(options?: CustomOptions): TUnknown;
-    /** `STANDARD` Creates an `any` schema. */
+    /** `standard` Creates an any type */
     Any(options?: CustomOptions): TAny;
-    /** `STANDARD` Creates a `keyof` schema. */
-    KeyOf<T extends TObject<TProperties>>(schema: T, options?: CustomOptions): TKeyOf<ObjectPropertyKeys<T>[]>;
-    /** `STANDARD` Creates a `Record<Keys, Value>` schema. */
-    Record<K extends TRecordKey, T extends TSchema>(key: K, value: T, options?: ObjectOptions): TRecord<K, T>;
-    /** `STANDARD` Make all properties in schema object required. */
-    Required<T extends TObject<TProperties>>(schema: T, options?: ObjectOptions): TObject<TRequired<T['properties']>>;
-    /** `STANDARD`  Make all properties in schema object optional. */
-    Partial<T extends TObject<TProperties>>(schema: T, options?: ObjectOptions): TObject<TPartial<T['properties']>>;
-    /** `STANDARD` Picks property keys from the given object schema. */
-    Pick<T extends TObject<TProperties>, K extends PropertyKeys<T['properties']>[]>(schema: T, keys: [...K], options?: ObjectOptions): TObject<Pick<T['properties'], K[number]>>;
-    /** `STANDARD` Omits property keys from the given object schema. */
-    Omit<T extends TObject<TProperties>, K extends PropertyKeys<T['properties']>[]>(schema: T, keys: [...K], options?: ObjectOptions): TObject<Omit<T['properties'], K[number]>>;
-    /** `STANDARD` Omits the `kind` and `modifier` properties from the given schema. */
+    /** `standard` Creates a keyof type from the given object */
+    KeyOf<T extends TObject<any>>(schema: T, options?: CustomOptions): TKeyOf<keyof T['_infer']>;
+    /** `standard` Creates a record type */
+    Record<K extends TRecordKey, T extends TSchema>(key: K, value: T, options?: ObjectOptions): TRecord<StaticRecord<K, T>>;
+    /** `standard` Makes all properties in the given object type required */
+    Required<T extends TObject<any>>(schema: T, options?: ObjectOptions): TObject<Required<T['_infer']>>;
+    /** `standard` Makes all properties in the given object type optional */
+    Partial<T extends TObject<any>>(schema: T, options?: ObjectOptions): TObject<Partial<T['_infer']>>;
+    /** `standard` Picks property keys from the given object type */
+    Pick<T extends TObject<any>, K extends (keyof T['_infer'])[]>(schema: T, keys: [...K], options?: ObjectOptions): TObject<Pick<T['_infer'], K[number]>>;
+    /** `standard` Omits property keys from the given object type */
+    Omit<T extends TObject<any>, K extends (keyof T['_infer'])[]>(schema: T, keys: [...K], options?: ObjectOptions): TObject<Omit<T['_infer'], K[number]>>;
+    /** `standard` Omits the `kind` and `modifier` properties from the underlying schema */
     Strict<T extends TSchema>(schema: T, options?: CustomOptions): T;
-    /** `EXTENDED` Creates a `constructor` schema. */
-    Constructor<T extends TSchema[], U extends TSchema>(args: [...T], returns: U, options?: CustomOptions): TConstructor<T, U>;
-    /** `EXTENDED` Creates a `function` schema. */
-    Function<T extends TSchema[], U extends TSchema>(args: [...T], returns: U, options?: CustomOptions): TFunction<T, U>;
-    /** `EXTENDED` Creates a `Promise<T>` schema. */
-    Promise<T extends TSchema>(item: T, options?: CustomOptions): TPromise<T>;
-    /** `EXTENDED` Creates a `undefined` schema. */
+    /** `extended` Creates a constructor type */
+    Constructor<T extends TSchema[], U extends TSchema>(args: [...T], returns: U, options?: CustomOptions): TConstructor<StaticConstructor<T, U>>;
+    /** `extended` Creates a function type */
+    Function<T extends TSchema[], U extends TSchema>(args: [...T], returns: U, options?: CustomOptions): TFunction<StaticFunction<T, U>>;
+    /** `extended` Creates a promise type */
+    Promise<T extends TSchema>(item: T, options?: CustomOptions): TPromise<StaticPromise<T>>;
+    /** `extended` Creates a undefined type */
     Undefined(options?: CustomOptions): TUndefined;
-    /** `EXTENDED` Creates a `void` schema. */
+    /** `extended` Creates a void type */
     Void(options?: CustomOptions): TVoid;
-    /** `EXPERIMENTAL` Creates a recursive type. */
+    /** `experimental` Creates a recursive type */
     Rec<T extends TSchema>(callback: (self: TAny) => T, options?: CustomOptions): T;
-    /** `EXPERIMENTAL` Creates a recursive type. Pending https://github.com/ajv-validator/ajv/issues/1709 */
-    /** `EXPERIMENTAL` Creates a container for schema definitions. */
-    Box<T extends TDefinitions>(definitions: T, options?: CustomOptions): TBox<T>;
-    /** `EXPERIMENTAL` References a schema inside a box. The referenced box must specify an `$id`. */
-    Ref<T extends TBox<TDefinitions>, K extends keyof T['definitions']>(box: T, key: K): T['definitions'][K];
-    /** `EXPERIMENTAL` References a schema. The referenced schema must specify an `$id`. */
+    /** `experimental` Creates a recursive type. Pending https://github.com/ajv-validator/ajv/issues/1709 */
+    /** `experimental` Creates a namespace for a set of related types */
+    Namespace<T extends TDefinitions>(definitions: T, options?: CustomOptions): TNamespace<T>;
+    /** `experimental` References a type within a namespace. The referenced namespace must specify an `$id` */
+    Ref<T extends TNamespace<TDefinitions>, K extends keyof T['definitions']>(box: T, key: K): T['definitions'][K];
+    /** `experimental` References type. The referenced type must specify an `$id` */
     Ref<T extends TSchema>(schema: T): T;
 }
 export declare const Type: TypeBuilder;

package/typebox.js

@@ -82,19 +82,19 @@ function clone(object) {
 // TypeBuilder
 // ------------------------------------------------------------------------
 class TypeBuilder {
-    /** `STANDARD` Modifies a schema object property to be `readonly` and `optional`. */
+    /** `standard` Modifies an object property to be both readonly and optional */
     ReadonlyOptional(item) {
         return { ...item, modifier: exports.ReadonlyOptionalModifier };
     }
-    /** `STANDARD` Modifies a schema object property to be `readonly`. */
+    /** `standard` Modifies an object property to be readonly */
     Readonly(item) {
         return { ...item, modifier: exports.ReadonlyModifier };
     }
-    /** `STANDARD` Modifies a schema object property to be `optional`. */
+    /** `standard` Modifies an object property to be optional */
     Optional(item) {
         return { ...item, modifier: exports.OptionalModifier };
     }
-    /** `STANDARD` Creates a Tuple schema. */
+    /** `standard` Creates a type type */
     Tuple(items, options = {}) {
         const additionalItems = false;
         const minItems = items.length;
@@ -103,7 +103,7 @@ class TypeBuilder {
             ? { ...options, kind: exports.TupleKind, type: 'array', items, additionalItems, minItems, maxItems }
             : { ...options, kind: exports.TupleKind, type: 'array', minItems, maxItems };
     }
-    /** `STANDARD` Creates a `object` schema with the given properties. */
+    /** `standard` Creates an object type with the given properties */
     Object(properties, options = {}) {
         const property_names = Object.keys(properties);
         const optional = property_names.filter(name => {
@@ -118,73 +118,73 @@ class TypeBuilder {
             { ...options, kind: exports.ObjectKind, type: 'object', properties, required } :
             { ...options, kind: exports.ObjectKind, type: 'object', properties };
     }
-    /** `STANDARD` Creates an intersection schema. Note this function requires draft `2019-09` to constrain with `unevaluatedProperties`. */
+    /** `standard` Creates an intersection type. Note this function requires draft `2019-09` to constrain with `unevaluatedProperties` */
     Intersect(items, options = {}) {
         return { ...options, kind: exports.IntersectKind, type: 'object', allOf: items };
     }
-    /** `STANDARD` Creates a Union schema. */
+    /** `standard` Creates a union type */
     Union(items, options = {}) {
         return { ...options, kind: exports.UnionKind, anyOf: items };
     }
-    /** `STANDARD` Creates an `Array<T>` schema. */
+    /** `standard` Creates an array type */
     Array(items, options = {}) {
         return { ...options, kind: exports.ArrayKind, type: 'array', items };
     }
-    /** `STANDARD` Creates an `Enum<T>` schema from a TypeScript `enum` definition. */
+    /** `standard` Creates an enum type from a TypeScript enum */
     Enum(item, options = {}) {
         const values = Object.keys(item).filter(key => isNaN(key)).map(key => item[key]);
         const anyOf = values.map(value => typeof value === 'string' ? { type: 'string', const: value } : { type: 'number', const: value });
         return { ...options, kind: exports.EnumKind, anyOf };
     }
-    /** `STANDARD` Creates a literal schema. Supports `string | number | boolean` values. */
+    /** `standard` Creates a literal type. Supports string, number and boolean values only */
     Literal(value, options = {}) {
         return { ...options, kind: exports.LiteralKind, const: value, type: typeof value };
     }
-    /** `STANDARD` Creates a `string` schema. */
+    /** `standard` Creates a string type */
     String(options = {}) {
         return { ...options, kind: exports.StringKind, type: 'string' };
     }
-    /** `STANDARD` Creates a `string` schema from a regular expression. */
+    /** `standard` Creates a string type from a regular expression */
     RegEx(regex, options = {}) {
         return this.String({ ...options, pattern: regex.source });
     }
-    /** `STANDARD` Creates a `number` schema. */
+    /** `standard` Creates a number type */
     Number(options = {}) {
         return { ...options, kind: exports.NumberKind, type: 'number' };
     }
-    /** `STANDARD` Creates a `integer` schema. */
+    /** `standard` Creates an integer type */
     Integer(options = {}) {
         return { ...options, kind: exports.IntegerKind, type: 'integer' };
     }
-    /** `STANDARD` Creates a `boolean` schema. */
+    /** `standard` Creates a boolean type */
     Boolean(options = {}) {
         return { ...options, kind: exports.BooleanKind, type: 'boolean' };
     }
-    /** `STANDARD` Creates a `null` schema. */
+    /** `standard` Creates a null type */
     Null(options = {}) {
         return { ...options, kind: exports.NullKind, type: 'null' };
     }
-    /** `STANDARD` Creates an `unknown` schema. */
+    /** `standard` Creates an unknown type */
     Unknown(options = {}) {
         return { ...options, kind: exports.UnknownKind };
     }
-    /** `STANDARD` Creates an `any` schema. */
+    /** `standard` Creates an any type */
     Any(options = {}) {
         return { ...options, kind: exports.AnyKind };
     }
-    /** `STANDARD` Creates a `keyof` schema. */
+    /** `standard` Creates a keyof type from the given object */
     KeyOf(schema, options = {}) {
         const keys = Object.keys(schema.properties);
         return { ...options, kind: exports.KeyOfKind, type: 'string', enum: keys };
     }
-    /** `STANDARD` Creates a `Record<Keys, Value>` schema. */
+    /** `standard` Creates a record type */
     Record(key, value, options = {}) {
-        const pattern = key.kind === exports.UnionKind ? `^${key.anyOf.map((literal) => literal.const).join('|')}$` :
+        const pattern = key.kind === exports.KeyOfKind ? `^${key.enum.join('|')}$` :
             key.kind === exports.NumberKind ? '^(0|[1-9][0-9]*)$' :
                 key.pattern ? key.pattern : '^.*$';
         return { ...options, kind: exports.RecordKind, type: 'object', patternProperties: { [pattern]: value } };
     }
-    /** `STANDARD` Make all properties in schema object required. */
+    /** `standard` Makes all properties in the given object type required */
     Required(schema, options = {}) {
         const next = { ...clone(schema), ...options };
         next.required = Object.keys(next.properties);
@@ -207,7 +207,7 @@ class TypeBuilder {
         }
         return next;
     }
-    /** `STANDARD`  Make all properties in schema object optional. */
+    /** `standard` Makes all properties in the given object type optional */
     Partial(schema, options = {}) {
         const next = { ...clone(schema), ...options };
         delete next.required;
@@ -230,7 +230,7 @@ class TypeBuilder {
         }
         return next;
     }
-    /** `STANDARD` Picks property keys from the given object schema. */
+    /** `standard` Picks property keys from the given object type */
     Pick(schema, keys, options = {}) {
         const next = { ...clone(schema), ...options };
         next.required = next.required ? next.required.filter((key) => keys.includes(key)) : undefined;
@@ -240,7 +240,7 @@ class TypeBuilder {
         }
         return next;
     }
-    /** `STANDARD` Omits property keys from the given object schema. */
+    /** `standard` Omits property keys from the given object type */
     Omit(schema, keys, options = {}) {
         const next = { ...clone(schema), ...options };
         next.required = next.required ? next.required.filter((key) => !keys.includes(key)) : undefined;
@@ -250,46 +250,45 @@ class TypeBuilder {
         }
         return next;
     }
-    /** `STANDARD` Omits the `kind` and `modifier` properties from the given schema. */
+    /** `standard` Omits the `kind` and `modifier` properties from the underlying schema */
     Strict(schema, options = {}) {
         return JSON.parse(JSON.stringify({ ...options, ...schema }));
     }
-    /** `EXTENDED` Creates a `constructor` schema. */
+    /** `extended` Creates a constructor type */
     Constructor(args, returns, options = {}) {
         return { ...options, kind: exports.ConstructorKind, type: 'constructor', arguments: args, returns };
     }
-    /** `EXTENDED` Creates a `function` schema. */
+    /** `extended` Creates a function type */
     Function(args, returns, options = {}) {
         return { ...options, kind: exports.FunctionKind, type: 'function', arguments: args, returns };
     }
-    /** `EXTENDED` Creates a `Promise<T>` schema. */
+    /** `extended` Creates a promise type */
     Promise(item, options = {}) {
         return { ...options, type: 'promise', kind: exports.PromiseKind, item };
     }
-    /** `EXTENDED` Creates a `undefined` schema. */
+    /** `extended` Creates a undefined type */
     Undefined(options = {}) {
         return { ...options, type: 'undefined', kind: exports.UndefinedKind };
     }
-    /** `EXTENDED` Creates a `void` schema. */
+    /** `extended` Creates a void type */
     Void(options = {}) {
         return { ...options, type: 'void', kind: exports.VoidKind };
     }
-    /** `EXPERIMENTAL` Creates a recursive type. */
+    /** `experimental` Creates a recursive type */
     Rec(callback, options = {}) {
         const $id = options.$id || '';
         const self = callback({ $ref: `${$id}#/definitions/self` });
         return { ...options, $ref: `${$id}#/definitions/self`, definitions: { self } };
     }
-    /** `EXPERIMENTAL` Creates a recursive type. Pending https://github.com/ajv-validator/ajv/issues/1709 */
+    /** `experimental` Creates a recursive type. Pending https://github.com/ajv-validator/ajv/issues/1709 */
     // public Rec<T extends TProperties>($id: string, callback: (self: TAny) => T, options: ObjectOptions = {}): TObject<T> {
     //     const properties = callback({ $recursiveRef: `${$id}` } as any)
     //     return { ...options, kind: ObjectKind, $id, $recursiveAnchor: true, type: 'object', properties }
     // }
-    /** `EXPERIMENTAL` Creates a container for schema definitions. */
-    Box(definitions, options = {}) {
+    /** `experimental` Creates a namespace for a set of related types */
+    Namespace(definitions, options = {}) {
         return { ...options, kind: exports.BoxKind, definitions };
     }
-    /** `EXPERIMENTAL` References a schema. */
     Ref(...args) {
         const $id = args[0]['$id'] || '';
         const key = args[1];