@sinclair/typebox 0.32.0-dev-12 → 0.32.0-dev-14

package/build/import/index.d.mts

@@ -21,25 +21,25 @@ export { Extends, type TExtends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCh
 export { Extract, type TExtract } from './type/extract/index.mjs';
 export { Function, type TFunction } from './type/function/index.mjs';
 export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index.mjs';
-export { Index, type TIndex, type TMappedIndex, IndexedPropertyKeys, IndexedType, MappedIndex } from './type/indexed/index.mjs';
+export { Index, IndexPropertyKeys, IndexMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexMappedResult } from './type/indexed/index.mjs';
 export { InstanceType, type TInstanceType } from './type/instance-type/index.mjs';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index.mjs';
 export { Intersect, type TIntersect, type IntersectOptions } from './type/intersect/index.mjs';
 export { Iterator, type TIterator } from './type/iterator/index.mjs';
-export { Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase, IntrinsicResolve } from './type/intrinsic/index.mjs';
+export { Intrinsic, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index.mjs';
 export { KeyOf, type TKeyOf, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index.mjs';
 export { Literal, type TLiteral } from './type/literal/index.mjs';
-export { Mapped, type MappedKey as TMappedKey, type MappedFunction, type TMapped as TMappedResult } from './type/mapped/index.mjs';
+export { Mapped, MappedKey, MappedResult, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction } from './type/mapped/index.mjs';
 export { Never, type TNever } from './type/never/index.mjs';
 export { Not, type TNot } from './type/not/index.mjs';
 export { Null, type TNull } from './type/null/index.mjs';
 export { Number, type TNumber, type NumberOptions } from './type/number/index.mjs';
 export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index.mjs';
-export { Omit, type TOmit } from './type/omit/index.mjs';
+export { Omit, type TOmit, type TOmitMappedResult } from './type/omit/index.mjs';
 export { Optional, type TOptional } from './type/optional/index.mjs';
 export { Parameters, type TParameters } from './type/parameters/index.mjs';
 export { Partial, type TPartial } from './type/partial/index.mjs';
-export { Pick, type TPick } from './type/pick/index.mjs';
+export { Pick, type TPick, type TPickMappedResult } from './type/pick/index.mjs';
 export { Promise, type TPromise } from './type/promise/index.mjs';
 export { Readonly, type TReadonly } from './type/readonly/index.mjs';
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index.mjs';

package/build/import/index.mjs

@@ -21,15 +21,15 @@ export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './t
 export { Extract } from './type/extract/index.mjs';
 export { Function } from './type/function/index.mjs';
 export { Increment } from './type/helpers/index.mjs';
-export { Index, IndexedPropertyKeys, IndexedType, MappedIndex } from './type/indexed/index.mjs';
+export { Index, IndexPropertyKeys, IndexMappedResult } from './type/indexed/index.mjs';
 export { InstanceType } from './type/instance-type/index.mjs';
 export { Integer } from './type/integer/index.mjs';
 export { Intersect } from './type/intersect/index.mjs';
 export { Iterator } from './type/iterator/index.mjs';
-export { Capitalize, Lowercase, Uncapitalize, Uppercase, IntrinsicResolve } from './type/intrinsic/index.mjs';
+export { Intrinsic, Capitalize, Lowercase, Uncapitalize, Uppercase } from './type/intrinsic/index.mjs';
 export { KeyOf, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index.mjs';
 export { Literal } from './type/literal/index.mjs';
-export { Mapped } from './type/mapped/index.mjs';
+export { Mapped, MappedKey, MappedResult } from './type/mapped/index.mjs';
 export { Never } from './type/never/index.mjs';
 export { Not } from './type/not/index.mjs';
 export { Null } from './type/null/index.mjs';

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

@@ -1,10 +1,10 @@
 import type { UnionToTuple, Assert, Evaluate } from '../helpers/index.mjs';
 import { type TObject, type ObjectOptions } from '../object/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
-import { IndexedType } from '../indexed/index.mjs';
+import { type TIndex } from '../indexed/index.mjs';
 type CompositeKeys<T extends TObject[]> = T extends [infer L extends TObject, ...infer R extends TObject[]] ? keyof L['properties'] | CompositeKeys<R> : never;
 type CompositeIndex<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L extends string, ...infer R extends string[]] ? {
-    [_ in L]: IndexedType<T, [L]>;
+    [_ in L]: TIndex<T, [L]>;
 } & CompositeIndex<T, R> : {};
 type CompositeReduce<T extends TObject[]> = UnionToTuple<CompositeKeys<T>> extends infer K ? Evaluate<CompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
 export type CompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<CompositeReduce<T>> : TObject<{}>;

package/build/import/type/extends/extends-mapped-result-from-result.d.mts

@@ -0,0 +1,13 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TExtends } from './extends.mjs';
+type MappedResultExtendsPropertyKeys<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema> = ({
+    [K2 in keyof K]: TExtends<K[K2], U, L, R>;
+});
+declare function MappedResultExtendsPropertyKeys<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedResultExtendsPropertyKeys<K, U, L, R>;
+type MappedResultExtendsProperties<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema> = (MappedResultExtendsPropertyKeys<K['properties'], U, L, R>);
+declare function MappedResultExtendsProperties<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedResultExtendsProperties<K, U, L, R>;
+export type TExtendsMappedResultFromResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedResultExtendsProperties<T, U, L, R>> = (TMappedResult<P>);
+export declare function ExtendsMappedResultFromResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedResultExtendsProperties<T, U, L, R>>(T: T, U: U, L: L, R: R): TMappedResult<P>;
+export {};

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

@@ -0,0 +1,14 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Extends } from './extends.mjs';
+function MappedResultExtendsPropertyKeys(K, U, L, R) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Extends(K[K2], U, L, R) };
+    }, {});
+}
+function MappedResultExtendsProperties(K, U, L, R) {
+    return MappedResultExtendsPropertyKeys(K.properties, U, L, R);
+}
+export function ExtendsMappedResultFromResult(T, U, L, R) {
+    const P = MappedResultExtendsProperties(T, U, L, R);
+    return MappedResult(P);
+}

