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

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

@@ -0,0 +1,88 @@
+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 {
+}
+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 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> & {
+    [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 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 {
+    [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 {
+    [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> & {
+    [Kind]: string;
+};
+export declare function TSchema(schema: unknown): schema is TSchema;

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

@@ -0,0 +1,41 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import type { TNever } from '../never/index.mjs';
+export type TupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TupleToIntersect<R> : never;
+export type TupleToUnion<T extends any[]> = {
+    [K in keyof T]: T[K];
+}[number];
+export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
+export type Trim<T> = T extends `${' '}${infer U}` ? Trim<U> : T extends `${infer U}${' '}` ? Trim<U> : T;
+export type Assert<T, E> = T extends E ? T : never;
+export type Evaluate<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+export type Ensure<T> = T extends infer U ? U : never;
+export type EmptyString = '';
+export type ZeroString = '0';
+type IncrementBase = {
+    m: '9';
+    t: '01';
+    '0': '1';
+    '1': '2';
+    '2': '3';
+    '3': '4';
+    '4': '5';
+    '5': '6';
+    '6': '7';
+    '7': '8';
+    '8': '9';
+    '9': '0';
+};
+type IncrementTake<T extends keyof IncrementBase> = IncrementBase[T];
+type IncrementStep<T extends string> = T extends IncrementBase['m'] ? IncrementBase['t'] : T extends `${infer L extends keyof IncrementBase}${infer R}` ? L extends IncrementBase['m'] ? `${IncrementTake<L>}${IncrementStep<R>}` : `${IncrementTake<L>}${R}` : never;
+type IncrementReverse<T extends string> = T extends `${infer L}${infer R}` ? `${IncrementReverse<R>}${L}` : T;
+export type Increment<T extends string> = IncrementReverse<IncrementStep<IncrementReverse<T>>>;
+export declare function Increment<T extends string>(T: T): Increment<T>;
+export type AssertProperties<T> = T extends TProperties ? T : TProperties;
+export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : [];
+export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNever;
+export {};

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

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

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

@@ -0,0 +1,70 @@
+export * from './any/index.mjs';
+export * from './array/index.mjs';
+export * from './async-iterator/index.mjs';
+export * from './awaited/index.mjs';
+export * from './bigint/index.mjs';
+export * from './boolean/index.mjs';
+export * from './clone/index.mjs';
+export * from './composite/index.mjs';
+export * from './const/index.mjs';
+export * from './constructor/index.mjs';
+export * from './constructor-parameters/index.mjs';
+export * from './date/index.mjs';
+export * from './deref/index.mjs';
+export * from './discard/index.mjs';
+export * from './enum/index.mjs';
+export * from './exclude/index.mjs';
+export * from './extends/index.mjs';
+export * from './extract/index.mjs';
+export * from './function/index.mjs';
+export * from './guard/index.mjs';
+export * from './helpers/index.mjs';
+export * from './indexed/index.mjs';
+export * from './instance-type/index.mjs';
+export * from './integer/index.mjs';
+export * from './intersect/index.mjs';
+export * from './intrinsic/index.mjs';
+export * from './iterator/index.mjs';
+export * from './keyof/index.mjs';
+export * from './literal/index.mjs';
+export * from './mapped/index.mjs';
+export * from './modifiers/index.mjs';
+export * from './never/index.mjs';
+export * from './not/index.mjs';
+export * from './null/index.mjs';
+export * from './number/index.mjs';
+export * from './object/index.mjs';
+export * from './omit/index.mjs';
+export * from './operators/index.mjs';
+export * from './optional/index.mjs';
+export * from './parameters/index.mjs';
+export * from './partial/index.mjs';
+export * from './patterns/index.mjs';
+export * from './pick/index.mjs';
+export * from './promise/index.mjs';
+export * from './readonly/index.mjs';
+export * from './readonly-optional/index.mjs';
+export * from './record/index.mjs';
+export * from './recursive/index.mjs';
+export * from './ref/index.mjs';
+export * from './regexp/index.mjs';
+export * from './registry/index.mjs';
+export * from './required/index.mjs';
+export * from './rest/index.mjs';
+export * from './return-type/index.mjs';
+export * from './schema/index.mjs';
+export * from './static/index.mjs';
+export * from './strict/index.mjs';
+export * from './string/index.mjs';
+export * from './symbol/index.mjs';
+export * from './symbols/index.mjs';
+export * from './template-literal/index.mjs';
+export * from './transform/index.mjs';
+export * from './tuple/index.mjs';
+export * from './type/index.mjs';
+export * from './uint8array/index.mjs';
+export * from './undefined/index.mjs';
+export * from './union/index.mjs';
+export * from './unknown/index.mjs';
+export * from './unsafe/index.mjs';
+export * from './void/index.mjs';

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

@@ -0,0 +1,3 @@
+export * from './indexed-key.mjs';
+export * from './indexed-type.mjs';
+export * from './indexed.mjs';

package/build/import/type/indexed/indexed-key.d.mts

@@ -0,0 +1,16 @@
+import { type TTemplateLiteral, TemplateLiteralGenerate, IsTemplateLiteralFinite } from '../template-literal/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
+import { type TInteger } from '../integer/index.mjs';
+import { type TNumber } from '../number/index.mjs';
+import { type TSchema } from '../schema/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+type FromTemplateLiteral<T extends TTemplateLiteral, F = IsTemplateLiteralFinite<T>> = (F extends true ? TemplateLiteralGenerate<T> extends infer R extends string[] ? R : [] : []);
+declare function FromTemplateLiteral<T extends TTemplateLiteral>(T: T): FromTemplateLiteral<T>;
+type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [...IndexedKeyResolve<L>, ...FromUnion<R>] : []);
+declare function FromUnion<T extends TSchema[]>(T: T): FromUnion<T>;
+type FromLiteral<T extends TLiteralValue> = (T extends PropertyKey ? [`${T}`] : []);
+declare function FromLiteral<T extends TLiteralValue>(T: T): FromLiteral<T>;
+export type IndexedKeyResolve<T extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T> : T extends TUnion<infer S> ? FromUnion<S> : T extends TLiteral<infer S> ? FromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
+]);
+export declare function IndexedKeyResolve<T extends TSchema>(T: T): IndexedKeyResolve<T>;
+export {};

package/build/import/type/indexed/indexed-type.d.mts

@@ -0,0 +1,33 @@
+import { type TSchema } from '../schema/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TRecursive } from '../recursive/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TTuple } from '../tuple/index.mjs';
+import { type TArray } from '../array/index.mjs';
+import { IntersectResolve } from '../intersect/index.mjs';
+import { UnionResolve } from '../union/index.mjs';
+type FromRest<T extends TSchema[], K extends PropertyKey> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromKey<L, K>, ...FromRest<R, K>] : []);
+declare function FromRest<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromRest<T, K>;
+type FromIntersectRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [...FromIntersectRest<R>] : [L, ...FromIntersectRest<R>] : []);
+declare function FromIntersectRest<T extends TSchema[]>(T: [...T]): FromIntersectRest<T>;
+type FromIntersect<T extends TSchema[], K extends PropertyKey> = (IntersectResolve<FromIntersectRest<FromRest<T, K>>>);
+declare function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromIntersect<T, K>;
+type FromUnionRest<T extends TSchema[], S = T> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : FromUnionRest<R, S> : S);
+declare function FromUnionRest<T extends TSchema[]>(T: [...T], S?: [...T]): FromUnionRest<T>;
+type FromUnion<T extends TSchema[], K extends PropertyKey> = (UnionResolve<FromUnionRest<FromRest<T, K>>>);
+declare function FromUnion<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromUnion<T, K>;
+type FromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? UnionResolve<T> : TNever);
+declare function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromTuple<T, K>;
+type FromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);
+declare function FromArray<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromArray<T, K>;
+type FromProperty<T extends TProperties, K extends PropertyKey> = (K extends keyof T ? T[K] : TNever);
+declare function FromProperty<T extends TProperties, K extends PropertyKey>(T: T, K: K): FromProperty<T, K>;
+type FromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<infer S> ? FromKey<S, K> : T extends TIntersect<infer S> ? FromIntersect<S, K> : T extends TUnion<infer S> ? FromUnion<S, K> : T extends TTuple<infer S> ? FromTuple<S, K> : T extends TArray<infer S> ? FromArray<S, K> : T extends TObject<infer S> ? FromProperty<S, K> : TNever);
+declare function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromKey<T, K>;
+type FromKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? [FromKey<T, L>, ...FromKeys<T, R>] : []);
+declare function FromKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromKeys<T, K>;
+export type IndexedTypeResolve<T extends TSchema, K extends PropertyKey[]> = (UnionResolve<FromKeys<T, K>>);
+export declare function IndexedTypeResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): IndexedTypeResolve<T, K>;
+export {};

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

