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

package/build/import/type/extends/extends-undefined.mjs

@@ -1,4 +1,32 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { Kind } from '../symbols/index.mjs';
+/** Fast undefined check used for properties of type undefined */
 function Intersect(schema) {
     return schema.allOf.every((schema) => ExtendsUndefinedCheck(schema));
 }
@@ -8,6 +36,8 @@ function Union(schema) {
 function Not(schema) {
     return !ExtendsUndefinedCheck(schema.not);
 }
+/** Fast undefined check used for properties of type undefined */
+// prettier-ignore
 export function ExtendsUndefinedCheck(schema) {
     return (schema[Kind] === 'Intersect' ? Intersect(schema) :
         schema[Kind] === 'Union' ? Union(schema) :

package/build/import/type/extends/extends.d.mts

@@ -8,7 +8,10 @@ import { type TExtendsFromMappedResult } from './extends-from-mapped-result.mjs'
 type ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = ((Static<L> extends Static<R> ? T : U) extends infer O extends TSchema ? UnionToTuple<O> extends [infer X extends TSchema, infer Y extends TSchema] ? TUnion<[X, Y]> : O : never);
 declare function ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U): ExtendsResolve<L, R, T, U>;
 export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema> = ExtendsResolve<L, R, T, F>;
+/** `[Json]` Creates a Conditional type */
 export declare function Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>;
+/** `[Json]` Creates a Conditional type */
 export declare function Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedKey<L, R, T, F>;
+/** `[Json]` Creates a Conditional type */
 export declare function Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
 export {};

package/build/import/type/extends/extends.mjs

@@ -1,16 +1,50 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { Union } from '../union/index.mjs';
 import { ExtendsCheck, ExtendsResult } from './extends-check.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { ExtendsFromMappedKey } from './extends-from-mapped-key.mjs';
 import { ExtendsFromMappedResult } from './extends-from-mapped-result.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TMappedKey as IsMappedKeyType, TMappedResult as IsMappedResultType } from '../guard/type.mjs';
+// prettier-ignore
 function ExtendsResolve(left, right, trueType, falseType) {
     const R = ExtendsCheck(left, right);
     return (R === ExtendsResult.Union ? Union([trueType, falseType]) :
         R === ExtendsResult.True ? trueType :
             falseType);
 }
+/** `[Json]` Creates a Conditional type */
 export function Extends(L, R, T, F, options = {}) {
+    // prettier-ignore
     return (IsMappedResultType(L) ? ExtendsFromMappedResult(L, R, T, F, options) :
         IsMappedKeyType(L) ? CloneType(ExtendsFromMappedKey(L, R, T, F, options)) :
             CloneType(ExtendsResolve(L, R, T, F), options));

package/build/import/type/extends/index.mjs

@@ -1,3 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 export * from './extends-check.mjs';
 export * from './extends-from-mapped-key.mjs';
 export * from './extends-from-mapped-result.mjs';

package/build/import/type/extract/extract-from-mapped-result.mjs

@@ -1,13 +1,43 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { MappedResult } from '../mapped/index.mjs';
 import { Extract } from './extract.mjs';
+// prettier-ignore
 function FromProperties(K, U, options) {
     return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
         return { ...Acc, [K2]: Extract(K[K2], U, options) };
     }, {});
 }
+// prettier-ignore
 function FromMappedResult(K, U, options) {
     return FromProperties(K.properties, U, options);
 }
+// prettier-ignore
 export function ExtractFromMappedResult(T, U, options) {
     const P = FromMappedResult(T, U, options);
     return MappedResult(P);

package/build/import/type/extract/extract.d.mts

@@ -17,6 +17,8 @@ type FromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple
 export type ExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T, U> : T extends TUnion<infer S> ? FromArray<S, U> : T extends U ? T : T);
 export declare function ExtractResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExtractResolve<L, R>;
 export type TExtract<T extends TSchema, U extends TSchema> = ExtractResolve<T, U>;
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
 export declare function Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
 export declare function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
 export {};

package/build/import/type/extract/extract.mjs

@@ -1,10 +1,39 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { TemplateLiteralToUnion } from '../template-literal/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Never } from '../never/index.mjs';
 import { ExtendsCheck, ExtendsResult } from '../extends/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { ExtractFromMappedResult } from './extract-from-mapped-result.mjs';
+// prettier-ignore
 import { TMappedResult as IsMappedResultType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType } from '../guard/type.mjs';
+// prettier-ignore
 export function ExtractResolve(L, R) {
     return (IsTemplateLiteralType(L) ? ExtractResolve(TemplateLiteralToUnion(L), R) :
         IsTemplateLiteralType(R) ? ExtractResolve(L, TemplateLiteralToUnion(R)) :
@@ -15,6 +44,7 @@ export function ExtractResolve(L, R) {
                 ExtendsCheck(L, R) !== ExtendsResult.False ? L :
                     Never());
 }
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
 export function Extract(type, union, options = {}) {
     if (IsMappedResultType(type)) {
         return ExtractFromMappedResult(type, union, options);

package/build/import/type/extract/index.mjs

@@ -1,2 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 export * from './extract-from-mapped-result.mjs';
 export * from './extract.mjs';

package/build/import/type/function/function.d.mts

@@ -12,5 +12,6 @@ export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema =
     parameters: T;
     returns: U;
 }
+/** `[JavaScript]` Creates a Function type */
 export declare function Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
 export {};

package/build/import/type/function/function.mjs

@@ -1,5 +1,33 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { CloneType, CloneRest } from '../clone/type.mjs';
 import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a Function type */
 export function Function(parameters, returns, options) {
     return {
         ...options,

package/build/import/type/function/index.mjs

@@ -1 +1,28 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 export * from './function.mjs';

package/build/import/type/guard/index.mjs

@@ -1,2 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 export * as TypeGuard from './type.mjs';
 export * as ValueGuard from './value.mjs';

package/build/import/type/guard/type.d.mts

@@ -37,57 +37,103 @@ import type { TDate } from '../date/index.mjs';
 import type { TThis } from '../recursive/index.mjs';
 export declare class TypeGuardUnknownTypeError extends Error {
 }
+/** Returns true if this value has a Readonly symbol */
 export declare function TReadonly<T extends TSchema>(value: T): value is TReadonly<T>;
+/** Returns true if this value has a Optional symbol */
 export declare function TOptional<T extends TSchema>(value: T): value is TOptional<T>;
+/** Returns true if the given value is TAny */
 export declare function TAny(value: unknown): value is TAny;
+/** Returns true if the given value is TArray */
 export declare function TArray(value: unknown): value is TArray;
+/** Returns true if the given value is TAsyncIterator */
 export declare function TAsyncIterator(value: unknown): value is TAsyncIterator;
+/** Returns true if the given value is TBigInt */
 export declare function TBigInt(value: unknown): value is TBigInt;
+/** Returns true if the given value is TBoolean */
 export declare function TBoolean(value: unknown): value is TBoolean;
+/** Returns true if the given value is TConstructor */
 export declare function TConstructor(value: unknown): value is TConstructor;
+/** Returns true if the given value is TDate */
 export declare function TDate(value: unknown): value is TDate;
+/** Returns true if the given value is TFunction */
 export declare function TFunction(value: unknown): value is TFunction;
+/** Returns true if the given value is TInteger */
 export declare function TInteger(value: unknown): value is TInteger;
+/** Returns true if the given schema is TProperties */
 export declare function TProperties(value: unknown): value is TProperties;
+/** Returns true if the given value is TIntersect */
 export declare function TIntersect(value: unknown): value is TIntersect;
+/** Returns true if the given value is TIterator */
 export declare function TIterator(value: unknown): value is TIterator;
+/** Returns true if the given value is a TKind with the given name. */
 export declare function TKindOf<T extends string>(value: unknown, kind: T): value is Record<PropertyKey, unknown> & {
     [Kind]: T;
 };
+/** Returns true if the given value is TLiteral<string> */
 export declare function TLiteralString(value: unknown): value is TLiteral<string>;
+/** Returns true if the given value is TLiteral<number> */
 export declare function TLiteralNumber(value: unknown): value is TLiteral<number>;
+/** Returns true if the given value is TLiteral<boolean> */
 export declare function TLiteralBoolean(value: unknown): value is TLiteral<boolean>;
+/** Returns true if the given value is TLiteral */
 export declare function TLiteral(value: unknown): value is TLiteral;
+/** Returns true if the given value is a TLiteralValue */
 export declare function TLiteralValue(value: unknown): value is TLiteralValue;
+/** Returns true if the given value is a TMappedKey */
 export declare function TMappedKey(value: unknown): value is TMappedKey;
+/** Returns true if the given value is TMappedResult */
 export declare function TMappedResult(value: unknown): value is TMappedResult;
+/** Returns true if the given value is TNever */
 export declare function TNever(value: unknown): value is TNever;
+/** Returns true if the given value is TNot */
 export declare function TNot(value: unknown): value is TNot;
+/** Returns true if the given value is TNull */
 export declare function TNull(value: unknown): value is TNull;
+/** Returns true if the given value is TNumber */
 export declare function TNumber(value: unknown): value is TNumber;
+/** Returns true if the given value is TObject */
 export declare function TObject(value: unknown): value is TObject;
+/** Returns true if the given value is TPromise */
 export declare function TPromise(value: unknown): value is TPromise;
+/** Returns true if the given value is TRecord */
 export declare function TRecord(value: unknown): value is TRecord;
+/** Returns true if this value is TRecursive */
 export declare function TRecursive(value: unknown): value is {
     [Hint]: 'Recursive';
 };
+/** Returns true if the given value is TRef */
 export declare function TRef(value: unknown): value is TRef;
+/** Returns true if the given value is TString */
 export declare function TString(value: unknown): value is TString;
+/** Returns true if the given value is TSymbol */
 export declare function TSymbol(value: unknown): value is TSymbol;
+/** Returns true if the given value is TTemplateLiteral */
 export declare function TTemplateLiteral(value: unknown): value is TTemplateLiteral<TTemplateLiteralKind[]>;
+/** Returns true if the given value is TThis */
 export declare function TThis(value: unknown): value is TThis;
+/** Returns true of this value is TTransform */
 export declare function TTransform(value: unknown): value is {
     [TransformKind]: TransformOptions;
 };
+/** Returns true if the given value is TTuple */
 export declare function TTuple(value: unknown): value is TTuple;
+/** Returns true if the given value is TUndefined */
 export declare function TUndefined(value: unknown): value is TUndefined;
+/** Returns true if the given value is TUnion<Literal<string | number>[]> */
 export declare function TUnionLiteral(value: unknown): value is TUnion<TLiteral[]>;
+/** Returns true if the given value is TUnion */
 export declare function TUnion(value: unknown): value is TUnion;
+/** Returns true if the given value is TUint8Array */
 export declare function TUint8Array(value: unknown): value is TUint8Array;
+/** Returns true if the given value is TUnknown */
 export declare function TUnknown(value: unknown): value is TUnknown;
+/** Returns true if the given value is a raw TUnsafe */
 export declare function TUnsafe(value: unknown): value is TUnsafe<unknown>;
+/** Returns true if the given value is TVoid */
 export declare function TVoid(value: unknown): value is TVoid;
+/** Returns true if the given value is TKind */
 export declare function TKind(value: unknown): value is Record<PropertyKey, unknown> & {
     [Kind]: string;
 };
+/** Returns true if the given value is TSchema */
 export declare function TSchema(value: unknown): value is TSchema;