package/build/import/type/extends/extends-mapped-result.d.mts

@@ -1,13 +1,17 @@
 import type { TSchema } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
-import { type TMappedResult } from '../mapped/index.mjs';
+import type { Assert } from '../helpers/index.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { TLiteral, TLiteralValue } from '../literal/index.mjs';
 import { type TExtends } from './extends.mjs';
-type MappedResultExtendsPropertyKeys<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema> = ({
-    [K2 in keyof K]: TExtends<K[K2], U, L, R>;
-});
-declare function MappedResultExtendsPropertyKeys<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedResultExtendsPropertyKeys<K, U, L, R>;
-type MappedResultExtendsProperties<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema> = (MappedResultExtendsPropertyKeys<K['properties'], U, L, R>);
-declare function MappedResultExtendsProperties<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedResultExtendsProperties<K, U, L, R>;
-export type MappedResultExtends<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedResultExtendsProperties<T, U, L, R>> = (TMappedResult<P>);
-export declare function MappedResultExtends<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedResultExtendsProperties<T, U, L, R>>(T: T, U: U, L: L, R: R): TMappedResult<P>;
+type MappedExtendsPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
+    [_ in K]: TExtends<TLiteral<Assert<K, TLiteralValue>>, U, L, R>;
+};
+declare function MappedExtendsPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedExtendsPropertyKey<K, U, L, R>;
+type MappedExtendsPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? MappedExtendsPropertyKey<LK, U, L, R> & MappedExtendsPropertyKeys<RK, U, L, R> : {});
+declare function MappedExtendsPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema>(K: [...K], U: U, L: L, R: R): MappedExtendsPropertyKeys<K, U, L, R>;
+type MappedExtendsProperties<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema> = (MappedExtendsPropertyKeys<K['keys'], U, L, R>);
+declare function MappedExtendsProperties<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedExtendsProperties<K, U, L, R>;
+export type TExtendsMappedResult<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedExtendsProperties<T, U, L, R>> = (TMappedResult<P>);
+export declare function ExtendsMappedResult<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedExtendsProperties<T, U, L, R>>(T: T, U: U, L: L, R: R): TMappedResult<P>;
 export {};