@@ -0,0 +1,6 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { IndexedTypeResolve } from './indexed-type.mjs';
+import { IndexedKeyResolve } from './indexed-key.mjs';
+export type TIndex<T extends TSchema, K extends PropertyKey[]> = IndexedTypeResolve<T, K>;
+export declare function Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
+export declare function Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;

package/build/import/type/instance-type/index.d.mts

@@ -0,0 +1 @@
+export * from './instance-type.mjs';

package/build/import/type/instance-type/instance-type.d.mts

@@ -0,0 +1,4 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TConstructor } from '../constructor/index.mjs';
+export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
+export declare function InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;

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

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

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

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface IntegerOptions extends SchemaOptions {
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    minimum?: number;
+    multipleOf?: number;
+}
+export interface TInteger extends TSchema, IntegerOptions {
+    [Kind]: 'Integer';
+    static: number;
+    type: 'integer';
+}
+export declare function Integer(options?: IntegerOptions): TInteger;

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

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

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

@@ -0,0 +1,21 @@
+import type { TupleToIntersect, AssertType } from '../helpers/index.mjs';
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { OptionalFromIntersect } from '../modifiers/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export type IntersectResolve<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : OptionalFromIntersect<T>);
+export declare function IntersectResolve<T extends TSchema[]>(T: T): IntersectResolve<T>;
+export type TUnevaluatedProperties = undefined | TSchema | boolean;
+export interface IntersectOptions extends SchemaOptions {
+    unevaluatedProperties?: TUnevaluatedProperties;
+}
+export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
+    [Kind]: 'Intersect';
+    static: TupleToIntersect<{
+        [K in keyof T]: Static<AssertType<T[K]>, this['params']>;
+    }>;
+    type?: 'object';
+    allOf: [...T];
+}
+export declare function Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): IntersectResolve<T>;

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

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

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

