@yaag/cli 0.1.0

package/assets/types/typebox/build/type/engine/cyclic/dependencies.d.mts

@@ -0,0 +1,22 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TFunction } from '../../types/function.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TProperties, type TPropertyValues } from '../../types/properties.mjs';
+import { type TRecord } from '../../types/record.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TInterfaceDeferred } from '../../action/interface.mjs';
+type TFromRef<Context extends TProperties, Ref extends string, Dependencies extends string[]> = Ref extends Dependencies[number] ? Dependencies : Ref extends keyof Context ? TFromType<Context, Context[Ref], [...Dependencies, Ref]> : TUnreachable;
+type TFromProperties<Context extends TProperties, Properties extends TProperties, Dependencies extends string[], Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Context, Types, Dependencies>;
+type TFromTypes<Context extends TProperties, Types extends TSchema[], Dependencies extends string[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Context, Right, TFromType<Context, Left, Dependencies>> : Dependencies;
+type TFromType<Context extends TProperties, Type extends TSchema, Result extends string[]> = (Type extends TRef<infer Ref extends string> ? TFromRef<Context, Ref, Result> : Type extends TArray<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Context, [...Parameters, InstanceType], Result> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Context, [...Parameters, ReturnType], Result> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Context, Type, Result> : Result);
+/** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
+export type TCyclicDependencies<Context extends TProperties, Key extends string, Type extends TSchema, Result extends string[] = TFromType<Context, Type, [Key]>> = Result;
+/** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
+export declare function CyclicDependencies<Context extends TProperties, Key extends string, Type extends TSchema>(context: Context, key: Key, type: Type): TCyclicDependencies<Context, Key, Type>;
+export {};

package/assets/types/typebox/build/type/engine/cyclic/extends.d.mts

@@ -0,0 +1,28 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TAny } from '../../types/any.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TFunction } from '../../types/function.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TRecord } from '../../types/record.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TUnknown } from '../../types/unknown.mjs';
+type TFromRef<_Ref extends string> = (TAny);
+type TFromProperties<Properties extends TProperties, Result extends TProperties = {
+    [Key in keyof Properties]: TFromType<Properties[Key]>;
+}> = {
+    [Key in keyof Result]: Result[Key];
+};
+type TFromTypes<Types extends TSchema[], Result extends TSchema[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Right, [...Result, TFromType<Left>]> : Result;
+type TFromType<Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TFromType<Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties>> : Type extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TRecord<Pattern, TFromType<Value>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types>> : Type);
+type TCyclicAnyFromParameters<Defs extends TProperties, Ref extends string> = (Ref extends keyof Defs ? TFromType<Defs[Ref]> : TUnknown);
+/** Transforms TCyclic TRef's into TAny's. This function is used prior to TExtends checks to enable cyclics to be structurally checked and terminated (with TAny) at first point of recursion, what would otherwise be a recursive TRef.*/
+export type TCyclicExtends<Type extends TCyclic, Result extends TSchema = TCyclicAnyFromParameters<Type['$defs'], Type['$ref']>> = Result;
+/** Transforms TCyclic TRef's into TAny's. This function is used prior to TExtends checks to enable cyclics to be structurally checked and terminated (with TAny) at first point of recursion, what would otherwise be a recursive TRef.*/
+export declare function CyclicExtends<Type extends TCyclic>(type: Type): TCyclicExtends<Type>;
+export {};

package/assets/types/typebox/build/type/engine/cyclic/index.d.mts

@@ -0,0 +1,6 @@
+export * from './candidates.mjs';
+export * from './check.mjs';
+export * from './dependencies.mjs';
+export * from './extends.mjs';
+export * from './instantiate.mjs';
+export * from './target.mjs';

package/assets/types/typebox/build/type/engine/cyclic/instantiate.d.mts

@@ -0,0 +1,17 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TCyclicDependencies } from '../cyclic/dependencies.mjs';
+import { type TInterfaceDeferred } from '../../action/index.mjs';
+import { type TInstantiateProperties } from '../instantiate.mjs';
+import { type TInstantiateTypes } from '../instantiate.mjs';
+import { type TState } from '../instantiate.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+type TCyclicInterface<Context extends TProperties, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, TState<[], []>, Heritage>, instantiatedProperties extends TProperties = TInstantiateProperties<{}, TState<[], []>, Properties>, EvaluatedInterface extends TSchema = TEvaluateIntersect<[...InstantiatedHeritage, TObject<instantiatedProperties>]>> = EvaluatedInterface;
+type TCyclicDefinitions<Context extends TProperties, Dependencies extends string[], Result extends TProperties = {
+    [Key in Extract<keyof Context, Dependencies[number]>]: Context[Key] extends TInterfaceDeferred<infer Heritage extends TSchema[], infer Properties extends TProperties> ? TCyclicInterface<Context, Heritage, Properties> : Context[Key];
+}> = Result;
+export type TInstantiateCyclic<Context extends TProperties, Ref extends string, Type extends TSchema, Dependencies extends string[] = TCyclicDependencies<Context, Ref, Type>, Definitions extends TProperties = TCyclicDefinitions<Context, Dependencies>, Result extends TSchema = TCyclic<Definitions, Ref>> = Result;
+export declare function InstantiateCyclic<Context extends TProperties, Ref extends string, Type extends TSchema>(context: Context, ref: Ref, type: Type): TInstantiateCyclic<Context, Ref, Type>;
+export {};

