@sinclair/typebox 0.28.3 → 0.28.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.3",
+  "version": "0.28.5",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -83,7 +83,7 @@ License MIT
   - [Conditional](#types-conditional)
   - [Template](#types-template-literal)
   - [Indexed](#types-indexed)
-  - [Variadic](#types-variadic)
+  - [Rest](#types-rest)
   - [Guards](#types-guards)
   - [Unsafe](#types-unsafe)
   - [Strict](#types-strict)
@@ -872,30 +872,43 @@ const A = Type.Index(T, ['x'])                       // type A = T['x']
 
 const B = Type.Index(T, Type.KeyOf(T))               // type B = T[keyof T]
 ```
-<a name='types-variadic'></a>
+<a name='types-rest'></a>
 
-### Variadic Types
+### Rest Types
 
-Variadic types are supported with `Type.Rest`. This type will extract interior types from a tuple and return them as a flat array. This array can then be passed to other types that accept arrays as arguments.
-
-The following creates variadic functions using the Rest type.
+Rest parameters are supported with `Type.Rest`. This function is used to extract interior arrays from tuples to allow them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatination and variadic function composition.
 
 ```typescript
 // TypeScript
 
-type P = [number, number]
+type T = [number, number]                            // type T = [number, number]
 
-type F1 = (param: [...P]) => void
+type C = [...T, number]                              // type C = [number, number, number]
 
-type F2 = (param: [...P, number]) => void
+type F = (...param: C) => void                       // type F = (
+                                                     //   param0: number,
+                                                     //   param1: number,
+                                                     //   param2: number,
+                                                     // ) => void
 
 // TypeBox
 
-const P = Type.Tuple([Type.Number(), Type.Number()])
-
-const F1 = Type.Function(Type.Rest(P), Type.Void())
-
-const F2 = Type.Function([...Type.Rest(P), Type.Number()], Type.Void())
+const T = Type.Tuple([                               // const T: TTuple<[
+  Type.Number(),                                     //   TNumber,
+  Type.Number()                                      //   TNumber,
+])                                                   // ]>
+
+const C = Type.Tuple([                               // const C: TTuple<[
+  ...Type.Rest(T),                                   //   TNumber,
+  Type.Number()                                      //   TNumber,
+])                                                   //   TNumber
+                                                     // ]>
+
+const F = Type.Function(Type.Rest(C), Type.Void())   // const F: TFunction<[
+                                                     //   TNumber,
+                                                     //   TNumber,
+                                                     //   TNumber
+                                                     // ], TVoid>
 ```
 <a name='types-unsafe'></a>
 
@@ -1476,11 +1489,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '126.7 kb' │ ' 56.6 kb' │  '2.24 x'   │
-│ typebox/errors       │ '110.4 kb' │ ' 48.8 kb' │  '2.26 x'   │
-│ typebox/system       │ ' 75.9 kb' │ ' 31.1 kb' │  '2.44 x'   │
-│ typebox/value        │ '176.4 kb' │ ' 76.4 kb' │  '2.31 x'   │
-│ typebox              │ ' 74.8 kb' │ ' 30.7 kb' │  '2.44 x'   │
+│ typebox/compiler     │ '127.1 kb' │ ' 56.7 kb' │  '2.24 x'   │
+│ typebox/errors       │ '110.9 kb' │ ' 48.9 kb' │  '2.27 x'   │
+│ typebox/system       │ ' 76.3 kb' │ ' 31.2 kb' │  '2.44 x'   │
+│ typebox/value        │ '176.8 kb' │ ' 76.5 kb' │  '2.31 x'   │
+│ typebox              │ ' 75.2 kb' │ ' 30.8 kb' │  '2.44 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/typebox.d.ts

@@ -34,7 +34,7 @@ export type TOptional<T extends TSchema> = T & {
 export type TReadonlyOptional<T extends TSchema> = T & {
     [Modifier]: 'ReadonlyOptional';
 };
-export type Key = keyof any;
+export type Key = string | number;
 export interface SchemaOptions {
     $schema?: string;
     /** Id for this schema */
@@ -168,18 +168,27 @@ 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 TIndexProperty<T extends TProperties, K extends Key> = T[K] extends infer R ? [R] : [
 ];
-export type TIndexTuple<T extends TSchema[], K extends IndexKey> = K extends keyof T ? [T[K]] : [
+export type TIndexTuple<T extends TSchema[], K extends Key> = K extends keyof T ? [T[K]] : [
 ];
-export type TIndexComposite<T extends TSchema[], K extends IndexKey> = T extends [infer L, ...infer R] ? [...TIndexKey<AssertType<L>, K>, ...TIndexComposite<AssertRest<R>, K>] : [
+export type TIndexComposite<T extends TSchema[], K extends Key> = T extends [infer L, ...infer R] ? [...TIndexKey<AssertType<L>, K>, ...TIndexComposite<AssertRest<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 TIndexKey<T extends TSchema, K extends Key> = 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 TIndexKeys<T extends TSchema, K extends Key[]> = K extends [infer L, ...infer R] ? [
+    ...TIndexKey<T, Assert<L, Key>>,
+    ...TIndexKeys<T, Assert<R, Key[]>>
+] : [
 ];
-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<AssertRest<R>> : T extends TIntersect ? UnionType<AssertRest<R>> : T extends TUnion ? UnionType<AssertRest<R>> : T extends TObject ? UnionType<AssertRest<R>> : T extends TArray ? UnionType<AssertRest<R>> : TNever : TNever;
+export type TIndexFromKeyTuple<T extends TSchema, K extends Key[]> = TIndexKeys<T, K> extends infer R ? T extends TRecursive<infer S> ? TIndexFromKeyTuple<S, K> : T extends TTuple ? UnionType<AssertRest<R>> : T extends TIntersect ? UnionType<AssertRest<R>> : T extends TUnion ? UnionType<AssertRest<R>> : T extends TObject ? UnionType<AssertRest<R>> : T extends TArray ? UnionType<AssertRest<R>> : TNever : TNever;
+export type TIndex<T extends TSchema, K extends TSchema> = [
+    T,
+    K
+] extends [TTuple, TNumber] ? UnionType<Assert<T['items'], TSchema[]>> : [
+    T,
+    K
+] extends [TArray, TNumber] ? AssertType<T['items']> : K extends TTemplateLiteral ? TIndexFromKeyTuple<T, TTemplateLiteralKeyTuple<K>> : K extends TUnion<TLiteral<Key>[]> ? TIndexFromKeyTuple<T, TUnionLiteral<K>> : K extends TLiteral<Key> ? TIndexFromKeyTuple<T, [K['const']]> : TNever;
 export interface TInteger extends TSchema, NumericOptions<number> {
     [Kind]: 'Integer';
     static: number;
@@ -299,7 +308,7 @@ export type RecordTemplateLiteralObjectType<K extends TTemplateLiteral, T extend
     [_ in Static<K>]: T;
 }>>>;
 export type RecordTemplateLiteralType<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends true ? RecordTemplateLiteralObjectType<K, T> : TRecord<K, T>;
-export type RecordUnionLiteralType<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema> = Static<K> extends string ? Ensure<TObject<{
+export type RecordUnionLiteralType<K extends TUnion, T extends TSchema> = Static<K> extends string ? Ensure<TObject<{
     [X in Static<K>]: T;
 }>> : never;
 export type RecordLiteralType<K extends TLiteral<string | number>, T extends TSchema> = Ensure<TObject<{
@@ -370,7 +379,7 @@ export type TTemplateLiteralConst<T, Acc extends string> = T extends TUnion<infe
     [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>}` : Acc;
-export type TTemplateLiteralKeyArray<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>;
+export type TTemplateLiteralKeyTuple<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>;
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
     [Kind]: 'TemplateLiteral';
     static: TTemplateLiteralUnion<T>;
@@ -378,11 +387,10 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
     pattern: string;
 }
 export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? AssertRest<R> : never;
+export type TTupleInfer<T extends TSchema[], P extends unknown[]> = T extends [infer L, ...infer R] ? [Static<AssertType<L>, P>, ...TTupleInfer<AssertRest<R>, P>] : [];
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
-    static: {
-        [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : T[K];
-    };
+    static: TTupleInfer<T, this['params']>;
     type: 'array';
     items?: T;
     additionalItems?: false;
@@ -397,7 +405,8 @@ export interface TUndefined extends TSchema {
 }
 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 | number>[]>>] : [
 ];
-export type TLiteralUnion<T extends TUnion<TLiteral<string | number>[]>> = T extends TUnion<infer S> ? TLiteralUnionReduce<Assert<S, TLiteral<string | number>[]>> : [];
+export type TUnionLiteral<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[]>>>;
@@ -499,8 +508,6 @@ export declare namespace TypeGuard {
     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 */
@@ -531,6 +538,8 @@ export declare namespace TypeGuard {
     function TTuple(schema: unknown): schema is TTuple;
     /** Returns true if the given schema is TUndefined */
     function TUndefined(schema: unknown): schema is TUndefined;
+    /** Returns true if the given schema is TUnion<Literal<string | number>[]> */
+    function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral[]>;
     /** Returns true if the given schema is TUnion */
     function TUnion(schema: unknown): schema is TUnion;
     /** Returns true if the given schema is TUint8Array */
@@ -568,7 +577,7 @@ export declare namespace TypeClone {
     function Clone<T extends TSchema>(schema: T, options: SchemaOptions): T;
 }
 export declare namespace IndexedAccessor {
-    function Resolve(schema: TSchema, keys: string[]): TSchema[];
+    function Resolve(schema: TSchema, keys: (string | number)[]): TSchema[];
 }
 export declare namespace ObjectMap {
     function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T;
@@ -586,6 +595,10 @@ 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 UnionResolver {
+    /** Returns a resolved union with interior unions flattened */
+    function Resolve(union: TUnion): TUnion;
+}
 export declare namespace TemplateLiteralPattern {
     function Create(kinds: TTemplateLiteralKind[]): string;
 }
@@ -651,19 +664,9 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     /** `[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 TTuple, K extends TNumber>(schema: T, key: K, options?: SchemaOptions): UnionType<Assert<T['items'], TSchema[]>>;
-    /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TArray, K extends TNumber>(schema: T, key: K, options?: SchemaOptions): AssertType<T['items']>;
+    Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndexFromKeyTuple<T, Assert<K, Key[]>>;
     /** `[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>;
+    Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TIndex<T, K>;
     /** `[Standard]` Creates an Integer type */
     Integer(options?: NumericOptions<number>): TInteger;
     /** `[Standard]` Creates a Intersect type */
@@ -688,11 +691,11 @@ 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, TLiteralUnion<K>[number]>;
+    Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionLiteral<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]>;
+    Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyTuple<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 */
@@ -700,15 +703,15 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     /** `[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, TLiteralUnion<K>[number]>;
+    Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionLiteral<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]>;
+    Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyTuple<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>;
+    Record<K extends TUnion, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordUnionLiteralType<K, T>;
     /** `[Standard]` Creates a Record type */
     Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordLiteralType<K, T>;
     /** `[Standard]` Creates a Record type */

package/typebox.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.TemplateLiteralGenerator = exports.TemplateLiteralFinite = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.KeyArrayResolver = exports.KeyResolver = exports.ObjectMap = exports.IndexedAccessor = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Modifier = void 0;
+exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.TemplateLiteralGenerator = exports.TemplateLiteralFinite = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.UnionResolver = exports.KeyArrayResolver = exports.KeyResolver = exports.ObjectMap = exports.IndexedAccessor = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Modifier = void 0;
 // --------------------------------------------------------------------------
 // Symbols
 // --------------------------------------------------------------------------
@@ -324,11 +324,6 @@ var TypeGuard;
         return TKind(schema) && schema[exports.Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'boolean';
     }
     TypeGuard.TLiteralBoolean = TLiteralBoolean;
-    /** Returns true if the given schema is TUnion<Literal<string>[]> */
-    function TLiteralUnion(schema) {
-        return TUnion(schema) && schema.anyOf.every((schema) => TLiteral(schema));
-    }
-    TypeGuard.TLiteralUnion = TLiteralUnion;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema) {
         return TLiteralString(schema) || TLiteralNumber(schema) || TLiteralBoolean(schema);
@@ -515,6 +510,11 @@ var TypeGuard;
             IsOptionalString(schema.$id));
     }
     TypeGuard.TUndefined = TUndefined;
+    /** Returns true if the given schema is TUnion<Literal<string | number>[]> */
+    function TUnionLiteral(schema) {
+        return TUnion(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
+    }
+    TypeGuard.TUnionLiteral = TUnionLiteral;
     /** Returns true if the given schema is TUnion */
     function TUnion(schema) {
         // prettier-ignore
@@ -1411,12 +1411,12 @@ var IndexedAccessor;
         return schema.anyOf.reduce((acc, schema) => [...acc, ...Visit(schema, key)], []);
     }
     function Object(schema, key) {
-        const keys = globalThis.Object.getOwnPropertyNames(schema.properties).filter((k) => k === key);
+        const keys = globalThis.Object.getOwnPropertyNames(schema.properties).filter((key_) => key_ === key);
         return keys.map((key) => schema.properties[key]);
     }
     function Tuple(schema, key) {
         const items = schema.items === undefined ? [] : schema.items;
-        return items.filter((_, index) => index.toString() === key.toString());
+        return items.filter((_, index) => index.toString() === key);
     }
     function Visit(schema, key) {
         if (schema[exports.Kind] === 'Intersect')
@@ -1430,7 +1430,7 @@ var IndexedAccessor;
         return [];
     }
     function Resolve(schema, keys) {
-        return keys.reduce((acc, key) => [...acc, ...Visit(schema, key)], []);
+        return keys.reduce((acc, key) => [...acc, ...Visit(schema, key.toString())], []);
     }
     IndexedAccessor.Resolve = Resolve;
 })(IndexedAccessor = exports.IndexedAccessor || (exports.IndexedAccessor = {}));
@@ -1519,8 +1519,8 @@ var KeyArrayResolver;
     function Resolve(schema) {
         if (globalThis.Array.isArray(schema))
             return schema;
-        if (TypeGuard.TLiteralUnion(schema))
-            return schema.anyOf.map((schema) => schema.const);
+        if (TypeGuard.TUnionLiteral(schema))
+            return schema.anyOf.map((schema) => schema.const.toString());
         if (TypeGuard.TLiteral(schema))
             return [schema.const];
         if (TypeGuard.TTemplateLiteral(schema)) {
@@ -1534,6 +1534,27 @@ var KeyArrayResolver;
     KeyArrayResolver.Resolve = Resolve;
 })(KeyArrayResolver = exports.KeyArrayResolver || (exports.KeyArrayResolver = {}));
 // --------------------------------------------------------------------------
+// UnionResolver
+// --------------------------------------------------------------------------
+var UnionResolver;
+(function (UnionResolver) {
+    function* Union(union) {
+        for (const schema of union.anyOf) {
+            if (schema[exports.Kind] === 'Union') {
+                yield* Union(schema);
+            }
+            else {
+                yield schema;
+            }
+        }
+    }
+    /** Returns a resolved union with interior unions flattened */
+    function Resolve(union) {
+        return exports.Type.Union([...Union(union)], { ...union });
+    }
+    UnionResolver.Resolve = Resolve;
+})(UnionResolver = exports.UnionResolver || (exports.UnionResolver = {}));
+// --------------------------------------------------------------------------
 // TemplateLiteralPattern
 // --------------------------------------------------------------------------
 var TemplateLiteralPattern;
@@ -2115,20 +2136,21 @@ class StandardTypeBuilder extends TypeBuilder {
                 ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema, {}) }), {}), options))
                 : this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) } });
         }
