@xfey/tenso 0.1.130

package/node_modules/@sinclair/typebox/build/esm/type/index.d.mts

@@ -0,0 +1,71 @@
+export * from './any/index.mjs';
+export * from './argument/index.mjs';
+export * from './array/index.mjs';
+export * from './async-iterator/index.mjs';
+export * from './awaited/index.mjs';
+export * from './bigint/index.mjs';
+export * from './boolean/index.mjs';
+export * from './clone/index.mjs';
+export * from './composite/index.mjs';
+export * from './const/index.mjs';
+export * from './constructor/index.mjs';
+export * from './constructor-parameters/index.mjs';
+export * from './date/index.mjs';
+export * from './discard/index.mjs';
+export * from './enum/index.mjs';
+export * from './error/index.mjs';
+export * from './exclude/index.mjs';
+export * from './extends/index.mjs';
+export * from './extract/index.mjs';
+export * from './function/index.mjs';
+export * from './guard/index.mjs';
+export * from './helpers/index.mjs';
+export * from './indexed/index.mjs';
+export * from './instance-type/index.mjs';
+export * from './instantiate/index.mjs';
+export * from './integer/index.mjs';
+export * from './intersect/index.mjs';
+export * from './intrinsic/index.mjs';
+export * from './iterator/index.mjs';
+export * from './keyof/index.mjs';
+export * from './literal/index.mjs';
+export * from './mapped/index.mjs';
+export * from './module/index.mjs';
+export * from './never/index.mjs';
+export * from './not/index.mjs';
+export * from './null/index.mjs';
+export * from './number/index.mjs';
+export * from './object/index.mjs';
+export * from './omit/index.mjs';
+export * from './optional/index.mjs';
+export * from './parameters/index.mjs';
+export * from './partial/index.mjs';
+export * from './patterns/index.mjs';
+export * from './pick/index.mjs';
+export * from './promise/index.mjs';
+export * from './readonly/index.mjs';
+export * from './readonly-optional/index.mjs';
+export * from './record/index.mjs';
+export * from './recursive/index.mjs';
+export * from './ref/index.mjs';
+export * from './regexp/index.mjs';
+export * from './registry/index.mjs';
+export * from './required/index.mjs';
+export * from './rest/index.mjs';
+export * from './return-type/index.mjs';
+export * from './schema/index.mjs';
+export * from './sets/index.mjs';
+export * from './static/index.mjs';
+export * from './string/index.mjs';
+export * from './symbol/index.mjs';
+export * from './symbols/index.mjs';
+export * from './template-literal/index.mjs';
+export * from './transform/index.mjs';
+export * from './tuple/index.mjs';
+export * from './type/index.mjs';
+export * from './uint8array/index.mjs';
+export * from './undefined/index.mjs';
+export * from './union/index.mjs';
+export * from './unknown/index.mjs';
+export * from './unsafe/index.mjs';
+export * from './void/index.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/index.mjs

