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

package/build/types/type/helpers/helpers.d.ts

@@ -0,0 +1,41 @@
+import type { TSchema } from '../schema/index';
+import type { TProperties } from '../object/index';
+import type { TNever } from '../never/index';
+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/types/type/helpers/index.d.ts

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

package/build/types/type/index.d.ts

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

package/build/types/type/indexed/index.d.ts

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

package/build/types/type/indexed/indexed-key.d.ts

@@ -0,0 +1,16 @@
+import { type TTemplateLiteral, TemplateLiteralGenerate, IsTemplateLiteralFinite } from '../template-literal/index';
+import { type TLiteral, type TLiteralValue } from '../literal/index';
+import { type TInteger } from '../integer/index';
+import { type TNumber } from '../number/index';
+import { type TSchema } from '../schema/index';
+import { type TUnion } from '../union/index';
+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/types/type/indexed/indexed-type.d.ts

@@ -0,0 +1,33 @@
+import { type TSchema } from '../schema/index';
+import { type TObject, type TProperties } from '../object/index';
+import { type TNever } from '../never/index';
+import { type TRecursive } from '../recursive/index';
+import { type TIntersect } from '../intersect/index';
+import { type TUnion } from '../union/index';
+import { type TTuple } from '../tuple/index';
+import { type TArray } from '../array/index';
+import { IntersectResolve } from '../intersect/index';
+import { UnionResolve } from '../union/index';
+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/types/type/indexed/indexed.d.ts

@@ -0,0 +1,6 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { IndexedTypeResolve } from './indexed-type';
+import { IndexedKeyResolve } from './indexed-key';
+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/types/type/instance-type/index.d.ts

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

package/build/types/type/instance-type/instance-type.d.ts

@@ -0,0 +1,4 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TConstructor } from '../constructor/index';
+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/types/type/integer/index.d.ts

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

package/build/types/type/integer/integer.d.ts

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+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/types/type/intersect/index.d.ts

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

package/build/types/type/intersect/intersect.d.ts

@@ -0,0 +1,21 @@
+import type { TupleToIntersect, AssertType } from '../helpers/index';
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { type TNever } from '../never/index';
+import { OptionalFromIntersect } from '../modifiers/index';
+import { Kind } from '../symbols/index';
+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/types/type/intrinsic/index.d.ts

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

package/build/types/type/intrinsic/intrinsic.d.ts

@@ -0,0 +1,22 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { type TTemplateLiteral, type TTemplateLiteralKind } from '../template-literal/index';
+import { type TLiteral, type TLiteralValue } from '../literal/index';
+import { type TUnion } from '../union/index';
+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/types/type/iterator/index.d.ts

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

package/build/types/type/iterator/iterator.d.ts

@@ -0,0 +1,10 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+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/types/type/keyof/index.d.ts

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

package/build/types/type/keyof/keyof-string.d.ts

@@ -0,0 +1,28 @@
+import type { TSchema } from '../schema/index';
+import { type ZeroString, type UnionToTuple, Increment } from '../helpers/index';
+import type { TRecursive } from '../recursive/index';
+import type { TIntersect } from '../intersect/index';
+import type { TUnion } from '../union/index';
+import type { TTuple } from '../tuple/index';
+import type { TArray } from '../array/index';
+import type { TObject, TProperties } from '../object/index';
+import { OperatorUnionMany, OperatorIntersectMany } from '../operators/index';
+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/types/type/keyof/keyof-type.d.ts

@@ -0,0 +1,11 @@
+import type { TSchema } from '../schema/index';
+import type { Ensure } from '../helpers/index';
+import { type TLiteral, TLiteralValue } from '../literal/index';
+import { type TNumber } from '../number/index';
+import { KeyOfStringResolve } from './keyof-string';
+import { UnionResolve } from '../union/index';
+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/types/type/keyof/keyof.d.ts

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

package/build/types/type/literal/index.d.ts

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

package/build/types/type/literal/literal.d.ts

@@ -0,0 +1,9 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+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/types/type/mapped/index.d.ts

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

package/build/types/type/mapped/mapped.d.ts

@@ -0,0 +1,24 @@
+import type { TSchema } from '../schema/index';
+import type { Evaluate } from '../helpers/index';
+import type { Static } from '../static/index';
+import { type TObject, type TProperties } from '../object/index';
+import { IndexedKeyResolve } from '../indexed/indexed-key';
+import { Kind } from '../symbols/index';
+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/types/type/modifiers/index.d.ts

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

package/build/types/type/modifiers/modifiers.d.ts

@@ -0,0 +1,18 @@
+import type { TSchema } from '../schema/index';
+import type { TReadonly } from '../readonly/index';
+import { type TIntersect } from '../intersect/index';
+import { type TUnion } from '../union/index';
+import { type TOptional } from '../optional/index';
+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/types/type/never/index.d.ts

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

package/build/types/type/never/never.d.ts

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

package/build/types/type/not/index.d.ts

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

package/build/types/type/not/not.d.ts

@@ -0,0 +1,9 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+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/types/type/null/index.d.ts

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

package/build/types/type/null/null.d.ts

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

package/build/types/type/number/index.d.ts

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

package/build/types/type/number/number.d.ts

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+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/types/type/object/index.d.ts

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

package/build/types/type/object/object.d.ts