package/assets/types/typebox/build/type/engine/cyclic/target.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TRef } from '../../types/ref.mjs';
+type TResolve<Defs extends TProperties, Ref extends string> = (Ref extends keyof Defs ? Defs[Ref] extends TRef<infer Ref extends string> ? TResolve<Defs, Ref> : Defs[Ref] : TNever);
+/** Returns the target Type from the Defs or Never if target is non-resolvable */
+export type TCyclicTarget<Defs extends TProperties, Ref extends string, Result extends TSchema = TResolve<Defs, Ref>> = Result;
+/** Returns the target Type from the Defs or Never if target is non-resolvable */
+export declare function CyclicTarget<Defs extends TProperties, Ref extends string>(defs: Defs, ref: Ref): TCyclicTarget<Defs, Ref>;
+export {};

package/assets/types/typebox/build/type/engine/enum/index.d.mts

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

package/assets/types/typebox/build/type/engine/enum/typescript_enum_to_enum_values.d.mts

@@ -0,0 +1,8 @@
+import { type TEnumValue } from '../../types/enum.mjs';
+import { type TUnionToTuple } from '../helpers/union.mjs';
+export type TTypeScriptEnumLike = Record<PropertyKey, TEnumValue>;
+export declare function IsTypeScriptEnumLike(value: unknown): value is TTypeScriptEnumLike;
+type TReduceEnumValues<Keys extends string[], Type extends TTypeScriptEnumLike, Result extends TEnumValue[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? TReduceEnumValues<Right, Type, [...Result, Type[Left]]> : Result);
+export type TTypeScriptEnumToEnumValues<Type extends TTypeScriptEnumLike, EnumKeys extends string[] = TUnionToTuple<Extract<keyof Type, string>>, Elements extends TEnumValue[] = TReduceEnumValues<EnumKeys, Type>> = Elements;
+export declare function TypeScriptEnumToEnumValues<Type extends TTypeScriptEnumLike>(type: Type): TTypeScriptEnumToEnumValues<Type>;
+export {};

package/assets/types/typebox/build/type/engine/evaluate/broaden.d.mts

@@ -0,0 +1,15 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TAny } from '../../types/any.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TCompare, ResultRightInside, ResultLeftInside, ResultEqual } from './compare.mjs';
+import { type TFlatten } from './flatten.mjs';
+import { type TEvaluateType } from './evaluate.mjs';
+type TBroadFilter<Type extends TSchema, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof ResultRightInside ? TBroadFilter<Type, Right, [...Result]> : TBroadFilter<Type, Right, [...Result, Left]> : Result);
+type TIsBroadestType<Type extends TSchema, Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof ResultLeftInside | typeof ResultEqual ? false : TIsBroadestType<Type, Right> : true);
+type TBroadenType<Type extends TSchema, Types extends TSchema[], Evaluated extends TSchema = TEvaluateType<Type>, Result extends TSchema[] = (Evaluated extends TAny ? [Evaluated] : TIsBroadestType<Evaluated, Types> extends true ? [...TBroadFilter<Evaluated, Types>, Evaluated] : Types)> = Result;
+type TBroadenTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? (Left extends TObject ? TBroadenTypes<Right, [...Result, Left]> : Left extends TNever ? TBroadenTypes<Right, Result> : TBroadenTypes<Right, TBroadenType<Left, Result>>) : Result);
+export type TBroaden<Types extends TSchema[], Broadened extends TSchema[] = TBroadenTypes<Types>, Flattened extends TSchema[] = TFlatten<Broadened>> = Flattened;
+/** Broadens a set of types and returns either the most broad type, or union or disjoint types. */
+export declare function Broaden<Types extends TSchema[]>(types: [...Types]): TBroaden<Types>;
+export {};

package/assets/types/typebox/build/type/engine/evaluate/compare.d.mts