@@ -0,0 +1,71 @@
+export * from './any/index.mjs';
+export * from './argument/index.mjs';
+export * from './array/index.mjs';
+export * from './async-iterator/index.mjs';
+export * from './awaited/index.mjs';
+export * from './bigint/index.mjs';
+export * from './boolean/index.mjs';
+export * from './clone/index.mjs';
+export * from './composite/index.mjs';
+export * from './const/index.mjs';
+export * from './constructor/index.mjs';
+export * from './constructor-parameters/index.mjs';
+export * from './date/index.mjs';
+export * from './discard/index.mjs';
+export * from './enum/index.mjs';
+export * from './error/index.mjs';
+export * from './exclude/index.mjs';
+export * from './extends/index.mjs';
+export * from './extract/index.mjs';
+export * from './function/index.mjs';
+export * from './guard/index.mjs';
+export * from './helpers/index.mjs';
+export * from './indexed/index.mjs';
+export * from './instance-type/index.mjs';
+export * from './instantiate/index.mjs';
+export * from './integer/index.mjs';
+export * from './intersect/index.mjs';
+export * from './intrinsic/index.mjs';
+export * from './iterator/index.mjs';
+export * from './keyof/index.mjs';
+export * from './literal/index.mjs';
+export * from './mapped/index.mjs';
+export * from './module/index.mjs';
+export * from './never/index.mjs';
+export * from './not/index.mjs';
+export * from './null/index.mjs';
+export * from './number/index.mjs';
+export * from './object/index.mjs';
+export * from './omit/index.mjs';
+export * from './optional/index.mjs';
+export * from './parameters/index.mjs';
+export * from './partial/index.mjs';
+export * from './patterns/index.mjs';
+export * from './pick/index.mjs';
+export * from './promise/index.mjs';
+export * from './readonly/index.mjs';
+export * from './readonly-optional/index.mjs';
+export * from './record/index.mjs';
+export * from './recursive/index.mjs';
+export * from './ref/index.mjs';
+export * from './regexp/index.mjs';
+export * from './registry/index.mjs';
+export * from './required/index.mjs';
+export * from './rest/index.mjs';
+export * from './return-type/index.mjs';
+export * from './schema/index.mjs';
+export * from './sets/index.mjs';
+export * from './static/index.mjs';
+export * from './string/index.mjs';
+export * from './symbol/index.mjs';
+export * from './symbols/index.mjs';
+export * from './template-literal/index.mjs';
+export * from './transform/index.mjs';
+export * from './tuple/index.mjs';
+export * from './type/index.mjs';
+export * from './uint8array/index.mjs';
+export * from './undefined/index.mjs';
+export * from './union/index.mjs';
+export * from './unknown/index.mjs';
+export * from './unsafe/index.mjs';
+export * from './void/index.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/indexed/index.d.mts

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

package/node_modules/@sinclair/typebox/build/esm/type/indexed/index.mjs

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

package/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-key.d.mts

@@ -0,0 +1,13 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Ensure, Evaluate } from '../helpers/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TIndex } from './indexed.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+type TMappedIndexPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+    [_ in Key]: TIndex<Type, [Key]>;
+};
+type TMappedIndexPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (PropertyKeys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? TMappedIndexPropertyKeys<Type, Right, Result & TMappedIndexPropertyKey<Type, Left>> : Result);
+type TMappedIndexProperties<Type extends TSchema, MappedKey extends TMappedKey> = Evaluate<TMappedIndexPropertyKeys<Type, MappedKey['keys']>>;
+export type TIndexFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TMappedIndexProperties<Type, MappedKey>> = (Ensure<TMappedResult<Properties>>);
+export declare function IndexFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TMappedIndexProperties<Type, MappedKey>>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedResult<Properties>;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-key.mjs

@@ -0,0 +1,22 @@
+import { Index } from './indexed.mjs';
+import { MappedResult } from '../mapped/index.mjs';
+import { Clone } from '../clone/value.mjs';
+// prettier-ignore
+function MappedIndexPropertyKey(type, key, options) {
+    return { [key]: Index(type, [key], Clone(options)) };
+}
+// prettier-ignore
+function MappedIndexPropertyKeys(type, propertyKeys, options) {
+    return propertyKeys.reduce((result, left) => {
+        return { ...result, ...MappedIndexPropertyKey(type, left, options) };
+    }, {});
+}
+// prettier-ignore
+function MappedIndexProperties(type, mappedKey, options) {
+    return MappedIndexPropertyKeys(type, mappedKey.keys, options);
+}
+// prettier-ignore
+export function IndexFromMappedKey(type, mappedKey, options) {
+    const properties = MappedIndexProperties(type, mappedKey, options);
+    return MappedResult(properties);
+}

package/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.d.mts

@@ -0,0 +1,12 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TIndexPropertyKeys } from './indexed-property-keys.mjs';
+import { type TIndex } from './index.mjs';
+type TFromProperties<Type extends TSchema, Properties extends TProperties> = ({
+    [K2 in keyof Properties]: TIndex<Type, TIndexPropertyKeys<Properties[K2]>>;
+});
+type TFromMappedResult<Type extends TSchema, MappedResult extends TMappedResult> = (TFromProperties<Type, MappedResult['properties']>);
+export type TIndexFromMappedResult<Type extends TSchema, MappedResult extends TMappedResult, Properties extends TProperties = TFromMappedResult<Type, MappedResult>> = (TMappedResult<Properties>);
+export declare function IndexFromMappedResult<Type extends TSchema, MappedResult extends TMappedResult, Properties extends TProperties = TFromMappedResult<Type, MappedResult>>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TMappedResult<Properties>;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.mjs

