@sinclair/typebox 0.32.13 → 0.32.15

package/build/import/value/guard/guard.mjs

@@ -10,24 +10,87 @@ export function IsIterator(value) {
     return IsObject(value) && Symbol.iterator in value;
 }
 // --------------------------------------------------------------------------
-// Nominal
+// Object Instances
 // --------------------------------------------------------------------------
-/** Returns true if this value is a typed array */
-export function IsTypedArray(value) {
-    return ArrayBuffer.isView(value);
+/** Returns true if this value is not an instance of a class */
+export function IsStandardObject(value) {
+    return IsObject(value) && !IsArray(value) && IsFunction(value.constructor) && value.constructor.name === 'Object';
+}
+/** Returns true if this value is an instance of a class */
+export function IsInstanceObject(value) {
+    return IsObject(value) && !IsArray(value) && IsFunction(value.constructor) && value.constructor.name !== 'Object';
 }
+// --------------------------------------------------------------------------
+// JavaScript
+// --------------------------------------------------------------------------
 /** Returns true if this value is a Promise */
 export function IsPromise(value) {
     return value instanceof Promise;
 }
-/** Returns true if the value is a Uint8Array */
-export function IsUint8Array(value) {
-    return value instanceof Uint8Array;
-}
 /** Returns true if this value is a Date */
 export function IsDate(value) {
     return value instanceof Date && Number.isFinite(value.getTime());
 }
+/** Returns true if this value is an instance of Map<K, T> */
+export function IsMap(value) {
+    return value instanceof globalThis.Map;
+}
+/** Returns true if this value is an instance of Set<T> */
+export function IsSet(value) {
+    return value instanceof globalThis.Set;
+}
+/** Returns true if this value is RegExp */
+export function IsRegExp(value) {
+    return value instanceof globalThis.RegExp;
+}
+/** Returns true if this value is a typed array */
+export function IsTypedArray(value) {
+    return ArrayBuffer.isView(value);
+}
+/** Returns true if the value is a Int8Array */
+export function IsInt8Array(value) {
+    return value instanceof globalThis.Int8Array;
+}
+/** Returns true if the value is a Uint8Array */
+export function IsUint8Array(value) {
+    return value instanceof globalThis.Uint8Array;
+}
+/** Returns true if the value is a Uint8ClampedArray */
+export function IsUint8ClampedArray(value) {
+    return value instanceof globalThis.Uint8ClampedArray;
+}
+/** Returns true if the value is a Int16Array */
+export function IsInt16Array(value) {
+    return value instanceof globalThis.Int16Array;
+}
+/** Returns true if the value is a Uint16Array */
+export function IsUint16Array(value) {
+    return value instanceof globalThis.Uint16Array;
+}
+/** Returns true if the value is a Int32Array */
+export function IsInt32Array(value) {
+    return value instanceof globalThis.Int32Array;
+}
+/** Returns true if the value is a Uint32Array */
+export function IsUint32Array(value) {
+    return value instanceof globalThis.Uint32Array;
+}
+/** Returns true if the value is a Float32Array */
+export function IsFloat32Array(value) {
+    return value instanceof globalThis.Float32Array;
+}
+/** Returns true if the value is a Float64Array */
+export function IsFloat64Array(value) {
+    return value instanceof globalThis.Float64Array;
+}
+/** Returns true if the value is a BigInt64Array */
+export function IsBigInt64Array(value) {
+    return value instanceof globalThis.BigInt64Array;
+}
+/** Returns true if the value is a BigUint64Array */
+export function IsBigUint64Array(value) {
+    return value instanceof globalThis.BigUint64Array;
+}
 // --------------------------------------------------------------------------
 // Standard
 // --------------------------------------------------------------------------
@@ -35,10 +98,6 @@ export function IsDate(value) {
 export function HasPropertyKey(value, key) {
     return key in value;
 }
-/** Returns true if this object is not an instance of any other type */
-export function IsPlainObject(value) {
-    return IsObject(value) && IsFunction(value.constructor) && value.constructor.name === 'Object';
-}
 /** Returns true of this value is an object type */
 export function IsObject(value) {
     return value !== null && typeof value === 'object';

package/build/import/value/hash/hash.mjs

@@ -1,4 +1,4 @@
-import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsPlainObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index.mjs';
+import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsStandardObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 // ------------------------------------------------------------------
 // Errors
@@ -120,7 +120,7 @@ function Visit(value) {
         return NullType(value);
     if (IsNumber(value))
         return NumberType(value);
-    if (IsPlainObject(value))
+    if (IsStandardObject(value))
         return ObjectType(value);
     if (IsString(value))
         return StringType(value);

package/build/import/value/index.d.mts

@@ -1,16 +1,16 @@
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
-export { Cast, ValueCastError } from './cast/index.mjs';
-export { Check } from './check/index.mjs';
-export { Clean } from './clean/index.mjs';
-export { Clone } from './clone/index.mjs';
-export { Convert } from './convert/index.mjs';
-export { Create, ValueCreateError } from './create/index.mjs';
-export { Default } from './default/index.mjs';
-export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaError } from './delta/index.mjs';
-export { Equal } from './equal/index.mjs';
-export { Hash, ValueHashError } from './hash/index.mjs';
-export { Mutate, ValueMutateError, type Mutable } from './mutate/index.mjs';
-export { ValuePointer } from './pointer/index.mjs';
-export { TransformDecode, TransformEncode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
-export { ArrayType, HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, type ObjectType, type TypedArrayType, type ValueType, } from './guard/index.mjs';
+export * from './guard/index.mjs';
+export * from './cast/index.mjs';
+export * from './check/index.mjs';
+export * from './clean/index.mjs';
+export * from './clone/index.mjs';
+export * from './convert/index.mjs';
+export * from './create/index.mjs';
+export * from './default/index.mjs';
+export * from './delta/index.mjs';
+export * from './equal/index.mjs';
+export * from './hash/index.mjs';
+export * from './mutate/index.mjs';
+export * from './pointer/index.mjs';
+export * from './transform/index.mjs';
 export { Value } from './value/index.mjs';

package/build/import/value/index.mjs

@@ -1,28 +1,28 @@
 // ------------------------------------------------------------------
-// Value Errors (re-export)
+// Errors (re-export)
 // ------------------------------------------------------------------
 export { ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
 // ------------------------------------------------------------------
-// Value Operators
+// Guards
 // ------------------------------------------------------------------
-export { Cast, ValueCastError } from './cast/index.mjs';
-export { Check } from './check/index.mjs';
-export { Clean } from './clean/index.mjs';
-export { Clone } from './clone/index.mjs';
-export { Convert } from './convert/index.mjs';
-export { Create, ValueCreateError } from './create/index.mjs';
-export { Default } from './default/index.mjs';
-export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaError } from './delta/index.mjs';
-export { Equal } from './equal/index.mjs';
-export { Hash, ValueHashError } from './hash/index.mjs';
-export { Mutate, ValueMutateError } from './mutate/index.mjs';
-export { ValuePointer } from './pointer/index.mjs';
-export { TransformDecode, TransformEncode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
+export * from './guard/index.mjs';
 // ------------------------------------------------------------------
-// Value Guards
+// Operators
 // ------------------------------------------------------------------
-export { HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, } from './guard/index.mjs';
+export * from './cast/index.mjs';
+export * from './check/index.mjs';
+export * from './clean/index.mjs';
+export * from './clone/index.mjs';
+export * from './convert/index.mjs';
+export * from './create/index.mjs';
+export * from './default/index.mjs';
+export * from './delta/index.mjs';
+export * from './equal/index.mjs';
+export * from './hash/index.mjs';
+export * from './mutate/index.mjs';
+export * from './pointer/index.mjs';
+export * from './transform/index.mjs';
 // ------------------------------------------------------------------
-// Value Namespace
+// Namespace
 // ------------------------------------------------------------------
 export { Value } from './value/index.mjs';

package/build/import/value/mutate/mutate.mjs

@@ -1,4 +1,4 @@
-import { IsPlainObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
+import { IsStandardObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
 import { ValuePointer } from '../pointer/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
@@ -11,7 +11,7 @@ export class ValueMutateError extends TypeBoxError {
     }
 }
 function ObjectType(root, path, current, next) {
-    if (!IsPlainObject(current)) {
+    if (!IsStandardObject(current)) {
         ValuePointer.Set(root, path, Clone(next));
     }
     else {
@@ -63,7 +63,7 @@ function Visit(root, path, current, next) {
         return ArrayType(root, path, current, next);
     if (IsTypedArray(next))
         return TypedArrayType(root, path, current, next);
-    if (IsPlainObject(next))
+    if (IsStandardObject(next))
         return ObjectType(root, path, current, next);
     if (IsValueType(next))
         return ValueType(root, path, current, next);
@@ -76,8 +76,8 @@ function IsNonMutableValue(value) {
 }
 function IsMismatchedValue(current, next) {
     // prettier-ignore
-    return ((IsPlainObject(current) && IsArray(next)) ||
-        (IsArray(current) && IsPlainObject(next)));
+    return ((IsStandardObject(current) && IsArray(next)) ||
+        (IsArray(current) && IsStandardObject(next)));
 }
 // ------------------------------------------------------------------
 // Mutate

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

@@ -7,7 +7,7 @@ import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
+import { IsStandardObject, IsArray, IsValueType } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -56,7 +56,7 @@ function FromArray(schema, references, value) {
 }
 // prettier-ignore
 function FromIntersect(schema, references, value) {
-    if (!IsPlainObject(value) || IsValueType(value))
+    if (!IsStandardObject(value) || IsValueType(value))
         return Default(schema, value);
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
@@ -81,7 +81,7 @@ function FromNot(schema, references, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, value) {
-    if (!IsPlainObject(value))
+    if (!IsStandardObject(value))
         return Default(schema, value);
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
@@ -103,7 +103,7 @@ function FromObject(schema, references, value) {
 }
 // prettier-ignore
 function FromRecord(schema, references, value) {
-    if (!IsPlainObject(value))
+    if (!IsStandardObject(value))
         return Default(schema, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);

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

@@ -7,7 +7,7 @@ import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
+import { IsStandardObject, IsArray, IsValueType } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -57,7 +57,7 @@ function FromArray(schema, references, value) {
 // prettier-ignore
 function FromIntersect(schema, references, value) {
     const defaulted = Default(schema, value);
-    if (!IsPlainObject(value) || IsValueType(value))
+    if (!IsStandardObject(value) || IsValueType(value))
         return defaulted;
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
@@ -83,7 +83,7 @@ function FromNot(schema, references, value) {
 // prettier-ignore
 function FromObject(schema, references, value) {
     const defaulted = Default(schema, value);
-    if (!IsPlainObject(value))
+    if (!IsStandardObject(value))
         return defaulted;
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
@@ -105,7 +105,7 @@ function FromObject(schema, references, value) {
 // prettier-ignore
 function FromRecord(schema, references, value) {
     const defaulted = Default(schema, value);
-    if (!IsPlainObject(value))
+    if (!IsStandardObject(value))
         return defaulted;
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);

package/build/require/compiler/index.d.ts

@@ -1,2 +1,2 @@
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
-export { TypeCompiler, TypeCheck, type TypeCompilerCodegenOptions, type TypeCompilerLanguageOption, TypeCompilerTypeGuardError, TypeCompilerUnknownTypeError } from './compiler';
+export * from './compiler';

package/build/require/compiler/index.js

@@ -1,12 +1,22 @@
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCompilerUnknownTypeError = exports.TypeCompilerTypeGuardError = exports.TypeCheck = exports.TypeCompiler = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
+exports.ValueErrorIterator = exports.ValueErrorType = void 0;
 var index_1 = require("../errors/index");
 Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
 Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return index_1.ValueErrorIterator; } });
-var compiler_1 = require("./compiler");
-Object.defineProperty(exports, "TypeCompiler", { enumerable: true, get: function () { return compiler_1.TypeCompiler; } });
-Object.defineProperty(exports, "TypeCheck", { enumerable: true, get: function () { return compiler_1.TypeCheck; } });
-Object.defineProperty(exports, "TypeCompilerTypeGuardError", { enumerable: true, get: function () { return compiler_1.TypeCompilerTypeGuardError; } });
-Object.defineProperty(exports, "TypeCompilerUnknownTypeError", { enumerable: true, get: function () { return compiler_1.TypeCompilerUnknownTypeError; } });
+__exportStar(require("./compiler"), exports);

package/build/require/errors/index.d.ts

@@ -1,2 +1,2 @@
-export { Errors, ValueError, ValueErrorIterator, ValueErrorType, ValueErrorsUnknownTypeError } from './errors';
-export { DefaultErrorFunction, GetErrorFunction, SetErrorFunction, type ErrorFunction, type ErrorFunctionParameter } from './function';
+export * from './errors';
+export * from './function';

package/build/require/errors/index.js

@@ -1,13 +1,19 @@
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetErrorFunction = exports.GetErrorFunction = exports.DefaultErrorFunction = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = exports.ValueErrorIterator = exports.Errors = void 0;
-var errors_1 = require("./errors");
-Object.defineProperty(exports, "Errors", { enumerable: true, get: function () { return errors_1.Errors; } });
-Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return errors_1.ValueErrorIterator; } });
-Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return errors_1.ValueErrorType; } });
-Object.defineProperty(exports, "ValueErrorsUnknownTypeError", { enumerable: true, get: function () { return errors_1.ValueErrorsUnknownTypeError; } });
-var function_1 = require("./function");
-Object.defineProperty(exports, "DefaultErrorFunction", { enumerable: true, get: function () { return function_1.DefaultErrorFunction; } });
-Object.defineProperty(exports, "GetErrorFunction", { enumerable: true, get: function () { return function_1.GetErrorFunction; } });
-Object.defineProperty(exports, "SetErrorFunction", { enumerable: true, get: function () { return function_1.SetErrorFunction; } });
+__exportStar(require("./errors"), exports);
+__exportStar(require("./function"), exports);

package/build/require/index.d.ts

@@ -1,69 +1,69 @@
-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 { TypeBoxError } from './type/error/index';
-export { SetComplement, SetDistinct, SetIncludes, SetIntersect, SetIntersectMany, SetIsSubset, SetUnion, SetUnionMany, type TSetComplement, type TSetDistinct, type TSetIncludes, type TSetIntersect, type TSetIntersectMany, type TSetIsSubset, type TSetUnion, type TSetUnionMany, } from './type/sets/index';
-export { Increment, type TIncrement, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index';
-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, type 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, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from './type/exclude/index';
-export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey } from './type/extends/index';
-export { Extract, type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from './type/extract/index';
-export { Function, type TFunction } from './type/function/index';
-export { Index, IndexPropertyKeys, IndexFromPropertyKeys, IndexFromPropertyKey, IndexFromMappedKey, IndexFromMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexFromPropertyKeys, type TIndexFromPropertyKey, type TIndexFromMappedKey, type TIndexFromMappedResult, } 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, IntersectEvaluated, type TIntersect, type TIntersectEvaluated, type IntersectOptions } from './type/intersect/index';
-export { Iterator, type TIterator } from './type/iterator/index';
-export { Intrinsic, IntrinsicFromMappedKey, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index';
-export { KeyOf, KeyOfPropertyKeys, KeyOfPropertyKeysToRest, KeyOfFromMappedResult, KeyOfPattern, type TKeyOf, type TKeyOfPropertyKeys, type TKeyOfPropertyKeysToRest, type TKeyOfFromMappedResult } from './type/keyof/index';
-export { Literal, type TLiteral, type TLiteralValue } from './type/literal/index';
-export { Mapped, MappedKey, MappedResult, MappedFunctionReturnType, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction, type TMappedFunctionReturnType } 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, type TOmitFromMappedKey, type TOmitFromMappedResult } from './type/omit/index';
-export { Optional, OptionalFromMappedResult, type TOptional, type TOptionalWithFlag, type TOptionalFromMappedResult } from './type/optional/index';
-export { Parameters, type TParameters } from './type/parameters/index';
-export { Partial, PartialFromMappedResult, type TPartial, type TPartialFromMappedResult } from './type/partial/index';
-export { Pick, type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from './type/pick/index';
-export { Promise, type TPromise } from './type/promise/index';
-export { Readonly, ReadonlyFromMappedResult, type TReadonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from './type/readonly/index';
-export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index';
-export { Record, type TRecord, type TRecordOrObject } 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, type RegExpOptions } from './type/regexp/index';
-export { Required, type TRequired, type TRequiredFromMappedResult } 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, type TDecodeType, type TDecodeRest, type TDecodeProperties } 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 TSymbolValue } from './type/symbol/index';
-export { TemplateLiteral, TemplateLiteralSyntax, TemplateLiteralGenerate, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralToUnion, IsTemplateLiteralFinite, TemplateLiteralExpressionGenerate, IsTemplateLiteralExpressionFinite, type TTemplateLiteral, type TTemplateLiteralSyntax, type TTemplateLiteralGenerate, type TTemplateLiteralKind, type TTemplateLiteralToUnion, type TIsTemplateLiteralFinite, } from './type/template-literal/index';
-export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransform, type TransformOptions, type TransformFunction } 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, UnionEvaluated, type TUnion, type TUnionEvaluated } 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 { Type, JsonTypeBuilder, JavaScriptTypeBuilder } from './type/type/index';
+export * from './type/clone/index';
+export * from './type/error/index';
+export * from './type/guard/index';
+export * from './type/helpers/index';
+export * from './type/patterns/index';
+export * from './type/registry/index';
+export * from './type/sets/index';
+export * from './type/symbols/index';
+export * from './type/any/index';
+export * from './type/array/index';
+export * from './type/async-iterator/index';
+export * from './type/awaited/index';
+export * from './type/bigint/index';
+export * from './type/boolean/index';
+export * from './type/composite/index';
+export * from './type/const/index';
+export * from './type/constructor/index';
+export * from './type/constructor-parameters/index';
+export * from './type/date/index';
+export * from './type/deref/index';
+export * from './type/enum/index';
+export * from './type/exclude/index';
+export * from './type/extends/index';
+export * from './type/extract/index';
+export * from './type/function/index';
+export * from './type/indexed/index';
+export * from './type/instance-type/index';
+export * from './type/integer/index';
+export * from './type/intersect/index';
+export * from './type/iterator/index';
+export * from './type/intrinsic/index';
+export * from './type/keyof/index';
+export * from './type/literal/index';
+export * from './type/mapped/index';
+export * from './type/never/index';
+export * from './type/not/index';
+export * from './type/null/index';
+export * from './type/number/index';
+export * from './type/object/index';
+export * from './type/omit/index';
+export * from './type/optional/index';
+export * from './type/parameters/index';
+export * from './type/partial/index';
+export * from './type/pick/index';
+export * from './type/promise/index';
+export * from './type/readonly/index';
+export * from './type/readonly-optional/index';
+export * from './type/record/index';
+export * from './type/recursive/index';
+export * from './type/ref/index';
+export * from './type/regexp/index';
+export * from './type/required/index';
+export * from './type/rest/index';
+export * from './type/return-type/index';
+export * from './type/schema/index';
+export * from './type/static/index';
+export * from './type/strict/index';
+export * from './type/string/index';
+export * from './type/symbol/index';
+export * from './type/template-literal/index';
+export * from './type/transform/index';
+export * from './type/tuple/index';
+export * from './type/uint8array/index';
+export * from './type/undefined/index';
+export * from './type/union/index';
+export * from './type/unknown/index';
+export * from './type/unsafe/index';
+export * from './type/void/index';
+export * from './type/type/index';