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

package/build/require/value/transform/has.js

@@ -1,60 +1,76 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HasTransform = void 0;
 const type_1 = require("../../type/guard/type");
 const index_1 = require("../guard/index");
 const index_2 = require("../deref/index");
 const index_3 = require("../../type/symbols/index");
+// prettier-ignore
 function TArray(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.items, references);
 }
+// prettier-ignore
 function TAsyncIterator(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.items, references);
 }
+// prettier-ignore
 function TConstructor(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
 }
+// prettier-ignore
 function TFunction(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
 }
+// prettier-ignore
 function TIntersect(schema, references) {
     return (0, type_1.TTransform)(schema) || (0, type_1.TTransform)(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));
 }
+// prettier-ignore
 function TIterator(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.items, references);
 }
+// prettier-ignore
 function TNot(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.not, references);
 }
+// prettier-ignore
 function TObject(schema, references) {
     return ((0, type_1.TTransform)(schema) ||
         Object.values(schema.properties).some((schema) => Visit(schema, references)) ||
         ((0, type_1.TSchema)(schema.additionalProperties) && Visit(schema.additionalProperties, references)));
 }
+// prettier-ignore
 function TPromise(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.item, references);
 }
+// prettier-ignore
 function TRecord(schema, references) {
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const property = schema.patternProperties[pattern];
     return (0, type_1.TTransform)(schema) || Visit(property, references) || ((0, type_1.TSchema)(schema.additionalProperties) && (0, type_1.TTransform)(schema.additionalProperties));
 }
+// prettier-ignore
 function TRef(schema, references) {
     if ((0, type_1.TTransform)(schema))
         return true;
     return Visit((0, index_2.Deref)(schema, references), references);
 }
+// prettier-ignore
 function TThis(schema, references) {
     if ((0, type_1.TTransform)(schema))
         return true;
     return Visit((0, index_2.Deref)(schema, references), references);
 }
+// prettier-ignore
 function TTuple(schema, references) {
     return (0, type_1.TTransform)(schema) || (!(0, index_1.IsUndefined)(schema.items) && schema.items.some((schema) => Visit(schema, references)));
 }
+// prettier-ignore
 function TUnion(schema, references) {
     return (0, type_1.TTransform)(schema) || schema.anyOf.some((schema) => Visit(schema, references));
 }
