@sinclair/typebox 0.27.8 → 0.28.0

package/typebox.d.ts

@@ -19,6 +19,16 @@ 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 AssertProperties<T> = T extends TProperties ? T : TProperties;
+export type AssertSchemas<T, E extends TSchema[] = TSchema[]> = T extends E ? T : [];
+export type AssertSchema<T, E extends TSchema = TSchema> = T extends E ? T : TNever;
+export type AssertObjects<T> = Assert<T, TObject[]>;
+export type AssertObject<T> = Assert<T, TObject>;
+export type AssertKeys<T> = Assert<T, Key[]>;
+export type AssertKey<T> = Assert<T, Key>;
+export type Key = keyof any;
+export type IntersectType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertSchema<T[0]> : TIntersect<T>;
+export type UnionType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertSchema<T[0]> : TUnion<T>;
 export type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>;
 export type TReadonly<T extends TSchema> = T & {
     [Modifier]: 'Readonly';
@@ -53,7 +63,6 @@ export interface TSchema extends SchemaOptions, TKind {
     static: unknown;
 }
 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;
     exclusiveMinimum?: N;
@@ -89,20 +98,22 @@ export interface TBoolean extends TSchema {
 }
 export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>;
 export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
-export type TCompositeEvaluateArray<T extends readonly TSchema[], P extends unknown[]> = {
-    [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
-};
-export type TCompositeArray<T extends readonly TObject[]> = {
-    [K in keyof T]: T[K] extends TObject<infer P> ? P : {};
-};
-export type TCompositeProperties<I extends unknown, T extends readonly any[]> = Evaluate<T extends [infer A, ...infer B] ? TCompositeProperties<I & A, B> : I extends object ? I : {}>;
-export interface TComposite<T extends TObject[] = TObject[]> extends TObject {
-    [Hint]: 'Composite';
-    static: Evaluate<TCompositeProperties<unknown, TCompositeEvaluateArray<T, this['params']>>>;
-    properties: TCompositeProperties<unknown, TCompositeArray<T>>;
-}
+export type TCompositeIsOptional<T extends TSchema> = T extends TOptional<T> | TReadonlyOptional<T> ? true : false;
+export type TCompositeOptional<T extends TSchema[]> = T extends [infer L, ...infer R] ? TCompositeIsOptional<AssertSchema<L>> extends false ? false : TCompositeOptional<AssertSchemas<R>> : true;
+export type TCompositeKeyOfUnion1<T extends TObject> = keyof T['properties'];
+export type TCompositeKeyOfUnion2<T extends TObject[]> = T extends [infer L, ...infer R] ? TCompositeKeyOfUnion1<Assert<L, TObject>> | TCompositeKeyOfUnion2<Assert<R, TObject[]>> : never;
+export type TCompositeKeyOf<T extends TObject[]> = UnionToTuple<TCompositeKeyOfUnion2<T>>;
+export type TCompositePropertiesWithKey1<T extends TObject, K extends Key> = K extends keyof T['properties'] ? [T['properties'][K]] : [];
+export type TCompositePropertiesWithKey2<T extends TObject[], K extends Key> = T extends [infer L, ...infer R] ? [...TCompositePropertiesWithKey1<AssertObject<L>, K>, ...TCompositePropertiesWithKey2<AssertObjects<R>, K>] : [];
+export type TCompositeObjectProperty<T extends TObject[], K extends Key> = TCompositePropertiesWithKey2<T, K> extends infer S ? TCompositeOptional<AssertSchemas<S>> extends true ? {
+    [_ in K]: TOptional<IntersectType<AssertSchemas<S>>>;
+} : {
+    [_ in K]: IntersectType<AssertSchemas<S>>;
+} : {};
+export type TCompositeObjectsWithKeys<T extends TObject[], K extends Key[]> = K extends [infer L, ...infer R] ? L extends Key ? TCompositeObjectProperty<T, L> & TCompositeObjectsWithKeys<T, AssertKeys<R>> : {} : {};
+export type TComposite<T extends TObject[]> = Ensure<TObject<Evaluate<TCompositeObjectsWithKeys<T, AssertKeys<TCompositeKeyOf<T>>>>>>;
 export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{
-    [K in keyof T]: Static<Assert<T[K], TSchema>, P>;
+    [K in keyof T]: Static<AssertSchema<T[K]>, P>;
 }];
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Constructor';
@@ -133,25 +144,25 @@ export interface TEnum<T extends Record<string, string | number> = Record<string
     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<{
+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<[AssertSchema<X>, AssertSchema<Y>]> : AssertSchema<O> : never;
+export type TExcludeTemplateLiteralResult<T extends string> = UnionType<AssertSchemas<UnionToTuple<{
     [K in T]: TLiteral<K>;
-}[T]>, TSchema[]>>;
+}[T]>>>;
 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 TExcludeArray<T extends TSchema[], U extends TSchema> = AssertSchemas<UnionToTuple<{
+    [K in keyof T]: Static<AssertSchema<T[K]>> extends Static<U> ? never : T[K];
+}[number]>> extends infer R ? UnionType<AssertSchemas<R>> : never;
 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<{
+export type TExtractTemplateLiteralResult<T extends string> = UnionType<AssertSchemas<UnionToTuple<{
     [K in T]: TLiteral<K>;
-}[T]>, TSchema[]>>;
+}[T]>>>;
 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 TExtractArray<T extends TSchema[], U extends TSchema> = AssertSchemas<UnionToTuple<{
+    [K in keyof T]: Static<AssertSchema<T[K]>> extends Static<U> ? T[K] : never;
+}[number]>> extends infer R ? UnionType<AssertSchemas<R>> : never;
 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>;
+    [K in keyof T]: Static<AssertSchema<T[K]>, P>;
 }];
 export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Function';
