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

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

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

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

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

package/build/types/type/pick/pick.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[]] ? [PickResolve<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[]] ? [PickResolve<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<Pick<T, I & keyof T>>;
+declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K): {};
+export type PickResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<PickResolve<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 PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): PickResolve<T, K>;
+export type TPick<T extends TSchema, K extends PropertyKey[]> = PickResolve<T, K>;
+export declare function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+export declare function Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
+export {};

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

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

package/build/types/type/promise/promise.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 TPromise<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Promise';
+    static: Promise<Static<T, this['params']>>;
+    type: 'Promise';
+    item: TSchema;
+}
+export declare function Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+import type { TSchema } from '../schema/index';
+import { type TReadonly } from '../readonly/index';
+import { type TOptional } from '../optional/index';
+export type TReadonlyOptional<T extends TSchema> = TOptional<T> & TReadonly<T>;
+export declare function ReadonlyOptional<T extends TSchema>(schema: T): TReadonly<TOptional<T>>;

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

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

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

@@ -0,0 +1,54 @@
+import type { TSchema } from '../schema/index';
+import type { Static } from '../static/index';
+import type { Evaluate, Ensure, Assert } from '../helpers/index';
+import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index';
+import { type TLiteral, TLiteralValue } from '../literal/index';
+import { type TNever } from '../never/index';
+import { type TUnion } from '../union/index';
+import { type TString } from '../string/index';
+import { type TInteger } from '../integer/index';
+import { type TNumber } from '../number/index';
+import { type TEnum } from '../enum/index';
+import { TTemplateLiteral, IsTemplateLiteralFinite } from '../template-literal/index';
+import { Kind } from '../symbols/index';
+type FromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>;
+type FromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I extends string = Static<K>> = (Ensure<TObject<Evaluate<{
+    [_ in I]: T;
+}>>>);
+type FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends false ? FromTemplateLiteralKeyInfinite<K, T> : FromTemplateLiteralKeyFinite<K, T>;
+declare function FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema>(K: K, T: T): FromTemplateLiteralKey<K, T>;
+type FromEnumKey<K extends Record<string, string | number>, T extends TSchema> = Ensure<TObject<{
+    [_ in K[keyof K]]: T;
+}>>;
+type FromUnionKeyLiteralString<K extends TLiteral<string>, T extends TSchema> = {
+    [_ in K['const']]: T;
+};
+type FromUnionKeyLiteralNumber<K extends TLiteral<number>, T extends TSchema> = {
+    [_ in K['const']]: T;
+};
+type FromUnionKeyRest<K extends TSchema[], T extends TSchema> = K extends [infer L extends TSchema, ...infer R extends TSchema[]] ? (L extends TUnion<infer S> ? FromUnionKeyRest<S, T> & FromUnionKeyRest<R, T> : L extends TLiteral<string> ? FromUnionKeyLiteralString<L, T> & FromUnionKeyRest<R, T> : L extends TLiteral<number> ? FromUnionKeyLiteralNumber<L, T> & FromUnionKeyRest<R, T> : {}) : {};
+type FromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties = FromUnionKeyRest<K, T>> = (Ensure<TObject<P>>);
+declare function FromUnionKey<K extends TSchema[], T extends TSchema>(K: K, T: T): FromUnionKey<K, T>;
+type FromLiteralKey<K extends TLiteralValue, T extends TSchema> = (Ensure<TObject<{
+    [_ in Assert<K, PropertyKey>]: T;
+}>>);
+declare function FromLiteralKey<K extends TLiteralValue, T extends TSchema>(K: K, T: T): FromLiteralKey<K, T>;
+type FromStringKey<_ extends TString, T extends TSchema> = (Ensure<TRecord<TString, T>>);
+declare function FromStringKey<K extends TString, T extends TSchema>(K: K, T: T): FromStringKey<K, T>;
+type FromIntegerKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
+declare function FromIntegerKey<K extends TInteger, T extends TSchema>(_: K, T: T): FromIntegerKey<K, T>;
+type FromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
+declare function FromNumberKey<K extends TNumber, T extends TSchema>(_: K, T: T): FromIntegerKey<K, T>;
+export type RecordResolve<K extends TSchema, T extends TSchema> = K extends TEnum<infer S> ? FromEnumKey<S, T> : K extends TUnion<infer S> ? FromUnionKey<S, T> : K extends TTemplateLiteral ? FromTemplateLiteralKey<K, T> : K extends TLiteral<infer S> ? FromLiteralKey<S, T> : K extends TInteger ? FromIntegerKey<K, T> : K extends TNumber ? FromNumberKey<K, T> : K extends TString ? FromStringKey<K, T> : TNever;
+export declare function RecordResolve<K extends TSchema, T extends TSchema>(K: K, T: T): RecordResolve<K, T>;
+export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Record';
+    static: Record<Assert<Static<K>, string | number>, Static<T, this['params']>>;
+    type: 'object';
+    patternProperties: {
+        [pattern: string]: T;
+    };
+    additionalProperties: TAdditionalProperties;
+}
+export declare function Record<K extends TSchema, T extends TSchema>(K: K, T: T, options?: ObjectOptions): RecordResolve<K, T>;
+export {};

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

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

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

