@sinclair/typebox 0.26.8 → 0.27.0

package/typebox.d.ts

@@ -1,6 +1,12 @@
 export declare const Modifier: unique symbol;
 export declare const Hint: unique symbol;
 export declare const Kind: unique symbol;
+export declare const PatternBoolean = "(true|false)";
+export declare const PatternNumber = "(0|[1-9][0-9]*)";
+export declare const PatternString = ".*";
+export declare const PatternBooleanExact: string;
+export declare const PatternNumberExact: string;
+export declare const PatternStringExact: string;
 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];
@@ -46,7 +52,7 @@ export interface TSchema extends SchemaOptions, TKind {
     params: unknown[];
     static: unknown;
 }
-export type TAnySchema = TSchema | TAny | TArray | TBigInt | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TIntersect | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TSelf | TString | TSymbol | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
+export type TAnySchema = TSchema | TAny | TArray | TBigInt | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TIntersect | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TString | TSymbol | TTemplateLiteral | TThis | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
 export type TNumeric = TInteger | TNumber;
 export interface NumericOptions<N extends number | bigint> extends SchemaOptions {
     exclusiveMaximum?: N;
@@ -122,21 +128,28 @@ export interface TEnumOption<T> {
     type: 'number' | 'string';
     const: T;
 }
-export type TEnumStatic<T extends Record<string, string | number>> = T[keyof T];
 export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
     [Kind]: 'Union';
-    static: TEnumStatic<T>;
+    static: T[keyof T];
     anyOf: TLiteral<string | number>[];
 }
 export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = (Static<L> extends Static<R> ? T : U) extends infer O ? UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[Assert<X, TSchema>, Assert<Y, TSchema>]> : Assert<O, TSchema> : never;
+export type TExcludeTemplateLiteralResult<T extends string> = TUnionResult<Assert<UnionToTuple<{
+    [K in T]: TLiteral<K>;
+}[T]>, TSchema[]>>;
+export type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never;
 export type TExcludeArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<{
     [K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? never : T[K];
 }[number]>, TSchema[]> extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never;
-export type TExclude<T extends TSchema, U extends TSchema> = T extends TUnion<infer S> ? TExcludeArray<S, U> : T extends U ? TNever : T;
+export type TExclude<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? TExcludeArray<S, U> : T extends U ? TNever : T;
+export type TExtractTemplateLiteralResult<T extends string> = TUnionResult<Assert<UnionToTuple<{
+    [K in T]: TLiteral<K>;
+}[T]>, TSchema[]>>;
+export type TExtractTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never;
 export type TExtractArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<{
     [K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? T[K] : never;
 }[number]>, TSchema[]> extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never;
-export type TExtract<T extends TSchema, U extends TSchema> = T extends TUnion<infer S> ? TExtractArray<S, U> : T extends U ? T : TNever;
+export type TExtract<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? TExtractTemplateLiteral<T, U> : T extends TUnion<infer S> ? TExtractArray<S, U> : T extends U ? T : T;
 export type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: Static<Assert<T[K], TSchema>, P>;
 }];
@@ -157,13 +170,12 @@ export type TUnevaluatedProperties = undefined | TSchema | boolean;
 export interface IntersectOptions extends SchemaOptions {
     unevaluatedProperties?: TUnevaluatedProperties;
 }
-export type TIntersectStatic<T extends TSchema[], P extends unknown[]> = TupleToIntersect<{
-    [K in keyof T]: Static<Assert<T[K], TSchema>, P>;
-}>;
 export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
     [Kind]: 'Intersect';
+    static: TupleToIntersect<{
+        [K in keyof T]: Static<Assert<T[K], TSchema>, this['params']>;
+    }>;
     type?: 'object';