@@ -0,0 +1,15 @@
+import { type TSchema } from '../../types/index.mjs';
+import { type TUnknown } from '../../types/unknown.mjs';
+import { type TExtends, ExtendsResult } from "../../extends/index.mjs";
+export declare const ResultEqual = "equal";
+export declare const ResultDisjoint = "disjoint";
+export declare const ResultLeftInside = "left-inside";
+export declare const ResultRightInside = "right-inside";
+export type TCompareResult = typeof ResultEqual | typeof ResultDisjoint | typeof ResultLeftInside | typeof ResultRightInside;
+/** Compares left and right types and determines their set relationship */
+export type TCompare<Left extends TSchema, Right extends TSchema, Extends extends [ExtendsResult.TResult, ExtendsResult.TResult] = [
+    Left extends TUnknown ? ExtendsResult.TExtendsFalse : TExtends<{}, Left, Right>,
+    Left extends TUnknown ? ExtendsResult.TExtendsTrue : TExtends<{}, Right, Left>
+]> = (Extends extends [ExtendsResult.TExtendsTrueLike, ExtendsResult.TExtendsTrueLike] ? typeof ResultEqual : Extends extends [ExtendsResult.TExtendsTrueLike, ExtendsResult.TExtendsFalse] ? typeof ResultLeftInside : Extends extends [ExtendsResult.TExtendsFalse, ExtendsResult.TExtendsTrueLike] ? typeof ResultRightInside : typeof ResultDisjoint);
+/** Compares left and right types and determines their set relationship. */
+export declare function Compare<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TCompare<Left, Right>;

package/assets/types/typebox/build/type/engine/evaluate/composite.d.mts

@@ -0,0 +1,34 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TReadonly } from '../../types/_readonly.mjs';
+import { type TOptional } from '../../types/_optional.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TAddReadonly } from '../../action/_add_readonly.mjs';
+import { type TAddOptional } from '../../action/_add_optional.mjs';
+import { type TRemoveReadonly } from '../../action/_remove_readonly.mjs';
+import { type TRemoveOptional } from '../../action/_remove_optional.mjs';
+import { type TTupleElementsToProperties } from '../tuple/to_object.mjs';
+import { type TEvaluateIntersect } from './evaluate.mjs';
+type TIsReadonlyProperty<Left extends TSchema, Right extends TSchema> = (Left extends TReadonly<Left> ? Right extends TReadonly<Right> ? true : false : false);
+type TIsOptionalProperty<Left extends TSchema, Right extends TSchema> = (Left extends TOptional<Left> ? Right extends TOptional<Right> ? true : false : false);
+type TCompositeProperty<Left extends TSchema, Right extends TSchema, IsReadonly extends boolean = TIsReadonlyProperty<Left, Right>, IsOptional extends boolean = TIsOptionalProperty<Left, Right>, Evaluated extends TSchema = TEvaluateIntersect<[Left, Right]>, Property extends TSchema = TRemoveReadonly<TRemoveOptional<Evaluated>>> = ([
+    IsReadonly,
+    IsOptional
+] extends [true, true] ? TAddReadonly<TAddOptional<Property>> : [
+    IsReadonly,
+    IsOptional
+] extends [true, false] ? TAddReadonly<Property> : [
+    IsReadonly,
+    IsOptional
+] extends [false, true] ? TAddOptional<Property> : Property);
+type TCompositePropertyKey<Left extends TProperties, Right extends TProperties, Key extends PropertyKey, Result extends TSchema = (Key extends keyof Left ? Key extends keyof Right ? TCompositeProperty<Left[Key], Right[Key]> : Left[Key] : Key extends keyof Right ? Right[Key] : TNever)> = Result;
+type TCompositeProperties<Left extends TProperties, Right extends TProperties, Result extends TProperties = {
+    [Key in keyof (Right & Left)]: TCompositePropertyKey<Left, Right, Key>;
+}> = Result;
+type TGetProperties<Type extends TSchema, Result extends TProperties = (Type extends TObject<infer Properties extends TProperties> ? Properties : Type extends TTuple<infer Types extends TSchema[]> ? TTupleElementsToProperties<Types> : TUnreachable)> = Result;
+export type TComposite<Left extends TSchema, Right extends TSchema, LeftProperties extends TProperties = TGetProperties<Left>, RightProperties extends TProperties = TGetProperties<Right>, Properties extends TProperties = TCompositeProperties<LeftProperties, RightProperties>, Result extends TSchema = TObject<Properties>> = Result;
+export declare function Composite<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TComposite<Left, Right>;
+export {};

package/assets/types/typebox/build/type/engine/evaluate/distribute.d.mts