-        else if (TypeGuard.TLiteralUnion(key)) {
-            if (key.anyOf.every((schema) => TypeGuard.TLiteral(schema) && (typeof schema.const === 'string' || typeof schema.const === 'number'))) {
-                const properties = key.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {});
+        else if (TypeGuard.TUnion(key)) {
+            const union = UnionResolver.Resolve(key);
+            if (TypeGuard.TUnionLiteral(union)) {
+                const properties = union.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {});
                 return this.Object(properties, { ...options, [exports.Hint]: 'Record' });
             }
             else
-                throw Error('TypeBuilder: Record key can only be derived from union literal of number or string');
+                throw Error('TypeBuilder: Record key of type union contains non-literal types');
         }
         else if (TypeGuard.TLiteral(key)) {
             if (typeof key.const === 'string' || typeof key.const === 'number') {
                 return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options);
             }
             else
-                throw Error('TypeBuilder: Record key can only be derived from literals of number or string');
+                throw Error('TypeBuilder: Record key of type literal is not of type string or number');
         }
         else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
             const pattern = exports.PatternNumberExact;
@@ -2139,7 +2161,7 @@ class StandardTypeBuilder extends TypeBuilder {
             return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) } });
         }
         else {
-            throw Error(`StandardTypeBuilder: Invalid Record Key`);
+            throw Error(`StandardTypeBuilder: Record key is an invalid type`);
         }
     }
     /** `[Standard]` Creates a Recursive type */