+// prettier-ignore
 function Visit(schema, references) {
     const references_ = (0, index_1.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
@@ -96,6 +112,7 @@ function Visit(schema, references) {
     }
 }
 const visited = new Set();
+/** Returns true if this schema contains a transform codec */
 function HasTransform(schema, references) {
     visited.clear();
     return Visit(schema, references);

package/build/require/value/transform/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/value/value/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Value = void 0;
 exports.Value = require("./value");

package/build/require/value/value/value.d.ts

@@ -3,27 +3,51 @@ import { Edit } from '../delta/index';
 import { ValueErrorIterator } from '../../errors/index';
 import type { TSchema } from '../../type/schema/index';
 import type { Static, StaticDecode, StaticEncode } from '../../type/static/index';
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 export declare function Cast<T extends TSchema>(schema: T, references: TSchema[], value: unknown): Static<T>;
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 export declare function Cast<T extends TSchema>(schema: T, value: unknown): Static<T>;
+/** Creates a value from the given type and references */
 export declare function Create<T extends TSchema>(schema: T, references: TSchema[]): Static<T>;
+/** Creates a value from the given type */
 export declare function Create<T extends TSchema>(schema: T): Static<T>;
+/** Returns true if the value matches the given type and references */
 export declare function Check<T extends TSchema>(schema: T, references: TSchema[], value: unknown): value is Static<T>;
+/** Returns true if the value matches the given type */
 export declare function Check<T extends TSchema>(schema: T, value: unknown): value is Static<T>;
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Clean<T extends TSchema>(schema: T, value: unknown): unknown;
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
 export declare function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+/** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
 export declare function Convert<T extends TSchema>(schema: T, value: unknown): unknown;
+/** Returns a structural clone of the given value */
 export declare function Clone<T>(value: T): T;
+/** Decodes a value or throws if error */
 export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
+/** Decodes a value or throws if error */
 export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Default<T extends TSchema>(schema: T, value: unknown): unknown;
+/** Encodes a value or throws if error */
 export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R;
+/** Encodes a value or throws if error */
 export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value: unknown): R;
+/** Returns an iterator for each error in this value. */
 export declare function Errors<T extends TSchema>(schema: T, references: TSchema[], value: unknown): ValueErrorIterator;
+/** Returns an iterator for each error in this value. */
 export declare function Errors<T extends TSchema>(schema: T, value: unknown): ValueErrorIterator;
+/** Returns true if left and right values are structurally equal */
 export declare function Equal<T>(left: T, right: unknown): right is T;
+/** Returns edits to transform the current value into the next value */
 export declare function Diff(current: unknown, next: unknown): Edit[];
+/** Returns a FNV1A-64 non cryptographic hash of the given value */
 export declare function Hash(value: unknown): bigint;
+/** Returns a new value with edits applied to the given value */
 export declare function Patch<T = any>(current: unknown, edits: Edit[]): T;
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references. */
 export declare function Mutate(current: Mutable, next: Mutable): void;

package/build/require/value/value/value.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mutate = exports.Patch = exports.Hash = exports.Diff = exports.Equal = exports.Errors = exports.Encode = exports.Default = exports.Decode = exports.Clone = exports.Convert = exports.Clean = exports.Check = exports.Create = exports.Cast = void 0;
 const index_1 = require("../transform/index");
@@ -14,30 +15,37 @@ const index_10 = require("../check/index");
 const index_11 = require("../default/index");
 const index_12 = require("../delta/index");
 const index_13 = require("../../errors/index");
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 function Cast(...args) {
     return index_5.Cast.apply(index_5.Cast, args);
 }
 exports.Cast = Cast;
+/** Creates a value from the given type */
 function Create(...args) {
     return index_8.Create.apply(index_8.Create, args);
 }
 exports.Create = Create;
+/** Returns true if the value matches the given type */
 function Check(...args) {
     return index_10.Check.apply(index_10.Check, args);
 }
 exports.Check = Check;
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 function Clean(...args) {
     return index_9.Clean.apply(index_9.Clean, args);
 }
 exports.Clean = Clean;
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
 function Convert(...args) {
     return index_7.Convert.apply(index_7.Convert, args);
 }
 exports.Convert = Convert;
+/** Returns a structural clone of the given value */
 function Clone(value) {
     return (0, index_6.Clone)(value);
 }
 exports.Clone = Clone;
+/** Decodes a value or throws if error */
 function Decode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
     if (!Check(schema, references, value))
@@ -45,10 +53,12 @@ function Decode(...args) {
     return (0, index_1.TransformDecode)(schema, references, value);
 }
 exports.Decode = Decode;
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 function Default(...args) {
     return index_11.Default.apply(index_11.Default, args);
 }
 exports.Default = Default;
+/** Encodes a value or throws if error */
 function Encode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
     const encoded = (0, index_1.TransformEncode)(schema, references, value);
@@ -57,26 +67,32 @@ function Encode(...args) {
     return encoded;
 }
 exports.Encode = Encode;
+/** Returns an iterator for each error in this value. */
 function Errors(...args) {
     return index_13.Errors.apply(index_13.Errors, args);
 }
 exports.Errors = Errors;
+/** Returns true if left and right values are structurally equal */
 function Equal(left, right) {
     return (0, index_4.Equal)(left, right);
 }
 exports.Equal = Equal;
+/** Returns edits to transform the current value into the next value */
 function Diff(current, next) {
     return (0, index_12.Diff)(current, next);
 }
 exports.Diff = Diff;
+/** Returns a FNV1A-64 non cryptographic hash of the given value */
 function Hash(value) {
     return (0, index_3.Hash)(value);
 }
 exports.Hash = Hash;
+/** Returns a new value with edits applied to the given value */
 function Patch(current, edits) {
     return (0, index_12.Patch)(current, edits);
 }
 exports.Patch = Patch;
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references. */
 function Mutate(current, next) {
     (0, index_2.Mutate)(current, next);
 }

package/license

@@ -1,4 +1,6 @@
-TypeBox: Json Schema Type Builder with Static Type Resolution for TypeScript 
+TypeBox
+
+Json Schema Type Builder with Static Type Resolution for TypeScript 
 
 The MIT License (MIT)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.0-dev-16",
+  "version": "0.32.0-dev-18",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -20,7 +20,6 @@
 
 ## Install
 
-#### Npm
 ```bash
 $ npm install @sinclair/typebox --save
 ```
@@ -646,9 +645,9 @@ TypeBox provides an extended type set that can be used to create schematics for
 
 <a name='types-modules'></a>
 
-### Type Modules
+### Modules
 
-TypeBox uses a modular type system and supports selective type imports. Using selective imports can be useful in resource constrained environments as the technique allows modern bundlers to tree shake unused types. This can reduce overall bundle sizes.
+TypeBox has a modular type system that supports selective type imports. Using selective imports can be useful in resource constrained environments as the technique enables modern bundlers to tree shake unused code leading to reduced bundle sizes. The following selectively imports a few types.
 
 ```typescript
 import { Object, Number, String, Boolean, type Static } from '@sinclair/typebox'
@@ -1724,7 +1723,7 @@ For additional comparative benchmarks, please refer to [typescript-runtime-type-
 
 ### Compile
 
-This benchmark measures compilation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/build/benchmark/measurement/module/compile.ts).
+This benchmark measures compilation performance for varying types.
 
 ```typescript
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
@@ -1766,7 +1765,7 @@ This benchmark measures compilation performance for varying types. You can revie
 
 ### Validate
 
-This benchmark measures validation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/build/benchmark/measurement/module/check.ts).
+This benchmark measures validation performance for varying types.
 
 ```typescript
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐

package/build/import/type/indexed/indexed-result.d.mts

@@ -1,33 +0,0 @@
-import { type TSchema, SchemaOptions } from '../schema/index.mjs';
-import { type TObject, type TProperties } from '../object/index.mjs';
-import { type TNever } from '../never/index.mjs';
-import { type TRecursive } from '../recursive/index.mjs';
-import { type TIntersect } from '../intersect/index.mjs';
-import { type TUnion } from '../union/index.mjs';
-import { type TTuple } from '../tuple/index.mjs';
-import { type TArray } from '../array/index.mjs';
-import { IntersectEvaluated } from '../intersect/index.mjs';
-import { UnionEvaluated } from '../union/index.mjs';
-type FromRest<T extends TSchema[], K extends PropertyKey> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromKey<L, K>, ...FromRest<R, K>] : []);
-declare function FromRest<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromRest<T, K>;
-type FromIntersectRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [...FromIntersectRest<R>] : [L, ...FromIntersectRest<R>] : []);
-declare function FromIntersectRest<T extends TSchema[]>(T: [...T]): FromIntersectRest<T>;
-type FromIntersect<T extends TSchema[], K extends PropertyKey> = (IntersectEvaluated<FromIntersectRest<FromRest<T, K>>>);
-declare function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromIntersect<T, K>;
-type FromUnionRest<T extends TSchema[], S = T> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : FromUnionRest<R, S> : S);
-declare function FromUnionRest<T extends TSchema[]>(T: [...T], S?: [...T]): FromUnionRest<T>;
-type FromUnion<T extends TSchema[], K extends PropertyKey> = (UnionEvaluated<FromUnionRest<FromRest<T, K>>>);
-declare function FromUnion<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromUnion<T, K>;
-type FromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? UnionEvaluated<T> : TNever);
-declare function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromTuple<T, K>;
-type FromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);
-declare function FromArray<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromArray<T, K>;
-type FromProperty<T extends TProperties, K extends PropertyKey> = (K extends keyof T ? T[K] : TNever);
-declare function FromProperty<T extends TProperties, K extends PropertyKey>(T: T, K: K): FromProperty<T, K>;
-type FromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<infer S> ? FromKey<S, K> : T extends TIntersect<infer S> ? FromIntersect<S, K> : T extends TUnion<infer S> ? FromUnion<S, K> : T extends TTuple<infer S> ? FromTuple<S, K> : T extends TArray<infer S> ? FromArray<S, K> : T extends TObject<infer S> ? FromProperty<S, K> : TNever);
-declare function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromKey<T, K>;
-type FromKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? [FromKey<T, L>, ...FromKeys<T, R>] : []);
-declare function FromKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromKeys<T, K>;
-export type TIndexResult<T extends TSchema, K extends PropertyKey[]> = (UnionEvaluated<FromKeys<T, K>>);
-export declare function IndexResult<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): TIndexResult<T, K>;
-export {};

package/build/import/type/indexed/indexed-result.mjs

@@ -1,65 +0,0 @@
-import { Never } from '../never/index.mjs';
-import { IntersectEvaluated } from '../intersect/index.mjs';
-import { UnionEvaluated } from '../union/index.mjs';
-import { CloneType } from '../clone/type.mjs';
-import { TArray as IsArrayType, TIntersect as IsIntersectType, TObject as IsObjectType, TNever as IsNeverType, TTuple as IsTupleType, TUnion as IsUnionType } from '../guard/type.mjs';
-function FromRest(T, K) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? [FromKey(L, K), ...FromRest(R, K)]
-        : []);
-}
-function FromIntersectRest(T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? IsNeverType(L)
-            ? [...FromIntersectRest(R)]
-            : [L, ...FromIntersectRest(R)]
-        : []);
-}
-function FromIntersect(T, K) {
-    return (IntersectEvaluated(FromIntersectRest(FromRest(T, K))));
-}
-function FromUnionRest(T, S = T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? IsNeverType(L)
-            ? []
-            : FromUnionRest(R, S)
-        : S);
-}
-function FromUnion(T, K) {
-    return (UnionEvaluated(FromUnionRest(FromRest(T, K))));
-}
-function FromTuple(T, K) {
-    return (K in T ? T[K] :
-        K === '[number]' ? UnionEvaluated(T) :
-            Never());
-}
-function FromArray(T, K) {
-    return (K === '[number]'
-        ? T
-        : Never());
-}
-function FromProperty(T, K) {
-    return (K in T
-        ? T[K]
-        : Never());
-}
-function FromKey(T, K) {
-    return (IsIntersectType(T) ? FromIntersect(T.allOf, K) :
-        IsUnionType(T) ? FromUnion(T.anyOf, K) :
-            IsTupleType(T) ? FromTuple(T.items ?? [], K) :
-                IsArrayType(T) ? FromArray(T.items, K) :
-                    IsObjectType(T) ? FromProperty(T.properties, K) :
-                        Never());
-}
-function FromKeys(T, K) {
-    const [L, ...R] = K;
-    return (K.length > 0
-        ? [FromKey(T, L), ...FromKeys(T, R)]
-        : []);
-}
-export function IndexResult(T, K, options) {
-    return (CloneType(UnionEvaluated(FromKeys(T, K)), options));
-}

package/build/require/type/indexed/indexed-result.d.ts

@@ -1,33 +0,0 @@
-import { type TSchema, SchemaOptions } from '../schema/index';
-import { type TObject, type TProperties } from '../object/index';
-import { type TNever } from '../never/index';
-import { type TRecursive } from '../recursive/index';
-import { type TIntersect } from '../intersect/index';
-import { type TUnion } from '../union/index';
-import { type TTuple } from '../tuple/index';
-import { type TArray } from '../array/index';
-import { IntersectEvaluated } from '../intersect/index';
-import { UnionEvaluated } from '../union/index';
-type FromRest<T extends TSchema[], K extends PropertyKey> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromKey<L, K>, ...FromRest<R, K>] : []);
-declare function FromRest<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromRest<T, K>;
-type FromIntersectRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [...FromIntersectRest<R>] : [L, ...FromIntersectRest<R>] : []);
-declare function FromIntersectRest<T extends TSchema[]>(T: [...T]): FromIntersectRest<T>;
-type FromIntersect<T extends TSchema[], K extends PropertyKey> = (IntersectEvaluated<FromIntersectRest<FromRest<T, K>>>);
-declare function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromIntersect<T, K>;
-type FromUnionRest<T extends TSchema[], S = T> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : FromUnionRest<R, S> : S);
-declare function FromUnionRest<T extends TSchema[]>(T: [...T], S?: [...T]): FromUnionRest<T>;
-type FromUnion<T extends TSchema[], K extends PropertyKey> = (UnionEvaluated<FromUnionRest<FromRest<T, K>>>);
-declare function FromUnion<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromUnion<T, K>;
-type FromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? UnionEvaluated<T> : TNever);
-declare function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromTuple<T, K>;
-type FromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);
-declare function FromArray<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromArray<T, K>;
-type FromProperty<T extends TProperties, K extends PropertyKey> = (K extends keyof T ? T[K] : TNever);
-declare function FromProperty<T extends TProperties, K extends PropertyKey>(T: T, K: K): FromProperty<T, K>;
-type FromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<infer S> ? FromKey<S, K> : T extends TIntersect<infer S> ? FromIntersect<S, K> : T extends TUnion<infer S> ? FromUnion<S, K> : T extends TTuple<infer S> ? FromTuple<S, K> : T extends TArray<infer S> ? FromArray<S, K> : T extends TObject<infer S> ? FromProperty<S, K> : TNever);
-declare function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromKey<T, K>;
-type FromKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? [FromKey<T, L>, ...FromKeys<T, R>] : []);
-declare function FromKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromKeys<T, K>;
-export type TIndexResult<T extends TSchema, K extends PropertyKey[]> = (UnionEvaluated<FromKeys<T, K>>);
-export declare function IndexResult<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): TIndexResult<T, K>;
-export {};

package/build/require/type/indexed/indexed-result.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexResult = void 0;
-const index_1 = require("../never/index");
-const index_2 = require("../intersect/index");
-const index_3 = require("../union/index");
-const type_1 = require("../clone/type");
-const type_2 = require("../guard/type");
-function FromRest(T, K) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? [FromKey(L, K), ...FromRest(R, K)]
-        : []);
-}
-function FromIntersectRest(T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? (0, type_2.TNever)(L)
-            ? [...FromIntersectRest(R)]
-            : [L, ...FromIntersectRest(R)]
-        : []);
-}
-function FromIntersect(T, K) {
-    return ((0, index_2.IntersectEvaluated)(FromIntersectRest(FromRest(T, K))));
-}
-function FromUnionRest(T, S = T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? (0, type_2.TNever)(L)
-            ? []
-            : FromUnionRest(R, S)
-        : S);
-}
-function FromUnion(T, K) {
-    return ((0, index_3.UnionEvaluated)(FromUnionRest(FromRest(T, K))));
-}
-function FromTuple(T, K) {
-    return (K in T ? T[K] :
-        K === '[number]' ? (0, index_3.UnionEvaluated)(T) :
-            (0, index_1.Never)());
-}
-function FromArray(T, K) {
-    return (K === '[number]'
-        ? T
-        : (0, index_1.Never)());
-}
-function FromProperty(T, K) {
-    return (K in T
-        ? T[K]
-        : (0, index_1.Never)());
-}
-function FromKey(T, K) {
-    return ((0, type_2.TIntersect)(T) ? FromIntersect(T.allOf, K) :
-        (0, type_2.TUnion)(T) ? FromUnion(T.anyOf, K) :
-            (0, type_2.TTuple)(T) ? FromTuple(T.items ?? [], K) :
-                (0, type_2.TArray)(T) ? FromArray(T.items, K) :
-                    (0, type_2.TObject)(T) ? FromProperty(T.properties, K) :
-                        (0, index_1.Never)());
-}
-function FromKeys(T, K) {
-    const [L, ...R] = K;
-    return (K.length > 0
-        ? [FromKey(T, L), ...FromKeys(T, R)]
-        : []);
-}
-function IndexResult(T, K, options) {
-    return ((0, type_1.CloneType)((0, index_3.UnionEvaluated)(FromKeys(T, K)), options));
-}
-exports.IndexResult = IndexResult;