package/build/import/type/extends/extends-mapped-result.mjs

@@ -1,14 +1,21 @@
 import { MappedResult } from '../mapped/index.mjs';
+import { Literal } from '../literal/index.mjs';
 import { Extends } from './extends.mjs';
-function MappedResultExtendsPropertyKeys(K, U, L, R) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Extends(K[K2], U, L, R) };
-    }, {});
+function MappedExtendsPropertyKey(K, U, L, R) {
+    return {
+        [K]: Extends(Literal(K), U, L, R)
+    };
 }
-function MappedResultExtendsProperties(K, U, L, R) {
-    return MappedResultExtendsPropertyKeys(K.properties, U, L, R);
+function MappedExtendsPropertyKeys(K, U, L, R) {
+    const [LK, ...RK] = K;
+    return (K.length > 0
+        ? { ...MappedExtendsPropertyKey(LK, U, L, R), ...MappedExtendsPropertyKeys(RK, U, L, R) }
+        : {});
 }
-export function MappedResultExtends(T, U, L, R) {
-    const P = MappedResultExtendsProperties(T, U, L, R);
+function MappedExtendsProperties(K, U, L, R) {
+    return MappedExtendsPropertyKeys(K.keys, U, L, R);
+}
+export function ExtendsMappedResult(T, U, L, R) {
+    const P = MappedExtendsProperties(T, U, L, R);
     return MappedResult(P);
 }

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

@@ -3,12 +3,12 @@ import type { Static } from '../static/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { TMappedKey, TMappedResult } from '../mapped/index.mjs';
 import { UnionToTuple } from '../helpers/index.mjs';
-import { MappedExtends } from './extends-mapped.mjs';
-import { MappedResultExtends } from './extends-mapped-result.mjs';
+import { type TExtendsMappedResult } from './extends-mapped-result.mjs';
+import { type TExtendsMappedResultFromResult } from './extends-mapped-result-from-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>;
-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): MappedResultExtends<L, R, T, F>;
-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): MappedExtends<L, R, T, F>;
+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): TExtendsMappedResultFromResult<L, R, T, F>;
+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): TExtendsMappedResult<L, R, T, F>;
 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

@@ -2,8 +2,8 @@ import { TMappedKey as IsMappedKeyType, TMappedResult as IsMappedResultType } fr
 import { Union } from '../union/index.mjs';
 import { ExtendsCheck, ExtendsResult } from './extends-check.mjs';
 import { CloneType } from '../clone/type.mjs';