-    static: TIntersectStatic<T, this['params']>;
     allOf: [...T];
 }
 export type TKeyOfTuple<T extends TSchema> = {
@@ -171,7 +183,7 @@ export type TKeyOfTuple<T extends TSchema> = {
 } extends infer U ? UnionToTuple<Exclude<{
     [K in keyof U]: U[K];
 }[keyof U], undefined>> : never;
-export type TKeyOf<T extends TSchema = TSchema> = (T extends TComposite ? TKeyOfTuple<T> : T extends TIntersect ? TKeyOfTuple<T> : T extends TUnion ? TKeyOfTuple<T> : T extends TObject ? TKeyOfTuple<T> : [
+export type TKeyOf<T extends TSchema = TSchema> = (T extends TComposite ? TKeyOfTuple<T> : T extends TIntersect ? TKeyOfTuple<T> : T extends TUnion ? TKeyOfTuple<T> : T extends TObject ? TKeyOfTuple<T> : T extends TRecord<infer K> ? [K] : [
 ]) extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never;
 export type TLiteralValue = string | number | boolean;
 export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
@@ -184,10 +196,9 @@ export interface TNever extends TSchema {
     static: never;
     not: {};
 }
-export type TNotStatic<_ extends TSchema = TSchema, T extends TSchema = TSchema> = Static<T>;
 export interface TNot<Not extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Not';
-    static: TNotStatic<Not, T>;
+    static: Static<T>;
     allOf: [{
         not: Not;
     }, T];
@@ -256,33 +267,37 @@ export type TPickProperties<T extends TProperties, K extends keyof any> = Pick<T
     [K in keyof R]: Assert<R[K], TSchema> extends TSchema ? R[K] : never;
 }) : never;
 export type TPick<T extends TSchema, K extends keyof any> = T extends TComposite<infer S> ? TComposite<TPickArray<S, K>> : T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : T extends TObject<infer S> ? TObject<TPickProperties<S, K>> : T;
-export type TPromiseStatic<T extends TSchema, P extends unknown[]> = Promise<Static<T, P>>;
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Promise';
-    static: TPromiseStatic<T, this['params']>;
+    static: Promise<Static<T, this['params']>>;
     type: 'object';
     instanceOf: 'Promise';
     item: TSchema;
 }
-export type TRecordKey = TString | TNumeric | TUnion<TLiteral<any>[]>;
-export type TRecordPropertiesFromUnionLiteral<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema> = Static<K> extends string ? {
+export type RecordTemplateLiteralObjectType<K extends TTemplateLiteral, T extends TSchema> = Ensure<TObject<Evaluate<{
+    [_ in Static<K>]: T;
+}>>>;
+export type RecordTemplateLiteralType<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends true ? RecordTemplateLiteralObjectType<K, T> : TRecord<TString, T>;
+export type RecordUnionLiteralType<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema> = Static<K> extends string ? Ensure<TObject<{
     [X in Static<K>]: T;
-} : never;
-export type TRecordPropertiesFromLiteral<K extends TLiteral<string | number>, T extends TSchema> = Evaluate<{
+}>> : never;
+export type RecordLiteralType<K extends TLiteral<string | number>, T extends TSchema> = Ensure<TObject<{
     [K2 in K['const']]: T;
-}>;
-export type TRecordStatic<K extends TRecordKey, T extends TSchema, P extends unknown[]> = Record<Static<K>, Static<T, P>>;
-export interface TRecord<K extends TRecordKey = TRecordKey, T extends TSchema = TSchema> extends TSchema {
+}>>;
+export type RecordNumberType<K extends TInteger | TNumber, T extends TSchema> = Ensure<TRecord<K, T>>;
+export type RecordStringType<K extends TString, T extends TSchema> = Ensure<TRecord<K, T>>;
+export type RecordKey = TUnion<TLiteral<string | number>[]> | TLiteral<string | number> | TTemplateLiteral | TInteger | TNumber | TString;
+export interface TRecord<K extends RecordKey = RecordKey, T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Record';
-    static: TRecordStatic<K, T, this['params']>;
+    static: Record<Static<K>, Static<T, this['params']>>;
     type: 'object';
     patternProperties: {
         [pattern: string]: T;
     };
     additionalProperties: false;
 }