@@ -0,0 +1,28 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TComposite } from './composite.mjs';
+import { type TNarrow } from './narrow.mjs';
+import { type TEvaluateType } from './evaluate.mjs';
+import { type TEvaluateIntersect } from './evaluate.mjs';
+type TIsObjectLike<Type extends TSchema> = (Type extends TObject<infer _ extends TProperties> ? true : Type extends TTuple<infer _ extends TSchema[]> ? true : false);
+type TIsUnionOperand<Left extends TSchema, Right extends TSchema, IsUnionLeft extends boolean = Left extends TUnion ? true : false, IsUnionRight extends boolean = Right extends TUnion ? true : false, Result extends boolean = IsUnionLeft extends true ? true : IsUnionRight extends true ? true : false> = Result;
+type TDistributeOperation<Left extends TSchema, Right extends TSchema, EvaluatedLeft extends TSchema = TEvaluateType<Left>, EvaluatedRight extends TSchema = TEvaluateType<Right>, IsUnionOperand extends boolean = TIsUnionOperand<EvaluatedLeft, EvaluatedRight>, IsObjectLeft extends boolean = TIsObjectLike<EvaluatedLeft>, IsObjectRight extends boolean = TIsObjectLike<EvaluatedRight>, Result extends TSchema = ([
+    IsUnionOperand
+] extends [true] ? TEvaluateIntersect<[EvaluatedLeft, EvaluatedRight]> : [
+    IsObjectLeft,
+    IsObjectRight
+] extends [true, true] ? TComposite<EvaluatedLeft, EvaluatedRight> : [
+    IsObjectLeft,
+    IsObjectRight
+] extends [true, false] ? EvaluatedLeft : [
+    IsObjectLeft,
+    IsObjectRight
+] extends [false, true] ? EvaluatedRight : TNarrow<EvaluatedLeft, EvaluatedRight>)> = Result;
+type TDistributeType<Type extends TSchema, Distribution extends TSchema[], Result extends TSchema[] = []> = (Distribution extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDistributeType<Type, Right, [...Result, TDistributeOperation<Type, Left>]> : Result extends [] ? [Type] : Result);
+type TDistributeUnion<Types extends TSchema[], Distribution extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDistributeUnion<Right, Distribution, [...Result, ...TDistribute<[Left], Distribution>]> : Result);
+export type TDistribute<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TUnion<infer UnionTypes extends TSchema[]> ? TDistribute<Right, TDistributeUnion<UnionTypes, Result>> : TDistribute<Right, TDistributeType<Left, Result>> : Result);
+export declare function Distribute<Types extends TSchema[]>(types: [...Types], result?: TSchema[]): TDistribute<Types>;
+export {};

package/assets/types/typebox/build/type/engine/evaluate/evaluate.d.mts

@@ -0,0 +1,26 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TDistribute } from './distribute.mjs';
+import { type TBroaden } from './broaden.mjs';
+import { type TExcludeOperation } from '../exclude/operation.mjs';
+import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
+export type TEvaluateDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Intersect extends TSchema = TIntersect<[If, Then]>, Excluded extends TSchema = TExcludeOperation<Else, If>, Result extends TSchema = TEvaluateUnion<[Intersect, Excluded]>> = Result;
+export declare function EvaluateDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TEvaluateDependent<If, Then, Else>;
+export type TEvaluateEnum<Values extends TEnumValue[], Result extends TSchema[] = []> = (Values extends [infer Left extends TEnumValue, ...infer Right extends TEnumValue[]] ? TEvaluateEnum<Right, [...Result, TLiteral<Left>]> : TEvaluateUnion<Result>);
+export declare function EvaluateEnum<Values extends TEnumValue[]>(values: [...Values]): TEvaluateEnum<Values>;
+export type TEvaluateIntersect<Types extends TSchema[], Distribution extends TSchema[] = TDistribute<Types>, Broadend extends TSchema[] = TBroaden<Distribution>, Result extends TSchema = TEvaluateUnionFast<Broadend>> = Result;
+export declare function EvaluateIntersect<Types extends TSchema[]>(types: [...Types]): TEvaluateIntersect<Types>;
+export type TEvaluateTemplateLiteral<Pattern extends string, Evaluated extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema = TEvaluateType<Evaluated>> = Result;
+export declare function EvaluateTemplateLiteral<Pattern extends string>(pattern: Pattern): TEvaluateTemplateLiteral<Pattern>;
+export type TEvaluateUnion<Types extends TSchema[], Broadend extends TSchema[] = TBroaden<Types>, Result extends TSchema = TEvaluateUnionFast<Broadend>> = Result;
+export declare function EvaluateUnion<Types extends TSchema[]>(types: [...Types]): TEvaluateUnion<Types>;
+export type TEvaluateType<Type extends TSchema, Result extends TSchema = (Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TEvaluateDependent<If, Then, Else> : Type extends TEnum<infer Values extends TEnumValue[]> ? TEvaluateEnum<Values> : Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type extends TTemplateLiteral<infer Pattern extends string> ? TEvaluateTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TEvaluateUnion<Types> : Type)> = Result;
+export declare function EvaluateType<Type extends TSchema>(type: Type): TEvaluateType<Type>;
+export type TEvaluateUnionFast<Types extends TSchema[], Result extends TSchema = (Types extends [infer Type extends TSchema] ? Type : Types extends [] ? TNever : TUnion<Types>)> = Result;
+export declare function EvaluateUnionFast<Types extends TSchema[]>(types: [...Types]): TEvaluateUnionFast<Types>;

