@sinclair/typebox 0.32.0-dev-16 → 0.32.0-dev-18

package/build/import/type/function/function.mjs

@@ -1,5 +1,6 @@
 import { CloneType, CloneRest } from '../clone/type.mjs';
 import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a Function type */
 export function Function(parameters, returns, options) {
     return {
         ...options,

package/build/import/type/guard/type.d.mts

@@ -37,57 +37,103 @@ import type { TDate } from '../date/index.mjs';
 import type { TThis } from '../recursive/index.mjs';
 export declare class TypeGuardUnknownTypeError extends Error {
 }
+/** Returns true if this value has a Readonly symbol */
 export declare function TReadonly<T extends TSchema>(value: T): value is TReadonly<T>;
+/** Returns true if this value has a Optional symbol */
 export declare function TOptional<T extends TSchema>(value: T): value is TOptional<T>;
+/** Returns true if the given value is TAny */
 export declare function TAny(value: unknown): value is TAny;
+/** Returns true if the given value is TArray */
 export declare function TArray(value: unknown): value is TArray;
+/** Returns true if the given value is TAsyncIterator */
 export declare function TAsyncIterator(value: unknown): value is TAsyncIterator;
+/** Returns true if the given value is TBigInt */
 export declare function TBigInt(value: unknown): value is TBigInt;
+/** Returns true if the given value is TBoolean */
 export declare function TBoolean(value: unknown): value is TBoolean;
+/** Returns true if the given value is TConstructor */
 export declare function TConstructor(value: unknown): value is TConstructor;
+/** Returns true if the given value is TDate */
 export declare function TDate(value: unknown): value is TDate;
+/** Returns true if the given value is TFunction */
 export declare function TFunction(value: unknown): value is TFunction;
+/** Returns true if the given value is TInteger */
 export declare function TInteger(value: unknown): value is TInteger;
+/** Returns true if the given schema is TProperties */
 export declare function TProperties(value: unknown): value is TProperties;
+/** Returns true if the given value is TIntersect */
 export declare function TIntersect(value: unknown): value is TIntersect;
+/** Returns true if the given value is TIterator */
 export declare function TIterator(value: unknown): value is TIterator;
+/** Returns true if the given value is a TKind with the given name. */
 export declare function TKindOf<T extends string>(value: unknown, kind: T): value is Record<PropertyKey, unknown> & {
     [Kind]: T;
 };
+/** Returns true if the given value is TLiteral<string> */
 export declare function TLiteralString(value: unknown): value is TLiteral<string>;
+/** Returns true if the given value is TLiteral<number> */
 export declare function TLiteralNumber(value: unknown): value is TLiteral<number>;
+/** Returns true if the given value is TLiteral<boolean> */
 export declare function TLiteralBoolean(value: unknown): value is TLiteral<boolean>;
+/** Returns true if the given value is TLiteral */
 export declare function TLiteral(value: unknown): value is TLiteral;
+/** Returns true if the given value is a TLiteralValue */
 export declare function TLiteralValue(value: unknown): value is TLiteralValue;
+/** Returns true if the given value is a TMappedKey */
 export declare function TMappedKey(value: unknown): value is TMappedKey;
+/** Returns true if the given value is TMappedResult */
 export declare function TMappedResult(value: unknown): value is TMappedResult;
+/** Returns true if the given value is TNever */
 export declare function TNever(value: unknown): value is TNever;
+/** Returns true if the given value is TNot */
 export declare function TNot(value: unknown): value is TNot;
+/** Returns true if the given value is TNull */
 export declare function TNull(value: unknown): value is TNull;
+/** Returns true if the given value is TNumber */
 export declare function TNumber(value: unknown): value is TNumber;
+/** Returns true if the given value is TObject */
 export declare function TObject(value: unknown): value is TObject;
+/** Returns true if the given value is TPromise */
 export declare function TPromise(value: unknown): value is TPromise;
+/** Returns true if the given value is TRecord */
 export declare function TRecord(value: unknown): value is TRecord;
+/** Returns true if this value is TRecursive */
 export declare function TRecursive(value: unknown): value is {
     [Hint]: 'Recursive';
 };
+/** Returns true if the given value is TRef */
 export declare function TRef(value: unknown): value is TRef;
+/** Returns true if the given value is TString */
 export declare function TString(value: unknown): value is TString;
+/** Returns true if the given value is TSymbol */
 export declare function TSymbol(value: unknown): value is TSymbol;
+/** Returns true if the given value is TTemplateLiteral */
 export declare function TTemplateLiteral(value: unknown): value is TTemplateLiteral<TTemplateLiteralKind[]>;
+/** Returns true if the given value is TThis */
 export declare function TThis(value: unknown): value is TThis;
+/** Returns true of this value is TTransform */
 export declare function TTransform(value: unknown): value is {
     [TransformKind]: TransformOptions;
 };
+/** Returns true if the given value is TTuple */
 export declare function TTuple(value: unknown): value is TTuple;
+/** Returns true if the given value is TUndefined */
 export declare function TUndefined(value: unknown): value is TUndefined;
+/** Returns true if the given value is TUnion<Literal<string | number>[]> */
 export declare function TUnionLiteral(value: unknown): value is TUnion<TLiteral[]>;
+/** Returns true if the given value is TUnion */
 export declare function TUnion(value: unknown): value is TUnion;
+/** Returns true if the given value is TUint8Array */
 export declare function TUint8Array(value: unknown): value is TUint8Array;
+/** Returns true if the given value is TUnknown */
 export declare function TUnknown(value: unknown): value is TUnknown;
+/** Returns true if the given value is a raw TUnsafe */
 export declare function TUnsafe(value: unknown): value is TUnsafe<unknown>;
+/** Returns true if the given value is TVoid */
 export declare function TVoid(value: unknown): value is TVoid;
+/** Returns true if the given value is TKind */
 export declare function TKind(value: unknown): value is Record<PropertyKey, unknown> & {
     [Kind]: string;
 };
+/** Returns true if the given value is TSchema */
 export declare function TSchema(value: unknown): value is TSchema;

package/build/import/type/guard/type.mjs

@@ -80,16 +80,27 @@ function IsOptionalFormat(value) {
 function IsOptionalSchema(value) {
     return ValueGuard.IsUndefined(value) || TSchema(value);
 }
+// ------------------------------------------------------------------
+// Modifiers
+// ------------------------------------------------------------------
+/** Returns true if this value has a Readonly symbol */
 export function TReadonly(value) {
     return ValueGuard.IsObject(value) && value[ReadonlyKind] === 'Readonly';
 }
+/** Returns true if this value has a Optional symbol */
 export function TOptional(value) {
     return ValueGuard.IsObject(value) && value[OptionalKind] === 'Optional';
 }
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+/** Returns true if the given value is TAny */
 export function TAny(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Any') &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TArray */
 export function TArray(value) {
     return (TKindOf(value, 'Array') &&
         value.type === 'array' &&
@@ -102,13 +113,17 @@ export function TArray(value) {
         IsOptionalNumber(value.minContains) &&
         IsOptionalNumber(value.maxContains));
 }
+/** Returns true if the given value is TAsyncIterator */
 export function TAsyncIterator(value) {
+    // prettier-ignore
     return (TKindOf(value, 'AsyncIterator') &&
         value.type === 'AsyncIterator' &&
         IsOptionalString(value.$id) &&
         TSchema(value.items));
 }
+/** Returns true if the given value is TBigInt */
 export function TBigInt(value) {
+    // prettier-ignore
     return (TKindOf(value, 'BigInt') &&
         value.type === 'bigint' &&
         IsOptionalString(value.$id) &&
@@ -118,12 +133,16 @@ export function TBigInt(value) {
         IsOptionalBigInt(value.minimum) &&
         IsOptionalBigInt(value.multipleOf));
 }
+/** Returns true if the given value is TBoolean */
 export function TBoolean(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Boolean') &&
         value.type === 'boolean' &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TConstructor */
 export function TConstructor(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Constructor') &&
         value.type === 'Constructor' &&
         IsOptionalString(value.$id) &&
@@ -131,6 +150,7 @@ export function TConstructor(value) {
         value.parameters.every(schema => TSchema(schema)) &&
         TSchema(value.returns));
 }
+/** Returns true if the given value is TDate */
 export function TDate(value) {
     return (TKindOf(value, 'Date') &&
         value.type === 'Date' &&
@@ -141,7 +161,9 @@ export function TDate(value) {
         IsOptionalNumber(value.minimumTimestamp) &&
         IsOptionalNumber(value.multipleOfTimestamp));
 }
+/** Returns true if the given value is TFunction */
 export function TFunction(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Function') &&
         value.type === 'Function' &&
         IsOptionalString(value.$id) &&
@@ -149,6 +171,7 @@ export function TFunction(value) {
         value.parameters.every(schema => TSchema(schema)) &&
         TSchema(value.returns));
 }
+/** Returns true if the given value is TInteger */
 export function TInteger(value) {
     return (TKindOf(value, 'Integer') &&
         value.type === 'integer' &&
@@ -159,11 +182,15 @@ export function TInteger(value) {
         IsOptionalNumber(value.minimum) &&
         IsOptionalNumber(value.multipleOf));
 }
+/** Returns true if the given schema is TProperties */
 export function TProperties(value) {
+    // prettier-ignore
     return (ValueGuard.IsObject(value) &&
         Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && TSchema(schema)));
 }
+/** Returns true if the given value is TIntersect */
 export function TIntersect(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Intersect') &&
         (ValueGuard.IsString(value.type) && value.type !== 'object' ? false : true) &&
         ValueGuard.IsArray(value.allOf) &&
@@ -172,54 +199,74 @@ export function TIntersect(value) {
         (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TIterator */
 export function TIterator(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Iterator') &&
         value.type === 'Iterator' &&
         IsOptionalString(value.$id) &&
         TSchema(value.items));
 }
+/** Returns true if the given value is a TKind with the given name. */
 export function TKindOf(value, kind) {
     return ValueGuard.IsObject(value) && Kind in value && value[Kind] === kind;
 }
+/** Returns true if the given value is TLiteral<string> */
 export function TLiteralString(value) {
     return TLiteral(value) && ValueGuard.IsString(value.const);
 }
+/** Returns true if the given value is TLiteral<number> */
 export function TLiteralNumber(value) {
     return TLiteral(value) && ValueGuard.IsNumber(value.const);
 }
+/** Returns true if the given value is TLiteral<boolean> */
 export function TLiteralBoolean(value) {
     return TLiteral(value) && ValueGuard.IsBoolean(value.const);
 }
+/** Returns true if the given value is TLiteral */
 export function TLiteral(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Literal') &&
         IsOptionalString(value.$id) && TLiteralValue(value.const));
 }
+/** Returns true if the given value is a TLiteralValue */
 export function TLiteralValue(value) {
     return ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value) || ValueGuard.IsString(value);
 }
+/** Returns true if the given value is a TMappedKey */
 export function TMappedKey(value) {
+    // prettier-ignore
     return (TKindOf(value, 'MappedKey') &&
         ValueGuard.IsArray(value.keys) &&
         value.keys.every(key => ValueGuard.IsNumber(key) || ValueGuard.IsString(key)));
 }
+/** Returns true if the given value is TMappedResult */
 export function TMappedResult(value) {
+    // prettier-ignore
     return (TKindOf(value, 'MappedResult') &&
         TProperties(value.properties));
 }
+/** Returns true if the given value is TNever */
 export function TNever(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Never') &&
         ValueGuard.IsObject(value.not) &&
         Object.getOwnPropertyNames(value.not).length === 0);
 }
+/** Returns true if the given value is TNot */
 export function TNot(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Not') &&
         TSchema(value.not));
 }
+/** Returns true if the given value is TNull */
 export function TNull(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Null') &&
         value.type === 'null' &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TNumber */
 export function TNumber(value) {
     return (TKindOf(value, 'Number') &&
         value.type === 'number' &&
@@ -230,7 +277,9 @@ export function TNumber(value) {
         IsOptionalNumber(value.minimum) &&
         IsOptionalNumber(value.multipleOf));
 }
+/** Returns true if the given value is TObject */
 export function TObject(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Object') &&
         value.type === 'object' &&
         IsOptionalString(value.$id) &&
@@ -239,13 +288,17 @@ export function TObject(value) {
         IsOptionalNumber(value.minProperties) &&
         IsOptionalNumber(value.maxProperties));
 }
+/** Returns true if the given value is TPromise */
 export function TPromise(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Promise') &&
         value.type === 'Promise' &&
         IsOptionalString(value.$id) &&
         TSchema(value.item));
 }
+/** Returns true if the given value is TRecord */
 export function TRecord(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Record') &&
         value.type === 'object' &&
         IsOptionalString(value.$id) &&
@@ -259,15 +312,20 @@ export function TRecord(value) {
                 TSchema(schema.patternProperties[keys[0]]));
         })(value));
 }
+/** Returns true if this value is TRecursive */
 export function TRecursive(value) {
     return ValueGuard.IsObject(value) && Hint in value && value[Hint] === 'Recursive';
 }
+/** Returns true if the given value is TRef */
 export function TRef(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Ref') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsString(value.$ref));
 }
+/** Returns true if the given value is TString */
 export function TString(value) {
+    // prettier-ignore
     return (TKindOf(value, 'String') &&
         value.type === 'string' &&
         IsOptionalString(value.$id) &&
@@ -276,76 +334,101 @@ export function TString(value) {
         IsOptionalPattern(value.pattern) &&
         IsOptionalFormat(value.format));
 }
+/** Returns true if the given value is TSymbol */
 export function TSymbol(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Symbol') &&
         value.type === 'symbol' &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TTemplateLiteral */
 export function TTemplateLiteral(value) {
+    // prettier-ignore
     return (TKindOf(value, 'TemplateLiteral') &&
         value.type === 'string' &&
         ValueGuard.IsString(value.pattern) &&
         value.pattern[0] === '^' &&
         value.pattern[value.pattern.length - 1] === '$');
 }
+/** Returns true if the given value is TThis */
 export function TThis(value) {
+    // prettier-ignore
     return (TKindOf(value, 'This') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsString(value.$ref));
 }
+/** Returns true of this value is TTransform */
 export function TTransform(value) {
     return ValueGuard.IsObject(value) && TransformKind in value;
 }
+/** Returns true if the given value is TTuple */
 export function TTuple(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Tuple') &&
         value.type === 'array' &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsNumber(value.minItems) &&
         ValueGuard.IsNumber(value.maxItems) &&
         value.minItems === value.maxItems &&
-        ((ValueGuard.IsUndefined(value.items) &&
+        (( // empty
+        ValueGuard.IsUndefined(value.items) &&
             ValueGuard.IsUndefined(value.additionalItems) &&
             value.minItems === 0) || (ValueGuard.IsArray(value.items) &&
             value.items.every(schema => TSchema(schema)))));
 }
+/** Returns true if the given value is TUndefined */
 export function TUndefined(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Undefined') &&
         value.type === 'undefined' &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TUnion<Literal<string | number>[]> */
 export function TUnionLiteral(value) {
     return TUnion(value) && value.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
 }
+/** Returns true if the given value is TUnion */
 export function TUnion(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Union') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsObject(value) &&
         ValueGuard.IsArray(value.anyOf) &&
         value.anyOf.every(schema => TSchema(schema)));
 }
+/** Returns true if the given value is TUint8Array */
 export function TUint8Array(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Uint8Array') &&
         value.type === 'Uint8Array' &&
         IsOptionalString(value.$id) &&
         IsOptionalNumber(value.minByteLength) &&
         IsOptionalNumber(value.maxByteLength));
 }
+/** Returns true if the given value is TUnknown */
 export function TUnknown(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Unknown') &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is a raw TUnsafe */
 export function TUnsafe(value) {
     return TKindOf(value, 'Unsafe');
 }
+/** Returns true if the given value is TVoid */
 export function TVoid(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Void') &&
         value.type === 'void' &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TKind */
 export function TKind(value) {
     return ValueGuard.IsObject(value) && Kind in value && ValueGuard.IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
 }
+/** Returns true if the given value is TSchema */
 export function TSchema(value) {
+    // prettier-ignore
     return (ValueGuard.IsObject(value)) && (TAny(value) ||
         TArray(value) ||
         TBoolean(value) ||

package/build/import/type/guard/value.d.mts

@@ -1,14 +1,28 @@
+/** Returns true if this value is an async iterator */
 export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<unknown>;
+/** Returns true if this value is an array */
 export declare function IsArray(value: unknown): value is unknown[];
+/** Returns true if this value is bigint */
 export declare function IsBigInt(value: unknown): value is bigint;
+/** Returns true if this value is a boolean */
 export declare function IsBoolean(value: unknown): value is boolean;
+/** Returns true if this value is a Date object */
 export declare function IsDate(value: unknown): value is Date;
+/** Returns true if this value is a function */
 export declare function IsFunction(value: unknown): value is Function;
+/** Returns true if this value is an iterator */
 export declare function IsIterator(value: unknown): value is IterableIterator<unknown>;
+/** Returns true if this value is null */
 export declare function IsNull(value: unknown): value is null;
+/** Returns true if this value is number */
 export declare function IsNumber(value: unknown): value is number;
+/** Returns true if this value is an object */
 export declare function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
+/** Returns true if this value is string */
 export declare function IsString(value: unknown): value is string;
+/** Returns true if this value is symbol */
 export declare function IsSymbol(value: unknown): value is symbol;
+/** Returns true if this value is a Uint8Array */
 export declare function IsUint8Array(value: unknown): value is Uint8Array;
+/** Returns true if this value is undefined */
 export declare function IsUndefined(value: unknown): value is undefined;

package/build/import/type/guard/value.mjs

@@ -1,42 +1,56 @@
+/** Returns true if this value is an async iterator */
 export function IsAsyncIterator(value) {
     return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
 }
+/** Returns true if this value is an array */
 export function IsArray(value) {
     return Array.isArray(value);
 }
+/** Returns true if this value is bigint */
 export function IsBigInt(value) {
     return typeof value === 'bigint';
 }
+/** Returns true if this value is a boolean */
 export function IsBoolean(value) {
     return typeof value === 'boolean';
 }
+/** Returns true if this value is a Date object */
 export function IsDate(value) {
     return value instanceof globalThis.Date;
 }
+/** Returns true if this value is a function */
 export function IsFunction(value) {
     return typeof value === 'function';
 }
+/** Returns true if this value is an iterator */
 export function IsIterator(value) {
     return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
 }
+/** Returns true if this value is null */
 export function IsNull(value) {
     return value === null;
 }
+/** Returns true if this value is number */
 export function IsNumber(value) {
     return typeof value === 'number';
 }
+/** Returns true if this value is an object */
 export function IsObject(value) {
     return typeof value === 'object' && value !== null;
 }
+/** Returns true if this value is string */
 export function IsString(value) {
     return typeof value === 'string';
 }
+/** Returns true if this value is symbol */
 export function IsSymbol(value) {
     return typeof value === 'symbol';
 }
+/** Returns true if this value is a Uint8Array */
 export function IsUint8Array(value) {
     return value instanceof globalThis.Uint8Array;
 }
+/** Returns true if this value is undefined */
 export function IsUndefined(value) {
     return value === undefined;
 }

package/build/import/type/helpers/helpers.d.mts

@@ -34,6 +34,7 @@ type IncrementTake<T extends keyof IncrementBase> = IncrementBase[T];
 type IncrementStep<T extends string> = T extends IncrementBase['m'] ? IncrementBase['t'] : T extends `${infer L extends keyof IncrementBase}${infer R}` ? L extends IncrementBase['m'] ? `${IncrementTake<L>}${IncrementStep<R>}` : `${IncrementTake<L>}${R}` : never;
 type IncrementReverse<T extends string> = T extends `${infer L}${infer R}` ? `${IncrementReverse<R>}${L}` : T;
 export type Increment<T extends string> = IncrementReverse<IncrementStep<IncrementReverse<T>>>;
+/** Increments the given string value + 1 */
 export declare function Increment<T extends string>(T: T): Increment<T>;
 export type AssertProperties<T> = T extends TProperties ? T : TProperties;
 export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : [];

package/build/import/type/helpers/helpers.mjs

@@ -1,3 +1,4 @@
+/** Increments the given string value + 1 */
 export function Increment(T) {
     return (parseInt(T) + 1).toString();
 }

package/build/import/type/indexed/index.d.mts

@@ -1,4 +1,3 @@
 export * from './indexed-from-mapped-key.mjs';
 export * from './indexed-property-keys.mjs';
-export * from './indexed-result.mjs';
 export * from './indexed.mjs';

package/build/import/type/indexed/index.mjs

@@ -1,4 +1,3 @@
 export * from './indexed-from-mapped-key.mjs';
 export * from './indexed-property-keys.mjs';
-export * from './indexed-result.mjs';
 export * from './indexed.mjs';

package/build/import/type/indexed/indexed-from-mapped-key.d.mts

@@ -1,10 +1,10 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { type TProperties } from '../object/index.mjs';
-import { type TIndexResult } from './indexed-result.mjs';
+import { type TIndex } from './indexed.mjs';
 import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
 import { Evaluate } from '../helpers/index.mjs';
 type MappedIndexPropertyKey<T extends TSchema, K extends PropertyKey> = {
-    [_ in K]: TIndexResult<T, [K]>;
+    [_ in K]: TIndex<T, [K]>;
 };
 declare function MappedIndexPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K, options: SchemaOptions): MappedIndexPropertyKey<T, K>;
 type MappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? MappedIndexPropertyKey<T, L> & MappedIndexPropertyKeys<T, R> : {});

package/build/import/type/indexed/indexed-from-mapped-key.mjs

@@ -1,17 +1,24 @@
-import { IndexResult } from './indexed-result.mjs';
+import { Index } from './indexed.mjs';
 import { MappedResult } from '../mapped/index.mjs';
+// prettier-ignore
 function MappedIndexPropertyKey(T, K, options) {
-    return { [K]: IndexResult(T, [K], options) };
+    // todo: propogate options into index result. This type looks like it
+    // could use a clean up, possibly inlining it into indexed.ts to
+    // bring it inline with other mapping types.
+    return { [K]: Index(T, [K], options) };
 }
+// prettier-ignore
 function MappedIndexPropertyKeys(T, K, options) {
     const [L, ...R] = K;
     return (K.length > 0
-        ? { ...MappedIndexPropertyKey(T, L, options), ...MappedIndexPropertyKeys(T, R, options) }
+        ? { ...MappedIndexPropertyKey(T, L, options), ...MappedIndexPropertyKeys(T, R, options) } // TS 5.4-dev
         : {});
 }
+// prettier-ignore
 function MappedIndexProperties(T, K, options) {
     return MappedIndexPropertyKeys(T, K.keys, options);
 }
+// prettier-ignore
 export function IndexFromMappedKey(T, K, options) {
     const P = MappedIndexProperties(T, K, options);
     return MappedResult(P);

package/build/import/type/indexed/indexed-property-keys.d.mts

@@ -12,5 +12,6 @@ type FromLiteral<T extends TLiteralValue> = (T extends PropertyKey ? [`${T}`] :
 declare function FromLiteral<T extends TLiteralValue>(T: T): FromLiteral<T>;
 export type TIndexPropertyKeys<T extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T> : T extends TUnion<infer S> ? FromUnion<S> : T extends TLiteral<infer S> ? FromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
 ]);
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
 export declare function IndexPropertyKeys<T extends TSchema>(T: T): TIndexPropertyKeys<T>;
 export {};

package/build/import/type/indexed/indexed-property-keys.mjs

@@ -1,5 +1,10 @@
 import { TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralToUnion } from '../template-literal/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TTemplateLiteral as IsTemplateLiteralType, TUnionLiteral as IsUnionLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType, TNumber as IsNumberType, TInteger as IsIntegerType } from '../guard/type.mjs';
+// prettier-ignore
 function FromTemplateLiteral(T) {
     const E = TemplateLiteralParseExact(T.pattern);
     const F = IsTemplateLiteralFinite(E);
@@ -10,15 +15,19 @@ function FromTemplateLiteral(T) {
             : []
         : []);
 }
+// prettier-ignore
 function FromUnion(T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [...IndexPropertyKeys(L), ...FromUnion(R)]
         : []);
 }
+// prettier-ignore
 function FromLiteral(T) {
     return ([T.toString()]);
 }
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
+// prettier-ignore
 export function IndexPropertyKeys(T) {
     return [...new Set((IsTemplateLiteralType(T) ? FromTemplateLiteral(T) :
             IsUnionType(T) ? FromUnion(T.anyOf) :