@sinclair/typebox 0.33.22 → 0.34.0

package/build/esm/type/type/type.mjs

@@ -12,7 +12,6 @@ export { Const } from '../const/index.mjs';
 export { Constructor } from '../constructor/index.mjs';
 export { ConstructorParameters } from '../constructor-parameters/index.mjs';
 export { Date } from '../date/index.mjs';
-export { Deref } from '../deref/index.mjs';
 export { Enum } from '../enum/index.mjs';
 export { Exclude } from '../exclude/index.mjs';
 export { Extends } from '../extends/index.mjs';
@@ -27,6 +26,7 @@ export { Iterator } from '../iterator/index.mjs';
 export { KeyOf } from '../keyof/index.mjs';
 export { Literal } from '../literal/index.mjs';
 export { Mapped } from '../mapped/index.mjs';
+export { Module } from '../module/index.mjs';
 export { Never } from '../never/index.mjs';
 export { Not } from '../not/index.mjs';
 export { Null } from '../null/index.mjs';
@@ -48,7 +48,6 @@ export { Required } from '../required/index.mjs';
 export { Rest } from '../rest/index.mjs';
 export { ReturnType } from '../return-type/index.mjs';
 export { String } from '../string/index.mjs';
-export { Strict } from '../strict/index.mjs';
 export { Symbol } from '../symbol/index.mjs';
 export { TemplateLiteral } from '../template-literal/index.mjs';
 export { Transform } from '../transform/index.mjs';

package/build/esm/value/cast/cast.mjs

@@ -4,7 +4,7 @@ import { Kind } from '../../type/symbols/index.mjs';
 import { Create } from '../create/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Clone } from '../clone/index.mjs';
-import { Deref } from '../deref/index.mjs';
+import { Deref, Pushref } from '../deref/index.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -98,6 +98,11 @@ function FromConstructor(schema, references, value) {
     }
     return result;
 }