@@ -0,0 +1,22 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TTemplateLiteral, type TTemplateLiteralKind } from '../template-literal/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+type IntrinsicMode = 'Uppercase' | 'Lowercase' | 'Capitalize' | 'Uncapitalize';
+type FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode> = M extends IntrinsicMode ? T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? [IntrinsicResolve<L, M>, ...FromTemplateLiteral<R, M>] : T : T;
+declare function FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode>(schema: TTemplateLiteral, mode: IntrinsicMode): FromTemplateLiteral<T, M>;
+type FromLiteralValue<T, M extends IntrinsicMode> = (T extends string ? M extends 'Uncapitalize' ? Uncapitalize<T> : M extends 'Capitalize' ? Capitalize<T> : M extends 'Uppercase' ? Uppercase<T> : M extends 'Lowercase' ? Lowercase<T> : string : T);
+declare function FromLiteralValue(value: TLiteralValue, mode: IntrinsicMode): string;
+type FromRest<T extends TSchema[], M extends IntrinsicMode> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [IntrinsicResolve<L, M>, ...FromRest<R, M>] : [];
+declare function FromRest<T extends TSchema[], M extends IntrinsicMode>(T: [...T], mode: M): FromRest<T, M>;
+export type IntrinsicResolve<T extends TSchema, M extends IntrinsicMode> = T extends TTemplateLiteral<infer S> ? TTemplateLiteral<FromTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<FromRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<FromLiteralValue<S, M>> : T;
+export declare function IntrinsicResolve<T extends TSchema, M extends IntrinsicMode>(schema: T, mode: M): IntrinsicResolve<T, M>;
+export type TUncapitalize<T extends TSchema> = IntrinsicResolve<T, 'Uncapitalize'>;
+export declare function Uncapitalize<T extends TSchema>(T: T, options?: SchemaOptions): TUncapitalize<T>;
+export type TUppercase<T extends TSchema> = IntrinsicResolve<T, 'Uppercase'>;
+export declare function Uppercase<T extends TSchema>(T: T, options?: SchemaOptions): TUppercase<T>;
+export type TLowercase<T extends TSchema> = IntrinsicResolve<T, 'Lowercase'>;
+export declare function Lowercase<T extends TSchema>(T: T, options?: SchemaOptions): TLowercase<T>;
+export type TCapitalize<T extends TSchema> = IntrinsicResolve<T, 'Capitalize'>;
+export declare function Capitalize<T extends TSchema>(T: T, options?: SchemaOptions): TCapitalize<T>;
+export {};

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

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

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

