@sinclair/typebox 0.21.1 → 0.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.21.1",
+  "version": "0.23.0",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "json-schema",
@@ -20,17 +20,21 @@
     "clean": "hammer task clean",
     "build": "hammer task build",
     "example": "hammer task example",
-    "test": "hammer task spec"
+    "spec": "hammer task spec",
+    "spec:types": "hammer task spec_types",
+    "spec:schemas": "hammer task spec_schemas",
+    "test": "npm run spec"
   },
   "devDependencies": {
-    "@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",
+    "@sinclair/hammer": "^0.15.8",
+    "@types/chai": "^4.2.22",
+    "@types/mocha": "^9.0.0",
+    "@types/node": "^16.11.9",
+    "ajv": "^8.8.2",
+    "ajv-formats": "^2.1.1",
     "chai": "^4.3.4",
-    "mocha": "^9.1.2",
+    "mocha": "^9.1.3",
+    "tsd": "^0.19.0",
     "typescript": "^4.5.2"
   }
 }

package/readme.md

@@ -452,7 +452,7 @@ It can be helpful to organize shared referenced types under a common namespace.
 ```typescript
 const Math3D = Type.Namespace({               //  const Math3D = {
   Vector4: Type.Object({                      //    $id: 'Math3D',
-    x: Type.Number(),                         //    definitions: {
+    x: Type.Number(),                         //    $defs: {
     y: Type.Number(),                         //      Vector4: {
     z: Type.Number(),                         //        type: 'object',
     w: Type.Number()                          //        properties: {
@@ -486,9 +486,9 @@ const Math3D = Type.Namespace({               //  const Math3D = {
 const Vertex = Type.Object({                  //  const Vertex = {
     position: Type.Ref(Math3D, 'Vector4'),    //    type: 'object',
     normal:   Type.Ref(Math3D, 'Vector3'),    //    properties: {
-    uv:       Type.Ref(Math3D, 'Vector2')     //      position: { $ref: 'Math3D#/definitions/Vector4' },
-})                                            //      normal: { $ref: 'Math3D#/definitions/Vector3' },
-                                              //      uv: { $ref: 'Math3D#/definitions/Vector2' }
+    uv:       Type.Ref(Math3D, 'Vector2')     //      position: { $ref: 'Math3D#/$defs/Vector4' },
+})                                            //      normal: { $ref: 'Math3D#/$defs/Vector3' },
+                                              //      uv: { $ref: 'Math3D#/$defs/Vector2' }
                                               //    },
                                               //    required: ['position', 'normal', 'uv']
                                               //  }
@@ -503,8 +503,8 @@ Recursive types can be created with the `Type.Rec(...)` function. The following
 ```typescript
 const Node = Type.Rec(Self => Type.Object({   // const Node = {
   id:    Type.String(),                       //   $id: 'Node',
-  nodes: Type.Array(Self),                    //   $ref: 'Node#/definitions/self',
-}), { $id: 'Node' })                          //   definitions: {
+  nodes: Type.Array(Self),                    //   $ref: 'Node#/$defs/self',
+}), { $id: 'Node' })                          //   $defs: {
                                               //     self: {
                                               //       type: 'object',
                                               //       properties: {