@@ -161,6 +172,18 @@ export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends T
     parameters: T;
     returns: U;
 }
+export type IndexKey = keyof any;
+export type TIndexProperty<T extends TProperties, K extends IndexKey> = K extends keyof T ? [T[K]] : [
+];
+export type TIndexTuple<T extends TSchema[], K extends IndexKey> = K extends keyof T ? [T[K]] : [
+];
+export type TIndexComposite<T extends TSchema[], K extends IndexKey> = T extends [infer L, ...infer R] ? [...TIndexKey<AssertSchema<L>, K>, ...TIndexComposite<AssertSchemas<R>, K>] : [
+];
+export type TIndexKey<T extends TSchema, K extends IndexKey> = T extends TRecursive<infer S> ? TIndexKey<S, K> : T extends TIntersect<infer S> ? TIndexComposite<S, K> : T extends TUnion<infer S> ? TIndexComposite<S, K> : T extends TObject<infer S> ? TIndexProperty<S, K> : T extends TTuple<infer S> ? TIndexTuple<S, K> : T extends TArray<infer S> ? S : [
+];
+export type TIndexKeys<T extends TSchema, K extends IndexKey[]> = K extends [infer L, ...infer R] ? [...TIndexKey<T, Assert<L, IndexKey>>, ...TIndexKeys<T, Assert<R, IndexKey[]>>] : [
+];
+export type TIndex<T extends TSchema, K extends IndexKey[]> = TIndexKeys<T, K> extends infer R ? T extends TRecursive<infer S> ? TIndex<S, K> : T extends TTuple ? UnionType<AssertSchemas<R>> : T extends TIntersect ? UnionType<AssertSchemas<R>> : T extends TUnion ? UnionType<AssertSchemas<R>> : T extends TObject ? UnionType<AssertSchemas<R>> : T extends TArray ? UnionType<AssertSchemas<R>> : TNever : TNever;
 export interface TInteger extends TSchema, NumericOptions<number> {
     [Kind]: 'Integer';
     static: number;
@@ -173,18 +196,20 @@ export interface IntersectOptions extends SchemaOptions {
 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']>;
+        [K in keyof T]: Static<AssertSchema<T[K]>, this['params']>;
     }>;
     type?: 'object';
     allOf: [...T];
 }