package/assets/types/typebox/build/type/engine/evaluate/flatten.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+type TFlattenType<Type extends TSchema, Result extends TSchema[] = Type extends TUnion<infer Types extends TSchema[]> ? TFlatten<Types> : [Type]> = Result;
+export type TFlatten<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFlatten<Right, [...Result, ...TFlattenType<Left>]> : Result);
+export declare function Flatten<Types extends TSchema[]>(types: [...Types]): TFlatten<Types>;
+export {};

package/assets/types/typebox/build/type/engine/evaluate/index.d.mts

@@ -0,0 +1,8 @@
+export * from './broaden.mjs';
+export * from './compare.mjs';
+export * from './composite.mjs';
+export * from './distribute.mjs';
+export * from './evaluate.mjs';
+export * from './flatten.mjs';
+export * from './instantiate.mjs';
+export * from './narrow.mjs';

package/assets/types/typebox/build/type/engine/evaluate/instantiate.d.mts

@@ -0,0 +1,8 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+import { type TEvaluateType } from './evaluate.mjs';
+export type TEvaluateAction<Type extends TSchema, Result extends TSchema = TEvaluateType<Type>> = Result;
+export declare function EvaluateAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TEvaluateAction<Type>;
+export type TEvaluateInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TEvaluateAction<InstantiatedType>;
+export declare function EvaluateInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TEvaluateInstantiate<Context, State, Type>;

package/assets/types/typebox/build/type/engine/evaluate/narrow.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TCompare, type TCompareResult, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
+export type TNarrow<Left extends TSchema, Right extends TSchema, Result extends TCompareResult = TCompare<Left, Right>> = (Result extends typeof ResultLeftInside ? Left : Result extends typeof ResultRightInside ? Right : Result extends typeof ResultEqual ? Right : TNever);
+export declare function Narrow<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TNarrow<Left, Right>;

package/assets/types/typebox/build/type/engine/exclude/index.d.mts

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

package/assets/types/typebox/build/type/engine/exclude/instantiate.d.mts

@@ -0,0 +1,9 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TExcludeDeferred } from '../../action/exclude.mjs';
+import { type TExcludeOperation } from './operation.mjs';
+export type TExcludeAction<Left extends TSchema, Right extends TSchema, Result extends TSchema = TCanInstantiate<[Left, Right]> extends true ? TExcludeOperation<Left, Right> : TExcludeDeferred<Left, Right>> = Result;
+export declare function ExcludeAction<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options: TSchemaOptions): TExcludeAction<Left, Right>;
+export type TExcludeInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, InstantiatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstantiatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TExcludeAction<InstantiatedLeft, InstantiatedRight>;
+export declare function ExcludeInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema>(context: Context, state: State, left: Left, right: Right, options: TSchemaOptions): TExcludeInstantiate<Context, State, Left, Right>;

package/assets/types/typebox/build/type/engine/exclude/operation.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TEvaluateType } from '../evaluate/evaluate.mjs';
+import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+type TExcludeType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike ? [] : [Left]> = Result;
+type TExcludeUnion<Left extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExcludeUnion<Tail, Right, [...Result, ...TExcludeType<Head, Right>]> : Result);
+export type TExcludeOperation<Left extends TSchema, Right extends TSchema, Evaluated extends TSchema = TEvaluateType<Left>, Canonical extends TSchema[] = Evaluated extends TUnion<infer Types extends TSchema[]> ? Types : [Evaluated], Remaining extends TSchema[] = TExcludeUnion<Canonical, Right>, Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
+export declare function ExcludeOperation<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TExcludeOperation<Left, Right>;
+export {};

package/assets/types/typebox/build/type/engine/extract/index.d.mts

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

package/assets/types/typebox/build/type/engine/extract/instantiate.d.mts

@@ -0,0 +1,9 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TExtractDeferred } from '../../action/extract.mjs';
+import { type TExtractOperation } from './operation.mjs';
+export type TExtractAction<Left extends TSchema, Right extends TSchema, Result extends TSchema = TCanInstantiate<[Left, Right]> extends true ? TExtractOperation<Left, Right> : TExtractDeferred<Left, Right>> = Result;
+export declare function ExtractAction<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options: TSchemaOptions): TExtractAction<Left, Right>;
+export type TExtractInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, InstantiatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstantiatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TExtractAction<InstantiatedLeft, InstantiatedRight>;
+export declare function ExtractInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema>(context: Context, state: State, left: Left, right: Right, options: TSchemaOptions): TExtractInstantiate<Context, State, Left, Right>;

package/assets/types/typebox/build/type/engine/extract/operation.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TEvaluateType } from '../evaluate/evaluate.mjs';
+import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+type TExtractType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike ? [Left] : []> = Result;
+type TExtractUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnion<Tail, Right, [...Result, ...TExtractType<Head, Right>]> : Result);
+export type TExtractOperation<Left extends TSchema, Right extends TSchema, Evaluated extends TSchema = TEvaluateType<Left>, Canonical extends TSchema[] = Evaluated extends TUnion<infer Types extends TSchema[]> ? Types : [Evaluated], Remaining extends TSchema[] = TExtractUnion<Canonical, Right>, Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
+export declare function ExtractOperation<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TExtractOperation<Left, Right>;
+export {};