@@ -0,0 +1,14 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind, Hint } from '../symbols/index';
+import { Static } from '../static/index';
+export interface TThis extends TSchema {
+    [Kind]: 'This';
+    static: this['params'][0];
+    $ref: string;
+}
+export type RecursiveResolve<T extends TSchema> = Static<T, [RecursiveResolve<T>]>;
+export interface TRecursive<T extends TSchema> extends TSchema {
+    [Hint]: 'Recursive';
+    static: RecursiveResolve<T>;
+}
+export declare function Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;

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

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

package/build/types/type/ref/ref.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 TRef<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Ref';
+    static: Static<T, this['params']>;
+    $ref: string;
+}
+export declare function Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
+export declare function Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;

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

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

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

@@ -0,0 +1,5 @@
+import type { SchemaOptions } from '../schema/index';
+import type { TString } from '../string/index';
+export type TRegExp = TString;
+export declare function RegExp(pattern: string, options?: SchemaOptions): TRegExp;
+export declare function RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;

package/build/types/type/registry/format.d.ts

@@ -0,0 +1,7 @@
+export type FormatRegistryValidationFunction = (value: string) => boolean;
+export declare function Entries(): Map<string, FormatRegistryValidationFunction>;
+export declare function Clear(): void;
+export declare function Delete(format: string): boolean;
+export declare function Has(format: string): boolean;
+export declare function Set(format: string, func: FormatRegistryValidationFunction): void;
+export declare function Get(format: string): FormatRegistryValidationFunction | undefined;

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

@@ -0,0 +1,2 @@
+export * as FormatRegistry from './format';
+export * as TypeRegistry from './type';

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

@@ -0,0 +1,7 @@
+export type TypeRegistryValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean;
+export declare function Entries(): Map<string, TypeRegistryValidationFunction<any>>;
+export declare function Clear(): void;
+export declare function Delete(kind: string): boolean;
+export declare function Has(kind: string): boolean;
+export declare function Set<TSchema = unknown>(kind: string, func: TypeRegistryValidationFunction<TSchema>): void;
+export declare function Get(kind: string): TypeRegistryValidationFunction<any> | undefined;

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

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

package/build/types/type/required/required.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 TIntersect } from '../intersect/index';
+import { type TUnion } from '../union/index';
+import { type TObject, type TProperties } from '../object/index';
+type FromIntersect<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [RequiredResolve<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[]] ? [RequiredResolve<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>) ? TReadonly<S> : T[K] extends (TReadonly<infer S>) ? TReadonly<S> : T[K] extends (TOptional<infer S>) ? S : T[K];
+}>;
+declare function FromProperties<T extends TProperties>(T: T): TProperties;
+export type RequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<RequiredResolve<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 RequiredResolve<T extends TSchema>(T: T): RequiredResolve<T>;
+export type TRequired<T extends TSchema> = RequiredResolve<T>;
+export declare function Required<T extends TSchema>(T: T, options?: SchemaOptions): TRequired<T>;
+export {};

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

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

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

