@sinclair/typebox 0.32.0-dev-3 → 0.32.0-dev-5

package/esm/type/extends/extends-undefined.mjs

@@ -1,47 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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));
-}
-function Union(schema) {
-    return schema.anyOf.some((schema) => ExtendsUndefinedCheck(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) :
-            schema[Kind] === 'Not' ? Not(schema) :
-                schema[Kind] === 'Undefined' ? true :
-                    false);
-}

package/esm/type/extends/extends.d.mts

@@ -1,9 +0,0 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Static } from '../static/index.mjs';
-import { type TUnion } from '../union/index.mjs';
-import { UnionToTuple } from '../helpers/index.mjs';
-export 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);
-export 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 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>;

package/esm/type/extends/extends.mjs

@@ -1,42 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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';
-// prettier-ignore
-export 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 = {}) {
-    const E = ExtendsResolve(L, R, T, F);
-    return CloneType(E, options);
-}

package/esm/type/extends/index.mjs

@@ -1,30 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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-undefined.mjs';
-export * from './extends.mjs';

package/esm/type/extract/extract.d.mts

@@ -1,20 +0,0 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Assert, AssertRest, AssertType, UnionToTuple } from '../helpers/index.mjs';
-import { type TTemplateLiteral } from '../template-literal/index.mjs';
-import { type TLiteral } from '../literal/index.mjs';
-import { type TUnion } from '../union/index.mjs';
-import { type Static } from '../static/index.mjs';
-import { UnionResolve } from '../union/index.mjs';
-type FromTemplateLiteralResult<T extends string> = UnionResolve<AssertRest<UnionToTuple<{
-    [K in T]: TLiteral<K>;
-}[T]>>>;
-type FromTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? FromTemplateLiteralResult<Assert<S, string>> : never;
-type FromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
-    [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never;
-}[number]>> extends infer R extends TSchema[] ? UnionResolve<R> : never;
-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 TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
-export {};

package/esm/type/extract/extract.mjs

@@ -1,49 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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 { 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)) :
-            IsUnionType(L) ? (() => {
-                const narrowed = L.anyOf.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
-                return (narrowed.length === 1 ? narrowed[0] : Union(narrowed));
-            })() :
-                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 = {}) {
-    const E = ExtractResolve(type, union);
-    return CloneType(E, options);
-}

package/esm/type/extract/index.mjs

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

package/esm/type/function/function.d.mts

@@ -1,17 +0,0 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Static } from '../static/index.mjs';
-import type { Ensure } from '../helpers/index.mjs';
-import { Kind } from '../symbols/index.mjs';
-type FunctionReturnTypeResolve<T extends TSchema, P extends unknown[]> = Static<T, P>;
-type FunctionParametersResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...FunctionParametersResolve<R, P>] : [];
-type FunctionResolve<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<(...param: FunctionParametersResolve<T, P>) => FunctionReturnTypeResolve<U, P>>);
-export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
-    [Kind]: 'Function';
-    static: FunctionResolve<T, U, this['params']>;
-    type: 'Function';
-    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/esm/type/function/function.mjs

@@ -1,39 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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,
-        [Kind]: 'Function',
-        type: 'Function',
-        parameters: CloneRest(parameters),
-        returns: CloneType(returns),
-    };
-}

package/esm/type/function/index.mjs

@@ -1,28 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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/esm/type/guard/index.mjs

@@ -1,29 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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/esm/type/guard/type.d.mts