-export type TKeyOfTuple<T extends TSchema> = {
-    [K in keyof Static<T>]: TLiteral<Assert<K, TLiteralValue>>;
-} extends infer U ? UnionToTuple<Exclude<{
-    [K in keyof U]: U[K];
-}[keyof U], undefined>> : never;
-export type TKeyOf<T extends TSchema = TSchema> = (T extends TRecursive<infer S> ? TKeyOfTuple<S> : 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 TKeyOfProperties<T extends TSchema> = Static<T> extends infer S ? UnionToTuple<{
+    [K in keyof S]: TLiteral<`${Assert<K, TLiteralValue>}`>;
+}[keyof S]> : [];
+export type TKeyOfIndicesArray<T extends TSchema[]> = UnionToTuple<keyof T & `${number}`>;
+export type TKeyOfIndices<T extends TSchema[]> = AssertSchemas<TKeyOfIndicesArray<T> extends infer R ? {
+    [K in keyof R]: TLiteral<Assert<R[K], TLiteralValue>>;
+} : []>;
+export type TKeyOf<T extends TSchema = TSchema> = (T extends TRecursive<infer S> ? TKeyOfProperties<S> : T extends TIntersect ? TKeyOfProperties<T> : T extends TUnion ? TKeyOfProperties<T> : T extends TObject ? TKeyOfProperties<T> : T extends TTuple<infer K> ? TKeyOfIndices<K> : T extends TArray ? [TNumber] : T extends TRecord<infer K> ? [K] : [
+]) extends infer R ? UnionType<AssertSchemas<R>> : never;
 export type TLiteralValue = string | number | boolean;
 export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
     [Kind]: 'Literal';
@@ -244,29 +269,29 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
     properties: T;
     required?: string[];
 }
