@sinclair/typebox 0.31.27 → 0.32.0-dev-1

package/errors/errors.js

@@ -28,11 +28,15 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Errors = exports.ValueErrorIterator = exports.EscapeKey = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = void 0;
-const guard_1 = require("../value/guard");
-const system_1 = require("../system/system");
-const deref_1 = require("../value/deref");
-const hash_1 = require("../value/hash");
-const Types = require("../typebox");
+const index_1 = require("../value/guard/index");
+const index_2 = require("../system/index");
+const index_3 = require("../type/keyof/index");
+const index_4 = require("../type/registry/index");
+const extends_undefined_1 = require("../type/extends/extends-undefined");
+const index_5 = require("../value/deref/index");
+const index_6 = require("../value/hash/index");
+const index_7 = require("../type/symbols/index");
+const index_8 = require("../type/never/index");
 // --------------------------------------------------------------------------
 // ValueErrorType
 // --------------------------------------------------------------------------
@@ -105,7 +109,7 @@ var ValueErrorType;
 // --------------------------------------------------------------------------
 // ValueErrors
 // --------------------------------------------------------------------------
-class ValueErrorsUnknownTypeError extends Types.TypeBoxError {
+class ValueErrorsUnknownTypeError extends Error {
     constructor(schema) {
         super('Unknown type');
         this.schema = schema;
@@ -146,14 +150,14 @@ exports.ValueErrorIterator = ValueErrorIterator;
 // Create
 // --------------------------------------------------------------------------
 function Create(type, schema, path, value) {
-    return { type, schema, path, value, message: system_1.TypeSystemErrorFunction.Get()(schema, type) };
+    return { type, schema, path, value, message: index_2.TypeSystemErrorFunction.Get()(schema, type) };
 }
 // --------------------------------------------------------------------------
 // Types
 // --------------------------------------------------------------------------
 function* TAny(schema, references, path, value) { }
 function* TArray(schema, references, path, value) {
-    if (!(0, guard_1.IsArray)(value)) {
+    if (!(0, index_1.IsArray)(value)) {
         return yield Create(ValueErrorType.Array, schema, path, value);
     }
     if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
@@ -167,7 +171,7 @@ function* TArray(schema, references, path, value) {
     }
     // prettier-ignore
     if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
-        const hashed = (0, hash_1.Hash)(element);
+        const hashed = (0, index_6.Hash)(element);
         if (set.has(hashed)) {
             return false;
         }
@@ -181,24 +185,24 @@ function* TArray(schema, references, path, value) {
     if (!(IsDefined(schema.contains) || IsDefined(schema.minContains) || IsDefined(schema.maxContains))) {
         return;
     }
-    const containsSchema = IsDefined(schema.contains) ? schema.contains : Types.Type.Never();
+    const containsSchema = IsDefined(schema.contains) ? schema.contains : (0, index_8.Never)();
     const containsCount = value.reduce((acc, value, index) => (Visit(containsSchema, references, `${path}${index}`, value).next().done === true ? acc + 1 : acc), 0);
     if (containsCount === 0) {
         yield Create(ValueErrorType.ArrayContains, schema, path, value);
     }
-    if ((0, guard_1.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
+    if ((0, index_1.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
         yield Create(ValueErrorType.ArrayMinContains, schema, path, value);
     }
-    if ((0, guard_1.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
+    if ((0, index_1.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
         yield Create(ValueErrorType.ArrayMaxContains, schema, path, value);
     }
 }
 function* TAsyncIterator(schema, references, path, value) {
-    if (!(0, guard_1.IsAsyncIterator)(value))
+    if (!(0, index_1.IsAsyncIterator)(value))
         yield Create(ValueErrorType.AsyncIterator, schema, path, value);
 }
 function* TBigInt(schema, references, path, value) {
-    if (!(0, guard_1.IsBigInt)(value))
+    if (!(0, index_1.IsBigInt)(value))
         return yield Create(ValueErrorType.BigInt, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path, value);
@@ -217,14 +221,14 @@ function* TBigInt(schema, references, path, value) {
     }
 }
 function* TBoolean(schema, references, path, value) {
-    if (!(0, guard_1.IsBoolean)(value))
+    if (!(0, index_1.IsBoolean)(value))
         yield Create(ValueErrorType.Boolean, schema, path, value);
 }
 function* TConstructor(schema, references, path, value) {
     yield* Visit(schema.returns, references, path, value.prototype);
 }
 function* TDate(schema, references, path, value) {
-    if (!(0, guard_1.IsDate)(value))
+    if (!(0, index_1.IsDate)(value))
         return yield Create(ValueErrorType.Date, schema, path, value);
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
         yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value);
@@ -243,11 +247,11 @@ function* TDate(schema, references, path, value) {
     }
 }
 function* TFunction(schema, references, path, value) {
-    if (!(0, guard_1.IsFunction)(value))
+    if (!(0, index_1.IsFunction)(value))
         yield Create(ValueErrorType.Function, schema, path, value);
 }
 function* TInteger(schema, references, path, value) {
-    if (!(0, guard_1.IsInteger)(value))
+    if (!(0, index_1.IsInteger)(value))
         return yield Create(ValueErrorType.Integer, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path, value);
@@ -274,7 +278,7 @@ function* TIntersect(schema, references, path, value) {
         }
     }
     if (schema.unevaluatedProperties === false) {
-        const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema));
+        const keyCheck = new RegExp((0, index_3.KeyOfStringResolvePattern)(schema));
         for (const valueKey of Object.getOwnPropertyNames(value)) {
             if (!keyCheck.test(valueKey)) {
                 yield Create(ValueErrorType.IntersectUnevaluatedProperties, schema, `${path}/${valueKey}`, value);
@@ -282,7 +286,7 @@ function* TIntersect(schema, references, path, value) {
         }
     }
     if (typeof schema.unevaluatedProperties === 'object') {
-        const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema));
+        const keyCheck = new RegExp((0, index_3.KeyOfStringResolvePattern)(schema));
         for (const valueKey of Object.getOwnPropertyNames(value)) {
             if (!keyCheck.test(valueKey)) {
                 const next = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next();
@@ -293,7 +297,7 @@ function* TIntersect(schema, references, path, value) {
     }
 }
 function* TIterator(schema, references, path, value) {
-    if (!(0, guard_1.IsIterator)(value))
+    if (!(0, index_1.IsIterator)(value))
         yield Create(ValueErrorType.Iterator, schema, path, value);
 }
 function* TLiteral(schema, references, path, value) {
@@ -308,11 +312,11 @@ function* TNot(schema, references, path, value) {
         yield Create(ValueErrorType.Not, schema, path, value);
 }
 function* TNull(schema, references, path, value) {
-    if (!(0, guard_1.IsNull)(value))
+    if (!(0, index_1.IsNull)(value))
         yield Create(ValueErrorType.Null, schema, path, value);
 }
 function* TNumber(schema, references, path, value) {
-    if (!system_1.TypeSystemPolicy.IsNumberLike(value))
+    if (!index_2.TypeSystemPolicy.IsNumberLike(value))
         return yield Create(ValueErrorType.Number, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path, value);
@@ -331,7 +335,7 @@ function* TNumber(schema, references, path, value) {
     }
 }
 function* TObject(schema, references, path, value) {
-    if (!system_1.TypeSystemPolicy.IsObjectLike(value))
+    if (!index_2.TypeSystemPolicy.IsObjectLike(value))
         return yield Create(ValueErrorType.Object, schema, path, value);
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
         yield Create(ValueErrorType.ObjectMinProperties, schema, path, value);
@@ -365,23 +369,23 @@ function* TObject(schema, references, path, value) {
         const property = schema.properties[knownKey];
         if (schema.required && schema.required.includes(knownKey)) {
             yield* Visit(property, references, `${path}/${EscapeKey(knownKey)}`, value[knownKey]);
-            if (Types.ExtendsUndefined.Check(schema) && !(knownKey in value)) {
+            if ((0, extends_undefined_1.ExtendsUndefinedCheck)(schema) && !(knownKey in value)) {
                 yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path}/${EscapeKey(knownKey)}`, undefined);
             }
         }
         else {
-            if (system_1.TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
+            if (index_2.TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
                 yield* Visit(property, references, `${path}/${EscapeKey(knownKey)}`, value[knownKey]);
             }
         }
     }
 }
 function* TPromise(schema, references, path, value) {
-    if (!(0, guard_1.IsPromise)(value))
+    if (!(0, index_1.IsPromise)(value))
         yield Create(ValueErrorType.Promise, schema, path, value);
 }
 function* TRecord(schema, references, path, value) {
-    if (!system_1.TypeSystemPolicy.IsRecordLike(value))
+    if (!index_2.TypeSystemPolicy.IsRecordLike(value))
         return yield Create(ValueErrorType.Object, schema, path, value);
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
         yield Create(ValueErrorType.ObjectMinProperties, schema, path, value);
@@ -410,10 +414,10 @@ function* TRecord(schema, references, path, value) {
     }
 }
 function* TRef(schema, references, path, value) {
-    yield* Visit((0, deref_1.Deref)(schema, references), references, path, value);
+    yield* Visit((0, index_5.Deref)(schema, references), references, path, value);
 }
 function* TString(schema, references, path, value) {
-    if (!(0, guard_1.IsString)(value))
+    if (!(0, index_1.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) {
         yield Create(ValueErrorType.StringMinLength, schema, path, value);
@@ -421,18 +425,18 @@ function* TString(schema, references, path, value) {
     if (IsDefined(schema.maxLength) && !(value.length <= schema.maxLength)) {
         yield Create(ValueErrorType.StringMaxLength, schema, path, value);
     }
-    if ((0, guard_1.IsString)(schema.pattern)) {
+    if ((0, index_1.IsString)(schema.pattern)) {
         const regex = new RegExp(schema.pattern);
         if (!regex.test(value)) {
             yield Create(ValueErrorType.StringPattern, schema, path, value);
         }
     }
-    if ((0, guard_1.IsString)(schema.format)) {
-        if (!Types.FormatRegistry.Has(schema.format)) {
+    if ((0, index_1.IsString)(schema.format)) {
+        if (!index_4.FormatRegistry.Has(schema.format)) {
             yield Create(ValueErrorType.StringFormatUnknown, schema, path, value);
         }
         else {
-            const format = Types.FormatRegistry.Get(schema.format);
+            const format = index_4.FormatRegistry.Get(schema.format);
             if (!format(value)) {
                 yield Create(ValueErrorType.StringFormat, schema, path, value);
             }
@@ -440,11 +444,11 @@ function* TString(schema, references, path, value) {
     }
 }
 function* TSymbol(schema, references, path, value) {
-    if (!(0, guard_1.IsSymbol)(value))
+    if (!(0, index_1.IsSymbol)(value))
         yield Create(ValueErrorType.Symbol, schema, path, value);
 }
 function* TTemplateLiteral(schema, references, path, value) {
-    if (!(0, guard_1.IsString)(value))
+    if (!(0, index_1.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     const regex = new RegExp(schema.pattern);
     if (!regex.test(value)) {
@@ -452,10 +456,10 @@ function* TTemplateLiteral(schema, references, path, value) {
     }
 }
 function* TThis(schema, references, path, value) {
-    yield* Visit((0, deref_1.Deref)(schema, references), references, path, value);
+    yield* Visit((0, index_5.Deref)(schema, references), references, path, value);
 }
 function* TTuple(schema, references, path, value) {
-    if (!(0, guard_1.IsArray)(value))
+    if (!(0, index_1.IsArray)(value))
         return yield Create(ValueErrorType.Tuple, schema, path, value);
     if (schema.items === undefined && !(value.length === 0)) {
         return yield Create(ValueErrorType.TupleLength, schema, path, value);
@@ -471,7 +475,7 @@ function* TTuple(schema, references, path, value) {
     }
 }
 function* TUndefined(schema, references, path, value) {
-    if (!(0, guard_1.IsUndefined)(value))
+    if (!(0, index_1.IsUndefined)(value))
         yield Create(ValueErrorType.Undefined, schema, path, value);
 }
 function* TUnion(schema, references, path, value) {
@@ -487,7 +491,7 @@ function* TUnion(schema, references, path, value) {
     }
 }
 function* TUint8Array(schema, references, path, value) {
-    if (!(0, guard_1.IsUint8Array)(value))
+    if (!(0, index_1.IsUint8Array)(value))
         return yield Create(ValueErrorType.Uint8Array, schema, path, value);
     if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
         yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value);
@@ -498,18 +502,18 @@ function* TUint8Array(schema, references, path, value) {
 }
 function* TUnknown(schema, references, path, value) { }
 function* TVoid(schema, references, path, value) {
-    if (!system_1.TypeSystemPolicy.IsVoidLike(value))
+    if (!index_2.TypeSystemPolicy.IsVoidLike(value))
         yield Create(ValueErrorType.Void, schema, path, value);
 }
 function* TKind(schema, references, path, value) {
-    const check = Types.TypeRegistry.Get(schema[Types.Kind]);
+    const check = index_4.TypeRegistry.Get(schema[index_7.Kind]);
     if (!check(schema, value))
         yield Create(ValueErrorType.Kind, schema, path, value);
 }
 function* Visit(schema, references, path, value) {
     const references_ = IsDefined(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema_[Types.Kind]) {
+    switch (schema_[index_7.Kind]) {
         case 'Any':
             return yield* TAny(schema_, references_, path, value);
         case 'Array':
@@ -571,7 +575,7 @@ function* Visit(schema, references, path, value) {
         case 'Void':
             return yield* TVoid(schema_, references_, path, value);
         default:
-            if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+            if (!index_4.TypeRegistry.Has(schema_[index_7.Kind]))
                 throw new ValueErrorsUnknownTypeError(schema);
             return yield* TKind(schema_, references_, path, value);
     }

package/index.d.ts

@@ -0,0 +1,71 @@
+export { Kind, Hint, ReadonlyKind, OptionalKind, TransformKind } from './type/symbols/index';
+export { PatternBoolean, PatternBooleanExact, PatternNumber, PatternNumberExact, PatternString, PatternStringExact } from './type/patterns/index';
+export { TypeRegistry, FormatRegistry } from './type/registry/index';
+export { TypeGuard, ValueGuard } from './type/guard/index';
+export { CloneType, CloneRest } from './type/clone/type';
+export { Clone } from './type/clone/value';
+export { Any, type TAny } from './type/any/index';
+export { Array, type TArray, type ArrayOptions } from './type/array/index';
+export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index';
+export { Awaited, type TAwaited } from './type/awaited/index';
+export { BigInt, type TBigInt, BigIntOptions } from './type/bigint/index';
+export { Boolean, type TBoolean } from './type/boolean/index';
+export { Composite, type TComposite } from './type/composite/index';
+export { Const, type TConst } from './type/const/index';
+export { Constructor, type TConstructor } from './type/constructor/index';
+export { ConstructorParameters, type TConstructorParameters } from './type/constructor-parameters/index';
+export { Date, type TDate, type DateOptions } from './type/date/index';
+export { Deref, type TDeref } from './type/deref/index';
+export { Enum, type TEnum } from './type/enum/index';
+export { Exclude, type TExclude } from './type/exclude/index';
+export { Extends, type TExtends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './type/extends/index';
+export { Extract, type TExtract } from './type/extract/index';
+export { Function, type TFunction } from './type/function/index';
+export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index';
+export { Index, type TIndex, IndexedKeyResolve, IndexedTypeResolve } from './type/indexed/index';
+export { InstanceType, type TInstanceType } from './type/instance-type/index';
+export { Integer, type TInteger, type IntegerOptions } from './type/integer/index';
+export { Intersect, type TIntersect, type IntersectOptions } from './type/intersect/index';
+export { Iterator, type TIterator } from './type/iterator/index';
+export { Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase, IntrinsicResolve } from './type/intrinsic/index';
+export { KeyOf, type TKeyOf, KeyOfStringResolve, KeyOfStringResolvePattern, KeyOfTypeResolve } from './type/keyof/index';
+export { Literal, type TLiteral } from './type/literal/index';
+export { Mapped, type TMappedKey, type MappedFunction, type TMappedResult } from './type/mapped/index';
+export { Never, type TNever } from './type/never/index';
+export { Not, type TNot } from './type/not/index';
+export { Null, type TNull } from './type/null/index';
+export { Number, type TNumber, type NumberOptions } from './type/number/index';
+export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index';
+export { Omit, type TOmit } from './type/omit/index';
+export { Optional, type TOptional } from './type/optional/index';
+export { Parameters, type TParameters } from './type/parameters/index';
+export { Partial, type TPartial } from './type/partial/index';
+export { Pick, type TPick } from './type/pick/index';
+export { Promise, type TPromise } from './type/promise/index';
+export { Readonly, type TReadonly } from './type/readonly/index';
+export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index';
+export { Record, type TRecord } from './type/record/index';
+export { Recursive, type TRecursive, type TThis } from './type/recursive/index';
+export { Ref, type TRef } from './type/ref/index';
+export { RegExp, type TRegExp } from './type/regexp/index';
+export { Required, type TRequired } from './type/required/index';
+export { Rest, type TRest } from './type/rest/index';
+export { ReturnType, type TReturnType } from './type/return-type/index';
+export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from './type/schema/index';
+export { type Static, type StaticDecode, type StaticEncode } from './type/static/index';
+export { Strict } from './type/strict/index';
+export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index';
+export { Symbol, type TSymbol, type SymbolValue } from './type/symbol/index';
+export { TemplateLiteral, IsTemplateLiteralFinite, TemplateLiteralParse, TemplateLiteralGenerate, type TTemplateLiteral, type TTemplateLiteralKind } from './type/template-literal/index';
+export { Transform, type TTransform, type TransformOptions, type TransformFunction, TransformDecodeBuilder, TransformEncodeBuilder } from './type/transform/index';
+export { Tuple, type TTuple } from './type/tuple/index';
+export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index';
+export { Undefined, type TUndefined } from './type/undefined/index';
+export { Union, type TUnion } from './type/union/index';
+export { Unknown, type TUnknown } from './type/unknown/index';
+export { Unsafe, type TUnsafe } from './type/unsafe/index';
+export { Void, type TVoid } from './type/void/index';
+export { JsonTypeBuilder, JavaScriptTypeBuilder } from './type/type/index';
+import { Type } from './type/type/index';
+export { Type };
+export default Type;

package/index.js

@@ -0,0 +1,205 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uppercase = exports.Uncapitalize = exports.Lowercase = exports.Capitalize = exports.Iterator = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexedTypeResolve = exports.IndexedKeyResolve = exports.Index = exports.Increment = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = exports.Clone = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
+exports.Type = exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Void = exports.Unsafe = exports.Unknown = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralGenerate = exports.TemplateLiteralParse = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.Readonly = exports.Promise = exports.Pick = exports.Partial = exports.Parameters = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.Mapped = exports.Literal = exports.KeyOfTypeResolve = exports.KeyOfStringResolvePattern = exports.KeyOfStringResolve = exports.KeyOf = exports.IntrinsicResolve = void 0;
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+var index_1 = require("./type/symbols/index");
+Object.defineProperty(exports, "Kind", { enumerable: true, get: function () { return index_1.Kind; } });
+Object.defineProperty(exports, "Hint", { enumerable: true, get: function () { return index_1.Hint; } });
+Object.defineProperty(exports, "ReadonlyKind", { enumerable: true, get: function () { return index_1.ReadonlyKind; } });
+Object.defineProperty(exports, "OptionalKind", { enumerable: true, get: function () { return index_1.OptionalKind; } });
+Object.defineProperty(exports, "TransformKind", { enumerable: true, get: function () { return index_1.TransformKind; } });
+var index_2 = require("./type/patterns/index");
+Object.defineProperty(exports, "PatternBoolean", { enumerable: true, get: function () { return index_2.PatternBoolean; } });
+Object.defineProperty(exports, "PatternBooleanExact", { enumerable: true, get: function () { return index_2.PatternBooleanExact; } });
+Object.defineProperty(exports, "PatternNumber", { enumerable: true, get: function () { return index_2.PatternNumber; } });
+Object.defineProperty(exports, "PatternNumberExact", { enumerable: true, get: function () { return index_2.PatternNumberExact; } });
+Object.defineProperty(exports, "PatternString", { enumerable: true, get: function () { return index_2.PatternString; } });
+Object.defineProperty(exports, "PatternStringExact", { enumerable: true, get: function () { return index_2.PatternStringExact; } });
+var index_3 = require("./type/registry/index");
+Object.defineProperty(exports, "TypeRegistry", { enumerable: true, get: function () { return index_3.TypeRegistry; } });
+Object.defineProperty(exports, "FormatRegistry", { enumerable: true, get: function () { return index_3.FormatRegistry; } });
+var index_4 = require("./type/guard/index");
+Object.defineProperty(exports, "TypeGuard", { enumerable: true, get: function () { return index_4.TypeGuard; } });
+Object.defineProperty(exports, "ValueGuard", { enumerable: true, get: function () { return index_4.ValueGuard; } });
+var type_1 = require("./type/clone/type");
+Object.defineProperty(exports, "CloneType", { enumerable: true, get: function () { return type_1.CloneType; } });
+Object.defineProperty(exports, "CloneRest", { enumerable: true, get: function () { return type_1.CloneRest; } });
+var value_1 = require("./type/clone/value");
+Object.defineProperty(exports, "Clone", { enumerable: true, get: function () { return value_1.Clone; } });
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+var index_5 = require("./type/any/index");
+Object.defineProperty(exports, "Any", { enumerable: true, get: function () { return index_5.Any; } });
+var index_6 = require("./type/array/index");
+Object.defineProperty(exports, "Array", { enumerable: true, get: function () { return index_6.Array; } });
+var index_7 = require("./type/async-iterator/index");
+Object.defineProperty(exports, "AsyncIterator", { enumerable: true, get: function () { return index_7.AsyncIterator; } });
+var index_8 = require("./type/awaited/index");
+Object.defineProperty(exports, "Awaited", { enumerable: true, get: function () { return index_8.Awaited; } });
+var index_9 = require("./type/bigint/index");
+Object.defineProperty(exports, "BigInt", { enumerable: true, get: function () { return index_9.BigInt; } });
+var index_10 = require("./type/boolean/index");
+Object.defineProperty(exports, "Boolean", { enumerable: true, get: function () { return index_10.Boolean; } });
+var index_11 = require("./type/composite/index");
+Object.defineProperty(exports, "Composite", { enumerable: true, get: function () { return index_11.Composite; } });
+var index_12 = require("./type/const/index");
+Object.defineProperty(exports, "Const", { enumerable: true, get: function () { return index_12.Const; } });
+var index_13 = require("./type/constructor/index");
+Object.defineProperty(exports, "Constructor", { enumerable: true, get: function () { return index_13.Constructor; } });
+var index_14 = require("./type/constructor-parameters/index");
+Object.defineProperty(exports, "ConstructorParameters", { enumerable: true, get: function () { return index_14.ConstructorParameters; } });
+var index_15 = require("./type/date/index");
+Object.defineProperty(exports, "Date", { enumerable: true, get: function () { return index_15.Date; } });
+var index_16 = require("./type/deref/index");
+Object.defineProperty(exports, "Deref", { enumerable: true, get: function () { return index_16.Deref; } });
+var index_17 = require("./type/enum/index");
+Object.defineProperty(exports, "Enum", { enumerable: true, get: function () { return index_17.Enum; } });
+var index_18 = require("./type/exclude/index");
+Object.defineProperty(exports, "Exclude", { enumerable: true, get: function () { return index_18.Exclude; } });
+var index_19 = require("./type/extends/index");
+Object.defineProperty(exports, "Extends", { enumerable: true, get: function () { return index_19.Extends; } });
+Object.defineProperty(exports, "ExtendsCheck", { enumerable: true, get: function () { return index_19.ExtendsCheck; } });
+Object.defineProperty(exports, "ExtendsResult", { enumerable: true, get: function () { return index_19.ExtendsResult; } });
+Object.defineProperty(exports, "ExtendsUndefinedCheck", { enumerable: true, get: function () { return index_19.ExtendsUndefinedCheck; } });
+var index_20 = require("./type/extract/index");
+Object.defineProperty(exports, "Extract", { enumerable: true, get: function () { return index_20.Extract; } });
+var index_21 = require("./type/function/index");
+Object.defineProperty(exports, "Function", { enumerable: true, get: function () { return index_21.Function; } });
+var index_22 = require("./type/helpers/index");
+Object.defineProperty(exports, "Increment", { enumerable: true, get: function () { return index_22.Increment; } });
+var index_23 = require("./type/indexed/index");
+Object.defineProperty(exports, "Index", { enumerable: true, get: function () { return index_23.Index; } });
+Object.defineProperty(exports, "IndexedKeyResolve", { enumerable: true, get: function () { return index_23.IndexedKeyResolve; } });
+Object.defineProperty(exports, "IndexedTypeResolve", { enumerable: true, get: function () { return index_23.IndexedTypeResolve; } });
+var index_24 = require("./type/instance-type/index");
+Object.defineProperty(exports, "InstanceType", { enumerable: true, get: function () { return index_24.InstanceType; } });
+var index_25 = require("./type/integer/index");
+Object.defineProperty(exports, "Integer", { enumerable: true, get: function () { return index_25.Integer; } });
+var index_26 = require("./type/intersect/index");
+Object.defineProperty(exports, "Intersect", { enumerable: true, get: function () { return index_26.Intersect; } });
+var index_27 = require("./type/iterator/index");
+Object.defineProperty(exports, "Iterator", { enumerable: true, get: function () { return index_27.Iterator; } });
+var index_28 = require("./type/intrinsic/index");
+Object.defineProperty(exports, "Capitalize", { enumerable: true, get: function () { return index_28.Capitalize; } });
+Object.defineProperty(exports, "Lowercase", { enumerable: true, get: function () { return index_28.Lowercase; } });
+Object.defineProperty(exports, "Uncapitalize", { enumerable: true, get: function () { return index_28.Uncapitalize; } });
+Object.defineProperty(exports, "Uppercase", { enumerable: true, get: function () { return index_28.Uppercase; } });
+Object.defineProperty(exports, "IntrinsicResolve", { enumerable: true, get: function () { return index_28.IntrinsicResolve; } });
+var index_29 = require("./type/keyof/index");
+Object.defineProperty(exports, "KeyOf", { enumerable: true, get: function () { return index_29.KeyOf; } });
+Object.defineProperty(exports, "KeyOfStringResolve", { enumerable: true, get: function () { return index_29.KeyOfStringResolve; } });
+Object.defineProperty(exports, "KeyOfStringResolvePattern", { enumerable: true, get: function () { return index_29.KeyOfStringResolvePattern; } });
+Object.defineProperty(exports, "KeyOfTypeResolve", { enumerable: true, get: function () { return index_29.KeyOfTypeResolve; } });
+var index_30 = require("./type/literal/index");
+Object.defineProperty(exports, "Literal", { enumerable: true, get: function () { return index_30.Literal; } });
+var index_31 = require("./type/mapped/index");
+Object.defineProperty(exports, "Mapped", { enumerable: true, get: function () { return index_31.Mapped; } });
+var index_32 = require("./type/never/index");
+Object.defineProperty(exports, "Never", { enumerable: true, get: function () { return index_32.Never; } });
+var index_33 = require("./type/not/index");
+Object.defineProperty(exports, "Not", { enumerable: true, get: function () { return index_33.Not; } });
+var index_34 = require("./type/null/index");
+Object.defineProperty(exports, "Null", { enumerable: true, get: function () { return index_34.Null; } });
+var index_35 = require("./type/number/index");
+Object.defineProperty(exports, "Number", { enumerable: true, get: function () { return index_35.Number; } });
+var index_36 = require("./type/object/index");
+Object.defineProperty(exports, "Object", { enumerable: true, get: function () { return index_36.Object; } });
+var index_37 = require("./type/omit/index");
+Object.defineProperty(exports, "Omit", { enumerable: true, get: function () { return index_37.Omit; } });
+var index_38 = require("./type/optional/index");
+Object.defineProperty(exports, "Optional", { enumerable: true, get: function () { return index_38.Optional; } });
+var index_39 = require("./type/parameters/index");
+Object.defineProperty(exports, "Parameters", { enumerable: true, get: function () { return index_39.Parameters; } });
+var index_40 = require("./type/partial/index");
+Object.defineProperty(exports, "Partial", { enumerable: true, get: function () { return index_40.Partial; } });
+var index_41 = require("./type/pick/index");
+Object.defineProperty(exports, "Pick", { enumerable: true, get: function () { return index_41.Pick; } });
+var index_42 = require("./type/promise/index");
+Object.defineProperty(exports, "Promise", { enumerable: true, get: function () { return index_42.Promise; } });
+var index_43 = require("./type/readonly/index");
+Object.defineProperty(exports, "Readonly", { enumerable: true, get: function () { return index_43.Readonly; } });
+var index_44 = require("./type/readonly-optional/index");
+Object.defineProperty(exports, "ReadonlyOptional", { enumerable: true, get: function () { return index_44.ReadonlyOptional; } });
+var index_45 = require("./type/record/index");
+Object.defineProperty(exports, "Record", { enumerable: true, get: function () { return index_45.Record; } });
+var index_46 = require("./type/recursive/index");
+Object.defineProperty(exports, "Recursive", { enumerable: true, get: function () { return index_46.Recursive; } });
+var index_47 = require("./type/ref/index");
+Object.defineProperty(exports, "Ref", { enumerable: true, get: function () { return index_47.Ref; } });
+var index_48 = require("./type/regexp/index");
+Object.defineProperty(exports, "RegExp", { enumerable: true, get: function () { return index_48.RegExp; } });
+var index_49 = require("./type/required/index");
+Object.defineProperty(exports, "Required", { enumerable: true, get: function () { return index_49.Required; } });
+var index_50 = require("./type/rest/index");
+Object.defineProperty(exports, "Rest", { enumerable: true, get: function () { return index_50.Rest; } });
+var index_51 = require("./type/return-type/index");
+Object.defineProperty(exports, "ReturnType", { enumerable: true, get: function () { return index_51.ReturnType; } });
+var index_52 = require("./type/strict/index");
+Object.defineProperty(exports, "Strict", { enumerable: true, get: function () { return index_52.Strict; } });
+var index_53 = require("./type/string/index");
+Object.defineProperty(exports, "String", { enumerable: true, get: function () { return index_53.String; } });
+var index_54 = require("./type/symbol/index");
+Object.defineProperty(exports, "Symbol", { enumerable: true, get: function () { return index_54.Symbol; } });
+var index_55 = require("./type/template-literal/index");
+Object.defineProperty(exports, "TemplateLiteral", { enumerable: true, get: function () { return index_55.TemplateLiteral; } });
+Object.defineProperty(exports, "IsTemplateLiteralFinite", { enumerable: true, get: function () { return index_55.IsTemplateLiteralFinite; } });
+Object.defineProperty(exports, "TemplateLiteralParse", { enumerable: true, get: function () { return index_55.TemplateLiteralParse; } });
+Object.defineProperty(exports, "TemplateLiteralGenerate", { enumerable: true, get: function () { return index_55.TemplateLiteralGenerate; } });
+var index_56 = require("./type/transform/index");
+Object.defineProperty(exports, "Transform", { enumerable: true, get: function () { return index_56.Transform; } });
+Object.defineProperty(exports, "TransformDecodeBuilder", { enumerable: true, get: function () { return index_56.TransformDecodeBuilder; } });
+Object.defineProperty(exports, "TransformEncodeBuilder", { enumerable: true, get: function () { return index_56.TransformEncodeBuilder; } });
+var index_57 = require("./type/tuple/index");
+Object.defineProperty(exports, "Tuple", { enumerable: true, get: function () { return index_57.Tuple; } });
+var index_58 = require("./type/uint8array/index");
+Object.defineProperty(exports, "Uint8Array", { enumerable: true, get: function () { return index_58.Uint8Array; } });
+var index_59 = require("./type/undefined/index");
+Object.defineProperty(exports, "Undefined", { enumerable: true, get: function () { return index_59.Undefined; } });
+var index_60 = require("./type/union/index");
+Object.defineProperty(exports, "Union", { enumerable: true, get: function () { return index_60.Union; } });
+var index_61 = require("./type/unknown/index");
+Object.defineProperty(exports, "Unknown", { enumerable: true, get: function () { return index_61.Unknown; } });
+var index_62 = require("./type/unsafe/index");
+Object.defineProperty(exports, "Unsafe", { enumerable: true, get: function () { return index_62.Unsafe; } });
+var index_63 = require("./type/void/index");
+Object.defineProperty(exports, "Void", { enumerable: true, get: function () { return index_63.Void; } });
+// ------------------------------------------------------------------
+// Namespace
+// ------------------------------------------------------------------
+var index_64 = require("./type/type/index");
+Object.defineProperty(exports, "JsonTypeBuilder", { enumerable: true, get: function () { return index_64.JsonTypeBuilder; } });
+Object.defineProperty(exports, "JavaScriptTypeBuilder", { enumerable: true, get: function () { return index_64.JavaScriptTypeBuilder; } });
+const index_65 = require("./type/type/index");
+Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return index_65.Type; } });
+exports.default = index_65.Type;