@@ -1,130 +0,0 @@
-import { Kind, Hint, TransformKind } from '../symbols/index.mjs';
-import type { TransformOptions } from '../transform/index.mjs';
-import type { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index.mjs';
-import type { TArray } from '../array/index.mjs';
-import type { TBoolean } from '../boolean/index.mjs';
-import type { TRecord } from '../record/index.mjs';
-import type { TString } from '../string/index.mjs';
-import type { TUnion } from '../union/index.mjs';
-import type { TAny } from '../any/index.mjs';
-import type { TAsyncIterator } from '../async-iterator/index.mjs';
-import type { TBigInt } from '../bigint/index.mjs';
-import type { TConstructor } from '../constructor/index.mjs';
-import type { TFunction } from '../function/index.mjs';
-import type { TInteger } from '../integer/index.mjs';
-import type { TIntersect } from '../intersect/index.mjs';
-import type { TIterator } from '../iterator/index.mjs';
-import type { TLiteral } from '../literal/index.mjs';
-import type { TNever } from '../never/index.mjs';
-import type { TNot } from '../not/index.mjs';
-import type { TNull } from '../null/index.mjs';
-import type { TNumber } from '../number/index.mjs';
-import type { TObject } from '../object/index.mjs';
-import type { TOptional } from '../optional/index.mjs';
-import type { TPromise } from '../promise/index.mjs';
-import type { TReadonly } from '../readonly/index.mjs';
-import type { TRef } from '../ref/index.mjs';
-import type { TSchema } from '../schema/index.mjs';
-import type { TSymbol } from '../symbol/index.mjs';
-import type { TTuple } from '../tuple/index.mjs';
-import type { TUint8Array } from '../uint8array/index.mjs';
-import type { TUndefined } from '../undefined/index.mjs';
-import type { TUnknown } from '../unknown/index.mjs';
-import type { TUnsafe } from '../unsafe/index.mjs';
-import type { TVoid } from '../void/index.mjs';
-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>(schema: T): schema is TReadonly<T>;
-/** Returns true if this value has a Optional symbol */
-export declare function TOptional<T extends TSchema>(schema: T): schema is TOptional<T>;
-/** Returns true if the given value is TAny */
-export declare function TAny(schema: unknown): schema is TAny;
-/** Returns true if the given value is TArray */
-export declare function TArray(schema: unknown): schema is TArray;
-/** Returns true if the given value is TAsyncIterator */
-export declare function TAsyncIterator(schema: unknown): schema is TAsyncIterator;
-/** Returns true if the given value is TBigInt */
-export declare function TBigInt(schema: unknown): schema is TBigInt;
-/** Returns true if the given value is TBoolean */
-export declare function TBoolean(schema: unknown): schema is TBoolean;
-/** Returns true if the given value is TConstructor */
-export declare function TConstructor(schema: unknown): schema is TConstructor;
-/** Returns true if the given value is TDate */
-export declare function TDate(schema: unknown): schema is TDate;
-/** Returns true if the given value is TFunction */
-export declare function TFunction(schema: unknown): schema is TFunction;
-/** Returns true if the given value is TInteger */
-export declare function TInteger(schema: unknown): schema is TInteger;
-/** Returns true if the given value is TIntersect */
-export declare function TIntersect(schema: unknown): schema is TIntersect;
-/** Returns true if the given value is TIterator */
-export declare function TIterator(schema: unknown): schema is TIterator;
-/** Returns true if the given value is a TKind with the given name. */
-export declare function TKindOf<T extends string>(schema: unknown, kind: T): schema is Record<PropertyKey, unknown> & {
-    [Kind]: T;
-};
-/** Returns true if the given value is TLiteral<string> */
-export declare function TLiteralString(schema: unknown): schema is TLiteral<string>;
-/** Returns true if the given value is TLiteral<number> */
-export declare function TLiteralNumber(schema: unknown): schema is TLiteral<number>;
-/** Returns true if the given value is TLiteral<boolean> */
-export declare function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean>;
-/** Returns true if the given value is TLiteral */
-export declare function TLiteral(schema: unknown): schema is TLiteral;
-/** Returns true if the given value is TNever */
-export declare function TNever(schema: unknown): schema is TNever;
-/** Returns true if the given value is TNot */
-export declare function TNot(schema: unknown): schema is TNot;
-/** Returns true if the given value is TNull */
-export declare function TNull(schema: unknown): schema is TNull;
-/** Returns true if the given value is TNumber */
-export declare function TNumber(schema: unknown): schema is TNumber;
-/** Returns true if the given value is TObject */
-export declare function TObject(schema: unknown): schema is TObject;
-/** Returns true if the given value is TPromise */
-export declare function TPromise(schema: unknown): schema is TPromise;
-/** Returns true if the given value is TRecord */
-export declare function TRecord(schema: unknown): schema is TRecord;
-/** Returns true if this value is TRecursive */
-export declare function TRecursive(schema: unknown): schema is {
-    [Hint]: 'Recursive';
-};
-/** Returns true if the given value is TRef */
-export declare function TRef(schema: unknown): schema is TRef;
-/** Returns true if the given value is TString */
-export declare function TString(schema: unknown): schema is TString;
-/** Returns true if the given value is TSymbol */
-export declare function TSymbol(schema: unknown): schema is TSymbol;
-/** Returns true if the given value is TTemplateLiteral */
-export declare function TTemplateLiteral(schema: unknown): schema is TTemplateLiteral<TTemplateLiteralKind[]>;
-/** Returns true if the given value is TThis */
-export declare function TThis(schema: unknown): schema is TThis;
-/** Returns true of this value is TTransform */
-export declare function TTransform(schema: unknown): schema is {
-    [TransformKind]: TransformOptions;
-};
-/** Returns true if the given value is TTuple */
-export declare function TTuple(schema: unknown): schema is TTuple;
-/** Returns true if the given value is TUndefined */
-export declare function TUndefined(schema: unknown): schema is TUndefined;
-/** Returns true if the given value is TUnion<Literal<string | number>[]> */
-export declare function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral[]>;
-/** Returns true if the given value is TUnion */
-export declare function TUnion(schema: unknown): schema is TUnion;
-/** Returns true if the given value is TUint8Array */
-export declare function TUint8Array(schema: unknown): schema is TUint8Array;
-/** Returns true if the given value is TUnknown */
-export declare function TUnknown(schema: unknown): schema is TUnknown;
-/** Returns true if the given value is a raw TUnsafe */
-export declare function TUnsafe(schema: unknown): schema is TUnsafe<unknown>;
-/** Returns true if the given value is TVoid */
-export declare function TVoid(schema: unknown): schema is TVoid;
-/** Returns true if the given value is TKind */
-export declare function TKind(schema: unknown): schema is Record<PropertyKey, unknown> & {
-    [Kind]: string;
-};
-/** Returns true if the given value is TSchema */
-export declare function TSchema(schema: unknown): schema is TSchema;