@@ -0,0 +1,39 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import type { Evaluate } from '../helpers/index';
+import type { TReadonly } from '../readonly/index';
+import type { TOptional } from '../optional/index';
+import { Kind } from '../symbols/index';
+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/types/type/omit/index.d.ts

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

package/build/types/type/omit/omit.d.ts

@@ -0,0 +1,19 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TupleToUnion, Evaluate } from '../helpers/index';
+import { type TRecursive } from '../recursive/index';
+import { type TIntersect } from '../intersect/index';
+import { type TUnion } from '../union/index';
+import { type TObject, type TProperties } from '../object/index';
+import { IndexedKeyResolve } from '../indexed/index';
+type FromIntersect<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [OmitResolve<L, K>, ...FromIntersect<R, K>] : [];
+declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
+type FromUnion<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [OmitResolve<L, K>, ...FromUnion<R, K>] : [];
+declare function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromUnion<T, K>;
+type FromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Omit<T, I>>;
+declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K): TProperties;
+export type OmitResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<OmitResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
+export declare function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): OmitResolve<T, K>;
+export type TOmit<T extends TSchema, K extends PropertyKey[]> = OmitResolve<T, K>;
+export declare function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
+export declare function Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
+export {};

package/build/types/type/operators/index.d.ts

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

package/build/types/type/operators/operators.d.ts

@@ -0,0 +1,16 @@
+export type OperatorIncludes<T extends PropertyKey[], S extends PropertyKey> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? S extends L ? true : OperatorIncludes<R, S> : false);
+export declare function OperatorIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [...T], S: S): OperatorIncludes<T, S>;
+export type OperatorSubset<T extends PropertyKey[], S extends PropertyKey[]> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? OperatorSubset<R, S> : false : true;
+export declare function OperatorSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorSubset<T, S>;
+export type OperatorDistinct<T extends PropertyKey[], Acc extends PropertyKey[] = []> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<Acc, L> extends false ? OperatorDistinct<R, [...Acc, L]> : OperatorDistinct<R, [...Acc]> : Acc;
+export declare function OperatorDistinct<T extends PropertyKey[]>(T: [...T], Acc?: PropertyKey[]): OperatorDistinct<T>;
+export type OperatorIntersect<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? [L, ...OperatorIntersect<R, S>] : [...OperatorIntersect<R, S>] : []);
+export declare function OperatorIntersect<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorIntersect<T, S>;
+export type OperatorUnion<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? [...OperatorUnion<R, S>] : [L, ...OperatorUnion<R, S>] : S);
+export declare function OperatorUnion<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorUnion<T, S>;
+export type OperatorComplement<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? [...OperatorComplement<R, S>] : [L, ...OperatorComplement<R, S>] : []);
+export declare function OperatorComplement<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorComplement<T, S>;
+export type OperatorIntersectMany<T extends PropertyKey[][]> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? OperatorIntersect<L, OperatorIntersectMany<R>> : []);
+export declare function OperatorIntersectMany<T extends PropertyKey[][]>(T: [...T]): OperatorIntersectMany<T>;
+export type OperatorUnionMany<T extends PropertyKey[][]> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? OperatorUnion<L, OperatorUnionMany<R>> : []);
+export declare function OperatorUnionMany<T extends PropertyKey[][]>(T: [...T]): OperatorUnionMany<T>;

package/build/types/type/optional/index.d.ts

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

package/build/types/type/optional/optional.d.ts

@@ -0,0 +1,6 @@
+import type { TSchema } from '../schema/index';
+import { OptionalKind } from '../symbols/index';
+export type TOptional<T extends TSchema> = T & {
+    [OptionalKind]: 'Optional';
+};
+export declare function Optional<T extends TSchema>(schema: T): TOptional<T>;

package/build/types/type/parameters/index.d.ts

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

package/build/types/type/parameters/parameters.d.ts

@@ -0,0 +1,6 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TFunction } from '../function/index';
+import type { Ensure } from '../helpers/index';
+import { type TTuple } from '../tuple/index';
+export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>;
+export declare function Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T>;

package/build/types/type/partial/index.d.ts

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

package/build/types/type/partial/partial.d.ts

@@ -0,0 +1,22 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Evaluate } from '../helpers/index';
+import { type TReadonlyOptional } from '../readonly-optional/index';
+import { type TOptional } from '../optional/index';
+import { type TReadonly } from '../readonly/index';
+import { type TRecursive } from '../recursive/index';
+import { type TObject, type TProperties } from '../object/index';
+import { type TIntersect } from '../intersect/index';
+import { type TUnion } from '../union/index';
+type FromIntersect<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PartialResolve<L>, ...FromIntersect<R>] : []);
+declare function FromIntersect<T extends TSchema[]>(T: [...T]): FromIntersect<T>;
+type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PartialResolve<L>, ...FromUnion<R>] : []);
+declare function FromUnion<T extends TSchema[]>(T: [...T]): FromUnion<T>;
+type FromProperties<T extends TProperties> = Evaluate<{
+    [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : T[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : T[K] extends (TOptional<infer S>) ? TOptional<S> : TOptional<T[K]>;
+}>;
+declare function FromProperties<T extends TProperties>(T: T): TProperties;
+export type PartialResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<PartialResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
+export declare function PartialResolve<T extends TSchema>(T: T): PartialResolve<T>;
+export type TPartial<T extends TSchema> = PartialResolve<T>;
+export declare function Partial<T extends TSchema>(T: T, options?: SchemaOptions): TPartial<T>;
+export {};