@@ -0,0 +1,20 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { IndexPropertyKeys } from './indexed-property-keys.mjs';
+import { Index } from './index.mjs';
+// prettier-ignore
+function FromProperties(type, properties, options) {
+    const result = {};
+    for (const K2 of Object.getOwnPropertyNames(properties)) {
+        result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options);
+    }
+    return result;
+}
+// prettier-ignore
+function FromMappedResult(type, mappedResult, options) {
+    return FromProperties(type, mappedResult.properties, options);
+}
+// prettier-ignore
+export function IndexFromMappedResult(type, mappedResult, options) {
+    const properties = FromMappedResult(type, mappedResult, options);
+    return MappedResult(properties);
+}

package/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.d.mts

@@ -0,0 +1,14 @@
+import { type TTemplateLiteralGenerate, type TTemplateLiteral } from '../template-literal/index.mjs';
+import type { TLiteral, TLiteralValue } from '../literal/index.mjs';
+import type { TInteger } from '../integer/index.mjs';
+import type { TNumber } from '../number/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
+import type { TUnion } from '../union/index.mjs';
+type TFromTemplateLiteral<TemplateLiteral extends TTemplateLiteral, Keys extends string[] = TTemplateLiteralGenerate<TemplateLiteral>> = (Keys);
+type TFromUnion<Types extends TSchema[], Result extends string[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TIndexPropertyKeys<Left>]> : Result);
+type TFromLiteral<LiteralValue extends TLiteralValue> = (LiteralValue extends PropertyKey ? [`${LiteralValue}`] : []);
+export type TIndexPropertyKeys<Type extends TSchema> = (Type extends TTemplateLiteral ? TFromTemplateLiteral<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Type extends TNumber ? ['[number]'] : Type extends TInteger ? ['[number]'] : [
+]);
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
+export declare function IndexPropertyKeys<Type extends TSchema>(type: Type): TIndexPropertyKeys<Type>;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.mjs

@@ -0,0 +1,32 @@
+import { TemplateLiteralGenerate } from '../template-literal/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../guard/kind.mjs';
+// prettier-ignore
+function FromTemplateLiteral(templateLiteral) {
+    const keys = TemplateLiteralGenerate(templateLiteral);
+    return keys.map(key => key.toString());
+}
+// prettier-ignore
+function FromUnion(types) {
+    const result = [];
+    for (const type of types)
+        result.push(...IndexPropertyKeys(type));
+    return result;
+}
+// prettier-ignore
+function FromLiteral(literalValue) {
+    return ([literalValue.toString()] // TS 5.4 observes TLiteralValue as not having a toString()
+    );
+}
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
+// prettier-ignore
+export function IndexPropertyKeys(type) {
+    return [...new Set((IsTemplateLiteral(type) ? FromTemplateLiteral(type) :
+            IsUnion(type) ? FromUnion(type.anyOf) :
+                IsLiteral(type) ? FromLiteral(type.const) :
+                    IsNumber(type) ? ['[number]'] :
+                        IsInteger(type) ? ['[number]'] :
+                            []))];
+}

package/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed.d.mts