package/assets/types/typebox/build/type/engine/helpers/index.d.mts

@@ -0,0 +1,3 @@
+export * from './keys_to_indexer.mjs';
+export * from './keys.mjs';
+export * from './union.mjs';

package/assets/types/typebox/build/type/engine/helpers/keys.d.mts

@@ -0,0 +1,3 @@
+import { type TLiteralValue } from '../../types/literal.mjs';
+export type TConvertToIntegerKey<Value extends TLiteralValue, Normal extends string = `${Value}`, Result extends TLiteralValue = (Normal extends ` ${infer _ extends number}` ? Normal : Normal extends `${infer _ extends number} ` ? Normal : Normal extends `0${infer _ extends number}` ? Normal : Normal extends `-${infer _ extends number}` ? Normal : Normal extends `${infer Value extends number}` ? Value : Value)> = Result;
+export declare function ConvertToIntegerKey<Value extends TLiteralValue>(value: Value): TConvertToIntegerKey<Value>;

package/assets/types/typebox/build/type/engine/helpers/keys_to_indexer.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
+type TKeysToLiterals<Keys extends PropertyKey[], Result extends TLiteral[] = []> = (Keys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? (Left extends TLiteralValue ? TKeysToLiterals<Right, [...Result, TLiteral<Left>]> : TKeysToLiterals<Right, Result>) : Result);
+export type TKeysToIndexer<Keys extends PropertyKey[], Literals extends TLiteral[] = TKeysToLiterals<Keys>, Result extends TSchema = TUnion<Literals>> = Result;
+export declare function KeysToIndexer<Keys extends PropertyKey[]>(keys: [...Keys]): TKeysToIndexer<Keys>;
+export {};

package/assets/types/typebox/build/type/engine/helpers/union.d.mts

@@ -0,0 +1,7 @@
+export type TTupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TTupleToIntersect<R> : never;
+export type TTupleToUnion<T extends any[]> = {
+    [K in keyof T]: T[K];
+}[number];
+export type TUnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+export type TUnionLast<U> = TUnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+export type TUnionToTuple<U, Result extends unknown[] = [], R = TUnionLast<U>> = [U] extends [never] ? Result : TUnionToTuple<Exclude<U, R>, [Extract<U, R>, ...Result]>;

package/assets/types/typebox/build/type/engine/immutable/instantiate_add.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TImmutable } from '../../types/_immutable.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TAddImmutableOperation<Type extends TSchema, Result extends TSchema = '~immutable' extends keyof Type ? Type : TImmutable<Type>> = Result;
+export type TAddImmutableAction<Type extends TSchema, Result extends TSchema = TAddImmutableOperation<Type>> = Result;
+export declare function AddImmutableAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAddImmutableAction<Type>;
+export type TAddImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAddImmutableAction<InstantiateType>;
+export declare function AddImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAddImmutableInstantiate<Context, State, Type>;
+export {};

package/assets/types/typebox/build/type/engine/immutable/instantiate_remove.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TImmutable } from '../../types/_immutable.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TRemoveImmutableOperation<Type extends TSchema, Result extends TSchema = Type extends TImmutable<infer Type extends TSchema> ? TRemoveImmutableOperation<Type> : Type> = Result;
+export type TRemoveImmutableAction<Type extends TSchema, Result extends TSchema = TRemoveImmutableOperation<Type>> = Result;
+export declare function RemoveImmutableAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TRemoveImmutableAction<Type>;
+export type TRemoveImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TRemoveImmutableAction<InstantiateType>;
+export declare function RemoveImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TRemoveImmutableInstantiate<Context, State, Type>;
+export {};

package/assets/types/typebox/build/type/engine/index.d.mts

@@ -0,0 +1,31 @@
+export { Instantiate, type TInstantiate } from './instantiate.mjs';
+export * from './conditional/index.mjs';
+export * from './constructor_parameters/index.mjs';
+export * from './cyclic/index.mjs';
+export * from './enum/index.mjs';
+export * from './evaluate/index.mjs';
+export * from './exclude/index.mjs';
+export * from './extract/index.mjs';
+export * from './helpers/index.mjs';
+export * from './indexed/index.mjs';
+export * from './instance_type/index.mjs';
+export * from './interface/index.mjs';
+export * from './intrinsics/index.mjs';
+export * from './keyof/index.mjs';
+export * from './mapped/index.mjs';
+export * from './module/index.mjs';
+export * from './non_nullable/index.mjs';
+export * from './object/index.mjs';
+export * from './omit/index.mjs';
+export * from './parameters/index.mjs';
+export * from './patterns/index.mjs';
+export * from './partial/index.mjs';
+export * from './pick/index.mjs';
+export * from './priority/index.mjs';
+export * from './readonly_object/index.mjs';
+export * from './record/index.mjs';
+export * from './ref/index.mjs';
+export * from './required/index.mjs';
+export * from './return_type/index.mjs';
+export * from './template_literal/index.mjs';
+export * from './with/index.mjs';

