@sinclair/typebox 0.32.0-dev-17 → 0.32.0-dev-19

package/build/require/type/guard/type.js

@@ -1,33 +1,7 @@
 "use strict";
-/*--------------------------------------------------------------------------
 
-@sinclair/typebox/type
-
-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.TSchema = exports.TKind = exports.TVoid = exports.TUnsafe = exports.TUnknown = exports.TUint8Array = exports.TUnion = exports.TUnionLiteral = exports.TUndefined = exports.TTuple = exports.TTransform = exports.TThis = exports.TTemplateLiteral = exports.TSymbol = exports.TString = exports.TRef = exports.TRecursive = exports.TRecord = exports.TPromise = exports.TObject = exports.TNumber = exports.TNull = exports.TNot = exports.TNever = exports.TMappedResult = exports.TMappedKey = exports.TLiteralValue = exports.TLiteral = exports.TLiteralBoolean = exports.TLiteralNumber = exports.TLiteralString = exports.TKindOf = exports.TIterator = exports.TIntersect = exports.TProperties = exports.TInteger = exports.TFunction = exports.TDate = exports.TConstructor = exports.TBoolean = exports.TBigInt = exports.TAsyncIterator = exports.TArray = exports.TAny = exports.TOptional = exports.TReadonly = exports.TypeGuardUnknownTypeError = void 0;
+exports.IsSchema = exports.IsKind = exports.IsVoid = exports.IsUnsafe = exports.IsUnknown = exports.IsUint8Array = exports.IsUnion = exports.IsUnionLiteral = exports.IsUndefined = exports.IsTuple = exports.IsTransform = exports.IsThis = exports.IsTemplateLiteral = exports.IsSymbol = exports.IsString = exports.IsRef = exports.IsRecursive = exports.IsRecord = exports.IsPromise = exports.IsObject = exports.IsNumber = exports.IsNull = exports.IsNot = exports.IsNever = exports.IsMappedResult = exports.IsMappedKey = exports.IsLiteralValue = exports.IsLiteral = exports.IsLiteralBoolean = exports.IsLiteralNumber = exports.IsLiteralString = exports.IsKindOf = exports.IsIterator = exports.IsIntersect = exports.IsProperties = exports.IsInteger = exports.IsFunction = exports.IsDate = exports.IsConstructor = exports.IsBoolean = exports.IsBigInt = exports.IsAsyncIterator = exports.IsArray = exports.IsAny = exports.IsOptional = exports.IsReadonly = exports.TypeGuardUnknownTypeError = void 0;
 const ValueGuard = require("./value");
 const index_1 = require("../symbols/index");
 class TypeGuardUnknownTypeError extends Error {
@@ -88,7 +62,7 @@ function IsControlCharacterFree(value) {
     return true;
 }
 function IsAdditionalProperties(value) {
-    return IsOptionalBoolean(value) || (0, index_2.TSchema)(value);
+    return IsOptionalBoolean(value) || IsSchema(value);
 }
 function IsOptionalBigInt(value) {
     return ValueGuard.IsUndefined(value) || ValueGuard.IsBigInt(value);
@@ -109,37 +83,37 @@ function IsOptionalFormat(value) {
     return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value));
 }
 function IsOptionalSchema(value) {
-    return ValueGuard.IsUndefined(value) || (0, index_2.TSchema)(value);
+    return ValueGuard.IsUndefined(value) || IsSchema(value);
 }
 // ------------------------------------------------------------------
 // Modifiers
 // ------------------------------------------------------------------
 /** Returns true if this value has a Readonly symbol */