@@ -0,0 +1,9 @@
+import type { TSchema } from '../schema/index';
+import type { TIntersect } from '../intersect/index';
+import type { TUnion } from '../union/index';
+import type { TTuple } from '../tuple/index';
+export type RestResolve<T extends TSchema> = T extends TIntersect<infer S> ? [...S] : T extends TUnion<infer S> ? [...S] : T extends TTuple<infer S> ? [...S] : [
+];
+export declare function RestResolve<T extends TSchema>(T: T): RestResolve<T>;
+export type TRest<T extends TSchema> = RestResolve<T>;
+export declare function Rest<T extends TSchema>(T: T): TRest<T>;

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

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

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

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

package/build/types/type/schema/anyschema.d.ts

@@ -0,0 +1,32 @@
+import type { TAny } from '../any/index';
+import type { TArray } from '../array/index';
+import type { TAsyncIterator } from '../async-iterator/index';
+import type { TBigInt } from '../bigint/index';
+import type { TBoolean } from '../boolean/index';
+import type { TConstructor } from '../constructor/index';
+import type { TDate } from '../date/index';
+import type { TEnum } from '../enum/index';
+import type { TFunction } from '../function/index';
+import type { TInteger } from '../integer/index';
+import type { TIntersect } from '../intersect/index';
+import type { TIterator } from '../iterator/index';
+import type { TLiteral } from '../literal/index';
+import type { TNot } from '../not/index';
+import type { TNull } from '../null/index';
+import type { TNumber } from '../number/index';
+import type { TObject } from '../object/index';
+import type { TPromise } from '../promise/index';
+import type { TRecord } from '../record/index';
+import type { TThis } from '../recursive/index';
+import type { TRef } from '../ref/index';
+import type { TString } from '../string/index';
+import type { TSymbol } from '../symbol/index';
+import type { TTemplateLiteral } from '../template-literal/index';
+import type { TTuple } from '../tuple/index';
+import type { TUint8Array } from '../uint8array/index';
+import type { TUndefined } from '../undefined/index';
+import type { TUnion } from '../union/index';
+import type { TUnknown } from '../unknown/index';
+import type { TVoid } from '../void/index';
+import type { TSchema } from './schema';
+export type TAnySchema = TSchema | TAny | TArray | TAsyncIterator | TBigInt | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TIntersect | TIterator | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TString | TSymbol | TTemplateLiteral | TThis | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;

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

@@ -0,0 +1,2 @@
+export * from './anyschema';
+export * from './schema';

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

@@ -0,0 +1,22 @@
+import { Kind, Hint, ReadonlyKind, OptionalKind } from '../symbols/index';
+export interface SchemaOptions {
+    $schema?: string;
+    $id?: string;
+    title?: string;
+    description?: string;
+    default?: any;
+    examples?: any;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    [prop: string]: any;
+}
+export interface TKind {
+    [Kind]: string;
+}
+export interface TSchema extends SchemaOptions, TKind {
+    [ReadonlyKind]?: string;
+    [OptionalKind]?: string;
+    [Hint]?: string;
+    params: unknown[];
+    static: unknown;
+}

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

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

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