package/assets/types/typebox/build/type/engine/indexable/from_cyclic.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TCyclicTarget } from '../cyclic/target.mjs';
+export type TFromCyclic<Defs extends TProperties, Ref extends string, Target extends TSchema = TCyclicTarget<Defs, Ref>, Result extends string[] = TFromType<Target>> = Result;
+export declare function FromCyclic<Defs extends TProperties, Ref extends string>(defs: Defs, ref: Ref): TFromCyclic<Defs, Ref>;

package/assets/types/typebox/build/type/engine/indexable/from_dependent.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateDependent } from '../evaluate/evaluate.mjs';
+export type TFromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Evaluated extends TSchema = TEvaluateDependent<If, Then, Else>, Result extends string[] = TFromType<Evaluated>> = Result;
+export declare function FromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TFromDependent<If, Then, Else>;

package/assets/types/typebox/build/type/engine/indexable/from_enum.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TEnumValue } from '../../types/enum.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateEnum } from '../evaluate/evaluate.mjs';
+export type TFromEnum<Values extends TEnumValue[], Evaluated extends TSchema = TEvaluateEnum<Values>, Result extends string[] = TFromType<Evaluated>> = Result;
+export declare function FromEnum<Values extends TEnumValue[]>(values: [...Values]): TFromEnum<Values>;

package/assets/types/typebox/build/type/engine/indexable/from_intersect.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { type TFromType } from './from_type.mjs';
+export type TFromIntersect<Types extends TSchema[], Evaluated extends TSchema = TEvaluateIntersect<Types>, Result extends string[] = TFromType<Evaluated>> = Result;
+export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;

package/assets/types/typebox/build/type/engine/indexable/from_literal.d.mts

@@ -0,0 +1,3 @@
+import { type TLiteralValue } from '../../types/literal.mjs';
+export type TFromLiteral<Value extends TLiteralValue, Result extends string[] = [`${Value}`]> = Result;
+export declare function FromLiteral<Value extends TLiteralValue>(value: Value): TFromLiteral<Value>;

package/assets/types/typebox/build/type/engine/indexable/from_template_literal.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+export type TFromTemplateLiteral<Pattern extends string, Evaluated extends TSchema = TEvaluateTemplateLiteral<Pattern>, Result extends string[] = TFromType<Evaluated>> = Result;
+export declare function FromTemplateLiteral<Pattern extends string>(pattern: Pattern): TFromTemplateLiteral<Pattern>;

package/assets/types/typebox/build/type/engine/indexable/from_type.d.mts

@@ -0,0 +1,19 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
+import { type TFromEnum } from './from_enum.mjs';
+import { type TFromIntersect } from './from_intersect.mjs';
+import { type TFromLiteral } from './from_literal.mjs';
+import { type TFromTemplateLiteral } from './from_template_literal.mjs';
+import { type TFromUnion } from './from_union.mjs';
+export type TFromType<Indexer extends TSchema, Result extends string[] = (Indexer extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Indexer extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Indexer extends TEnum<infer Values extends TEnumValue[]> ? TFromEnum<Values> : Indexer extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Indexer extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Indexer extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Indexer extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
+])> = Result;
+export declare function FromType<Indexer extends TSchema>(type: Indexer): TFromType<Indexer>;

package/assets/types/typebox/build/type/engine/indexable/from_union.d.mts

@@ -0,0 +1,4 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+export type TFromUnion<Types extends TSchema[], Result extends string[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TFromType<Left>]> : Result);
+export declare function FromUnion<Types extends TSchema[]>(types: [...Types]): TFromUnion<Types>;

package/assets/types/typebox/build/type/engine/indexable/to_indexable.d.mts

@@ -0,0 +1,9 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TCollapseToObject } from '../object/index.mjs';
+/** Transforms a type into a TProperties used for indexing operations */
+export type TToIndexable<Type extends TSchema, Collapsed extends TSchema = TCollapseToObject<Type>, Result extends TProperties = (Collapsed extends TObject<infer Properties extends TProperties> ? Properties : TUnreachable)> = Result;
+/** Transforms a type into a TProperties used for indexing operations */
+export declare function ToIndexable<Type extends TSchema>(type: Type): TToIndexable<Type>;

package/assets/types/typebox/build/type/engine/indexable/to_indexable_keys.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+export type TToIndexableKeys<Indexer extends TSchema, Result extends string[] = TFromType<Indexer>> = Result;
+/**
+ * Transforms a type meant as an Indexer into string[] array which is used by Indexable types
+ * like Index, Pick and Omit to select from property keys. This function should only be used
+ * for Object key selection, and not for Array / Tuple key selection as Array-Like structures
+ * require TNumber indexing support.
+ */
+export declare function ToIndexableKeys<Indexer extends TSchema>(type: Indexer): TToIndexableKeys<Indexer>;