@@ -0,0 +1,52 @@
+import { type TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type Assert } from '../helpers/index.mjs';
+import { type TComputed } from '../computed/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TArray } from '../array/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TRecursive } from '../recursive/index.mjs';
+import { type TRef } from '../ref/index.mjs';
+import { type TTuple } from '../tuple/index.mjs';
+import { type TIntersectEvaluated } from '../intersect/index.mjs';
+import { type TUnionEvaluated } from '../union/index.mjs';
+import { type TIndexPropertyKeys } from './indexed-property-keys.mjs';
+import { type TIndexFromMappedKey } from './indexed-from-mapped-key.mjs';
+import { type TIndexFromMappedResult } from './indexed-from-mapped-result.mjs';
+type TFromRest<Types extends TSchema[], Key extends PropertyKey, Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<Right, Key, [...Result, Assert<TIndexFromPropertyKey<Left, Key>, TSchema>]> : Result);
+type TFromIntersectRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TNever ? TFromIntersectRest<Right, [...Result]> : TFromIntersectRest<Right, [...Result, Left]> : Result);
+type TFromIntersect<Types extends TSchema[], Key extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<Types, Key>>>);
+type TFromUnionRest<Types extends TSchema[], Result extends TSchema[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TNever ? [] : TFromUnionRest<Right, [Left, ...Result]> : Result;
+type TFromUnion<Types extends TSchema[], Key extends PropertyKey> = (TUnionEvaluated<TFromUnionRest<TFromRest<Types, Key>>>);
+type TFromTuple<Types extends TSchema[], Key extends PropertyKey> = (Key extends keyof Types ? Types[Key] : Key extends '[number]' ? TUnionEvaluated<Types> : TNever);
+type TFromArray<Type extends TSchema, Key extends PropertyKey> = (Key extends '[number]' ? Type : TNever);
+type AssertPropertyKey<T> = Assert<T, string | number>;
+type TFromProperty<Properties extends TProperties, Key extends PropertyKey> = (Key extends keyof Properties ? Properties[Key] : `${AssertPropertyKey<Key>}` extends `${AssertPropertyKey<keyof Properties>}` ? Properties[AssertPropertyKey<Key>] : TNever);
+export type TIndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = (Type extends TRecursive<infer Type extends TSchema> ? TIndexFromPropertyKey<Type, Key> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types, Key> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types, Key> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Key> : Type extends TArray<infer Type extends TSchema> ? TFromArray<Type, Key> : Type extends TObject<infer Properties extends TProperties> ? TFromProperty<Properties, Key> : TNever);
+export declare function IndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, propertyKey: Key): TIndexFromPropertyKey<Type, Key>;
+export type TIndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = (PropertyKeys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? TIndexFromPropertyKeys<Type, Right, [...Result, Assert<TIndexFromPropertyKey<Type, Left>, TSchema>]> : Result);
+export declare function IndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): TIndexFromPropertyKeys<Type, PropertyKeys>;
+type FromSchema<Type extends TSchema, PropertyKeys extends PropertyKey[]> = (TUnionEvaluated<TIndexFromPropertyKeys<Type, PropertyKeys>>);
+declare function FromSchema<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): FromSchema<Type, PropertyKeys>;
+export type TIndexFromComputed<Type extends TSchema, Key extends TSchema> = (TComputed<'Index', [Type, Key]>);
+export declare function IndexFromComputed<Type extends TSchema, Key extends TSchema>(type: Type, key: Key): TIndexFromComputed<Type, Key>;
+export type TIndex<Type extends TSchema, PropertyKeys extends PropertyKey[]> = (FromSchema<Type, PropertyKeys>);
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TRef, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TRef, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TIndexFromMappedKey<Type, MappedKey>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, Key extends TSchema, PropertyKeys extends PropertyKey[] = TIndexPropertyKeys<Key>>(T: Type, K: Key, options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed.mjs

@@ -0,0 +1,91 @@
+import { CreateType } from '../create/type.mjs';
+import { TypeBoxError } from '../error/index.mjs';
+import { Computed } from '../computed/index.mjs';
+import { Never } from '../never/index.mjs';
+import { IntersectEvaluated } from '../intersect/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
+import { IndexPropertyKeys } from './indexed-property-keys.mjs';
+import { IndexFromMappedKey } from './indexed-from-mapped-key.mjs';
+import { IndexFromMappedResult } from './indexed-from-mapped-result.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion, IsRef } from '../guard/kind.mjs';
+// prettier-ignore
+function FromRest(types, key) {
+    return types.map(type => IndexFromPropertyKey(type, key));
+}
+// prettier-ignore
+function FromIntersectRest(types) {
+    return types.filter(type => !IsNever(type));
+}
+// prettier-ignore
+function FromIntersect(types, key) {
+    return (IntersectEvaluated(FromIntersectRest(FromRest(types, key))));
+}
+// prettier-ignore
+function FromUnionRest(types) {
+    return (types.some(L => IsNever(L))
+        ? []
+        : types);
+}
+// prettier-ignore
+function FromUnion(types, key) {
+    return (UnionEvaluated(FromUnionRest(FromRest(types, key))));
+}
+// prettier-ignore
+function FromTuple(types, key) {
+    return (key in types ? types[key] :
+        key === '[number]' ? UnionEvaluated(types) :
+            Never());
+}
+// prettier-ignore
+function FromArray(type, key) {
+    return (key === '[number]'
+        ? type
+        : Never());
+}
+// prettier-ignore
+function FromProperty(properties, propertyKey) {
+    return (propertyKey in properties ? properties[propertyKey] : Never());
+}
+// prettier-ignore
+export function IndexFromPropertyKey(type, propertyKey) {
+    return (IsIntersect(type) ? FromIntersect(type.allOf, propertyKey) :
+        IsUnion(type) ? FromUnion(type.anyOf, propertyKey) :
+            IsTuple(type) ? FromTuple(type.items ?? [], propertyKey) :
+                IsArray(type) ? FromArray(type.items, propertyKey) :
+                    IsObject(type) ? FromProperty(type.properties, propertyKey) :
+                        Never());
+}
+// prettier-ignore
+export function IndexFromPropertyKeys(type, propertyKeys) {
+    return propertyKeys.map(propertyKey => IndexFromPropertyKey(type, propertyKey));
+}
+// prettier-ignore
+function FromSchema(type, propertyKeys) {
+    return (UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys)));
+}
+// prettier-ignore
+export function IndexFromComputed(type, key) {
+    return Computed('Index', [type, key]);
+}
+/** `[Json]` Returns an Indexed property type for the given keys */
+export function Index(type, key, options) {
+    // computed-type
+    if (IsRef(type) || IsRef(key)) {
+        const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
+        if (!IsSchema(type) || !IsSchema(key))
+            throw new TypeBoxError(error);
+        return Computed('Index', [type, key]);
+    }
+    // mapped-types
+    if (IsMappedResult(key))
+        return IndexFromMappedResult(type, key, options);
+    if (IsMappedKey(key))
+        return IndexFromMappedKey(type, key, options);
+    // prettier-ignore
+    return CreateType(IsSchema(key)
+        ? FromSchema(type, IndexPropertyKeys(key))
+        : FromSchema(type, key), options);
+}

