@sinclair/typebox 0.31.28 → 0.32.0-dev-1

package/type/extends/extends-undefined.js

@@ -0,0 +1,51 @@
+"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.ExtendsUndefinedCheck = void 0;
+const index_1 = require("../symbols/index");
+/** 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
+function ExtendsUndefinedCheck(schema) {
+    return (schema[index_1.Kind] === 'Intersect' ? Intersect(schema) :
+        schema[index_1.Kind] === 'Union' ? Union(schema) :
+            schema[index_1.Kind] === 'Not' ? Not(schema) :
+                schema[index_1.Kind] === 'Undefined' ? true :
+                    false);
+}
+exports.ExtendsUndefinedCheck = ExtendsUndefinedCheck;

package/type/extends/extends.d.ts

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

@@ -0,0 +1,47 @@
+"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.Extends = exports.ExtendsResolve = void 0;
+const index_1 = require("../union/index");
+const extends_check_1 = require("./extends-check");
+const type_1 = require("../clone/type");
+// prettier-ignore
+function ExtendsResolve(left, right, trueType, falseType) {
+    const R = (0, extends_check_1.ExtendsCheck)(left, right);
+    return (R === extends_check_1.ExtendsResult.Union ? (0, index_1.Union)([trueType, falseType]) :
+        R === extends_check_1.ExtendsResult.True ? trueType :
+            falseType);
+}
+exports.ExtendsResolve = ExtendsResolve;
+/** `[Json]` Creates a Conditional type */
+function Extends(L, R, T, F, options = {}) {
+    const E = ExtendsResolve(L, R, T, F);
+    return (0, type_1.CloneType)(E, options);
+}
+exports.Extends = Extends;

package/type/extends/index.d.ts

@@ -0,0 +1,3 @@
+export * from './extends-check';
+export * from './extends-undefined';
+export * from './extends';

package/type/extends/index.js

@@ -0,0 +1,46 @@
+"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.
+
+---------------------------------------------------------------------------*/
+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 });
+__exportStar(require("./extends-check"), exports);
+__exportStar(require("./extends-undefined"), exports);
+__exportStar(require("./extends"), exports);

package/type/extract/extract.d.ts

@@ -0,0 +1,20 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Assert, AssertRest, AssertType, UnionToTuple } from '../helpers/index';
+import { type TTemplateLiteral } from '../template-literal/index';
+import { type TLiteral } from '../literal/index';
+import { type TUnion } from '../union/index';
+import { type Static } from '../static/index';
+import { UnionResolve } from '../union/index';
+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/type/extract/extract.js

@@ -0,0 +1,54 @@
+"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.Extract = exports.ExtractResolve = void 0;
+const index_1 = require("../template-literal/index");
+const index_2 = require("../union/index");
+const index_3 = require("../never/index");
+const index_4 = require("../extends/index");
+const type_1 = require("../clone/type");
+const type_2 = require("../guard/type");
+// prettier-ignore
+function ExtractResolve(L, R) {
+    return ((0, type_2.TTemplateLiteral)(L) ? ExtractResolve((0, index_1.TemplateLiteralToUnion)(L), R) :
+        (0, type_2.TTemplateLiteral)(R) ? ExtractResolve(L, (0, index_1.TemplateLiteralToUnion)(R)) :
+            (0, type_2.TUnion)(L) ? (() => {
+                const narrowed = L.anyOf.filter((inner) => (0, index_4.ExtendsCheck)(inner, R) !== index_4.ExtendsResult.False);
+                return (narrowed.length === 1 ? narrowed[0] : (0, index_2.Union)(narrowed));
+            })() :
+                (0, index_4.ExtendsCheck)(L, R) !== index_4.ExtendsResult.False ? L :
+                    (0, index_3.Never)());
+}
+exports.ExtractResolve = ExtractResolve;
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+function Extract(type, union, options = {}) {
+    const E = ExtractResolve(type, union);
+    return (0, type_1.CloneType)(E, options);
+}
+exports.Extract = Extract;

package/type/extract/index.d.ts

@@ -0,0 +1 @@
+export * from './extract';

package/type/extract/index.js

@@ -0,0 +1,44 @@
+"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.
+
+---------------------------------------------------------------------------*/
+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 });
+__exportStar(require("./extract"), exports);

package/type/function/function.d.ts

@@ -0,0 +1,17 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import type { Ensure } from '../helpers/index';
+import { Kind } from '../symbols/index';
+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/type/function/function.js

@@ -0,0 +1,43 @@
+"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.Function = void 0;
+const type_1 = require("../clone/type");
+const index_1 = require("../symbols/index");
+/** `[JavaScript]` Creates a Function type */
+function Function(parameters, returns, options) {
+    return {
+        ...options,
+        [index_1.Kind]: 'Function',
+        type: 'Function',
+        parameters: (0, type_1.CloneRest)(parameters),
+        returns: (0, type_1.CloneType)(returns),
+    };
+}
+exports.Function = Function;

package/type/function/index.d.ts

@@ -0,0 +1 @@
+export * from './function';

package/type/function/index.js

@@ -0,0 +1,44 @@
+"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.
+
+---------------------------------------------------------------------------*/
+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 });
+__exportStar(require("./function"), exports);

package/type/guard/index.d.ts

@@ -0,0 +1,2 @@
+export * as TypeGuard from './type';
+export * as ValueGuard from './value';

package/type/guard/index.js

@@ -0,0 +1,32 @@
+"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.ValueGuard = exports.TypeGuard = void 0;
+exports.TypeGuard = require("./type");
+exports.ValueGuard = require("./value");

package/type/guard/type.d.ts

@@ -0,0 +1,130 @@
+import { Kind, Hint, TransformKind } from '../symbols/index';
+import type { TransformOptions } from '../transform/index';
+import type { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index';
+import type { TArray } from '../array/index';
+import type { TBoolean } from '../boolean/index';
+import type { TRecord } from '../record/index';
+import type { TString } from '../string/index';
+import type { TUnion } from '../union/index';
+import type { TAny } from '../any/index';
+import type { TAsyncIterator } from '../async-iterator/index';
+import type { TBigInt } from '../bigint/index';
+import type { TConstructor } from '../constructor/index';
+import type { TFunction } from '../function/index';
+import type { TInteger } from '../integer/index';
+import type { TIntersect } from '../intersect/index';
+import type { TIterator } from '../iterator/index';
+import type { TLiteral } from '../literal/index';
+import type { TNever } from '../never/index';
+import type { TNot } from '../not/index';
+import type { TNull } from '../null/index';
+import type { TNumber } from '../number/index';
+import type { TObject } from '../object/index';
+import type { TOptional } from '../optional/index';
+import type { TPromise } from '../promise/index';
+import type { TReadonly } from '../readonly/index';
+import type { TRef } from '../ref/index';
+import type { TSchema } from '../schema/index';
+import type { TSymbol } from '../symbol/index';
+import type { TTuple } from '../tuple/index';
+import type { TUint8Array } from '../uint8array/index';
+import type { TUndefined } from '../undefined/index';
+import type { TUnknown } from '../unknown/index';
+import type { TUnsafe } from '../unsafe/index';
+import type { TVoid } from '../void/index';
+import type { TDate } from '../date/index';
+import type { TThis } from '../recursive/index';
+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;