package/assets/types/typebox/build/type/engine/indexed/array_indexer.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TConvertToIntegerKey } from '../helpers/keys.mjs';
+type TConvertLiteral<Value extends TLiteralValue, Result extends TSchema = TLiteral<TConvertToIntegerKey<Value>>> = Result;
+type TArrayIndexerTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TArrayIndexerTypes<Right, [...Result, TFormatArrayIndexer<Left>]> : Result);
+/** Formats embedded integer-like strings on an Indexer to be number values inline with TS indexing | coercion behaviors. */
+export type TFormatArrayIndexer<Type extends TSchema, Result extends TSchema = (Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TArrayIndexerTypes<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TArrayIndexerTypes<Types>> : Type extends TLiteral<infer Value extends TLiteralValue> ? TConvertLiteral<Value> : Type)> = Result;
+/** Formats embedded integer-like strings on an Indexer to be number values inline with TS indexing | coercion behaviors. */
+export declare function FormatArrayIndexer<Type extends TSchema>(type: Type): TFormatArrayIndexer<Type>;
+export {};

package/assets/types/typebox/build/type/engine/indexed/from_array.d.mts

@@ -0,0 +1,15 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TNumber } from '../../types/number.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TConvertToIntegerKey } from '../helpers/keys.mjs';
+type TNormalizeLiteral<Value extends TLiteralValue, Result extends TSchema = TLiteral<TConvertToIntegerKey<Value>>> = Result;
+type TNormalizeIndexerTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TNormalizeIndexerTypes<Right, [...Result, TNormalizeIndexer<Left>]> : Result);
+export type TNormalizeIndexer<Type extends TSchema, Result extends TSchema = (Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TNormalizeIndexerTypes<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TNormalizeIndexerTypes<Types>> : Type extends TLiteral<infer Value extends TLiteralValue> ? TNormalizeLiteral<Value> : Type)> = Result;
+export declare function NormalizeIndexer<Type extends TSchema>(type: Type): TNormalizeIndexer<Type>;
+export type TFromArray<Type extends TSchema, Indexer extends TSchema, NormalizedIndexer extends TSchema = TNormalizeIndexer<Indexer>, Check extends ExtendsResult.TResult = TExtends<{}, NormalizedIndexer, TNumber>, Result extends TSchema = (Check extends ExtendsResult.TExtendsTrueLike ? Type : Indexer extends TLiteral<infer _ extends 'length'> ? TNumber : TNever)> = Result;
+export declare function FromArray<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer): TFromArray<Type, Indexer>;
+export {};

package/assets/types/typebox/build/type/engine/indexed/from_object.d.mts

@@ -0,0 +1,16 @@
+import { type TProperties } from '../../types/properties.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TNumber } from '../../types/number.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TPropertyKeys } from '../../types/properties.mjs';
+import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+import { type TToIndexableKeys } from '../indexable/to_indexable_keys.mjs';
+import { type TExpandThis } from '../this/expand_this.mjs';
+type TIndexProperty<Properties extends TProperties, Key extends string, CanonicalKey extends string = keyof Properties extends string | number ? `${keyof Properties}` : never, SelectedType extends TSchema = Key extends CanonicalKey ? Properties[Key] : TNever, Result extends TSchema = TExpandThis<Properties, SelectedType>> = Result;
+type TIndexProperties<Properties extends TProperties, Keys extends string[], Result extends TSchema[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? TIndexProperties<Properties, Right, [...Result, TIndexProperty<Properties, Left>]> : Result);
+type TFromIndexer<Properties extends TProperties, Indexer extends TSchema, Keys extends string[] = TToIndexableKeys<Indexer>, Variants extends TSchema[] = TIndexProperties<Properties, Keys>, Result extends TSchema = TEvaluateUnion<Variants>> = Result;
+type TNumericKeys<Keys extends string[], Result extends string[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends `${infer _ extends number}` ? TNumericKeys<Right, [...Result, Left]> : TNumericKeys<Right, Result> : Result);
+type TFromIndexerNumber<Properties extends TProperties, Keys extends string[] = TPropertyKeys<Properties>, NumericKeys extends string[] = TNumericKeys<Keys>, Variants extends TSchema[] = TIndexProperties<Properties, NumericKeys>, Result extends TSchema = TEvaluateUnion<Variants>> = Result;
+export type TFromObject<Properties extends TProperties, Indexer extends TSchema, Result extends TSchema = Indexer extends TNumber ? TFromIndexerNumber<Properties> : TFromIndexer<Properties, Indexer>> = Result;
+export declare function FromObject<Properties extends TProperties, Indexer extends TSchema>(properties: Properties, indexer: Indexer): TFromObject<Properties, Indexer>;
+export {};