package/node_modules/@sinclair/typebox/build/esm/type/instance-type/index.d.mts

@@ -0,0 +1 @@
+export * from './instance-type.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/instance-type/index.mjs

@@ -0,0 +1 @@
+export * from './instance-type.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TConstructor } from '../constructor/index.mjs';
+import { type TNever } from '../never/index.mjs';
+export type TInstanceType<Type extends TSchema, Result extends TSchema = Type extends TConstructor<infer _Parameters extends TSchema[], infer InstanceType extends TSchema> ? InstanceType : TNever> = Result;
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
+export declare function InstanceType<Type extends TSchema>(schema: Type, options?: SchemaOptions): TInstanceType<Type>;

package/node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.mjs

@@ -0,0 +1,7 @@
+import { CreateType } from '../create/type.mjs';
+import { Never } from '../never/index.mjs';
+import * as KindGuard from '../guard/kind.mjs';
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
+export function InstanceType(schema, options) {
+    return (KindGuard.IsConstructor(schema) ? CreateType(schema.returns, options) : Never(options));
+}

package/node_modules/@sinclair/typebox/build/esm/type/instantiate/index.d.mts

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/instantiate/index.mjs

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/instantiate/instantiate.d.mts

@@ -0,0 +1,50 @@
+import { type TSchema } from '../schema/index.mjs';
+import { type TArgument } from '../argument/index.mjs';
+import { type TUnknown } from '../unknown/index.mjs';
+import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
+import { type TReadonly } from '../readonly/index.mjs';
+import { type TOptional } from '../optional/index.mjs';
+import { type TConstructor } from '../constructor/index.mjs';
+import { type TFunction } from '../function/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 { type TAsyncIterator } from '../async-iterator/index.mjs';
+import { type TIterator } from '../iterator/index.mjs';
+import { type TPromise } from '../promise/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
+import { type TRecordOrObject, type TRecord } from '../record/index.mjs';
+type TFromConstructor<Args extends TSchema[], Parameters extends TSchema[], InstanceType extends TSchema, Result extends TConstructor = TConstructor<TFromTypes<Args, Parameters>, TFromType<Args, InstanceType>>> = Result;
+type TFromFunction<Args extends TSchema[], Parameters extends TSchema[], ReturnType extends TSchema, Result extends TFunction = TFunction<TFromTypes<Args, Parameters>, TFromType<Args, ReturnType>>> = Result;
+type TFromIntersect<Args extends TSchema[], Types extends TSchema[], Result extends TIntersect = TIntersect<TFromTypes<Args, Types>>> = Result;
+type TFromUnion<Args extends TSchema[], Types extends TSchema[], Result extends TUnion = TUnion<TFromTypes<Args, Types>>> = Result;
+type TFromTuple<Args extends TSchema[], Types extends TSchema[], Result extends TTuple = TTuple<TFromTypes<Args, Types>>> = Result;
+type TFromArray<Args extends TSchema[], Type extends TSchema, Result extends TArray = TArray<TFromType<Args, Type>>> = Result;
+type TFromAsyncIterator<Args extends TSchema[], Type extends TSchema, Result extends TAsyncIterator = TAsyncIterator<TFromType<Args, Type>>> = Result;
+type TFromIterator<Args extends TSchema[], Type extends TSchema, Result extends TIterator = TIterator<TFromType<Args, Type>>> = Result;
+type TFromPromise<Args extends TSchema[], Type extends TSchema, Result extends TPromise = TPromise<TFromType<Args, Type>>> = Result;
+type TFromObject<Args extends TSchema[], Properties extends TProperties, MappedProperties extends TProperties = TFromProperties<Args, Properties>, Result extends TSchema = TObject<MappedProperties>> = Result;
+type TFromRecord<Args extends TSchema[], Key extends TSchema, Value extends TSchema, MappedKey extends TSchema = TFromType<Args, Key>, MappedValue extends TSchema = TFromType<Args, Value>, Result extends TSchema = TRecordOrObject<MappedKey, MappedValue>> = Result;
+type TFromArgument<Args extends TSchema[], Index extends number, Result extends TSchema = Index extends keyof Args[Index] ? Args[Index] : TUnknown> = Result;
+type TFromProperty<Args extends TSchema[], Type extends TSchema, IsReadonly extends boolean = Type extends TReadonly<Type> ? true : false, IsOptional extends boolean = Type extends TOptional<Type> ? true : false, Mapped extends TSchema = TFromType<Args, Type>, Result extends TSchema = ([
+    IsReadonly,
+    IsOptional
+] extends [true, true] ? TReadonlyOptional<Mapped> : [
+    IsReadonly,
+    IsOptional
+] extends [true, false] ? TReadonly<Mapped> : [
+    IsReadonly,
+    IsOptional
+] extends [false, true] ? TOptional<Mapped> : Mapped)> = Result;
+type TFromProperties<Args extends TSchema[], Properties extends TProperties, Result extends TProperties = {
+    [Key in keyof Properties]: TFromProperty<Args, Properties[Key]>;
+}> = Result;
+export type TFromTypes<Args extends TSchema[], Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Args, Right, [...Result, TFromType<Args, Left>]> : Result);
+export declare function FromTypes<Args extends TSchema[], Types extends TSchema[]>(args: [...Args], types: [...Types]): TFromTypes<Args, Types>;
+export type TFromType<Args extends TSchema[], Type extends TSchema> = (Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<Args, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<Args, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Args, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Args, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Args, Types> : Type extends TArray<infer Type extends TSchema> ? TFromArray<Args, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<Args, Type> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<Args, Type> : Type extends TPromise<infer Type extends TSchema> ? TFromPromise<Args, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Args, Properties> : Type extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TFromRecord<Args, Key, Value> : Type extends TArgument<infer Index extends number> ? TFromArgument<Args, Index> : Type);
+/** `[JavaScript]` Instantiates a type with the given parameters */
+export type TInstantiate<Type extends TSchema, Args extends TSchema[], Result extends TSchema = TFromType<Args, Type>> = Result;
+/** `[JavaScript]` Instantiates a type with the given parameters */
+export declare function Instantiate<Type extends TSchema, Args extends TSchema[]>(type: Type, args: [...Args]): TInstantiate<Type, Args>;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/instantiate/instantiate.mjs