@@ -0,0 +1,31 @@
+import type { Evaluate } from '../helpers/index';
+import type { TOptional } from '../optional/index';
+import type { TReadonly } from '../readonly/index';
+import type { TArray } from '../array/index';
+import type { TAsyncIterator } from '../async-iterator/index';
+import type { TConstructor } from '../constructor/index';
+import type { TEnum } from '../enum/index';
+import type { TFunction } from '../function/index';
+import type { TIntersect } from '../intersect/index';
+import type { TIterator } from '../iterator/index';
+import type { TNot } from '../not/index';
+import type { TObject, TProperties } from '../object/index';
+import type { TPromise } from '../promise/index';
+import type { TRecursive } from '../recursive/index';
+import type { TRecord } from '../record/index';
+import type { TRef } from '../ref/index';
+import type { TTuple } from '../tuple/index';
+import type { TUnion } from '../union/index';
+import type { TUnsafe } from '../unsafe/index';
+import type { TSchema } from '../schema/index';
+import type { TTransform } from '../transform/index';
+export type DecodeProperties<T extends TProperties> = {
+    [K in keyof T]: DecodeType<T[K]>;
+};
+export type DecodeRest<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [DecodeType<L>, ...DecodeRest<R>] : [];
+export type DecodeType<T extends TSchema> = (T extends TOptional<infer S extends TSchema> ? TOptional<DecodeType<S>> : T extends TReadonly<infer S extends TSchema> ? TReadonly<DecodeType<S>> : T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S extends TSchema> ? TArray<DecodeType<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> : T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<DecodeRest<P>, DecodeType<R>> : T extends TEnum<infer S> ? TEnum<S> : T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<DecodeRest<P>, DecodeType<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<DecodeRest<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> : T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> : T extends TObject<infer S> ? TObject<Evaluate<DecodeProperties<S>>> : T extends TPromise<infer S extends TSchema> ? TPromise<DecodeType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, DecodeType<S>> : T extends TRecursive<infer S extends TSchema> ? TRecursive<DecodeType<S>> : T extends TRef<infer S extends TSchema> ? TRef<DecodeType<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<DecodeRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<DecodeRest<S>> : T);
+export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeType<T>, P>;
+export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>;
+export type Static<T extends TSchema, P extends unknown[] = []> = (T & {
+    params: P;
+})['static'];

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

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

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

@@ -0,0 +1,2 @@
+import type { TSchema } from '../schema/index';
+export declare function Strict<T extends TSchema>(schema: T): T;

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

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

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