-export type TOmitArray<T extends TSchema[], K extends keyof any> = Assert<{
-    [K2 in keyof T]: TOmit<Assert<T[K2], TSchema>, K>;
-}, TSchema[]>;
-export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<Assert<Omit<T, K>, TProperties>>;
-export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> : T extends TComposite<infer S> ? TComposite<TOmitArray<S, K>> : T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : T;
-export type TParameters<T extends TFunction> = TTuple<T['parameters']>;
-export type TPartialObjectArray<T extends TObject[]> = Assert<{
-    [K in keyof T]: TPartial<Assert<T[K], TObject>>;
+export type TOmitArray<T extends TSchema[], K extends keyof any> = AssertSchemas<{
+    [K2 in keyof T]: TOmit<AssertSchema<T[K2]>, K>;
+}>;
+export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<AssertProperties<Omit<T, K>>>;
+export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> : T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : T;
+export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>;
+export type TPartialObjectArray<T extends TObject[]> = AssertSchemas<{
+    [K in keyof T]: TPartial<AssertSchema<T[K], TObject>>;
 }, TObject[]>;
-export type TPartialArray<T extends TSchema[]> = Assert<{
-    [K in keyof T]: TPartial<Assert<T[K], TSchema>>;
-}, TSchema[]>;
-export type TPartialProperties<T extends TProperties> = Evaluate<Assert<{
+export type TPartialArray<T extends TSchema[]> = AssertSchemas<{
+    [K in keyof T]: TPartial<AssertSchema<T[K]>>;
+}>;
+export type TPartialProperties<T extends TProperties> = Evaluate<AssertProperties<{
     [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : T[K] extends TReadonly<infer U> ? TReadonlyOptional<U> : T[K] extends TOptional<infer U> ? TOptional<U> : TOptional<T[K]>;
-}, TProperties>>;
-export type TPartial<T extends TSchema> = T extends TRecursive<infer S> ? TRecursive<TPartial<S>> : T extends TComposite<infer S> ? TComposite<TPartialArray<S>> : T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : T extends TUnion<infer S> ? TUnion<TPartialArray<S>> : T extends TObject<infer S> ? TObject<TPartialProperties<S>> : T;
+}>>;
+export type TPartial<T extends TSchema> = T extends TRecursive<infer S> ? TRecursive<TPartial<S>> : T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : T extends TUnion<infer S> ? TUnion<TPartialArray<S>> : T extends TObject<infer S> ? TObject<TPartialProperties<S>> : T;
 export type TPickArray<T extends TSchema[], K extends keyof any> = {
-    [K2 in keyof T]: TPick<Assert<T[K2], TSchema>, K>;
+    [K2 in keyof T]: TPick<AssertSchema<T[K2]>, K>;
 };
 export type TPickProperties<T extends TProperties, K extends keyof any> = Pick<T, Assert<Extract<K, keyof T>, keyof T>> extends infer R ? ({
-    [K in keyof R]: Assert<R[K], TSchema> extends TSchema ? R[K] : never;
+    [K in keyof R]: AssertSchema<R[K]> extends TSchema ? R[K] : never;
 }) : never;
-export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> : 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 TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TPick<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 interface TPromise<T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Promise';
     static: Promise<Static<T, this['params']>>;
@@ -294,7 +319,7 @@ export interface TRecord<K extends RecordKey = RecordKey, T extends TSchema = TS
     patternProperties: {
         [pattern: string]: T;
     };
-    additionalProperties: false;
+    additionalProperties: TAdditionalProperties;
 }
 export interface TThis extends TSchema {
     [Kind]: 'This';
@@ -312,23 +337,23 @@ export interface TRef<T extends TSchema = TSchema> extends TSchema {
     $ref: string;
 }
 export type TReturnType<T extends TFunction> = T['returns'];
-export type TRequiredArray<T extends TSchema[]> = Assert<{
-    [K in keyof T]: TRequired<Assert<T[K], TSchema>>;
-}, TSchema[]>;
-export type TRequiredProperties<T extends TProperties> = Evaluate<Assert<{
+export type TRequiredArray<T extends TSchema[]> = AssertSchemas<{
+    [K in keyof T]: TRequired<AssertSchema<T[K]>>;
+}>;
+export type TRequiredProperties<T extends TProperties> = Evaluate<AssertProperties<{
     [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> : T[K] extends TReadonly<infer U> ? TReadonly<U> : T[K] extends TOptional<infer U> ? U : T[K];
-}, TProperties>>;
-export type TRequired<T extends TSchema> = T extends TRecursive<infer S> ? TRecursive<TRequired<S>> : T extends TComposite<infer S> ? TComposite<TRequiredArray<S>> : T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : T extends TUnion<infer S> ? TUnion<TRequiredArray<S>> : T extends TObject<infer S> ? TObject<TRequiredProperties<S>> : T;
+}>>;
+export type TRequired<T extends TSchema> = T extends TRecursive<infer S> ? TRecursive<TRequired<S>> : T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : T extends TUnion<infer S> ? TUnion<TRequiredArray<S>> : T extends TObject<infer S> ? TObject<TRequiredProperties<S>> : T;
 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';
-export interface StringOptions<Format extends string> extends SchemaOptions {
+export interface StringOptions extends SchemaOptions {
     minLength?: number;
     maxLength?: number;
     pattern?: string;
-    format?: Format;
+    format?: string;
     contentEncoding?: '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64';
     contentMediaType?: string;
 }
-export interface TString<Format extends string = string> extends TSchema, StringOptions<Format> {
+export interface TString extends TSchema, StringOptions {
     [Kind]: 'String';
     static: string;
     type: 'string';
@@ -341,20 +366,21 @@ export interface TSymbol extends TSchema, SchemaOptions {
     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 IsTemplateLiteralFiniteArray<T extends TTemplateLiteralKind[]> = T extends [infer L, ...infer R] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : IsTemplateLiteralFiniteArray<Assert<R, TTemplateLiteralKind[]>> : 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 type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
+export type TTemplateLiteralKeyArray<T extends TTemplateLiteral> = AssertKeys<UnionToTuple<Static<T>>>;
 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 TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? AssertSchemas<R> : never;
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
     static: {
@@ -372,12 +398,10 @@ export interface TUndefined extends TSchema {
     type: 'null';
     typeOf: 'Undefined';
 }
-export type TUnionOfLiteralArray<T extends TLiteral<string>[]> = {
-    [K in keyof T]: Assert<T[K], TLiteral>['const'];
-}[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<{
+export type TLiteralUnionReduce<T extends TLiteral<string | number>[]> = T extends [infer L, ...infer R] ? [Assert<L, TLiteral<string | number>>['const'], ...TLiteralUnionReduce<Assert<R, TLiteral<string>[]>>] : [
+];
+export type TLiteralUnion<T extends TUnion<TLiteral<string | number>[]>> = T extends TUnion<infer S> ? TLiteralUnionReduce<Assert<S, TLiteral<string | number>[]>> : [];
+export type TUnionTemplateLiteral<T extends TTemplateLiteral, S extends string = Static<T>> = Ensure<UnionType<Assert<UnionToTuple<{
     [K in S]: TLiteral<K>;
 }[S]>, TLiteral[]>>>;
 export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
@@ -472,6 +496,14 @@ export declare namespace TypeGuard {
     function TIntersect(schema: unknown): schema is TIntersect;
     /** Returns true if the given schema is TKind */
     function TKind(schema: unknown): schema is Record<typeof Kind | string, unknown>;
+    /** Returns true if the given schema is TLiteral<string> */
+    function TLiteralString(schema: unknown): schema is TLiteral<string>;
+    /** Returns true if the given schema is TLiteral<number> */
+    function TLiteralNumber(schema: unknown): schema is TLiteral<number>;
+    /** Returns true if the given schema is TLiteral<boolean> */
+    function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean>;
+    /** Returns true if the given schema is TUnion<Literal<string>[]> */
+    function TLiteralUnion(schema: unknown): schema is TUnion<TLiteral<string>[]>;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema: unknown): schema is TLiteral;
     /** Returns true if the given schema is TNever */
@@ -504,8 +536,6 @@ export declare namespace TypeGuard {
     function TUndefined(schema: unknown): schema is TUndefined;
     /** Returns true if the given schema is TUnion */
     function TUnion(schema: unknown): schema is TUnion;
-    /** Returns true if the given schema is TUnion<Literal<string>[]> */
-    function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral<string>[]>;
     /** Returns true if the given schema is TUint8Array */
     function TUint8Array(schema: unknown): schema is TUint8Array;
     /** Returns true if the given schema is TUnknown */
@@ -540,16 +570,30 @@ export declare namespace TypeClone {
     /** Clones a type. */
     function Clone<T extends TSchema>(schema: T, options: SchemaOptions): T;
 }
+export declare namespace IndexedAccessor {
+    function Resolve(schema: TSchema, keys: string[]): TSchema[];
+}
 export declare namespace ObjectMap {
     function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T;
 }
+export interface KeyResolverOptions {
+    includePatterns: boolean;
+}
 export declare namespace KeyResolver {
-    function Resolve<T extends TSchema>(schema: T): string[];
+    /** Resolves an array of keys in this schema */
+    function ResolveKeys(schema: TSchema, options: KeyResolverOptions): string[];
+    /** Resolves a regular expression pattern matching all keys in this schema */
+    function ResolvePattern(schema: TSchema): string;
+}
+export declare namespace KeyArrayResolver {
+    /** Resolves an array of string[] keys from the given schema or array type. */
+    function Resolve(schema: TSchema | string[]): string[];
 }
 export declare namespace TemplateLiteralPattern {
     function Create(kinds: TTemplateLiteralKind[]): string;
 }
 export declare namespace TemplateLiteralResolver {
+    /** Resolves a template literal as a TUnion */
     function Resolve(template: TTemplateLiteral): TString | TUnion | TLiteral;
 }
 export declare class TemplateLiteralParserError extends Error {
@@ -609,6 +653,18 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Exclude<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExclude<L, R>;
     /** `[Standard]` Extracts from the left type any type that is assignable to the right */
     Extract<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExtract<L, R>;
+    /** `[Standard]` Returns indexed property types for the given keys */
+    Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, K>;
+    /** `[Standard]` Returns indexed property types for the given keys */
+    Index<T extends TSchema, K extends TUnion<TLiteral<string | number>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TLiteralUnion<K>>;
+    /** `[Standard]` Returns indexed property types for the given keys */
+    Index<T extends TSchema, K extends TLiteral<string | number>>(schema: T, key: K, options?: SchemaOptions): TIndex<T, [K['const']]>;
+    /** `[Standard]` Returns indexed property types for the given keys */
+    Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyArray<K>>;
+    /** `[Standard]` Returns indexed property types for the given keys */
+    Index<T extends TArray, K extends TNumber>(schema: T, key: K, options?: SchemaOptions): T['items'];
+    /** `[Standard]` Returns indexed property types for the given keys */
+    Index<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TIndex<T, never>;
     /** `[Standard]` Creates an Integer type */
     Integer(options?: NumericOptions<number>): TInteger;
     /** `[Standard]` Creates a Intersect type */
@@ -633,20 +689,24 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>;
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
-    Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionOfLiteral<K>>;
+    Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TLiteralUnion<K>[number]>;
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TOmit<T, K['const']>;
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
+    Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyArray<K>[number]>;
+    /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TOmit<T, never>;
     /** `[Standard]` Creates a mapped type where all properties are Optional */
     Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
     /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TPick<T, K[number]>;
     /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionOfLiteral<K>>;
+    Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TLiteralUnion<K>[number]>;
     /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
     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 TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyArray<K>[number]>;
+    /** `[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 a Record type */
     Record<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordUnionLiteralType<K, T>;
@@ -665,7 +725,7 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     /** `[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>;
+    String(options?: StringOptions): TString;
     /** `[Standard]` Creates a template literal type */
     TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
     /** `[Standard]` Creates a Tuple type */