@@ -0,0 +1,10 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TIterator<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Iterator';
+    static: IterableIterator<Static<T, this['params']>>;
+    type: 'Iterator';
+    items: T;
+}
+export declare function Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T>;

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

@@ -0,0 +1,3 @@
+export * from './keyof-string.mjs';
+export * from './keyof-type.mjs';
+export * from './keyof.mjs';

package/build/import/type/keyof/keyof-string.d.mts

@@ -0,0 +1,28 @@
+import type { TSchema } from '../schema/index.mjs';
+import { type ZeroString, type UnionToTuple, Increment } from '../helpers/index.mjs';
+import type { TRecursive } from '../recursive/index.mjs';
+import type { TIntersect } from '../intersect/index.mjs';
+import type { TUnion } from '../union/index.mjs';
+import type { TTuple } from '../tuple/index.mjs';
+import type { TArray } from '../array/index.mjs';
+import type { TObject, TProperties } from '../object/index.mjs';
+import { OperatorUnionMany, OperatorIntersectMany } from '../operators/index.mjs';
+type FromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [KeyOfStringResolve<L>, ...FromRest<R>] : []);
+declare function FromRest<T extends TSchema[]>(T: [...T]): FromRest<T>;
+type FromIntersect<T extends TSchema[], C extends PropertyKey[][] = FromRest<T>> = (OperatorUnionMany<C>);
+declare function FromIntersect<T extends TSchema[]>(T: [...T], C?: FromRest<T>): FromIntersect<T>;
+type FromUnion<T extends TSchema[], C extends PropertyKey[][] = FromRest<T>> = (OperatorIntersectMany<C>);
+declare function FromUnion<T extends TSchema[]>(T: [...T]): FromUnion<T>;
+type FromTuple<T extends TSchema[], I extends string = ZeroString> = T extends [infer _ extends TSchema, ...infer R extends TSchema[]] ? [I, ...FromTuple<R, Increment<I>>] : [];
+declare function FromTuple<T extends TSchema[]>(T: [...T], I?: string): FromTuple<T>;
+type FromArray<_ extends TSchema> = ([
+    '[number]'
+]);
+declare function FromArray<_ extends TSchema>(_: _): FromArray<_>;
+type FromProperties<T extends TProperties> = (UnionToTuple<keyof T>);
+declare function FromProperties<T extends TProperties>(T: T): FromProperties<T>;
+export type KeyOfStringResolve<T extends TSchema> = (T extends TRecursive<infer S> ? KeyOfStringResolve<S> : T extends TIntersect<infer S> ? FromIntersect<S> : T extends TUnion<infer S> ? FromUnion<S> : T extends TTuple<infer S> ? FromTuple<S> : T extends TArray<infer S> ? FromArray<S> : T extends TObject<infer S> ? FromProperties<S> : [
+]);
+export declare function KeyOfStringResolve<T extends TSchema>(T: T): KeyOfStringResolve<T>;
+export declare function KeyOfStringResolvePattern(schema: TSchema): string;
+export {};