-function TReadonly(value) {
+function IsReadonly(value) {
     return ValueGuard.IsObject(value) && value[index_1.ReadonlyKind] === 'Readonly';
 }
-exports.TReadonly = TReadonly;
+exports.IsReadonly = IsReadonly;
 /** Returns true if this value has a Optional symbol */
-function TOptional(value) {
+function IsOptional(value) {
     return ValueGuard.IsObject(value) && value[index_1.OptionalKind] === 'Optional';
 }
-exports.TOptional = TOptional;
+exports.IsOptional = IsOptional;
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
 /** Returns true if the given value is TAny */
-function TAny(value) {
+function IsAny(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Any') &&
+    return (IsKindOf(value, 'Any') &&
         IsOptionalString(value.$id));
 }
-exports.TAny = TAny;
+exports.IsAny = IsAny;
 /** Returns true if the given value is TArray */
-function TArray(value) {
-    return (TKindOf(value, 'Array') &&
+function IsArray(value) {
+    return (IsKindOf(value, 'Array') &&
         value.type === 'array' &&
         IsOptionalString(value.$id) &&
-        (0, index_2.TSchema)(value.items) &&
+        IsSchema(value.items) &&
         IsOptionalNumber(value.minItems) &&
         IsOptionalNumber(value.maxItems) &&
         IsOptionalBoolean(value.uniqueItems) &&
@@ -147,20 +121,20 @@ function TArray(value) {
         IsOptionalNumber(value.minContains) &&
         IsOptionalNumber(value.maxContains));
 }
-exports.TArray = TArray;
+exports.IsArray = IsArray;
 /** Returns true if the given value is TAsyncIterator */
-function TAsyncIterator(value) {
+function IsAsyncIterator(value) {
     // prettier-ignore
-    return (TKindOf(value, 'AsyncIterator') &&
+    return (IsKindOf(value, 'AsyncIterator') &&
         value.type === 'AsyncIterator' &&
         IsOptionalString(value.$id) &&
-        (0, index_2.TSchema)(value.items));
+        IsSchema(value.items));
 }
-exports.TAsyncIterator = TAsyncIterator;
+exports.IsAsyncIterator = IsAsyncIterator;
 /** Returns true if the given value is TBigInt */
-function TBigInt(value) {
+function IsBigInt(value) {
     // prettier-ignore
-    return (TKindOf(value, 'BigInt') &&
+    return (IsKindOf(value, 'BigInt') &&
         value.type === 'bigint' &&
         IsOptionalString(value.$id) &&
         IsOptionalBigInt(value.exclusiveMaximum) &&
@@ -169,29 +143,29 @@ function TBigInt(value) {
         IsOptionalBigInt(value.minimum) &&
         IsOptionalBigInt(value.multipleOf));
 }
-exports.TBigInt = TBigInt;
+exports.IsBigInt = IsBigInt;
 /** Returns true if the given value is TBoolean */
-function TBoolean(value) {
+function IsBoolean(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Boolean') &&
+    return (IsKindOf(value, 'Boolean') &&
         value.type === 'boolean' &&
         IsOptionalString(value.$id));
 }
-exports.TBoolean = TBoolean;
+exports.IsBoolean = IsBoolean;
 /** Returns true if the given value is TConstructor */
-function TConstructor(value) {
+function IsConstructor(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Constructor') &&
+    return (IsKindOf(value, 'Constructor') &&
         value.type === 'Constructor' &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsArray(value.parameters) &&
-        value.parameters.every(schema => (0, index_2.TSchema)(schema)) &&
-        (0, index_2.TSchema)(value.returns));
+        value.parameters.every(schema => IsSchema(schema)) &&
+        IsSchema(value.returns));
 }
-exports.TConstructor = TConstructor;
+exports.IsConstructor = IsConstructor;
 /** Returns true if the given value is TDate */
-function TDate(value) {
-    return (TKindOf(value, 'Date') &&
+function IsDate(value) {
+    return (IsKindOf(value, 'Date') &&
         value.type === 'Date' &&
         IsOptionalString(value.$id) &&
         IsOptionalNumber(value.exclusiveMaximumTimestamp) &&
@@ -200,21 +174,21 @@ function TDate(value) {
         IsOptionalNumber(value.minimumTimestamp) &&
         IsOptionalNumber(value.multipleOfTimestamp));
 }
-exports.TDate = TDate;
+exports.IsDate = IsDate;
 /** Returns true if the given value is TFunction */
-function TFunction(value) {
+function IsFunction(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Function') &&
+    return (IsKindOf(value, 'Function') &&
         value.type === 'Function' &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsArray(value.parameters) &&
-        value.parameters.every(schema => (0, index_2.TSchema)(schema)) &&
-        (0, index_2.TSchema)(value.returns));
+        value.parameters.every(schema => IsSchema(schema)) &&
+        IsSchema(value.returns));
 }
-exports.TFunction = TFunction;
+exports.IsFunction = IsFunction;
 /** Returns true if the given value is TInteger */
-function TInteger(value) {
-    return (TKindOf(value, 'Integer') &&
+function IsInteger(value) {
+    return (IsKindOf(value, 'Integer') &&
         value.type === 'integer' &&
         IsOptionalString(value.$id) &&
         IsOptionalNumber(value.exclusiveMaximum) &&
@@ -223,108 +197,108 @@ function TInteger(value) {
         IsOptionalNumber(value.minimum) &&
         IsOptionalNumber(value.multipleOf));
 }
-exports.TInteger = TInteger;
+exports.IsInteger = IsInteger;
 /** Returns true if the given schema is TProperties */
-function TProperties(value) {
+function IsProperties(value) {
     // prettier-ignore
     return (ValueGuard.IsObject(value) &&
-        Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && (0, index_2.TSchema)(schema)));
+        Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema(schema)));
 }
-exports.TProperties = TProperties;
+exports.IsProperties = IsProperties;
 /** Returns true if the given value is TIntersect */
-function TIntersect(value) {
+function IsIntersect(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Intersect') &&
+    return (IsKindOf(value, 'Intersect') &&
         (ValueGuard.IsString(value.type) && value.type !== 'object' ? false : true) &&
         ValueGuard.IsArray(value.allOf) &&
-        value.allOf.every(schema => (0, index_2.TSchema)(schema) && !TTransform(schema)) &&
+        value.allOf.every(schema => IsSchema(schema) && !IsTransform(schema)) &&
         IsOptionalString(value.type) &&
         (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) &&
         IsOptionalString(value.$id));
 }
-exports.TIntersect = TIntersect;
+exports.IsIntersect = IsIntersect;
 /** Returns true if the given value is TIterator */
-function TIterator(value) {
+function IsIterator(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Iterator') &&
+    return (IsKindOf(value, 'Iterator') &&
         value.type === 'Iterator' &&
         IsOptionalString(value.$id) &&
-        (0, index_2.TSchema)(value.items));
+        IsSchema(value.items));
 }
-exports.TIterator = TIterator;
+exports.IsIterator = IsIterator;
 /** Returns true if the given value is a TKind with the given name. */
-function TKindOf(value, kind) {
+function IsKindOf(value, kind) {
     return ValueGuard.IsObject(value) && index_1.Kind in value && value[index_1.Kind] === kind;
 }
-exports.TKindOf = TKindOf;
+exports.IsKindOf = IsKindOf;
 /** Returns true if the given value is TLiteral<string> */
-function TLiteralString(value) {
-    return (0, index_3.TLiteral)(value) && ValueGuard.IsString(value.const);
+function IsLiteralString(value) {
+    return IsLiteral(value) && ValueGuard.IsString(value.const);
 }
-exports.TLiteralString = TLiteralString;
+exports.IsLiteralString = IsLiteralString;
 /** Returns true if the given value is TLiteral<number> */
-function TLiteralNumber(value) {
-    return (0, index_3.TLiteral)(value) && ValueGuard.IsNumber(value.const);
+function IsLiteralNumber(value) {
+    return IsLiteral(value) && ValueGuard.IsNumber(value.const);
 }
-exports.TLiteralNumber = TLiteralNumber;
+exports.IsLiteralNumber = IsLiteralNumber;
 /** Returns true if the given value is TLiteral<boolean> */
-function TLiteralBoolean(value) {
-    return (0, index_3.TLiteral)(value) && ValueGuard.IsBoolean(value.const);
+function IsLiteralBoolean(value) {
+    return IsLiteral(value) && ValueGuard.IsBoolean(value.const);
 }
-exports.TLiteralBoolean = TLiteralBoolean;
+exports.IsLiteralBoolean = IsLiteralBoolean;
 /** Returns true if the given value is TLiteral */
-function TLiteral(value) {
+function IsLiteral(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Literal') &&
-        IsOptionalString(value.$id) && (0, index_3.TLiteralValue)(value.const));
+    return (IsKindOf(value, 'Literal') &&
+        IsOptionalString(value.$id) && IsLiteralValue(value.const));
 }
-exports.TLiteral = TLiteral;
+exports.IsLiteral = IsLiteral;
 /** Returns true if the given value is a TLiteralValue */
-function TLiteralValue(value) {
+function IsLiteralValue(value) {
     return ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value) || ValueGuard.IsString(value);
 }
-exports.TLiteralValue = TLiteralValue;
+exports.IsLiteralValue = IsLiteralValue;
 /** Returns true if the given value is a TMappedKey */
-function TMappedKey(value) {
+function IsMappedKey(value) {
     // prettier-ignore
-    return (TKindOf(value, 'MappedKey') &&
+    return (IsKindOf(value, 'MappedKey') &&
         ValueGuard.IsArray(value.keys) &&
         value.keys.every(key => ValueGuard.IsNumber(key) || ValueGuard.IsString(key)));
 }
-exports.TMappedKey = TMappedKey;
+exports.IsMappedKey = IsMappedKey;
 /** Returns true if the given value is TMappedResult */
-function TMappedResult(value) {
+function IsMappedResult(value) {
     // prettier-ignore
-    return (TKindOf(value, 'MappedResult') &&
-        (0, index_4.TProperties)(value.properties));
+    return (IsKindOf(value, 'MappedResult') &&
+        IsProperties(value.properties));
 }
-exports.TMappedResult = TMappedResult;
+exports.IsMappedResult = IsMappedResult;
 /** Returns true if the given value is TNever */
-function TNever(value) {
+function IsNever(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Never') &&
+    return (IsKindOf(value, 'Never') &&
         ValueGuard.IsObject(value.not) &&
         Object.getOwnPropertyNames(value.not).length === 0);
 }
-exports.TNever = TNever;
+exports.IsNever = IsNever;
 /** Returns true if the given value is TNot */
-function TNot(value) {
+function IsNot(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Not') &&
-        (0, index_2.TSchema)(value.not));
+    return (IsKindOf(value, 'Not') &&
+        IsSchema(value.not));
 }
-exports.TNot = TNot;
+exports.IsNot = IsNot;
 /** Returns true if the given value is TNull */
-function TNull(value) {
+function IsNull(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Null') &&
+    return (IsKindOf(value, 'Null') &&
         value.type === 'null' &&
         IsOptionalString(value.$id));
 }
-exports.TNull = TNull;
+exports.IsNull = IsNull;
 /** Returns true if the given value is TNumber */
-function TNumber(value) {
-    return (TKindOf(value, 'Number') &&
+function IsNumber(value) {
+    return (IsKindOf(value, 'Number') &&
         value.type === 'number' &&
         IsOptionalString(value.$id) &&
         IsOptionalNumber(value.exclusiveMaximum) &&
@@ -333,32 +307,32 @@ function TNumber(value) {
         IsOptionalNumber(value.minimum) &&
         IsOptionalNumber(value.multipleOf));
 }
-exports.TNumber = TNumber;
+exports.IsNumber = IsNumber;
 /** Returns true if the given value is TObject */
-function TObject(value) {
+function IsObject(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Object') &&
+    return (IsKindOf(value, 'Object') &&
         value.type === 'object' &&
         IsOptionalString(value.$id) &&
-        (0, index_4.TProperties)(value.properties) &&
+        IsProperties(value.properties) &&
         IsAdditionalProperties(value.additionalProperties) &&
         IsOptionalNumber(value.minProperties) &&
         IsOptionalNumber(value.maxProperties));
 }
-exports.TObject = TObject;
+exports.IsObject = IsObject;
 /** Returns true if the given value is TPromise */
-function TPromise(value) {
+function IsPromise(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Promise') &&
+    return (IsKindOf(value, 'Promise') &&
         value.type === 'Promise' &&
         IsOptionalString(value.$id) &&
-        (0, index_2.TSchema)(value.item));
+        IsSchema(value.item));
 }
-exports.TPromise = TPromise;
+exports.IsPromise = IsPromise;
 /** Returns true if the given value is TRecord */
-function TRecord(value) {
+function IsRecord(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Record') &&
+    return (IsKindOf(value, 'Record') &&
         value.type === 'object' &&
         IsOptionalString(value.$id) &&
         IsAdditionalProperties(value.additionalProperties) &&
@@ -368,27 +342,27 @@ function TRecord(value) {
             return (keys.length === 1 &&
                 IsPattern(keys[0]) &&
                 ValueGuard.IsObject(schema.patternProperties) &&
-                (0, index_2.TSchema)(schema.patternProperties[keys[0]]));
+                IsSchema(schema.patternProperties[keys[0]]));
         })(value));
 }
-exports.TRecord = TRecord;
+exports.IsRecord = IsRecord;
 /** Returns true if this value is TRecursive */
-function TRecursive(value) {
+function IsRecursive(value) {
     return ValueGuard.IsObject(value) && index_1.Hint in value && value[index_1.Hint] === 'Recursive';
 }
-exports.TRecursive = TRecursive;
+exports.IsRecursive = IsRecursive;
 /** Returns true if the given value is TRef */
-function TRef(value) {
+function IsRef(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Ref') &&
+    return (IsKindOf(value, 'Ref') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsString(value.$ref));
 }
-exports.TRef = TRef;
+exports.IsRef = IsRef;
 /** Returns true if the given value is TString */
-function TString(value) {
+function IsString(value) {
     // prettier-ignore
-    return (TKindOf(value, 'String') &&
+    return (IsKindOf(value, 'String') &&
         value.type === 'string' &&
         IsOptionalString(value.$id) &&
         IsOptionalNumber(value.minLength) &&
@@ -396,42 +370,42 @@ function TString(value) {
         IsOptionalPattern(value.pattern) &&
         IsOptionalFormat(value.format));
 }
-exports.TString = TString;
+exports.IsString = IsString;
 /** Returns true if the given value is TSymbol */
-function TSymbol(value) {
+function IsSymbol(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Symbol') &&
+    return (IsKindOf(value, 'Symbol') &&
         value.type === 'symbol' &&
         IsOptionalString(value.$id));
 }
-exports.TSymbol = TSymbol;
+exports.IsSymbol = IsSymbol;
 /** Returns true if the given value is TTemplateLiteral */
-function TTemplateLiteral(value) {
+function IsTemplateLiteral(value) {
     // prettier-ignore
-    return (TKindOf(value, 'TemplateLiteral') &&
+    return (IsKindOf(value, 'TemplateLiteral') &&
         value.type === 'string' &&
         ValueGuard.IsString(value.pattern) &&
         value.pattern[0] === '^' &&
         value.pattern[value.pattern.length - 1] === '$');
 }
-exports.TTemplateLiteral = TTemplateLiteral;
+exports.IsTemplateLiteral = IsTemplateLiteral;
 /** Returns true if the given value is TThis */
-function TThis(value) {
+function IsThis(value) {
     // prettier-ignore
-    return (TKindOf(value, 'This') &&
+    return (IsKindOf(value, 'This') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsString(value.$ref));
 }
-exports.TThis = TThis;
+exports.IsThis = IsThis;
 /** Returns true of this value is TTransform */
-function TTransform(value) {
+function IsTransform(value) {
     return ValueGuard.IsObject(value) && index_1.TransformKind in value;
 }
-exports.TTransform = TTransform;
+exports.IsTransform = IsTransform;
 /** Returns true if the given value is TTuple */
-function TTuple(value) {
+function IsTuple(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Tuple') &&
+    return (IsKindOf(value, 'Tuple') &&
         value.type === 'array' &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsNumber(value.minItems) &&
@@ -441,103 +415,103 @@ function TTuple(value) {
         ValueGuard.IsUndefined(value.items) &&
             ValueGuard.IsUndefined(value.additionalItems) &&
             value.minItems === 0) || (ValueGuard.IsArray(value.items) &&
-            value.items.every(schema => (0, index_2.TSchema)(schema)))));
+            value.items.every(schema => IsSchema(schema)))));
 }
-exports.TTuple = TTuple;
+exports.IsTuple = IsTuple;
 /** Returns true if the given value is TUndefined */
-function TUndefined(value) {
+function IsUndefined(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Undefined') &&
+    return (IsKindOf(value, 'Undefined') &&
         value.type === 'undefined' &&
         IsOptionalString(value.$id));
 }
-exports.TUndefined = TUndefined;
+exports.IsUndefined = IsUndefined;
 /** Returns true if the given value is TUnion<Literal<string | number>[]> */
-function TUnionLiteral(value) {
-    return (0, index_5.TUnion)(value) && value.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
+function IsUnionLiteral(value) {
+    return IsUnion(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
 }
-exports.TUnionLiteral = TUnionLiteral;
+exports.IsUnionLiteral = IsUnionLiteral;
 /** Returns true if the given value is TUnion */
-function TUnion(value) {
+function IsUnion(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Union') &&
+    return (IsKindOf(value, 'Union') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsObject(value) &&
         ValueGuard.IsArray(value.anyOf) &&
-        value.anyOf.every(schema => (0, index_2.TSchema)(schema)));
+        value.anyOf.every(schema => IsSchema(schema)));
 }
-exports.TUnion = TUnion;
+exports.IsUnion = IsUnion;
 /** Returns true if the given value is TUint8Array */
-function TUint8Array(value) {
+function IsUint8Array(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Uint8Array') &&
+    return (IsKindOf(value, 'Uint8Array') &&
         value.type === 'Uint8Array' &&
         IsOptionalString(value.$id) &&
         IsOptionalNumber(value.minByteLength) &&
         IsOptionalNumber(value.maxByteLength));
 }
-exports.TUint8Array = TUint8Array;
+exports.IsUint8Array = IsUint8Array;
 /** Returns true if the given value is TUnknown */
-function TUnknown(value) {
+function IsUnknown(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Unknown') &&
+    return (IsKindOf(value, 'Unknown') &&
         IsOptionalString(value.$id));
 }
-exports.TUnknown = TUnknown;
+exports.IsUnknown = IsUnknown;
 /** Returns true if the given value is a raw TUnsafe */
-function TUnsafe(value) {
-    return TKindOf(value, 'Unsafe');
+function IsUnsafe(value) {
+    return IsKindOf(value, 'Unsafe');
 }
-exports.TUnsafe = TUnsafe;
+exports.IsUnsafe = IsUnsafe;
 /** Returns true if the given value is TVoid */
-function TVoid(value) {
+function IsVoid(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Void') &&
+    return (IsKindOf(value, 'Void') &&
         value.type === 'void' &&
         IsOptionalString(value.$id));
 }
-exports.TVoid = TVoid;
+exports.IsVoid = IsVoid;
 /** Returns true if the given value is TKind */
-function TKind(value) {
+function IsKind(value) {
     return ValueGuard.IsObject(value) && index_1.Kind in value && ValueGuard.IsString(value[index_1.Kind]) && !KnownTypes.includes(value[index_1.Kind]);
 }
-exports.TKind = TKind;
+exports.IsKind = IsKind;
 /** Returns true if the given value is TSchema */
-function TSchema(value) {
+function IsSchema(value) {
     // prettier-ignore
-    return (ValueGuard.IsObject(value)) && ((0, index_6.TAny)(value) ||
-        (0, index_7.TArray)(value) ||
-        (0, index_8.TBoolean)(value) ||
-        (0, index_9.TBigInt)(value) ||
-        (0, index_10.TAsyncIterator)(value) ||
-        (0, index_11.TConstructor)(value) ||
-        (0, index_12.TDate)(value) ||
-        (0, index_13.TFunction)(value) ||
-        (0, index_14.TInteger)(value) ||
-        (0, index_15.TIntersect)(value) ||
-        (0, index_16.TIterator)(value) ||
-        (0, index_3.TLiteral)(value) ||
-        (0, index_17.TMappedKey)(value) ||
-        (0, index_17.TMappedResult)(value) ||
-        (0, index_18.TNever)(value) ||
-        (0, index_19.TNot)(value) ||
-        (0, index_20.TNull)(value) ||
-        (0, index_21.TNumber)(value) ||
-        (0, index_4.TObject)(value) ||
-        (0, index_22.TPromise)(value) ||
-        (0, index_23.TRecord)(value) ||
-        (0, index_24.TRef)(value) ||
-        (0, index_25.TString)(value) ||
-        (0, index_26.TSymbol)(value) ||
-        (0, index_27.TTemplateLiteral)(value) ||
-        (0, index_28.TThis)(value) ||
-        (0, index_29.TTuple)(value) ||
-        (0, index_30.TUndefined)(value) ||
-        (0, index_5.TUnion)(value) ||
-        (0, index_31.TUint8Array)(value) ||
-        (0, index_32.TUnknown)(value) ||
-        (0, index_33.TUnsafe)(value) ||
-        (0, index_34.TVoid)(value) ||
-        TKind(value));
-}
-exports.TSchema = TSchema;
+    return (ValueGuard.IsObject(value)) && (IsAny(value) ||
+        IsArray(value) ||
+        IsBoolean(value) ||
+        IsBigInt(value) ||
+        IsAsyncIterator(value) ||
+        IsConstructor(value) ||
+        IsDate(value) ||
+        IsFunction(value) ||
+        IsInteger(value) ||
+        IsIntersect(value) ||
+        IsIterator(value) ||
+        IsLiteral(value) ||
+        IsMappedKey(value) ||
+        IsMappedResult(value) ||
+        IsNever(value) ||
+        IsNot(value) ||
+        IsNull(value) ||
+        IsNumber(value) ||
+        IsObject(value) ||
+        IsPromise(value) ||
+        IsRecord(value) ||
+        IsRef(value) ||
+        IsString(value) ||
+        IsSymbol(value) ||
+        IsTemplateLiteral(value) ||
+        IsThis(value) ||
+        IsTuple(value) ||
+        IsUndefined(value) ||
+        IsUnion(value) ||
+        IsUint8Array(value) ||
+        IsUnknown(value) ||
+        IsUnsafe(value) ||
+        IsVoid(value) ||
+        IsKind(value));
+}
+exports.IsSchema = IsSchema;