@@ -0,0 +1,115 @@
+import { CloneType } from '../clone/type.mjs';
+import { Unknown } from '../unknown/index.mjs';
+import { ReadonlyOptional } from '../readonly-optional/index.mjs';
+import { Readonly } from '../readonly/index.mjs';
+import { Optional } from '../optional/index.mjs';
+import { Object } from '../object/index.mjs';
+import { Record, RecordKey, RecordValue } from '../record/index.mjs';
+import * as ValueGuard from '../guard/value.mjs';
+import * as KindGuard from '../guard/kind.mjs';
+// prettier-ignore
+function FromConstructor(args, type) {
+    type.parameters = FromTypes(args, type.parameters);
+    type.returns = FromType(args, type.returns);
+    return type;
+}
+// prettier-ignore
+function FromFunction(args, type) {
+    type.parameters = FromTypes(args, type.parameters);
+    type.returns = FromType(args, type.returns);
+    return type;
+}
+// prettier-ignore
+function FromIntersect(args, type) {
+    type.allOf = FromTypes(args, type.allOf);
+    return type;
+}
+// prettier-ignore
+function FromUnion(args, type) {
+    type.anyOf = FromTypes(args, type.anyOf);
+    return type;
+}
+// prettier-ignore
+function FromTuple(args, type) {
+    if (ValueGuard.IsUndefined(type.items))
+        return type;
+    type.items = FromTypes(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromArray(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromAsyncIterator(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromIterator(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromPromise(args, type) {
+    type.item = FromType(args, type.item);
+    return type;
+}
+// prettier-ignore
+function FromObject(args, type) {
+    const mappedProperties = FromProperties(args, type.properties);
+    return { ...type, ...Object(mappedProperties) }; // retain options
+}
+// prettier-ignore
+function FromRecord(args, type) {
+    const mappedKey = FromType(args, RecordKey(type));
+    const mappedValue = FromType(args, RecordValue(type));
+    const result = Record(mappedKey, mappedValue);
+    return { ...type, ...result }; // retain options
+}
+// prettier-ignore
+function FromArgument(args, argument) {
+    return argument.index in args ? args[argument.index] : Unknown();
+}
+// prettier-ignore
+function FromProperty(args, type) {
+    const isReadonly = KindGuard.IsReadonly(type);
+    const isOptional = KindGuard.IsOptional(type);
+    const mapped = FromType(args, type);
+    return (isReadonly && isOptional ? ReadonlyOptional(mapped) :
+        isReadonly && !isOptional ? Readonly(mapped) :
+            !isReadonly && isOptional ? Optional(mapped) :
+                mapped);
+}
+// prettier-ignore
+function FromProperties(args, properties) {
+    return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+        return { ...result, [key]: FromProperty(args, properties[key]) };
+    }, {});
+}
+// prettier-ignore
+export function FromTypes(args, types) {
+    return types.map(type => FromType(args, type));
+}
+// prettier-ignore
+function FromType(args, type) {
+    return (KindGuard.IsConstructor(type) ? FromConstructor(args, type) :
+        KindGuard.IsFunction(type) ? FromFunction(args, type) :
+            KindGuard.IsIntersect(type) ? FromIntersect(args, type) :
+                KindGuard.IsUnion(type) ? FromUnion(args, type) :
+                    KindGuard.IsTuple(type) ? FromTuple(args, type) :
+                        KindGuard.IsArray(type) ? FromArray(args, type) :
+                            KindGuard.IsAsyncIterator(type) ? FromAsyncIterator(args, type) :
+                                KindGuard.IsIterator(type) ? FromIterator(args, type) :
+                                    KindGuard.IsPromise(type) ? FromPromise(args, type) :
+                                        KindGuard.IsObject(type) ? FromObject(args, type) :
+                                            KindGuard.IsRecord(type) ? FromRecord(args, type) :
+                                                KindGuard.IsArgument(type) ? FromArgument(args, type) :
+                                                    type);
+}
+/** `[JavaScript]` Instantiates a type with the given parameters */
+// prettier-ignore
+export function Instantiate(type, args) {
+    return FromType(args, CloneType(type));
+}

package/node_modules/@sinclair/typebox/build/esm/type/integer/index.d.mts

@@ -0,0 +1 @@
+export * from './integer.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/integer/index.mjs

@@ -0,0 +1 @@
+export * from './integer.mjs';