-import { MappedExtends } from './extends-mapped.mjs';
-import { MappedResultExtends } from './extends-mapped-result.mjs';
+import { ExtendsMappedResult } from './extends-mapped-result.mjs';
+import { ExtendsMappedResultFromResult } from './extends-mapped-result-from-result.mjs';
 function ExtendsResolve(left, right, trueType, falseType) {
     const R = ExtendsCheck(left, right);
     return (R === ExtendsResult.Union ? Union([trueType, falseType]) :
@@ -11,7 +11,7 @@ function ExtendsResolve(left, right, trueType, falseType) {
             falseType);
 }
 export function Extends(L, R, T, F, options = {}) {
-    return (IsMappedResultType(L) ? CloneType(MappedResultExtends(L, R, T, F), options) :
-        IsMappedKeyType(L) ? CloneType(MappedExtends(L, R, T, F), options) :
+    return (IsMappedResultType(L) ? CloneType(ExtendsMappedResultFromResult(L, R, T, F), options) :
+        IsMappedKeyType(L) ? CloneType(ExtendsMappedResult(L, R, T, F), options) :
             CloneType(ExtendsResolve(L, R, T, F), options));
 }

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

@@ -1,5 +1,5 @@
 export * from './extends-check.mjs';
+export * from './extends-mapped-result-from-result.mjs';
 export * from './extends-mapped-result.mjs';
-export * from './extends-mapped.mjs';
 export * from './extends-undefined.mjs';
 export * from './extends.mjs';

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

@@ -1,5 +1,5 @@
 export * from './extends-check.mjs';
+export * from './extends-mapped-result-from-result.mjs';
 export * from './extends-mapped-result.mjs';
-export * from './extends-mapped.mjs';
 export * from './extends-undefined.mjs';
 export * from './extends.mjs';

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

@@ -14,7 +14,7 @@ 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 { TLiteral, TLiteralValue } from '../literal/index.mjs';
 import type { TMappedKey, TMappedResult } from '../mapped/index.mjs';
 import type { TNever } from '../never/index.mjs';
 import type { TNot } from '../not/index.mjs';
@@ -37,56 +37,57 @@ import type { TDate } from '../date/index.mjs';
 import type { TThis } from '../recursive/index.mjs';
 export declare class TypeGuardUnknownTypeError extends Error {
 }
-export declare function TReadonly<T extends TSchema>(schema: T): schema is TReadonly<T>;
-export declare function TOptional<T extends TSchema>(schema: T): schema is TOptional<T>;
-export declare function TAny(schema: unknown): schema is TAny;
-export declare function TArray(schema: unknown): schema is TArray;
-export declare function TAsyncIterator(schema: unknown): schema is TAsyncIterator;
-export declare function TBigInt(schema: unknown): schema is TBigInt;
-export declare function TBoolean(schema: unknown): schema is TBoolean;
-export declare function TConstructor(schema: unknown): schema is TConstructor;
-export declare function TDate(schema: unknown): schema is TDate;
-export declare function TFunction(schema: unknown): schema is TFunction;
-export declare function TInteger(schema: unknown): schema is TInteger;
-export declare function TProperties(schema: unknown): schema is TProperties;
-export declare function TIntersect(schema: unknown): schema is TIntersect;
-export declare function TIterator(schema: unknown): schema is TIterator;
-export declare function TKindOf<T extends string>(schema: unknown, kind: T): schema is Record<PropertyKey, unknown> & {
+export declare function TReadonly<T extends TSchema>(value: T): value is TReadonly<T>;
+export declare function TOptional<T extends TSchema>(value: T): value is TOptional<T>;
+export declare function TAny(value: unknown): value is TAny;
+export declare function TArray(value: unknown): value is TArray;
+export declare function TAsyncIterator(value: unknown): value is TAsyncIterator;
+export declare function TBigInt(value: unknown): value is TBigInt;
+export declare function TBoolean(value: unknown): value is TBoolean;
+export declare function TConstructor(value: unknown): value is TConstructor;
+export declare function TDate(value: unknown): value is TDate;
+export declare function TFunction(value: unknown): value is TFunction;
+export declare function TInteger(value: unknown): value is TInteger;
+export declare function TProperties(value: unknown): value is TProperties;
+export declare function TIntersect(value: unknown): value is TIntersect;
+export declare function TIterator(value: unknown): value is TIterator;
+export declare function TKindOf<T extends string>(value: unknown, kind: T): value is Record<PropertyKey, unknown> & {
     [Kind]: T;
 };
-export declare function TLiteralString(schema: unknown): schema is TLiteral<string>;
-export declare function TLiteralNumber(schema: unknown): schema is TLiteral<number>;
-export declare function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean>;
-export declare function TLiteral(schema: unknown): schema is TLiteral;
-export declare function TMappedKey(schema: unknown): schema is TMappedKey;
-export declare function TMappedResult(schema: unknown): schema is TMappedResult;
-export declare function TNever(schema: unknown): schema is TNever;
-export declare function TNot(schema: unknown): schema is TNot;
-export declare function TNull(schema: unknown): schema is TNull;
-export declare function TNumber(schema: unknown): schema is TNumber;
-export declare function TObject(schema: unknown): schema is TObject;
-export declare function TPromise(schema: unknown): schema is TPromise;
-export declare function TRecord(schema: unknown): schema is TRecord;
-export declare function TRecursive(schema: unknown): schema is {
+export declare function TLiteralString(value: unknown): value is TLiteral<string>;
+export declare function TLiteralNumber(value: unknown): value is TLiteral<number>;
+export declare function TLiteralBoolean(value: unknown): value is TLiteral<boolean>;
+export declare function TLiteral(value: unknown): value is TLiteral;
+export declare function TLiteralValue(value: unknown): value is TLiteralValue;
+export declare function TMappedKey(value: unknown): value is TMappedKey;
+export declare function TMappedResult(value: unknown): value is TMappedResult;
+export declare function TNever(value: unknown): value is TNever;
+export declare function TNot(value: unknown): value is TNot;
+export declare function TNull(value: unknown): value is TNull;
+export declare function TNumber(value: unknown): value is TNumber;
+export declare function TObject(value: unknown): value is TObject;
+export declare function TPromise(value: unknown): value is TPromise;
+export declare function TRecord(value: unknown): value is TRecord;
+export declare function TRecursive(value: unknown): value is {
     [Hint]: 'Recursive';
 };
-export declare function TRef(schema: unknown): schema is TRef;
-export declare function TString(schema: unknown): schema is TString;
-export declare function TSymbol(schema: unknown): schema is TSymbol;
-export declare function TTemplateLiteral(schema: unknown): schema is TTemplateLiteral<TTemplateLiteralKind[]>;
-export declare function TThis(schema: unknown): schema is TThis;
-export declare function TTransform(schema: unknown): schema is {
+export declare function TRef(value: unknown): value is TRef;
+export declare function TString(value: unknown): value is TString;
+export declare function TSymbol(value: unknown): value is TSymbol;
+export declare function TTemplateLiteral(value: unknown): value is TTemplateLiteral<TTemplateLiteralKind[]>;
+export declare function TThis(value: unknown): value is TThis;
+export declare function TTransform(value: unknown): value is {
     [TransformKind]: TransformOptions;
 };
-export declare function TTuple(schema: unknown): schema is TTuple;
-export declare function TUndefined(schema: unknown): schema is TUndefined;
-export declare function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral[]>;
-export declare function TUnion(schema: unknown): schema is TUnion;
-export declare function TUint8Array(schema: unknown): schema is TUint8Array;
-export declare function TUnknown(schema: unknown): schema is TUnknown;
-export declare function TUnsafe(schema: unknown): schema is TUnsafe<unknown>;
-export declare function TVoid(schema: unknown): schema is TVoid;
-export declare function TKind(schema: unknown): schema is Record<PropertyKey, unknown> & {
+export declare function TTuple(value: unknown): value is TTuple;
+export declare function TUndefined(value: unknown): value is TUndefined;
+export declare function TUnionLiteral(value: unknown): value is TUnion<TLiteral[]>;
+export declare function TUnion(value: unknown): value is TUnion;
+export declare function TUint8Array(value: unknown): value is TUint8Array;
+export declare function TUnknown(value: unknown): value is TUnknown;
+export declare function TUnsafe(value: unknown): value is TUnsafe<unknown>;
+export declare function TVoid(value: unknown): value is TVoid;
+export declare function TKind(value: unknown): value is Record<PropertyKey, unknown> & {
     [Kind]: string;
 };
-export declare function TSchema(schema: unknown): schema is TSchema;
+export declare function TSchema(value: unknown): value is TSchema;