@@ -0,0 +1,18 @@
+import { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
+export type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
+export interface StringOptions extends SchemaOptions {
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    format?: StringFormatOption;
+    contentEncoding?: StringContentEncodingOption;
+    contentMediaType?: string;
+}
+export interface TString extends TSchema, StringOptions {
+    [Kind]: 'String';
+    static: string;
+    type: 'string';
+}
+export declare function String(options?: StringOptions): TString;

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

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

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

@@ -0,0 +1,9 @@
+import { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export type SymbolValue = string | number | undefined;
+export interface TSymbol extends TSchema, SchemaOptions {
+    [Kind]: 'Symbol';
+    static: symbol;
+    type: 'symbol';
+}
+export declare function Symbol(options?: SchemaOptions): TSymbol;

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

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

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

@@ -0,0 +1,5 @@
+export declare const TransformKind: unique symbol;
+export declare const ReadonlyKind: unique symbol;
+export declare const OptionalKind: unique symbol;
+export declare const Hint: unique symbol;
+export declare const Kind: unique symbol;

package/build/types/type/template-literal/finite.d.ts

@@ -0,0 +1,16 @@
+import type { TTemplateLiteral, TTemplateLiteralKind } from './index';
+import type { TUnion } from '../union/index';
+import type { TString } from '../string/index';
+import type { TBoolean } from '../boolean/index';
+import type { TNumber } from '../number/index';
+import type { TInteger } from '../integer/index';
+import type { TBigInt } from '../bigint/index';
+import type { TLiteral } from '../literal/index';
+import type { Expression } from './parser';
+export declare class TemplateLiteralFiniteError extends Error {
+}
+type IsTemplateLiteralFiniteCheck<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? IsTemplateLiteralFiniteArray<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? IsTemplateLiteralFiniteArray<U> : T extends TString ? false : T extends TBoolean ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TLiteral ? true : false;
+type IsTemplateLiteralFiniteArray<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : IsTemplateLiteralFiniteArray<R> : true;
+export type IsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<U> : false;
+export declare function IsTemplateLiteralFinite(expression: Expression): boolean;
+export {};

package/build/types/type/template-literal/generate.d.ts

@@ -0,0 +1,15 @@
+import type { TTemplateLiteral, TTemplateLiteralKind } from './index';
+import type { TLiteral, TLiteralValue } from '../literal/index';
+import type { Expression } from './parser';
+import type { TUnion } from '../union/index';
+type StringReduceUnary<L extends string, R extends string[]> = R extends [infer A extends string, ...infer B extends string[]] ? [`${L}${A}`, ...StringReduceUnary<L, B>] : [];
+type StringReduceBinary<L extends string[], R extends string[]> = L extends [infer A extends string, ...infer B extends string[]] ? [...StringReduceUnary<A, R>, ...StringReduceBinary<B, R>] : [];
+type StringReduceMany<T extends string[][]> = T extends [infer L extends string[], infer R extends string[], ...infer Rest extends string[][]] ? StringReduceMany<[StringReduceBinary<L, R>, ...Rest]> : T;
+type StringReduce<T extends string[][], O = StringReduceMany<T>> = 0 extends keyof O ? O[0] : [];
+type TemplateLiteralReduceUnion<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [L['const'], ...TemplateLiteralReduceUnion<R>] : [];
+type TemplateLiteralReduce<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? L extends TLiteral<infer S extends TLiteralValue> ? [[S], ...TemplateLiteralReduce<R>] : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? [TemplateLiteralReduceUnion<S>, ...TemplateLiteralReduce<R>] : [] : [];
+export declare class TemplateLiteralGenerateError extends Error {
+}
+export type TemplateLiteralGenerate<T> = T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TemplateLiteralReduce<S> extends infer R extends string[][] ? StringReduce<R> : [] : [];
+export declare function TemplateLiteralGenerate(expression: Expression): IterableIterator<string>;
+export {};

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

@@ -0,0 +1,7 @@
+export * from './finite';
+export * from './generate';
+export * from './syntax';
+export * from './parser';
+export * from './pattern';
+export * from './union';
+export * from './template-literal';

package/build/types/type/template-literal/parser.d.ts

@@ -0,0 +1,17 @@
+export declare class TemplateLiteralParserError extends Error {
+}
+export type Expression = ExpressionAnd | ExpressionOr | ExpressionConst;
+export type ExpressionConst = {
+    type: 'const';
+    const: string;
+};
+export type ExpressionAnd = {
+    type: 'and';
+    expr: Expression[];
+};
+export type ExpressionOr = {
+    type: 'or';
+    expr: Expression[];
+};
+export declare function TemplateLiteralParse(pattern: string): Expression;
+export declare function TemplateLiteralParseExact(pattern: string): Expression;

package/build/types/type/template-literal/pattern.d.ts

@@ -0,0 +1,4 @@
+import type { TTemplateLiteralKind } from './index';
+export declare class TemplateLiteralPatternError extends Error {
+}
+export declare function TemplateLiteralPattern(kinds: TTemplateLiteralKind[]): string;

package/build/types/type/template-literal/syntax.d.ts

@@ -0,0 +1,19 @@
+import type { Ensure, Assert, Trim } from '../helpers/index';
+import type { TTemplateLiteralKind, TTemplateLiteral } from './index';
+import { type TLiteral } from '../literal/index';
+import { type TBoolean } from '../boolean/index';
+import { type TBigInt } from '../bigint/index';
+import { type TNumber } from '../number/index';
+import { type TString } from '../string/index';
+import { UnionResolve } from '../union/index';
+declare function FromUnion(syntax: string): IterableIterator<TTemplateLiteralKind>;
+declare function FromTerminal(syntax: string): IterableIterator<TTemplateLiteralKind>;
+type FromUnionLiteral<T extends string> = T extends `${infer L}|${infer R}` ? [TLiteral<Trim<L>>, ...FromUnionLiteral<R>] : T extends `${infer L}` ? [TLiteral<Trim<L>>] : [
+];
+type FromUnion<T extends string> = UnionResolve<FromUnionLiteral<T>>;
+type FromTerminal<T extends string> = T extends 'boolean' ? TBoolean : T extends 'bigint' ? TBigInt : T extends 'number' ? TNumber : T extends 'string' ? TString : FromUnion<T>;
+type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$${infer R}` ? [TLiteral<L>, ...FromString<R>] : T extends `${infer L}` ? [TLiteral<L>] : [
+];
+export type TemplateLiteralSyntax<T extends string> = Ensure<TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>>;
+export declare function TemplateLiteralSyntax(syntax: string): TTemplateLiteralKind[];
+export {};

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

@@ -0,0 +1,28 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Assert } from '../helpers/index';
+import type { TUnion } from '../union/index';
+import type { TLiteral } from '../literal/index';
+import type { TInteger } from '../integer/index';
+import type { TNumber } from '../number/index';
+import type { TBigInt } from '../bigint/index';
+import type { TString } from '../string/index';
+import type { TBoolean } from '../boolean/index';
+import type { TNever } from '../never/index';
+import type { Static } from '../static/index';
+import { TemplateLiteralSyntax } from './syntax';
+import { EmptyString } from '../helpers/index';
+import { Kind } from '../symbols/index';
+type TemplateLiteralResolveConst<T, Acc extends string> = T extends TUnion<infer U> ? {
+    [K in keyof U]: TemplateLiteralResolve<Assert<[U[K]], TTemplateLiteralKind[]>, Acc>;
+}[number] : T extends TTemplateLiteral ? `${Static<T>}` : T extends TLiteral<infer U> ? `${U}` : T extends TString ? `${string}` : T extends TNumber ? `${number}` : T extends TBigInt ? `${bigint}` : T extends TBoolean ? `${boolean}` : never;
+export type TemplateLiteralResolve<T extends TTemplateLiteralKind[], Acc extends string> = T extends [infer L, ...infer R] ? `${TemplateLiteralResolveConst<L, Acc>}${TemplateLiteralResolve<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
+export type TTemplateLiteralKind = TTemplateLiteral | TUnion | TLiteral | TInteger | TNumber | TBigInt | TString | TBoolean | TNever;
+export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
+    [Kind]: 'TemplateLiteral';
+    static: TemplateLiteralResolve<T, EmptyString>;
+    type: 'string';
+    pattern: string;
+}
+export declare function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+export declare function TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
+export {};

package/build/types/type/template-literal/union.d.ts

@@ -0,0 +1,6 @@
+import type { TTemplateLiteral } from './template-literal';
+import { type TUnion } from '../union/index';
+import { type TLiteral } from '../literal/index';
+import { type TString } from '../string/index';
+import { type TNever } from '../never/index';
+export declare function TemplateLiteralToUnion(template: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;

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

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

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

@@ -0,0 +1,28 @@
+import type { TSchema } from '../schema/index';
+import type { Static, StaticDecode } from '../static/index';
+import { TransformKind } from '../symbols/index';
+export declare class TransformDecodeBuilder<T extends TSchema> {
+    private readonly schema;
+    constructor(schema: T);
+    Decode<U extends unknown, D extends TransformFunction<StaticDecode<T>, U>>(decode: D): TransformEncodeBuilder<T, D>;
+}
+export declare class TransformEncodeBuilder<T extends TSchema, D extends TransformFunction> {
+    private readonly schema;
+    private readonly decode;
+    constructor(schema: T, decode: D);
+    private EncodeTransform;
+    private EncodeSchema;
+    Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>>;
+}
+export type TransformFunction<T = any, U = any> = (value: T) => U;
+export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
+    Decode: TransformFunction<StaticDecode<I>, O>;
+    Encode: TransformFunction<O, StaticDecode<I>>;
+}
+export type TTransformResolve<T extends TSchema, P extends unknown[] = []> = T extends TTransform<infer _, infer S> ? S : Static<T, P>;
+export interface TTransform<I extends TSchema = TSchema, O extends unknown = unknown> extends TSchema {
+    static: TTransformResolve<I, this['params']>;
+    [TransformKind]: TransformOptions<I, O>;
+    [key: string]: any;
+}
+export declare function Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;

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

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

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

@@ -0,0 +1,14 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+export type TupleResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TupleResolve<R, P>] : [];
+export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Tuple';
+    static: TupleResolve<T, this['params']>;
+    type: 'array';
+    items?: T;
+    additionalItems?: false;
+    minItems: number;
+    maxItems: number;
+}
+export declare function Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;

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

@@ -0,0 +1,5 @@
+export { JsonTypeBuilder } from './json';
+import { JavaScriptTypeBuilder } from './javascript';
+declare const Type: JavaScriptTypeBuilder;
+export { JavaScriptTypeBuilder };
+export { Type };