@@ -514,7 +514,7 @@ const Node = Type.Rec(Self => Type.Object({   // const Node = {
                                               //         nodes: {
                                               //            type: 'array',
                                               //            items: {
-                                              //              $ref: 'Node#/definitions/self'
+                                              //              $ref: 'Node#/$defs/self'
                                               //            }
                                               //         }
                                               //      }
@@ -774,7 +774,9 @@ type T = Static<typeof T>                // type T = string | null
 //
 //--------------------------------------------------------------------------------------------
 
-function StringUnion<T extends string[]>(values: [...T]): TUnion<{[K in keyof T]: T[K] }[number]> {
+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
 }
 

package/typebox.d.ts

@@ -28,6 +28,7 @@ export declare const BooleanKind: unique symbol;
 export declare const NullKind: unique symbol;
 export declare const UnknownKind: unique symbol;
 export declare const AnyKind: unique symbol;
+export declare const RefKind: unique symbol;
 export interface CustomOptions {
     $id?: string;
     title?: string;
@@ -68,239 +69,280 @@ export declare type TDefinitions = {
 };
 export declare type TNamespace<T extends TDefinitions> = {
     kind: typeof BoxKind;
-    definitions: T;
+    $defs: T;
 } & CustomOptions;
-export declare type Infer<T> = {
-    '_infer': T;
-};
+export interface TSchema {
+    $static: unknown;
+}
 export declare type TEnumType = Record<string, string | number>;
-export declare type TKey = string | number;
+export declare type TKey = string | number | symbol;
 export declare type TValue = string | number | boolean;
-export declare type TRecordKey = TString | TNumber | TKeyOf<any> | TUnion<string | number>;
+export declare type TRecordKey = TString | TNumber | TKeyOf<any> | TUnion<any>;
 export declare type TEnumKey<T = TKey> = {
     type: 'number' | 'string';
     const: T;
 };
-export declare type TProperties = {
+export interface TProperties {
     [key: string]: TSchema;
-};
-export declare type TTuple<I> = Infer<I> & {
+}
+export interface TRecord<K extends TRecordKey, T extends TSchema> extends TSchema, ObjectOptions {
+    $static: StaticRecord<K, T>;
+    kind: typeof RecordKind;
+    type: 'object';
+    patternProperties: {
+        [pattern: string]: T;
+    };
+}
+export interface TTuple<T extends TSchema[]> extends TSchema, CustomOptions {
+    $static: StaticTuple<T>;
     kind: typeof TupleKind;
     type: 'array';
-    items?: TSchema[];
+    items?: T;
     additionalItems?: false;
     minItems: number;
     maxItems: number;
-} & CustomOptions;
-export declare type TObject<I> = Infer<I> & {
+}
+export interface TObject<T extends TProperties> extends TSchema, ObjectOptions {
+    $static: StaticObject<T>;
     kind: typeof ObjectKind;
     type: 'object';
-    properties: TProperties;
+    properties: T;
     required?: string[];
-} & ObjectOptions;
-export declare type TUnion<I> = Infer<I> & {
+}
+export interface TUnion<T extends TSchema[]> extends TSchema, CustomOptions {
+    $static: StaticUnion<T>;
     kind: typeof UnionKind;
-    anyOf: TSchema[];
-} & CustomOptions;
-export declare type TIntersect<I> = Infer<I> & {
+    anyOf: T;
+}
+export interface TIntersect<T extends TSchema[]> extends TSchema, IntersectOptions {
+    $static: StaticIntersect<T>;
     kind: typeof IntersectKind;
     type: 'object';
-    allOf: TSchema[];
-} & IntersectOptions;
-export declare type TKeyOf<I> = Infer<I> & {
+    allOf: T;
+}
+export interface TKeyOf<T extends TKey[]> extends TSchema, CustomOptions {
+    $static: StaticKeyOf<T>;
     kind: typeof KeyOfKind;
     type: 'string';
-    enum: string[];
-} & CustomOptions;
-export declare type TRecord<I> = Infer<I> & {
-    kind: typeof RecordKind;
-    type: 'object';
-    patternProperties: {
-        [pattern: string]: TSchema;
-    };
-} & ObjectOptions;
-export declare type TArray<I> = Infer<I> & {
+    enum: T;
+}
+export interface TArray<T extends TSchema> extends TSchema, ArrayOptions {
+    $static: StaticArray<T>;
     kind: typeof ArrayKind;
     type: 'array';
-    items: any;
-} & ArrayOptions;
-export declare type TLiteral<I> = Infer<I> & {
+    items: T;
+}
+export interface TLiteral<T extends TValue> extends TSchema, CustomOptions {
+    $static: StaticLiteral<T>;
     kind: typeof LiteralKind;
-    const: TValue;
-} & CustomOptions;
-export declare type TEnum<I> = Infer<I> & {
+    const: T;
+}
+export interface TEnum<T extends TEnumKey[]> extends TSchema, CustomOptions {
+    $static: StaticEnum<T>;
     kind: typeof EnumKind;
-    anyOf: TSchema;
-} & CustomOptions;
-export declare type TString = Infer<string> & {
+    anyOf: T;
+}
+export interface TString extends TSchema, StringOptions<string> {
+    $static: string;
     kind: typeof StringKind;
     type: 'string';
-} & StringOptions<string>;
-export declare type TNumber = Infer<number> & {
+}
+export interface TNumber extends TSchema, NumberOptions {
+    $static: number;
     kind: typeof NumberKind;
     type: 'number';
-} & NumberOptions;
-export declare type TInteger = Infer<number> & {
+}
+export interface TInteger extends TSchema, NumberOptions {
+    $static: number;
     kind: typeof IntegerKind;
     type: 'integer';
-} & NumberOptions;
-export declare type TBoolean = Infer<boolean> & {
+}
+export interface TBoolean extends TSchema, CustomOptions {
+    $static: boolean;
     kind: typeof BooleanKind;
     type: 'boolean';
-} & CustomOptions;
-export declare type TNull = Infer<null> & {
+}
+export interface TNull extends TSchema, CustomOptions {
+    $static: null;
     kind: typeof NullKind;
     type: 'null';
-} & CustomOptions;
-export declare type TUnknown = Infer<unknown> & {
+}
+export interface TUnknown extends TSchema, CustomOptions {
+    $static: unknown;
     kind: typeof UnknownKind;
-} & CustomOptions;
-export declare type TAny = Infer<any> & {
+}
+export interface TAny extends TSchema, CustomOptions {
+    $static: any;
     kind: typeof AnyKind;
-} & CustomOptions;
+}
+export interface TRef<T extends TSchema> extends TSchema, CustomOptions {
+    $static: Static<T>;
+    kind: typeof RefKind;
+    $ref: string;
+}
 export declare const ConstructorKind: unique symbol;
 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> = Infer<T> & {
+export interface TConstructor<T extends TSchema[], U extends TSchema> extends TSchema, CustomOptions {
+    $static: StaticConstructor<T, U>;
     kind: typeof ConstructorKind;
     type: 'constructor';
     arguments: TSchema[];
     returns: TSchema;
-} & CustomOptions;
-export declare type TFunction<T> = Infer<T> & {
+}
+export interface TFunction<T extends TSchema[], U extends TSchema> extends TSchema, CustomOptions {
+    $static: StaticFunction<T, U>;
     kind: typeof FunctionKind;
     type: 'function';
     arguments: TSchema[];
     returns: TSchema;
-} & CustomOptions;
-export declare type TPromise<T> = Infer<T> & {
+}
+export interface TPromise<T extends TSchema> extends TSchema, CustomOptions {
+    $static: StaticPromise<T>;
     kind: typeof PromiseKind;
     type: 'promise';
     item: TSchema;
-} & CustomOptions;
-export declare type TUndefined = Infer<undefined> & {
+}
+export interface TUndefined extends TSchema, CustomOptions {
+    $static: undefined;
     kind: typeof UndefinedKind;
     type: 'undefined';
-} & CustomOptions;
-export declare type TVoid = Infer<void> & {
+}
+export interface TVoid extends TSchema, CustomOptions {
+    $static: void;
     kind: typeof VoidKind;
     type: 'void';
-} & CustomOptions;
-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 Pickable = TObject<TProperties> | TRef<TObject<TProperties>>;
+export declare type PickablePropertyKeys<T extends Pickable> = T extends TObject<infer U> ? keyof U : T extends TRef<TObject<infer U>> ? keyof U : never;
+export declare type PickableProperties<T extends Pickable> = T extends TObject<infer U> ? U : T extends TRef<TObject<infer U>> ? U : never;
 export declare type UnionToIntersect<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-export declare type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
+export declare type StaticReadonlyOptionalPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never;
 }[keyof T];
-export declare type ReadonlyPropertyKeys<T extends TProperties> = {
+export declare type StaticReadonlyPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never;
 }[keyof T];
-export declare type OptionalPropertyKeys<T extends TProperties> = {
+export declare type StaticOptionalPropertyKeys<T extends TProperties> = {
     [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 StaticRequiredPropertyKeys<T extends TProperties> = keyof Omit<T, StaticReadonlyOptionalPropertyKeys<T> | StaticReadonlyPropertyKeys<T> | StaticOptionalPropertyKeys<T>>;
+export declare type StaticIntersectEvaluate<T extends readonly TSchema[]> = {
+    [K in keyof T]: T[K] extends TSchema ? Static<T[K]> : never;
+};
+export declare type StaticIntersectReduce<I extends unknown, T extends readonly any[]> = T extends [infer A, ...infer B] ? StaticIntersectReduce<I & A, B> : I;
+export declare type StaticRequired<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 StaticPartial<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 StaticProperties<T extends TProperties> = {
-    readonly [K in ReadonlyOptionalPropertyKeys<T>]?: Static<T[K]>;
+    readonly [K in StaticReadonlyOptionalPropertyKeys<T>]?: Static<T[K]>;
 } & {
-    readonly [K in ReadonlyPropertyKeys<T>]: Static<T[K]>;
+    readonly [K in StaticReadonlyPropertyKeys<T>]: Static<T[K]>;
 } & {
-    [K in OptionalPropertyKeys<T>]?: Static<T[K]>;
+    [K in StaticOptionalPropertyKeys<T>]?: Static<T[K]>;
 } & {
-    [K in RequiredPropertyKeys<T>]: Static<T[K]>;
+    [K in StaticRequiredPropertyKeys<T>]: Static<T[K]>;
 };
+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<TKey[]> ? Record<K['$static'], Static<T>> : K extends TUnion<TSchema[]> ? Record<K['$static'], Static<T>> : never;
 export declare type StaticEnum<T> = T extends TEnumKey<infer U>[] ? U : never;
 export declare type StaticKeyOf<T extends TKey[]> = T extends Array<infer K> ? K : never;
-export declare type StaticIntersect<T extends readonly TSchema[]> = UnionToIntersect<StaticUnion<T>>;
+export declare type StaticIntersect<T extends readonly TSchema[]> = StaticIntersectReduce<unknown, StaticIntersectEvaluate<T>>;
 export declare type StaticUnion<T extends readonly TSchema[]> = {
-    [K in keyof T]: Static<T[K]>;
+    [K in keyof T]: T[K] extends TSchema ? Static<T[K]> : never;
 }[number];
 export declare type StaticTuple<T extends readonly TSchema[]> = {
-    [K in keyof T]: Static<T[K]>;
+    [K in keyof T]: T[K] extends TSchema ? Static<T[K]> : 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>> : K extends TUnion<any> ? Record<K['_infer'], Static<T>> : never;
+export declare type StaticObject<T extends TProperties> = StaticProperties<T> extends infer I ? {
+    [K in keyof I]: I[K];
+} : 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: [...{
-    [K in keyof T]: Static<T[K]>;
-}]) => Static<U>;
-export declare type StaticFunction<T extends readonly TSchema[], U extends TSchema> = (...args: [...{
-    [K in keyof T]: Static<T[K]>;
-}]) => Static<U>;
+export declare type StaticParameters<T extends readonly TSchema[]> = {
+    [K in keyof T]: T[K] extends TSchema ? Static<T[K]> : never;
+};
+export declare type StaticConstructor<T extends readonly TSchema[], U extends TSchema> = new (...args: [...StaticParameters<T>]) => Static<U>;
+export declare type StaticFunction<T extends readonly TSchema[], U extends TSchema> = (...args: [...StaticParameters<T>]) => Static<U>;
 export declare type StaticPromise<T extends TSchema> = Promise<Static<T>>;
-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 type Static<T extends TSchema> = T['$static'];
 export declare class TypeBuilder {
-    /** `standard` Modifies an object property to be both readonly and optional */
+    private readonly schemas;
+    /** `Standard` Modifies an object property to be both readonly and optional */
     ReadonlyOptional<T extends TSchema>(item: T): TReadonlyOptional<T>;
-    /** `standard` Modifies an object property to be readonly */
+    /** `Standard` Modifies an object property to be readonly */
     Readonly<T extends TSchema>(item: T): TReadonly<T>;
-    /** `standard` Modifies an object property to be optional */
+    /** `Standard` Modifies an object property to be optional */
     Optional<T extends TSchema>(item: T): TOptional<T>;
-    /** `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 */
+    /** `Standard` Creates a type type */
+    Tuple<T extends TSchema[]>(items: [...T], options?: CustomOptions): TTuple<T>;
+    /** `Standard` Creates an object type with the given properties */
+    Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+    /** `Standard` Creates an intersect type. */
+    Intersect<T extends TSchema[]>(items: [...T], options?: IntersectOptions): TIntersect<T>;
+    /** `Standard` Creates a union type */
+    Union<T extends TSchema[]>(items: [...T], options?: CustomOptions): TUnion<T>;
+    /** `Standard` Creates an array type */
+    Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
+    /** `Standard` Creates an enum type from a TypeScript enum */
+    Enum<T extends TEnumType>(item: T, options?: CustomOptions): TEnum<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<T>;
+    /** `Standard` Creates a string type */
     String<TCustomFormatOption extends string>(options?: StringOptions<StringFormatOption | TCustomFormatOption>): TString;
-    /** `standard` Creates a string type from a regular expression */
+    /** `Standard` Creates a string type from a regular expression */
     RegEx(regex: RegExp, options?: CustomOptions): TString;
-    /** `standard` Creates a number type */
+    /** `Standard` Creates a number type */
     Number(options?: NumberOptions): TNumber;
-    /** `standard` Creates an integer type */
+    /** `Standard` Creates an integer type */
     Integer(options?: NumberOptions): TInteger;
-    /** `standard` Creates a boolean type */
+    /** `Standard` Creates a boolean type */
     Boolean(options?: CustomOptions): TBoolean;
-    /** `standard` Creates a null type */
+    /** `Standard` Creates a null type */
     Null(options?: CustomOptions): TNull;
-    /** `standard` Creates an unknown type */
+    /** `Standard` Creates an unknown type */
     Unknown(options?: CustomOptions): TUnknown;
-    /** `standard` Creates an any type */
+    /** `Standard` Creates an any type */
     Any(options?: CustomOptions): TAny;
-    /** `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 */
+    /** `Standard` Creates a keyof type from the given object */
+    KeyOf<T extends TObject<TProperties>>(object: T, options?: CustomOptions): TKeyOf<(keyof T['properties'])[]>;
+    /** `Standard` Creates a record type */
+    Record<K extends TRecordKey, T extends TSchema>(key: K, value: T, options?: ObjectOptions): TRecord<K, T>;
+    /** `Standard` Makes all properties in the given object type required */
+    Required<T extends TObject<TProperties> | TRef<TObject<TProperties>>>(object: T, options?: ObjectOptions): TObject<StaticRequired<T['properties']>>;
+    /** `Standard` Makes all properties in the given object type optional */
+    Partial<T extends TObject<TProperties> | TRef<TObject<TProperties>>>(object: T, options?: ObjectOptions): TObject<StaticPartial<T['properties']>>;
+    /** `Standard` Picks property keys from the given object type */
+    Pick<T extends TObject<TProperties> | TRef<TObject<TProperties>>, K extends PickablePropertyKeys<T>[]>(object: T, keys: [...K], options?: ObjectOptions): TObject<Pick<PickableProperties<T>, K[number]>>;
+    /** `Standard` Omits property keys from the given object type */
+    Omit<T extends TObject<TProperties> | TRef<TObject<TProperties>>, K extends PickablePropertyKeys<T>[]>(object: T, keys: [...K], options?: ObjectOptions): TObject<Omit<PickableProperties<T>, 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 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 */
+    /** `Extended` Creates a constructor type */
+    Constructor<T extends TSchema[], U extends TSchema>(args: [...T], returns: U, options?: CustomOptions): TConstructor<T, U>;
+    /** `Extended` Creates a function type */
+    Function<T extends TSchema[], U extends TSchema>(args: [...T], returns: U, options?: CustomOptions): TFunction<T, U>;
+    /** `Extended` Creates a promise type */
+    Promise<T extends TSchema>(item: T, options?: CustomOptions): TPromise<T>;
+    /** `Extended` Creates a undefined type */
     Undefined(options?: CustomOptions): TUndefined;
-    /** `extended` Creates a void type */
+    /** `Extended` Creates a void type */
     Void(options?: CustomOptions): TVoid;
-    /** `experimental` Creates a recursive type */
+    /** `Standard` Creates a namespace for a set of related types */
+    Namespace<T extends TDefinitions>($defs: T, options?: CustomOptions): TNamespace<T>;
+    /** `Standard` References a type within a namespace. The referenced namespace must specify an `$id` */
+    Ref<T extends TNamespace<TDefinitions>, K extends keyof T['$defs']>(box: T, key: K): TRef<T['$defs'][K]>;
+    /** `Standard` References type. The referenced type must specify an `$id` */
+    Ref<T extends TSchema>(schema: T): TRef<T>;
+    /** `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 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;
+    /** Stores this schema if it contains an $id. This function is used for later referencing. */
+    private Store;
+    /** Resolves a schema by $id. May resolve recursively if the target is a TRef. */
+    private Resolve;
 }
 export declare const Type: TypeBuilder;

package/typebox.js

@@ -27,16 +27,16 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Type = exports.TypeBuilder = exports.VoidKind = exports.UndefinedKind = exports.PromiseKind = exports.FunctionKind = exports.ConstructorKind = exports.AnyKind = exports.UnknownKind = exports.NullKind = exports.BooleanKind = exports.IntegerKind = exports.NumberKind = exports.StringKind = exports.LiteralKind = exports.EnumKind = exports.ArrayKind = exports.RecordKind = exports.ObjectKind = exports.TupleKind = exports.UnionKind = exports.IntersectKind = exports.KeyOfKind = exports.BoxKind = exports.ReadonlyModifier = exports.OptionalModifier = exports.ReadonlyOptionalModifier = void 0;
-// ------------------------------------------------------------------------
+exports.Type = exports.TypeBuilder = exports.VoidKind = exports.UndefinedKind = exports.PromiseKind = exports.FunctionKind = exports.ConstructorKind = exports.RefKind = exports.AnyKind = exports.UnknownKind = exports.NullKind = exports.BooleanKind = exports.IntegerKind = exports.NumberKind = exports.StringKind = exports.LiteralKind = exports.EnumKind = exports.ArrayKind = exports.RecordKind = exports.ObjectKind = exports.TupleKind = exports.UnionKind = exports.IntersectKind = exports.KeyOfKind = exports.BoxKind = exports.ReadonlyModifier = exports.OptionalModifier = exports.ReadonlyOptionalModifier = void 0;
+// --------------------------------------------------------------------------
 // Modifiers
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 exports.ReadonlyOptionalModifier = Symbol('ReadonlyOptionalModifier');
 exports.OptionalModifier = Symbol('OptionalModifier');
 exports.ReadonlyModifier = Symbol('ReadonlyModifier');
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // Schema Standard
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 exports.BoxKind = Symbol('BoxKind');
 exports.KeyOfKind = Symbol('KeyOfKind');
 exports.IntersectKind = Symbol('IntersectKind');
@@ -54,17 +54,18 @@ exports.BooleanKind = Symbol('BooleanKind');
 exports.NullKind = Symbol('NullKind');
 exports.UnknownKind = Symbol('UnknownKind');
 exports.AnyKind = Symbol('AnyKind');
-// ------------------------------------------------------------------------
+exports.RefKind = Symbol('RefKind');
+// --------------------------------------------------------------------------
 // Extended Schema Types
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 exports.ConstructorKind = Symbol('ConstructorKind');
 exports.FunctionKind = Symbol('FunctionKind');
 exports.PromiseKind = Symbol('PromiseKind');
 exports.UndefinedKind = Symbol('UndefinedKind');
 exports.VoidKind = Symbol('VoidKind');
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // Utility
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 function isObject(object) {
     return typeof object === 'object' && object !== null && !Array.isArray(object);
 }
@@ -78,32 +79,34 @@ function clone(object) {
         return object.map((item) => clone(item));
     return object;
 }
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // TypeBuilder
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 class TypeBuilder {
-    /** `standard` Modifies an object property to be both readonly and optional */
+    schemas = new Map();
+    /** `Standard` Modifies an object property to be both readonly and optional */
     ReadonlyOptional(item) {
         return { ...item, modifier: exports.ReadonlyOptionalModifier };
     }
-    /** `standard` Modifies an object property to be readonly */
+    /** `Standard` Modifies an object property to be readonly */
     Readonly(item) {
         return { ...item, modifier: exports.ReadonlyModifier };
     }
-    /** `standard` Modifies an object property to be optional */
+    /** `Standard` Modifies an object property to be optional */
     Optional(item) {
         return { ...item, modifier: exports.OptionalModifier };
     }
-    /** `standard` Creates a type type */
+    /** `Standard` Creates a type type */
     Tuple(items, options = {}) {
         const additionalItems = false;
         const minItems = items.length;
         const maxItems = items.length;
-        return (items.length > 0)
+        const schema = ((items.length > 0)
             ? { ...options, kind: exports.TupleKind, type: 'array', items, additionalItems, minItems, maxItems }
-            : { ...options, kind: exports.TupleKind, type: 'array', minItems, maxItems };
+            : { ...options, kind: exports.TupleKind, type: 'array', minItems, maxItems });
+        return this.Store(schema);
     }
-    /** `standard` Creates an object type 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 => {
@@ -114,88 +117,89 @@ class TypeBuilder {
         });
         const required_names = property_names.filter(name => !optional.includes(name));
         const required = (required_names.length > 0) ? required_names : undefined;
-        return (required) ?
-            { ...options, kind: exports.ObjectKind, type: 'object', properties, required } :
-            { ...options, kind: exports.ObjectKind, type: 'object', properties };
+        return this.Store(((required)
+            ? { ...options, kind: exports.ObjectKind, type: 'object', properties, required }
+            : { ...options, kind: exports.ObjectKind, type: 'object', properties }));
     }
-    /** `standard` Creates an intersection type. Note this function requires draft `2019-09` to constrain with `unevaluatedProperties` */
+    /** `Standard` Creates an intersect type. */
     Intersect(items, options = {}) {
-        return { ...options, kind: exports.IntersectKind, type: 'object', allOf: items };
+        return this.Store({ ...options, kind: exports.IntersectKind, type: 'object', allOf: items });
     }
-    /** `standard` Creates a union type */
+    /** `Standard` Creates a union type */
     Union(items, options = {}) {
-        return { ...options, kind: exports.UnionKind, anyOf: items };
+        return this.Store({ ...options, kind: exports.UnionKind, anyOf: items });
     }
-    /** `standard` Creates an array type */
+    /** `Standard` Creates an array type */
     Array(items, options = {}) {
-        return { ...options, kind: exports.ArrayKind, type: 'array', items };
+        return this.Store({ ...options, kind: exports.ArrayKind, type: 'array', items });
     }
-    /** `standard` Creates an enum type from a TypeScript enum */
+    /** `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 };
+        return this.Store({ ...options, kind: exports.EnumKind, anyOf });
     }
-    /** `standard` Creates a literal type. Supports string, number and boolean values only */
+    /** `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 };
+        return this.Store({ ...options, kind: exports.LiteralKind, const: value, type: typeof value });
     }
-    /** `standard` Creates a string type */
+    /** `Standard` Creates a string type */
     String(options = {}) {
-        return { ...options, kind: exports.StringKind, type: 'string' };
+        return this.Store({ ...options, kind: exports.StringKind, type: 'string' });
     }
-    /** `standard` Creates a string type 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 type */
+    /** `Standard` Creates a number type */
     Number(options = {}) {
-        return { ...options, kind: exports.NumberKind, type: 'number' };
+        return this.Store({ ...options, kind: exports.NumberKind, type: 'number' });
     }
-    /** `standard` Creates an integer type */
+    /** `Standard` Creates an integer type */
     Integer(options = {}) {
-        return { ...options, kind: exports.IntegerKind, type: 'integer' };
+        return this.Store({ ...options, kind: exports.IntegerKind, type: 'integer' });
     }
-    /** `standard` Creates a boolean type */
+    /** `Standard` Creates a boolean type */
     Boolean(options = {}) {
-        return { ...options, kind: exports.BooleanKind, type: 'boolean' };
+        return this.Store({ ...options, kind: exports.BooleanKind, type: 'boolean' });
     }
-    /** `standard` Creates a null type */
+    /** `Standard` Creates a null type */
     Null(options = {}) {
-        return { ...options, kind: exports.NullKind, type: 'null' };
+        return this.Store({ ...options, kind: exports.NullKind, type: 'null' });
     }
-    /** `standard` Creates an unknown type */
+    /** `Standard` Creates an unknown type */
     Unknown(options = {}) {
-        return { ...options, kind: exports.UnknownKind };
+        return this.Store({ ...options, kind: exports.UnknownKind });
     }
-    /** `standard` Creates an any type */
+    /** `Standard` Creates an any type */
     Any(options = {}) {
-        return { ...options, kind: exports.AnyKind };
+        return this.Store({ ...options, kind: exports.AnyKind });
     }
-    /** `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 keyof type from the given object */
+    KeyOf(object, options = {}) {
+        const keys = Object.keys(object.properties);
+        return this.Store({ ...options, kind: exports.KeyOfKind, type: 'string', enum: keys });
     }
-    /** `standard` Creates a record type */
+    /** `Standard` Creates a record type */
     Record(key, value, options = {}) {
         const pattern = (() => {
             switch (key.kind) {
-                case exports.UnionKind: return `^${key.anyOf.map(literal => literal.const).join('|')}$`;
+                case exports.UnionKind: return `^${key.anyOf.map((literal) => literal.const).join('|')}$`;
                 case exports.KeyOfKind: return `^${key.enum.join('|')}$`;
                 case exports.NumberKind: return '^(0|[1-9][0-9]*)$';
                 case exports.StringKind: return key.pattern ? key.pattern : '^.*$';
                 default: throw Error('Invalid Record Key');
             }
         })();
-        return { ...options, kind: exports.RecordKind, type: 'object', patternProperties: { [pattern]: value } };
-    }
-    /** `standard` Makes all properties in the given object type required */
-    Required(schema, options = {}) {
-        const next = { ...clone(schema), ...options };
-        next.required = Object.keys(next.properties);
-        for (const key of Object.keys(next.properties)) {
-            const property = next.properties[key];
+        return this.Store({ ...options, kind: exports.RecordKind, type: 'object', patternProperties: { [pattern]: value } });
+    }
+    /** `Standard` Makes all properties in the given object type required */
+    Required(object, options = {}) {
+        const source = this.Resolve(object);
+        const schema = { ...clone(source), ...options };
+        schema.required = Object.keys(schema.properties);
+        for (const key of Object.keys(schema.properties)) {
+            const property = schema.properties[key];
             switch (property.modifier) {
                 case exports.ReadonlyOptionalModifier:
                     property.modifier = exports.ReadonlyModifier;
@@ -211,14 +215,15 @@ class TypeBuilder {
                     break;
             }
         }
-        return next;
-    }
-    /** `standard` Makes all properties in the given object type optional */
-    Partial(schema, options = {}) {
-        const next = { ...clone(schema), ...options };
-        delete next.required;
-        for (const key of Object.keys(next.properties)) {
-            const property = next.properties[key];
+        return this.Store(schema);
+    }
+    /** `Standard` Makes all properties in the given object type optional */
+    Partial(object, options = {}) {
+        const source = this.Resolve(object);
+        const schema = { ...clone(source), ...options };
+        delete schema.required;
+        for (const key of Object.keys(schema.properties)) {
+            const property = schema.properties[key];
             switch (property.modifier) {
                 case exports.ReadonlyOptionalModifier:
                     property.modifier = exports.ReadonlyOptionalModifier;
@@ -234,71 +239,100 @@ class TypeBuilder {
                     break;
             }
         }
-        return next;
-    }
-    /** `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;
-        for (const key of Object.keys(next.properties)) {
+        return this.Store(schema);
+    }
+    /** `Standard` Picks property keys from the given object type */
+    Pick(object, keys, options = {}) {
+        const source = this.Resolve(object);
+        const schema = { ...clone(source), ...options };
+        schema.required = schema.required ? schema.required.filter((key) => keys.includes(key)) : undefined;
+        for (const key of Object.keys(schema.properties)) {
             if (!keys.includes(key))
-                delete next.properties[key];
+                delete schema.properties[key];
         }
-        return next;
-    }
-    /** `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;
-        for (const key of Object.keys(next.properties)) {
+        return this.Store(schema);
+    }
+    /** `Standard` Omits property keys from the given object type */
+    Omit(object, keys, options = {}) {
+        const source = this.Resolve(object);
+        const schema = { ...clone(source), ...options };
+        schema.required = schema.required ? schema.required.filter((key) => !keys.includes(key)) : undefined;
+        for (const key of Object.keys(schema.properties)) {
             if (keys.includes(key))
-                delete next.properties[key];
+                delete schema.properties[key];
         }
-        return next;
+        return this.Store(schema);
     }
-    /** `standard` Omits the `kind` and `modifier` properties from the underlying 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 type */
+    /** `Extended` Creates a constructor type */
     Constructor(args, returns, options = {}) {
-        return { ...options, kind: exports.ConstructorKind, type: 'constructor', arguments: args, returns };
+        return this.Store({ ...options, kind: exports.ConstructorKind, type: 'constructor', arguments: args, returns });
     }
-    /** `extended` Creates a function type */
+    /** `Extended` Creates a function type */
     Function(args, returns, options = {}) {
-        return { ...options, kind: exports.FunctionKind, type: 'function', arguments: args, returns };
+        return this.Store({ ...options, kind: exports.FunctionKind, type: 'function', arguments: args, returns });
     }
-    /** `extended` Creates a promise type */
+    /** `Extended` Creates a promise type */
     Promise(item, options = {}) {
-        return { ...options, type: 'promise', kind: exports.PromiseKind, item };
+        return this.Store({ ...options, type: 'promise', kind: exports.PromiseKind, item });
     }
-    /** `extended` Creates a undefined type */
+    /** `Extended` Creates a undefined type */
     Undefined(options = {}) {
-        return { ...options, type: 'undefined', kind: exports.UndefinedKind };
+        return this.Store({ ...options, type: 'undefined', kind: exports.UndefinedKind });
     }
-    /** `extended` Creates a void type */
+    /** `Extended` Creates a void type */
     Void(options = {}) {
-        return { ...options, type: 'void', kind: exports.VoidKind };
+        return this.Store({ ...options, type: 'void', kind: exports.VoidKind });
     }
-    /** `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 */
-    // 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 namespace for a set of related types */
-    Namespace(definitions, options = {}) {
-        return { ...options, kind: exports.BoxKind, definitions };
+    /** `Standard` Creates a namespace for a set of related types */
+    Namespace($defs, options = {}) {
+        return this.Store({ ...options, kind: exports.BoxKind, $defs });
     }
     Ref(...args) {
-        const $id = args[0]['$id'] || '';
-        const key = args[1];
-        return (args.length === 2) ? { $ref: `${$id}#/definitions/${key}` } : { $ref: $id };
+        if (args.length === 2) {
+            const namespace = args[0];
+            const targetKey = args[1];
+            if (namespace.$id === undefined)
+                throw new Error(`Referenced namespace has no $id`);
+            if (!this.schemas.has(namespace.$id))
+                throw new Error(`Unable to locate namespace with $id '${namespace.$id}'`);
+            return this.Store({ kind: exports.RefKind, $ref: `${namespace.$id}#/$defs/${targetKey}` });
+        }
+        else if (args.length === 1) {
+            const target = args[0];
+            if (target.$id === undefined)
+                throw new Error(`Referenced schema has no $id`);
+            if (!this.schemas.has(target.$id))
+                throw new Error(`Unable to locate schema with $id '${target.$id}'`);
+            return this.Store({ kind: exports.RefKind, $ref: target.$id });
+        }
+        else {
+            throw new Error('Type.Ref: Invalid arguments');
+        }
+    }
+    /** `Experimental` Creates a recursive type */
+    Rec(callback, options = {}) {
+        const $id = options.$id || '';
+        const self = callback({ $ref: `${$id}#/$defs/self` });
+        return this.Store({ ...options, $ref: `${$id}#/$defs/self`, $defs: { self } });
+    }
+    /** Stores this schema if it contains an $id. This function is used for later referencing. */
+    Store(schema) {
+        if (!schema.$id)
+            return schema;
+        this.schemas.set(schema.$id, schema);
+        return schema;
+    }
+    /** Resolves a schema by $id. May resolve recursively if the target is a TRef. */
+    Resolve(schema) {
+        if (schema.kind !== exports.RefKind)
+            return schema;
+        if (!this.schemas.has(schema.$ref))
+            throw Error(`Unable to locate schema with $id '${schema.$ref}'`);
+        return this.Resolve(this.schemas.get(schema.$ref));
     }
 }
 exports.TypeBuilder = TypeBuilder;