@sinclair/typebox 0.28.4 → 0.28.6

package/package.json

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

package/readme.md

@@ -11,6 +11,8 @@
 
 [![npm version](https://badge.fury.io/js/%40sinclair%2Ftypebox.svg)](https://badge.fury.io/js/%40sinclair%2Ftypebox)
 [![Downloads](https://img.shields.io/npm/dm/%40sinclair%2Ftypebox.svg)](https://www.npmjs.com/package/%40sinclair%2Ftypebox)
+[![Install Size](https://packagephobia.com/badge?p=@sinclair/typebox)](https://packagephobia.com/result?p=@sinclair/typebox)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![GitHub CI](https://github.com/sinclairzx81/typebox/workflows/GitHub%20CI/badge.svg)](https://github.com/sinclairzx81/typebox/actions)
 
 </div>
@@ -83,7 +85,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 +874,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>
 
@@ -1356,9 +1371,15 @@ const B = Value.Check(T, 'hello')                    // const B = true
 
 ### Policies
 
-TypeBox validates using JSON Schema assertion policies by default. It is possible to override these policies and have TypeBox assert using TypeScript policies. The following overrides are available.
+TypeBox validates using standard JSON Schema assertion policies by default. It is possible to override some of these policies to have TypeBox assert inline with TypeScript static assertion rules. The following policy overrides are available.
 
 ```typescript
+// Disallow undefined values for optional properties (default is false)
+//
+// const A: { x?: number } = { x: undefined } - disallowed when enabled
+
+TypeSystem.ExactOptionalPropertyTypes = true
+
 // Allow arrays to validate as object types (default is false)
 //
 // const A: {} = [] - allowed in TS

package/typebox.d.ts

@@ -14,6 +14,8 @@ export type TupleToUnion<T extends any[]> = {
 export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
 export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
 export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
+export type Discard<T extends unknown[], D extends unknown> = T extends [infer L, ...infer R] ? (L extends D ? Discard<R, D> : [L, ...Discard<R, D>]) : [];
+export type Flat<T> = T extends [] ? [] : T extends [infer L] ? [...Flat<L>] : T extends [infer L, ...infer R] ? [...Flat<L>, ...Flat<R>] : [T];
 export type Assert<T, E> = T extends E ? T : never;
 export type Evaluate<T> = T extends infer O ? {
     [K in keyof O]: O[K];
@@ -168,20 +170,21 @@ export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends T
     parameters: T;
     returns: U;
 }
-export type TIndexProperty<T extends TProperties, K extends Key> = T[K] extends infer R ? [R] : [
+export type TIndexRest<T extends TSchema[], K extends Key> = T extends [infer L, ...infer R] ? [TIndexType<AssertType<L>, K>, ...TIndexRest<AssertRest<R>, K>] : [];
+export type TIndexProperty<T extends TProperties, K extends Key> = K extends keyof T ? [T[K]] : [];
+export type TIndexTuple<T extends TSchema[], K extends Key> = K extends keyof T ? [T[K]] : [];
+export type TIndexType<T extends TSchema, K extends Key> = T extends TRecursive<infer S> ? TIndexType<S, K> : T extends TIntersect<infer S> ? IntersectType<AssertRest<Discard<Flat<TIndexRest<S, K>>, TNever>>> : T extends TUnion<infer S> ? UnionType<AssertRest<Flat<TIndexRest<S, K>>>> : T extends TObject<infer S> ? UnionType<AssertRest<Flat<TIndexProperty<S, K>>>> : T extends TTuple<infer S> ? UnionType<AssertRest<Flat<TIndexTuple<S, K>>>> : [
 ];
-export type TIndexTuple<T extends TSchema[], K extends Key> = K extends keyof T ? [T[K]] : [
+export type TIndexRestMany<T extends TSchema, K extends Key[]> = K extends [infer L, ...infer R] ? [TIndexType<T, Assert<L, Key>>, ...TIndexRestMany<T, Assert<R, Key[]>>] : [
 ];
-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 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 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 Key[]> = 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 TIndexReduce<T extends TSchema, K extends Key[]> = T extends TRecursive<infer S> ? TIndexReduce<S, K> : T extends TIntersect ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TUnion ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TObject ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TTuple ? UnionType<Flat<TIndexRestMany<T, K>>> : 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 ? TIndexReduce<T, TTemplateLiteralKeyRest<K>> : K extends TUnion<TLiteral<Key>[]> ? TIndexReduce<T, TUnionLiteralKeyRest<K>> : K extends TLiteral<Key> ? TIndexReduce<T, [K['const']]> : TNever;
 export interface TInteger extends TSchema, NumericOptions<number> {
     [Kind]: 'Integer';
     static: number;
@@ -372,7 +375,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 TTemplateLiteralKeyRest<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>;
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
     [Kind]: 'TemplateLiteral';
     static: TTemplateLiteralUnion<T>;
@@ -380,11 +383,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;
@@ -399,7 +401,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 TUnionLiteralKeyRest<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[]>>>;
@@ -437,7 +440,7 @@ export interface TVoid extends TSchema {
     type: 'null';
     typeOf: 'Void';
 }
-/** Creates a TypeScript static type from a TypeBox type */
+/** Infers a static type from a TypeBox type */
 export type Static<T extends TSchema, P extends unknown[] = []> = (T & {
     params: P;
 })['static'];
@@ -501,8 +504,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 | number>[]> */
-    function TLiteralUnion(schema: unknown): schema is TUnion<TLiteral[]>;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema: unknown): schema is TLiteral;
     /** Returns true if the given schema is TNever */
@@ -533,6 +534,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 */
@@ -570,7 +573,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 | number)[]): TSchema[];
+    function Resolve(schema: TSchema, keys: Key[], options?: SchemaOptions): TSchema;
 }
 export declare namespace ObjectMap {
     function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T;
@@ -657,19 +660,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, Assert<K, Key[]>>;
-    /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TSchema, K extends TUnion<TLiteral<Key>[]>>(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<Key>>(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): TIndexReduce<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 */
@@ -694,11 +687,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, TUnionLiteralKeyRest<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, TTemplateLiteralKeyRest<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 */
@@ -706,11 +699,11 @@ 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, TUnionLiteralKeyRest<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, TTemplateLiteralKeyRest<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 */

package/typebox.js

@@ -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 | number>[]> */
-    function TLiteralUnion(schema) {
-        return TUnion(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(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
@@ -1405,18 +1405,28 @@ var TypeClone;
 var IndexedAccessor;
 (function (IndexedAccessor) {
     function Intersect(schema, key) {
-        return schema.allOf.reduce((acc, schema) => [...acc, ...Visit(schema, key)], []);
+        const schemas = schema.allOf.reduce((acc, schema) => {
+            const indexed = Visit(schema, key);
+            return indexed[exports.Kind] === 'Never' ? acc : [...acc, indexed];
+        }, []);
+        return exports.Type.Intersect(schemas);
     }
     function Union(schema, key) {
-        return schema.anyOf.reduce((acc, schema) => [...acc, ...Visit(schema, key)], []);
+        const schemas = schema.anyOf.map((schema) => Visit(schema, key));
+        return exports.Type.Union(schemas);
     }
     function Object(schema, key) {
-        const keys = globalThis.Object.getOwnPropertyNames(schema.properties).filter((key_) => key_ === key);
-        return keys.map((key) => schema.properties[key]);
+        const property = schema.properties[key];
+        return property === undefined ? exports.Type.Never() : exports.Type.Union([property]);
     }
     function Tuple(schema, key) {
-        const items = schema.items === undefined ? [] : schema.items;
-        return items.filter((_, index) => index.toString() === key);
+        const items = schema.items;
+        if (items === undefined)
+            return exports.Type.Never();
+        const element = items[key]; //
+        if (element === undefined)
+            return exports.Type.Never();
+        return element;
     }
     function Visit(schema, key) {
         if (schema[exports.Kind] === 'Intersect')
@@ -1427,10 +1437,10 @@ var IndexedAccessor;
             return Object(schema, key);
         if (schema[exports.Kind] === 'Tuple')
             return Tuple(schema, key);
-        return [];
+        return exports.Type.Never();
     }
-    function Resolve(schema, keys) {
-        return keys.reduce((acc, key) => [...acc, ...Visit(schema, key.toString())], []);
+    function Resolve(schema, keys, options = {}) {
+        return exports.Type.Union(keys.map((key) => Visit(schema, key.toString())));
     }
     IndexedAccessor.Resolve = Resolve;
 })(IndexedAccessor = exports.IndexedAccessor || (exports.IndexedAccessor = {}));
@@ -1519,7 +1529,7 @@ var KeyArrayResolver;
     function Resolve(schema) {
         if (globalThis.Array.isArray(schema))
             return schema;
-        if (TypeGuard.TLiteralUnion(schema))
+        if (TypeGuard.TUnionLiteral(schema))
             return schema.anyOf.map((schema) => schema.const.toString());
         if (TypeGuard.TLiteral(schema))
             return [schema.const];
@@ -1977,18 +1987,19 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Returns indexed property types for the given keys */
     Index(schema, unresolved, options = {}) {
-        const keys = KeyArrayResolver.Resolve(unresolved);
         if (TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved)) {
             return TypeClone.Clone(schema.items, options);
         }
-        if (TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved)) {
+        else if (TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved)) {
             const items = schema.items === undefined ? [] : schema.items;
             const cloned = items.map((schema) => TypeClone.Clone(schema, {}));
             return this.Union(cloned, options);
         }
-        const resolved = IndexedAccessor.Resolve(schema, keys);
-        const cloned = resolved.map((schema) => TypeClone.Clone(schema, {}));
-        return this.Union(cloned, options);
+        else {
+            const keys = KeyArrayResolver.Resolve(unresolved);
+            const clone = TypeClone.Clone(schema, {});
+            return IndexedAccessor.Resolve(clone, keys, options);
+        }
     }
     /** `[Standard]` Creates an Integer type */
     Integer(options = {}) {
@@ -2138,7 +2149,7 @@ class StandardTypeBuilder extends TypeBuilder {
         }
         else if (TypeGuard.TUnion(key)) {
             const union = UnionResolver.Resolve(key);
-            if (TypeGuard.TLiteralUnion(union)) {
+            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' });
             }