package/build/import/type/keyof/keyof-type.d.mts

@@ -0,0 +1,11 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { Ensure } from '../helpers/index.mjs';
+import { type TLiteral, TLiteralValue } from '../literal/index.mjs';
+import { type TNumber } from '../number/index.mjs';
+import { KeyOfStringResolve } from './keyof-string.mjs';
+import { UnionResolve } from '../union/index.mjs';
+type FromLiterals<T extends TLiteralValue[]> = (T extends [infer L extends TLiteralValue, ...infer R extends TLiteralValue[]] ? L extends '[number]' ? [TNumber, ...FromLiterals<R>] : [TLiteral<L>, ...FromLiterals<R>] : []);
+declare function FromLiterals<T extends TLiteralValue[]>(T: [...T]): FromLiterals<T>;
+export type KeyOfTypeResolve<T extends TSchema> = (Ensure<UnionResolve<FromLiterals<KeyOfStringResolve<T>>>>);
+export declare function KeyOfTypeResolve<T extends TSchema>(T: T): KeyOfTypeResolve<T>;
+export {};

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

@@ -0,0 +1,4 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { KeyOfTypeResolve } from './keyof-type.mjs';
+export type TKeyOf<T extends TSchema> = KeyOfTypeResolve<T>;
+export declare function KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): KeyOfTypeResolve<T>;

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

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

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

@@ -0,0 +1,9 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export type TLiteralValue = boolean | number | string;
+export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
+    [Kind]: 'Literal';
+    static: T;
+    const: T;
+}
+export declare function Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;

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

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

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

@@ -0,0 +1,24 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { Evaluate } from '../helpers/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
+import { IndexedKeyResolve } from '../indexed/indexed-key.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TMappedKey<T extends PropertyKey[] = PropertyKey[]> extends TSchema {
+    [Kind]: 'MappedKey';
+    static: T[number];
+    anyOf: [];
+}
+export type MappedFunction<K extends PropertyKey[], I = TMappedKey<K>> = (T: I) => TSchema;
+export type MappedResultProperties<K extends PropertyKey[], T extends TSchema> = K extends [infer L extends string, ...infer R extends PropertyKey[]] ? {
+    [_ in `${L}`]: T;
+} & MappedResultProperties<R, T> : {};
+export type UnevaluatedMappedResult<T extends TSchema> = T;
+export type EvaluatedMappedResult<K extends PropertyKey[], T extends TSchema> = T;
+export interface TMappedResult<K extends PropertyKey[], F extends MappedFunction<K>, S extends TSchema = ReturnType<F>, R extends TSchema = EvaluatedMappedResult<K, S>, P extends TProperties = Evaluate<MappedResultProperties<K, R>>, O extends TObject = TObject<P>> extends TSchema {
+    [Kind]: 'MappedResult';
+    static: Static<O, this['params']>;
+    properties: P;
+}
+export declare function Mapped<K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>, F extends MappedFunction<I> = MappedFunction<I>, R extends TMappedResult<I, F> = TMappedResult<I, F>>(key: K, map: F): R;
+export declare function Mapped<K extends PropertyKey[], F extends MappedFunction<K> = MappedFunction<K>, R extends TMappedResult<K, F> = TMappedResult<K, F>>(key: [...K], map: F): R;

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

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

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