-export interface TSelf extends TSchema {
-    [Kind]: 'Self';
+export interface TThis extends TSchema {
+    [Kind]: 'This';
     static: this['params'][0];
     $ref: string;
 }
@@ -290,10 +305,9 @@ export type TRecursiveReduce<T extends TSchema> = Static<T, [TRecursiveReduce<T>
 export interface TRecursive<T extends TSchema> extends TSchema {
     static: TRecursiveReduce<T>;
 }
-export type TRefStatic<T extends TSchema, P extends unknown[]> = Static<T, P>;
 export interface TRef<T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Ref';
-    static: TRefStatic<T, this['params']>;
+    static: Static<T, this['params']>;
     $ref: string;
 }
 export type TReturnType<T extends TFunction> = T['returns'];
@@ -325,13 +339,26 @@ export interface TSymbol extends TSchema, SchemaOptions {
     type: 'null';
     typeOf: 'Symbol';
 }
+export type IsTemplateLiteralFiniteCheck<T> = T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<Assert<U, TTemplateLiteralKind[]>> : T extends TUnion<infer U> ? IsTemplateLiteralFiniteArray<Assert<U, TTemplateLiteralKind[]>> : 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;
+export type IsTemplateLiteralFiniteArray<T extends TTemplateLiteralKind[]> = T extends [infer L, ...infer R] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : IsTemplateLiteralFiniteArray<Assert<R, TTemplateLiteralKind[]>> : T extends [infer L] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : true : true;
+export type IsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<U> : false;
+export type TTemplateLiteralKind = TUnion | TLiteral | TInteger | TTemplateLiteral | TNumber | TBigInt | TString | TBoolean | TNever;
+export type TTemplateLiteralConst<T, Acc extends string> = T extends TUnion<infer U> ? {
+    [K in keyof U]: TTemplateLiteralUnion<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 TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` : T extends [infer L] ? `${TTemplateLiteralConst<L, Acc>}${Acc}` : Acc;
+export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
+    [Kind]: 'TemplateLiteral';
+    static: TTemplateLiteralUnion<T>;
+    type: 'string';
+    pattern: string;
+}
 export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? Assert<R, TSchema[]> : never;
-export type TTupleStatic<T extends TSchema[], P extends unknown[]> = {
-    [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : T[K];
-};
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
-    static: TTupleStatic<T, this['params']>;
+    static: {
+        [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : T[K];
+    };
     type: 'array';
     items?: T;
     additionalItems?: false;
@@ -349,6 +376,9 @@ export type TUnionOfLiteralArray<T extends TLiteral<string>[]> = {
 }[number];
 export type TUnionOfLiteral<T extends TUnion<TLiteral<string>[]>> = TUnionOfLiteralArray<T['anyOf']>;
 export type TUnionResult<T extends TSchema[]> = T extends [] ? TNever : T extends [infer S] ? S : TUnion<T>;
+export type TUnionTemplateLiteral<T extends TTemplateLiteral, S extends string = Static<T>> = Ensure<TUnionResult<Assert<UnionToTuple<{
+    [K in S]: TLiteral<K>;
+}[S]>, TLiteral[]>>>;
 export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Union';
     static: {
@@ -425,7 +455,7 @@ export declare namespace TypeGuard {
     function TAny(schema: unknown): schema is TAny;
     /** Returns true if the given schema is TArray */
     function TArray(schema: unknown): schema is TArray;
-    /** Returns true if the given schema is TSymbol */
+    /** Returns true if the given schema is TBigInt */
     function TBigInt(schema: unknown): schema is TBigInt;
     /** Returns true if the given schema is TBoolean */
     function TBoolean(schema: unknown): schema is TBoolean;
@@ -457,14 +487,16 @@ export declare namespace TypeGuard {
     function TPromise(schema: unknown): schema is TPromise;
     /** Returns true if the given schema is TRecord */
     function TRecord(schema: unknown): schema is TRecord;
-    /** Returns true if the given schema is TSelf */
-    function TSelf(schema: unknown): schema is TSelf;
     /** Returns true if the given schema is TRef */
     function TRef(schema: unknown): schema is TRef;
     /** Returns true if the given schema is TString */
     function TString(schema: unknown): schema is TString;
     /** Returns true if the given schema is TSymbol */
     function TSymbol(schema: unknown): schema is TSymbol;
+    /** Returns true if the given schema is TTemplateLiteral */
+    function TTemplateLiteral(schema: unknown): schema is TTemplateLiteral;
+    /** Returns true if the given schema is TThis */
+    function TThis(schema: unknown): schema is TThis;
     /** Returns true if the given schema is TTuple */
     function TTuple(schema: unknown): schema is TTuple;
     /** Returns true if the given schema is TUndefined */
@@ -513,6 +545,40 @@ export declare namespace ObjectMap {
 export declare namespace KeyResolver {
     function Resolve<T extends TSchema>(schema: T): string[];
 }
+export declare namespace TemplateLiteralPattern {
+    function Create(kinds: TTemplateLiteralKind[]): string;
+}
+export declare namespace TemplateLiteralResolver {
+    function Resolve(template: TTemplateLiteral): TString | TUnion | TLiteral;
+}
+export declare class TemplateLiteralParserError extends Error {
+    constructor(message: string);
+}
+export declare namespace TemplateLiteralParser {
+    type Expression = And | Or | Const;
+    type Const = {
+        type: 'const';
+        const: string;
+    };
+    type And = {
+        type: 'and';
+        expr: Expression[];
+    };
+    type Or = {
+        type: 'or';
+        expr: Expression[];
+    };
+    /** Parses a pattern and returns an expression tree */
+    function Parse(pattern: string): Expression;
+    /** Parses a pattern and strips forward and trailing ^ and $ */
+    function ParseExact(pattern: string): Expression;
+}
+export declare namespace TemplateLiteralFinite {
+    function Check(expression: TemplateLiteralParser.Expression): boolean;
+}
+export declare namespace TemplateLiteralGenerator {
+    function Generate(expression: TemplateLiteralParser.Expression): IterableIterator<string>;
+}
 export declare class TypeBuilder {
     /** `[Utility]` Creates a schema without `static` and `params` types */
     protected Create<T>(schema: Omit<T, 'static' | 'params'>): T;
@@ -581,20 +647,26 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Pick<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TPick<T, K['const']>;
     /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TPick<T, never>;
-    /** `[Standard]` Creates an Object type from the given Literal Union */
-    Record<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordPropertiesFromUnionLiteral<K, T>>;
-    /** `[Standard]` Creates an Object type from the given Literal Union */
-    Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TObject<TRecordPropertiesFromLiteral<K, T>>;
     /** `[Standard]` Creates a Record type */
-    Record<K extends TString | TNumeric, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecord<K, T>;
+    Record<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema>(key: K, schema: T): RecordUnionLiteralType<K, T>;
+    /** `[Standard]` Creates a Record type */
+    Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T): RecordLiteralType<K, T>;
+    /** `[Standard]` Creates a Record type */
+    Record<K extends TTemplateLiteral, T extends TSchema>(key: K, schema: T): RecordTemplateLiteralType<K, T>;
+    /** `[Standard]` Creates a Record type */
+    Record<K extends TInteger | TNumber, T extends TSchema>(key: K, schema: T): RecordNumberType<K, T>;
+    /** `[Standard]` Creates a Record type */
+    Record<K extends TString, T extends TSchema>(key: K, schema: T): RecordStringType<K, T>;
     /** `[Standard]` Creates a Recursive type */
-    Recursive<T extends TSchema>(callback: (self: TSelf) => T, options?: SchemaOptions): TRecursive<T>;
+    Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
     /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
     Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
     /** `[Standard]` Creates a mapped type where all properties are Required */
     Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
     /** `[Standard]` Creates a String type */
     String<Format extends string>(options?: StringOptions<StringFormatOption | Format>): TString<Format>;
+    /** `[Standard]` Creates a template literal type */
+    TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
     /** `[Standard]` Creates a Tuple type */
     Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
     /** `[Standard]` Creates a Union type */
@@ -603,6 +675,8 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Union<T extends [TSchema]>(anyOf: [...T], options?: SchemaOptions): T[0];
     /** `[Standard]` Creates a Union type */
     Union<T extends TSchema[]>(anyOf: [...T], options?: SchemaOptions): TUnion<T>;
+    /** `[Experimental]` Remaps a TemplateLiteral into a Union representation. This function is known to cause TS compiler crashes for finite templates with large generation counts. Use with caution. */
+    Union<T extends TTemplateLiteral>(template: T): TUnionTemplateLiteral<T>;
     /** `[Standard]` Creates an Unknown type */
     Unknown(options?: SchemaOptions): TUnknown;
     /** `[Standard]` Creates a Unsafe type that infers for the generic argument */