+function FromImport(schema, references, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    return Visit(target, [...references, ...definitions], value);
+}
 function FromIntersect(schema, references, value) {
     const created = Create(schema, references);
     const mapped = IsObject(created) && IsObject(value) ? { ...created, ...value } : value;
@@ -161,7 +166,7 @@ function FromUnion(schema, references, value) {
     return Check(schema, references, value) ? Clone(value) : CastUnion(schema, references, value);
 }
 function Visit(schema, references, value) {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references;
+    const references_ = IsString(schema.$id) ? Pushref(schema, references) : references;
     const schema_ = schema;
     switch (schema[Kind]) {
         // --------------------------------------------------------------
@@ -171,6 +176,8 @@ function Visit(schema, references, value) {
             return FromArray(schema_, references_, value);
         case 'Constructor':
             return FromConstructor(schema_, references_, value);
+        case 'Import':
+            return FromImport(schema_, references_, value);
         case 'Intersect':
             return FromIntersect(schema_, references_, value);
         case 'Never':

package/build/esm/value/check/check.mjs

@@ -1,5 +1,5 @@
 import { TypeSystemPolicy } from '../../system/index.mjs';
-import { Deref } from '../deref/index.mjs';
+import { Deref, Pushref } from '../deref/index.mjs';
 import { Hash } from '../hash/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 import { KeyOfPattern } from '../../type/keyof/index.mjs';
@@ -135,6 +135,11 @@ function FromDate(schema, references, value) {
 function FromFunction(schema, references, value) {
     return IsFunction(value);
 }
+function FromImport(schema, references, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    return Visit(target, [...references, ...definitions], value);
+}
 function FromInteger(schema, references, value) {
     if (!IsInteger(value)) {
         return false;
@@ -380,7 +385,7 @@ function FromKind(schema, references, value) {
     return func(schema, value);
 }
 function Visit(schema, references, value) {
-    const references_ = IsDefined(schema.$id) ? [...references, schema] : references;
+    const references_ = IsDefined(schema.$id) ? Pushref(schema, references) : references;
     const schema_ = schema;
     switch (schema_[Kind]) {
         case 'Any':
@@ -399,6 +404,8 @@ function Visit(schema, references, value) {
             return FromDate(schema_, references_, value);
         case 'Function':
             return FromFunction(schema_, references_, value);
+        case 'Import':
+            return FromImport(schema_, references_, value);
         case 'Integer':
             return FromInteger(schema_, references_, value);
         case 'Intersect':

package/build/esm/value/clean/clean.mjs

@@ -1,7 +1,7 @@
 import { KeyOfPropertyKeys } from '../../type/keyof/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Clone } from '../clone/index.mjs';
-import { Deref } from '../deref/index.mjs';
+import { Deref, Pushref } from '../deref/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
@@ -27,6 +27,11 @@ function FromArray(schema, references, value) {
         return value;
     return value.map((value) => Visit(schema.items, references, value));
 }
+function FromImport(schema, references, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    return Visit(target, [...references, ...definitions], value);
+}
 function FromIntersect(schema, references, value) {
     const unevaluatedProperties = schema.unevaluatedProperties;
     const intersections = schema.allOf.map((schema) => Visit(schema, references, Clone(value)));
@@ -109,11 +114,13 @@ function FromUnion(schema, references, value) {
     return value;
 }
 function Visit(schema, references, value) {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references;
+    const references_ = IsString(schema.$id) ? Pushref(schema, references) : references;
     const schema_ = schema;
     switch (schema_[Kind]) {
         case 'Array':
             return FromArray(schema_, references_, value);
+        case 'Import':
+            return FromImport(schema_, references_, value);
         case 'Intersect':
             return FromIntersect(schema_, references_, value);
         case 'Object':

package/build/esm/value/convert/convert.mjs

@@ -123,6 +123,11 @@ function FromBoolean(schema, references, value) {
 function FromDate(schema, references, value) {
     return TryConvertDate(value);
 }
+function FromImport(schema, references, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    return Visit(target, [...references, ...definitions], value);
+}
 function FromInteger(schema, references, value) {
     return TryConvertInteger(value);
 }
@@ -207,6 +212,8 @@ function Visit(schema, references, value) {
             return FromBoolean(schema_, references_, value);
         case 'Date':
             return FromDate(schema_, references_, value);
+        case 'Import':
+            return FromImport(schema_, references_, value);
         case 'Integer':
             return FromInteger(schema_, references_, value);
         case 'Intersect':

package/build/esm/value/create/create.mjs

@@ -118,6 +118,11 @@ function FromFunction(schema, references) {
         return () => Visit(schema.returns, references);
     }
 }
+function FromImport(schema, references) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    return Visit(target, [...references, ...definitions]);
+}
 function FromInteger(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return FromDefault(schema.default);
@@ -401,6 +406,8 @@ function Visit(schema, references) {
             return FromDate(schema_, references_);
         case 'Function':
             return FromFunction(schema_, references_);
+        case 'Import':
+            return FromImport(schema_, references_);
         case 'Integer':
             return FromInteger(schema_, references_);
         case 'Intersect':

package/build/esm/value/default/default.mjs

@@ -40,6 +40,11 @@ function FromDate(schema, references, value) {
     // special case intercept for dates
     return IsDate(value) ? value : ValueOrDefault(schema, value);
 }
+function FromImport(schema, references, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    return Visit(target, [...references, ...definitions], value);
+}
 function FromIntersect(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     return schema.allOf.reduce((acc, schema) => {
@@ -133,6 +138,8 @@ function Visit(schema, references, value) {
             return FromArray(schema_, references_, value);
         case 'Date':
             return FromDate(schema_, references_, value);
+        case 'Import':
+            return FromImport(schema_, references_, value);
         case 'Intersect':
             return FromIntersect(schema_, references_, value);
         case 'Object':

package/build/esm/value/transform/decode.mjs

@@ -76,6 +76,15 @@ function FromIntersect(schema, references, path, value) {
         }
     return Default(schema, path, unknownProperties);
 }
+// prettier-ignore
+function FromImport(schema, references, path, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    const transform = schema[TransformKind];
+    // Note: we need to re-spec the target as TSchema + [TransformKind]
+    const transformTarget = { [TransformKind]: transform, ...target };
+    return Visit(transformTarget, [...references, ...definitions], path, value);
+}
 function FromNot(schema, references, path, value) {
     return Default(schema, path, Visit(schema.not, references, path, value));
 }
@@ -166,6 +175,8 @@ function Visit(schema, references, path, value) {
     switch (schema[Kind]) {
         case 'Array':
             return FromArray(schema_, references_, path, value);
+        case 'Import':
+            return FromImport(schema_, references_, path, value);
         case 'Intersect':
             return FromIntersect(schema_, references_, path, value);
         case 'Not':

package/build/esm/value/transform/encode.mjs

@@ -54,6 +54,15 @@ function FromArray(schema, references, path, value) {
         : defaulted;
 }
 // prettier-ignore
+function FromImport(schema, references, path, value) {
+    const definitions = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    const transform = schema[TransformKind];
+    // Note: we need to re-spec the target as TSchema + [TransformKind]
+    const transformTarget = { [TransformKind]: transform, ...target };
+    return Visit(transformTarget, [...references, ...definitions], path, value);
+}
+// prettier-ignore
 function FromIntersect(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
     if (!IsObject(value) || IsValueType(value))
@@ -178,6 +187,8 @@ function Visit(schema, references, path, value) {
     switch (schema[Kind]) {
         case 'Array':
             return FromArray(schema_, references_, path, value);
+        case 'Import':
+            return FromImport(schema_, references_, path, value);
         case 'Intersect':
             return FromIntersect(schema_, references_, path, value);
         case 'Not':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.33.22",
+  "version": "0.34.0",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -68,8 +68,7 @@ License MIT
   - [Options](#types-options)
   - [Properties](#types-properties)
   - [Generics](#types-generics)
-  - [References](#types-references)
-  - [Recursive](#types-recursive)
+  - [Modules](#types-modules)
   - [Template Literal](#types-template-literal)
   - [Indexed](#types-indexed)
   - [Mapped](#types-mapped)
@@ -77,6 +76,13 @@ License MIT
   - [Transform](#types-transform)
   - [Guard](#types-guard)
   - [Unsafe](#types-unsafe)
+- [Syntax](#syntax)
+  - [Parse](#syntax-parse)
+  - [Compose](#syntax-compose)
+  - [Context](#syntax-context)
+  - [Module](#syntax-module)
+  - [Static](#syntax-static)
+  - [Limits](#syntax-limits)
 - [Values](#values)
   - [Assert](#values-assert)
   - [Create](#values-create)
@@ -764,103 +770,40 @@ const T = Nullable(Type.String())                    // const T = {
 type T = Static<typeof T>                            // type T = string | null
 ```
 
-<a name='types-references'></a>
+<a name='types-modules'></a>
 
-### Reference Types
+### Module Types
 
-Reference types can be created with Ref. These types infer the same as the target type but only store a named `$ref` to the target type.
+TypeBox Modules are containers for related types. They function as namespaces and enable internal types to reference each other via string references. Modules support both singular and mutually recursive types. They provide a mechanism to create circular types irrespective of the order in which types are defined.
 
 ```typescript
-const Vector = Type.Object({                         // const Vector = {
-  x: Type.Number(),                                  //   type: 'object',
-  y: Type.Number(),                                  //   required: ['x', 'y', 'z'],
-}, { $id: 'Vector' })                                //   properties: {
-                                                     //     x: { type: 'number' },
-                                                     //     y: { type: 'number' }
-                                                     //   },
-                                                     //   $id: 'Vector'
-                                                     // }
+// The following creates a circular recursive type.
+
+const Module = Type.Module({
+  A: Type.Object({ 
+    b: Type.Ref('B') // Ref B:
+  }),
+  B: Type.Object({
+    c: Type.Ref('C') // Ref C:
+  }),
+  C: Type.Object({
+    a: Type.Ref('A') // Ref A:
+  }),
+})
 
-const VectorRef = Type.Ref(Vector)                   // const VectorRef = {
-                                                     //   $ref: 'Vector'
-                                                     // }
+// Module types must be imported before use.
 
-type VectorRef = Static<typeof VectorRef>            // type VectorRef = {
-                                                     //    x: number,
-                                                     //    y: number
-                                                     // }
-```
-Use Deref to dereference a type. This function will replace any interior reference with the target type.
-```typescript
-const Vertex = Type.Object({                         // const Vertex = {
-  position: VectorRef,                               //   type: 'object',
-  texcoord: VectorRef,                               //   required: ['position', 'texcoord'],
-})                                                   //   properties: {
-                                                     //     position: { $ref: 'Vector' },
-                                                     //     texcoord: { $ref: 'Vector' }
-                                                     //   }
-                                                     // }
+const A = Module.Import('A')                     // const A: TImport<{...}, 'A'>
 
-const VertexDeref = Type.Deref(Vertex, [Vector])     // const VertexDeref = {
-                                                     //   type: 'object',
-                                                     //   required: ['position', 'texcoord'],
-                                                     //   properties: {
-                                                     //     position: {
-                                                     //       type: 'object',
-                                                     //       required: ['x', 'y', 'z'],
-                                                     //       properties: {
-                                                     //         x: { type: 'number' },
-                                                     //         y: { type: 'number' }
-                                                     //       }
-                                                     //     },
-                                                     //     texcoord: {
-                                                     //       type: 'object',
-                                                     //       required: ['x', 'y', 'z'],
-                                                     //       properties: {
-                                                     //         x: { type: 'number' },
-                                                     //         y: { type: 'number' }
-                                                     //       }
-                                                     //     }
-                                                     //   }
-                                                     // }
-```
-Note that Ref types do not store structural information about the type they're referencing. Because of this, these types cannot be used with some mapping types (such as Partial or Pick). For applications that require mapping on Ref, use Deref to normalize the type first.
-
-<a name='types-recursive'></a>
-
-### Recursive Types
-
-TypeBox supports recursive data structures with Recursive. This type wraps an interior type and provides it a `this` context that allows the type to reference itself. The following creates a recursive type. Singular recursive inference is also supported.
-
-```typescript
-const Node = Type.Recursive(This => Type.Object({    // const Node = {
-  id: Type.String(),                                 //   $id: 'Node',
-  nodes: Type.Array(This)                            //   type: 'object',
-}), { $id: 'Node' })                                 //   properties: {
-                                                     //     id: {
-                                                     //       type: 'string'
-                                                     //     },
-                                                     //     nodes: {
-                                                     //       type: 'array',
-                                                     //       items: {
-                                                     //         $ref: 'Node'
-                                                     //       }
-                                                     //     }
-                                                     //   },
-                                                     //   required: [
-                                                     //     'id',
-                                                     //     'nodes'
-                                                     //   ]
-                                                     // }
-
-type Node = Static<typeof Node>                      // type Node = {
-                                                     //   id: string
-                                                     //   nodes: Node[]
-                                                     // }
-
-function test(node: Node) {
-  const id = node.nodes[0].nodes[0].id               // id is string
-}
+type A = Static<typeof A>                        // type A = { 
+                                                 //   b: {
+                                                 //     c: {
+                                                 //       a: {
+                                                 //         b: ...
+                                                 //       }
+                                                 //     }
+                                                 //   }
+                                                 // }
 ```
 
 <a name='types-template-literal'></a>
@@ -1077,6 +1020,185 @@ if(TypeGuard.IsString(T)) {
 }
 ```
 
+<a name='syntax'></a>
+
+## Syntax Types
+
+TypeBox provides support for Syntax Types, enabling it to parse TypeScript syntax directly into TypeBox types. Syntax Types serve as a DSL frontend for TypeBox's type builder and are useful for converting existing TypeScript type definitions into Json Schema schematics.
+
+Syntax Types are provided via optional import.
+
+```typescript
+import { Parse } from '@sinclair/typebox/syntax'
+```
+
+<a name='syntax-parse'></a>
+
+### Parse
+
+Use the Parse function to convert a TypeScript string into a TypeBox type. TypeBox will infer the appropriate TSchema type or return undefined if there is a syntax error.
+
+```typescript
+const A = Parse('string')                           // const A: TString
+
+const B = Parse('[1, 2, 3]')                        // const B: TTuple<[
+                                                    //   TLiteral<1>,
+                                                    //   TLiteral<2>,
+                                                    //   TLiteral<3>
+                                                    // ]>
+
+const C = Parse(`{ x: number, y: number }`)         // const C: TObject<{
+                                                    //   x: TNumber
+                                                    //   y: TNumber
+                                                    // }>
+```
+
+
+
+<a name='syntax-compose'></a>
+
+### Compose
+
+Syntax Types are designed to be interchangeable with standard Types.
+
+```typescript
+const T = Type.Object({                             // const T: TObject<{
+  x: Parse('number'),                               //   x: TNumber,
+  y: Parse('number'),                               //   y: TNumber,
+  z: Parse('number')                                //   z: TNumber
+})                                                  // }>
+```
+
+<a name='syntax-module'></a>
+
+### Module
+
+Syntax Types support Module parsing, which is useful for processing multiple TypeScript types. Module parsing supports type alias and interface definitions. Generics are currently unsupported as of 0.34.0.
+
+```typescript
+const Foo = Parse(`module Foo {
+
+  export type A = string
+
+  export type B = number
+
+  export type C = A | B
+
+}`)
+
+const C = Foo.Import('C')                           // const C: TImport<{
+                                                    //   ...
+                                                    // }, 'C'>
+```
+
+<a name='syntax-context'></a>
+
+### Context
+
+The Parse function accepts an initial Context argument, allowing external types to be passed into the parser.
+
+```typescript
+const T = Type.Object({                             // could be written as: Parse(`{
+  x: Type.Number(),                                 //   x: number,
+  y: Type.Number(),                                 //   y: number,
+  z: Type.Number()                                  //   z: number
+})                                                  // }`)
+
+const A = Parse({ T }, 'Partial<T>')                // const A: TObject<{
+                                                    //   x: TOptional<TNumber>,
+                                                    //   y: TOptional<TNumber>,
+                                                    //   z: TOptional<TNumber>
+                                                    // }>
+
+const B = Parse({ T }, 'keyof T')                   // const B: TUnion<[
+                                                    //   TLiteral<'x'>,
+                                                    //   TLiteral<'y'>,
+                                                    //   TLiteral<'z'>
+                                                    // ]>
+
+const C = Parse({ T }, 'T & { w: number }')         // const C: TIntersect<[TObject<{
+                                                    //    x: TNumber;
+                                                    //    y: TNumber;
+                                                    //    z: TNumber;
+                                                    // }>, TObject<{
+                                                    //    w: TNumber;
+                                                    // }>]>
+```
+
+<a name='syntax-static'></a>
+
+### Static
+
+Syntax Types provide two Static types for inferring TypeScript syntax from strings.
+
+```typescript
+import { StaticParseAsSchema, StaticParseAsType } from '@sinclair/typebox/syntax' 
+
+// Will infer as a TSchema
+
+type S = StaticParseAsSchema<{}, '{ x: number }'>   // type S: TObject<{
+                                                    //   x: TNumber
+                                                    // }>
+
+// Will infer as a type
+
+type T = StaticParseAsType<{}, '{ x: number }'>     // type T = {
+                                                    //  x: number
+                                                    //                       
+```
+
+
+<a name='syntax-limits'></a>
+
+### Limitations
+
+Syntax Types work by having TypeBox parse TypeScript syntax within the TypeScript type system. This approach can place some strain on the TypeScript compiler and language service, potentially affecting responsiveness. While TypeBox makes a best-effort attempt to optimize for Syntax Types, users should be mindful of the following structures:
+
+```typescript
+// Excessively wide structures will result in instantiation limits exceeding
+const A = Parse(`[
+  0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7,
+]`)
+
+// Excessively nested structures will result in instantiation limits exceeding
+const B = Parse(`{
+  x: {
+    y: {
+      z: {
+        w: 1 <-- Type instantiation is excessively deep and possibly infinite.
+      } 
+    }
+  }  
+}`)
+```
+
+In cases where Syntax Types busts through TypeScript instantiation limits, TypeBox offers a fallback ParseOnly function which will Parse the types at runtime, but not infer the type. This function can also be used for parsing non-constant strings.
+
+```typescript
+import { ParseOnly } from '@sinclair/typebox/syntax'
+
+// Where A is TSchema | undefined 
+
+const A = ParseOnly(`{
+  x: {
+    y: {
+      z: {
+        w: 1
+      } 
+    }
+  }  
+}`)
+```
+
+For more information on TypeBox's parsing infrastructure, refer to the [ParseBox](https://github.com/sinclairzx81/parsebox) project.
+
 <a name='values'></a>
 
 ## Values
@@ -1760,12 +1882,12 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │ (index)              │ Compiled   │ Minified   │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '119.8 kb' │ ' 52.6 kb' │ '2.28 x'    │
-│ typebox/errors       │ ' 74.4 kb' │ ' 33.1 kb' │ '2.25 x'    │
-│ typebox/parse        │ '115.3 kb' │ ' 48.3 kb' │ '2.39 x'    │
+│ typebox/compiler     │ '121.7 kb' │ ' 53.4 kb' │ '2.28 x'    │
+│ typebox/errors       │ ' 75.3 kb' │ ' 33.4 kb' │ '2.25 x'    │
+│ typebox/syntax       │ '120.1 kb' │ ' 50.5 kb' │ '2.38 x'    │
 │ typebox/system       │ '  7.4 kb' │ '  3.2 kb' │ '2.33 x'    │
-│ typebox/value        │ '157.2 kb' │ ' 66.1 kb' │ '2.38 x'    │
-│ typebox              │ '127.3 kb' │ ' 53.3 kb' │ '2.39 x'    │
+│ typebox/value        │ '160.3 kb' │ ' 67.4 kb' │ '2.38 x'    │
+│ typebox              │ ' 96.2 kb' │ ' 40.2 kb' │ '2.39 x'    │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/build/cjs/type/deref/deref.d.ts

@@ -1,22 +0,0 @@
-import type { TSchema } from '../schema/index';
-import type { Evaluate } from '../helpers/index';
-import type { TTuple } from '../tuple/index';
-import type { TIntersect } from '../intersect/index';
-import type { TUnion } from '../union/index';
-import type { TPromise } from '../promise/index';
-import type { TAsyncIterator } from '../async-iterator/index';
-import type { TIterator } from '../iterator/index';
-import type { TArray } from '../array/index';
-import type { TConstructor } from '../constructor/index';
-import type { TFunction } from '../function/index';
-import type { TRef } from '../ref/index';
-import type { TObject, TProperties } from '../object/index';
-export type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TDeref<L>]> : Acc);
-type FromProperties<T extends TProperties> = Evaluate<{
-    [K in keyof T]: TDeref<T[K]>;
-}>;
-declare function FromProperties(properties: TProperties, references: TSchema[]): never;
-export type TDeref<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<S>, TDeref<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<S>, TDeref<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<TDeref<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<TDeref<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDeref<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<TDeref<S>> : T extends TRef<infer S extends TSchema> ? TDeref<S> : T;
-/** `[Json]` Creates a dereferenced type */
-export declare function Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
-export {};