@@ -0,0 +1,18 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TReadonly } from '../readonly/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TOptional } from '../optional/index.mjs';
+type IsOptionalFromIntersect<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? IsOptionalFromIntersect<R> : false : true);
+declare function IsOptionalFromIntersect<T extends TSchema[]>(T: T): IsOptionalFromIntersect<T>;
+type IsOptionalFromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? true : IsOptionalFromUnion<R> : false);
+declare function IsOptionalFromUnion<T extends TSchema[]>(T: T): IsOptionalFromUnion<T>;
+type RemoveOptionalFromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? [RemoveOptionalFromSchema<S>, ...RemoveOptionalFromRest<R>] : [L, ...RemoveOptionalFromRest<R>] : []);
+declare function RemoveOptionalFromRest<T extends TSchema[]>(T: T): RemoveOptionalFromRest<T>;
+type RemoveOptionalFromSchema<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<RemoveOptionalFromSchema<S>> : T extends TOptional<infer S extends TSchema> ? RemoveOptionalFromSchema<S> : T);
+declare function RemoveOptionalFromSchema<T extends TSchema>(T: T): RemoveOptionalFromSchema<T>;
+export type OptionalFromIntersect<T extends TSchema[], D extends TSchema[] = RemoveOptionalFromRest<T>> = (IsOptionalFromIntersect<T> extends true ? TOptional<TIntersect<D>> : TIntersect<T>);
+export declare function OptionalFromIntersect<T extends TSchema[]>(T: T): OptionalFromIntersect<T>;
+export type OptionalFromUnion<T extends TSchema[], D extends TSchema[] = RemoveOptionalFromRest<T>> = (IsOptionalFromUnion<T> extends true ? TOptional<TUnion<D>> : TUnion<T>);
+export declare function OptionalFromUnion<T extends TSchema[]>(T: T): OptionalFromUnion<T>;
+export {};

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

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

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

@@ -0,0 +1,8 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TNever extends TSchema {
+    [Kind]: 'Never';
+    static: never;
+    not: {};
+}
+export declare function Never(options?: SchemaOptions): TNever;

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

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

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

@@ -0,0 +1,9 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TNot<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Not';
+    static: T extends TNot<infer U> ? Static<U> : unknown;
+    not: T;
+}
+export declare function Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T>;

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

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

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

@@ -0,0 +1,8 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TNull extends TSchema {
+    [Kind]: 'Null';
+    static: null;
+    type: 'null';
+}
+export declare function Null(options?: SchemaOptions): TNull;

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

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

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

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface NumberOptions extends SchemaOptions {
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    minimum?: number;
+    multipleOf?: number;
+}
+export interface TNumber extends TSchema, NumberOptions {
+    [Kind]: 'Number';
+    static: number;
+    type: 'number';
+}
+export declare function Number(options?: NumberOptions): TNumber;

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

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

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

@@ -0,0 +1,39 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import type { Evaluate } from '../helpers/index.mjs';
+import type { TReadonly } from '../readonly/index.mjs';
+import type { TOptional } from '../optional/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export type TPropertyKey = string | number;
+export type TProperties = Record<TPropertyKey, TSchema>;
+type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never;
+}[keyof T];
+type ReadonlyPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? never : K) : never;
+}[keyof T];
+type OptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never;
+}[keyof T];
+type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
+type PropertiesResolve<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
+export type ObjectResolve<T extends TProperties, P extends unknown[]> = PropertiesResolve<T, {
+    [K in keyof T]: Static<T[K], P>;
+}>;
+export type TAdditionalProperties = undefined | TSchema | boolean;
+export interface ObjectOptions extends SchemaOptions {
+    additionalProperties?: TAdditionalProperties;
+    minProperties?: number;
+    maxProperties?: number;
+}
+export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
+    [Kind]: 'Object';
+    static: ObjectResolve<T, this['params']>;
+    additionalProperties?: TAdditionalProperties;
+    type: 'object';
+    properties: T;
+    required?: string[];
+}
+export declare function _Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+export declare const Object: typeof _Object;
+export {};

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

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