@yaag/cli 0.1.0

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

@@ -0,0 +1,13 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
+import { type TNumber } from '../../types/number.mjs';
+import { type TInteger } from '../../types/integer.mjs';
+import { type TEvaluateUnionFast } from '../evaluate/evaluate.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TFormatArrayIndexer } from './array_indexer.mjs';
+type TIndexElementsWithIndexer<Types extends TSchema[], Indexer extends TSchema, Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer Right extends TSchema] ? TExtends<{}, TLiteral<Left['length']>, Indexer> extends ExtendsResult.TExtendsTrueLike ? TIndexElementsWithIndexer<Left, Indexer, [Right, ...Result]> : TIndexElementsWithIndexer<Left, Indexer, Result> : Result);
+type TFromTupleWithIndexer<Types extends TSchema[], Indexer extends TSchema, ArrayIndexer extends TSchema = TFormatArrayIndexer<Indexer>, Elements extends TSchema[] = TIndexElementsWithIndexer<Types, ArrayIndexer>, Result extends TSchema = TEvaluateUnionFast<Elements>> = Result;
+type TFromTupleWithoutIndexer<Types extends TSchema[], Result extends TSchema = TEvaluateUnionFast<Types>> = Result;
+export type TFromTuple<Types extends TSchema[], Indexer extends TSchema, Result extends TSchema = (Indexer extends TLiteral<infer _ extends 'length'> ? TLiteral<Types['length']> : Indexer extends TNumber | TInteger ? TFromTupleWithoutIndexer<Types> : TFromTupleWithIndexer<Types, Indexer>)> = Result;
+export declare function FromTuple<Types extends TSchema[], Indexer extends TSchema>(types: [...Types], indexer: Indexer): TFromTuple<Types, Indexer>;
+export {};

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

@@ -0,0 +1,11 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TFromArray } from './from_array.mjs';
+import { type TFromObject } from './from_object.mjs';
+import { type TFromTuple } from './from_tuple.mjs';
+export type TFromType<Type extends TSchema, Indexer extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<Type, Indexer> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties, Indexer> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Indexer> : TNever);
+export declare function FromType<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer): TFromType<Type, Indexer>;

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

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

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

@@ -0,0 +1,16 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TIndexDeferred } from '../../action/indexed.mjs';
+import { type TCollapseToObject } from '../object/index.mjs';
+import { type TFromType } from './from_type.mjs';
+type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic ? TCollapseToObject<Type> : Type extends TDependent ? TCollapseToObject<Type> : Type extends TIntersect ? TCollapseToObject<Type> : Type extends TUnion ? TCollapseToObject<Type> : Type)> = Result;
+export type TIndexAction<Type extends TSchema, Indexer extends TSchema, Result extends TSchema = TCanInstantiate<[Type, Indexer]> extends true ? TFromType<TNormalizeType<Type>, Indexer> : TIndexDeferred<Type, Indexer>> = Result;
+export declare function IndexAction<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options: TSchemaOptions): TIndexAction<Type, Indexer>;
+export type TIndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>, InstantiatedIndexer extends TSchema = TInstantiateType<Context, State, Indexer>> = TIndexAction<InstantiatedType, InstantiatedIndexer>;
+export declare function IndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema>(context: Context, state: State, type: Type, indexer: Indexer, options: TSchemaOptions): TIndexInstantiate<Context, State, Type, Indexer>;
+export {};

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

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

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TInstanceTypeDeferred } from '../../action/instance_type.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TInstanceTypeOperation<Type extends TSchema> = (Type extends TConstructor ? Type['instanceType'] : TNever);
+export type TInstanceTypeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TInstanceTypeOperation<Type> : TInstanceTypeDeferred<Type>> = Result;
+export declare function InstanceTypeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TInstanceTypeAction<Type>;
+export type TInstanceTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TInstanceTypeAction<InstantiatedType>;
+export declare function InstanceTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options?: TSchemaOptions): TInstanceTypeInstantiate<Context, State, Type>;
+export {};

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

@@ -0,0 +1,178 @@
+import { type TAddImmutableAction } from './immutable/instantiate_add.mjs';
+import { type TAddReadonlyAction } from './readonly/instantiate_add.mjs';
+import { type TAddOptionalAction } from './optional/instantiate_add.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TArray } from '../types/array.mjs';
+import { type TConstructor } from '../types/constructor.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TFunction } from '../types/function.mjs';
+import { type TCall } from '../types/call.mjs';
+import { type TIdentifier } from '../types/identifier.mjs';
+import { type TDependent } from '../types/dependent.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 TTuple } from '../types/tuple.mjs';
+import { type TUnion } from '../types/union.mjs';
+import { type TRef } from '../types/ref.mjs';
+import { type TRest } from '../types/rest.mjs';
+import { type TAddImmutableInstantiate } from './immutable/instantiate_add.mjs';
+import { type TRemoveImmutableInstantiate } from './immutable/instantiate_remove.mjs';
+import { type TAddReadonlyInstantiate } from './readonly/instantiate_add.mjs';
+import { type TRemoveReadonlyInstantiate } from './readonly/instantiate_remove.mjs';
+import { type TAddOptionalInstantiate } from './optional/instantiate_add.mjs';
+import { type TRemoveOptionalInstantiate } from './optional/instantiate_remove.mjs';
+import { type TOptional } from '../types/_optional.mjs';
+import { type TImmutable } from '../types/_immutable.mjs';
+import { type TReadonly } from '../types/_readonly.mjs';
+import { type TCallInstantiate } from './call/instantiate.mjs';
+import { type TCapitalizeInstantiate } from './intrinsics/instantiate.mjs';
+import { type TConditionalInstantiate } from './conditional/index.mjs';
+import { type TConstructorParametersInstantiate } from './constructor_parameters/instantiate.mjs';
+import { type TEvaluateInstantiate } from './evaluate/instantiate.mjs';
+import { type TExcludeInstantiate } from './exclude/instantiate.mjs';
+import { type TExtractInstantiate } from './extract/instantiate.mjs';
+import { type TIndexInstantiate } from './indexed/instantiate.mjs';
+import { type TInstanceTypeInstantiate } from './instance_type/instantiate.mjs';
+import { type TInterfaceInstantiate } from './interface/instantiate.mjs';
+import { type TKeyOfInstantiate } from './keyof/instantiate.mjs';
+import { type TLowercaseInstantiate } from './intrinsics/instantiate.mjs';
+import { type TMappedInstantiate } from './mapped/instantiate.mjs';
+import { type TModuleInstantiate } from './module/instantiate.mjs';
+import { type TNonNullableInstantiate } from './non_nullable/instantiate.mjs';
+import { type TOmitInstantiate } from './omit/instantiate.mjs';
+import { type TParametersInstantiate } from './parameters/instantiate.mjs';
+import { type TPartialInstantiate } from './partial/instantiate.mjs';
+import { type TPickInstantiate } from './pick/instantiate.mjs';
+import { type TReadonlyObjectInstantiate } from './readonly_object/instantiate.mjs';
+import { type TRecordInstantiate } from './record/instantiate.mjs';
+import { type TRefInstantiate } from './ref/instantiate.mjs';
+import { type TRequiredInstantiate } from './required/instantiate.mjs';
+import { type TReturnTypeInstantiate } from './return_type/instantiate.mjs';
+import { type TTemplateLiteralInstantiate } from './template_literal/instantiate.mjs';
+import { type TUncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
+import { type TUppercaseInstantiate } from './intrinsics/instantiate.mjs';
+import { type TWithInstantiate } from './with/instantiate.mjs';
+import { type TRestSpread } from './rest/index.mjs';
+export interface TState<CallStack extends string[] = string[], Visited extends string[] = string[]> {
+    callstack: CallStack;
+    visited: Visited;
+}
+export declare function State<CallStack extends string[], Visited extends string[]>(callstack: CallStack, visited: Visited): TState<CallStack, Visited>;
+export type TCanInstantiate<Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TRef ? false : TCanInstantiate<Right> : true;
+export declare function CanInstantiate<Types extends TSchema[]>(types: [...Types]): TCanInstantiate<Types>;
+export type TInstantiateProperties<Context extends TProperties, State extends TState, Properties extends TProperties, Result extends TProperties = {
+    [Key in keyof Properties]: TInstantiateType<Context, State, Properties[Key]>;
+}> = Result;
+export declare function InstantiateProperties<Context extends TProperties, State extends TState, Properties extends TProperties>(context: Context, state: State, properties: TProperties): TInstantiateProperties<Context, State, Properties>;
+export type TInstantiateElements<Context extends TProperties, State extends TState, Types extends TSchema[], Elements extends TSchema[] = TInstantiateTypes<Context, State, Types>, Result extends TSchema[] = TRestSpread<Elements>> = Result;
+export declare function InstantiateElements<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types]): TInstantiateElements<Context, State, Types>;
+export type TInstantiateTypes<Context extends TProperties, State extends TState, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TInstantiateTypes<Context, State, Right, [...Result, TInstantiateType<Context, State, Left>]> : Result);
+export declare function InstantiateTypes<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types]): TInstantiateTypes<Context, State, Types>;
+type TWithModifiers<Type extends TSchema, InstantiatedType extends TSchema, WithOptional extends TSchema = Type extends TOptional ? TAddOptionalAction<InstantiatedType> : InstantiatedType, WithReadonly extends TSchema = Type extends TReadonly ? TAddReadonlyAction<WithOptional> : WithOptional, WithImmutable extends TSchema = Type extends TImmutable ? TAddImmutableAction<WithReadonly> : WithReadonly> = WithImmutable;
+type TInstantiateDeferred<Context extends TProperties, State extends TState, Action extends string, Parameters extends TSchema[]> = ([
+    Action,
+    Parameters
+] extends ['AddImmutable', [infer Type extends TSchema]] ? TAddImmutableInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveImmutable', [infer Type extends TSchema]] ? TRemoveImmutableInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['AddReadonly', [infer Type extends TSchema]] ? TAddReadonlyInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveReadonly', [infer Type extends TSchema]] ? TRemoveReadonlyInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['AddOptional', [infer Type extends TSchema]] ? TAddOptionalInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveOptional', [infer Type extends TSchema]] ? TRemoveOptionalInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Capitalize', [infer Type extends TSchema]] ? TCapitalizeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Conditional', [infer Left extends TSchema, infer Right extends TSchema, infer True extends TSchema, infer False extends TSchema]] ? TConditionalInstantiate<Context, State, Left, Right, True, False> : [
+    Action,
+    Parameters
+] extends ['ConstructorParameters', [infer Type extends TSchema]] ? TConstructorParametersInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Evaluate', [infer Type extends TSchema]] ? TEvaluateInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Exclude', [infer Left extends TSchema, infer Right extends TSchema]] ? TExcludeInstantiate<Context, State, Left, Right> : [
+    Action,
+    Parameters
+] extends ['Extract', [infer Left extends TSchema, infer Right extends TSchema]] ? TExtractInstantiate<Context, State, Left, Right> : [
+    Action,
+    Parameters
+] extends ['Index', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TIndexInstantiate<Context, State, Type, Indexer> : [
+    Action,
+    Parameters
+] extends ['InstanceType', [infer Type extends TSchema]] ? TInstanceTypeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Interface', [infer Heritage extends TSchema[], infer Properties extends TProperties]] ? TInterfaceInstantiate<Context, State, Heritage, Properties> : [
+    Action,
+    Parameters
+] extends ['KeyOf', [infer Type extends TSchema]] ? TKeyOfInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Lowercase', [infer Type extends TSchema]] ? TLowercaseInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Mapped', [infer Name extends TIdentifier, infer Key extends TSchema, infer As extends TSchema, infer Property extends TSchema]] ? TMappedInstantiate<Context, State, Name, Key, As, Property> : [
+    Action,
+    Parameters
+] extends ['Module', [infer Declarations extends TProperties]] ? TModuleInstantiate<Context, State, Declarations> : [
+    Action,
+    Parameters
+] extends ['NonNullable', [infer Type extends TSchema]] ? TNonNullableInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Pick', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TPickInstantiate<Context, State, Type, Indexer> : [
+    Action,
+    Parameters
+] extends ['Parameters', [infer Type extends TSchema]] ? TParametersInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Partial', [infer Type extends TSchema]] ? TPartialInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Omit', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TOmitInstantiate<Context, State, Type, Indexer> : [
+    Action,
+    Parameters
+] extends ['ReadonlyObject', [infer Type extends TSchema]] ? TReadonlyObjectInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Record', [infer Key extends TSchema, infer Value extends TSchema]] ? TRecordInstantiate<Context, State, Key, Value> : [
+    Action,
+    Parameters
+] extends ['Required', [infer Type extends TSchema]] ? TRequiredInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['ReturnType', [infer Type extends TSchema]] ? TReturnTypeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['TemplateLiteral', [infer Types extends TSchema[]]] ? TTemplateLiteralInstantiate<Context, State, Types> : [
+    Action,
+    Parameters
+] extends ['Uncapitalize', [infer Type extends TSchema]] ? TUncapitalizeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Uppercase', [infer Type extends TSchema]] ? TUppercaseInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['With', [infer Type extends TSchema, infer Options extends TSchema]] ? TWithInstantiate<Context, State, Type, Options> : TDeferred<Action, Parameters>);
+type TInstantiateImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Type, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TDependent<TInstantiateType<Context, State, If>, TInstantiateType<Context, State, Then>, TInstantiateType<Context, State, Else>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type), WithModifiers extends TSchema = TWithModifiers<Type, InstantiatedType>> = WithModifiers;
+export type TInstantiateType<Context extends TProperties, State extends TState, Type extends TSchema, Result extends TSchema = Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : TInstantiateImmediate<Context, State, Type>> = Result;
+export declare function InstantiateType<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type): TInstantiateImmediate<Context, State, Type>;
+/** Instantiates computed schematics using the given context and type. */
+export type TInstantiate<Context extends TProperties, Type extends TSchema> = (TInstantiateType<Context, TState<[], []>, Type>);
+/** Instantiates computed schematics using the given context and type. */
+export declare function Instantiate<Context extends TProperties, Type extends TSchema>(context: Context, type: Type): TInstantiate<Context, Type>;
+export {};

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

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

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

@@ -0,0 +1,15 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { type TInterfaceDeferred } from '../../action/index.mjs';
+import { type TCanInstantiate } from '../instantiate.mjs';
+import { type TInstantiateProperties } from '../instantiate.mjs';
+import { type TInstantiateTypes } from '../instantiate.mjs';
+import { type TState } from '../instantiate.mjs';
+type TInterfaceOperation<Heritage extends TSchema[], Properties extends TProperties, Result extends TSchema = TEvaluateIntersect<[...Heritage, TObject<Properties>]>> = Result;
+export type TInterfaceAction<Heritage extends TSchema[], Properties extends TProperties, Result extends TSchema = TCanInstantiate<Heritage> extends true ? TInterfaceOperation<Heritage, Properties> : TInterfaceDeferred<Heritage, Properties>> = Result;
+export declare function InterfaceAction<Heritage extends TSchema[], Properties extends TProperties>(heritage: [...Heritage], properties: Properties, options: TSchemaOptions): TInterfaceAction<Heritage, Properties>;
+export type TInterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, State, Heritage>, InstantiatedProperties extends TProperties = TInstantiateProperties<Context, State, Properties>> = TInterfaceAction<InstantiatedHeritage, InstantiatedProperties>;
+export declare function InterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties>(context: Context, state: State, heritage: [...Heritage], properties: Properties, options: TSchemaOptions): TInterfaceInstantiate<Context, State, Heritage, Properties>;
+export {};

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

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TMappingType, type TMappingFunc, type TApplyMapping } from './mapping.mjs';
+export type TFromLiteral<Mapping extends TMappingType, Value extends TLiteralValue> = (Value extends string ? TLiteral<TApplyMapping<Mapping, Value>> : TLiteral<Value>);
+export declare function FromLiteral(mapping: TMappingFunc, value: TLiteralValue): TSchema;

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

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

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

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TMappingType, type TMappingFunc } from './mapping.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<Mapping extends TMappingType, Type extends TSchema> = (Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Mapping, Value> : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Mapping, Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Mapping, Types> : Type);
+export declare function FromType(mapping: TMappingFunc, type: TSchema): TSchema;

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

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

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

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

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

@@ -0,0 +1,38 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TMappingType } from './mapping.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TCapitalizeDeferred } from '../../action/capitalize.mjs';
+import { type TLowercaseDeferred } from '../../action/lowercase.mjs';
+import { type TUncapitalizeDeferred } from '../../action/uncapitalize.mjs';
+import { type TUppercaseDeferred } from '../../action/uppercase.mjs';
+interface TCapitalizeMapping extends TMappingType {
+    output: Capitalize<this['input']>;
+}
+interface TLowercaseMapping extends TMappingType {
+    output: Lowercase<this['input']>;
+}
+interface TUncapitalizeMapping extends TMappingType {
+    output: Uncapitalize<this['input']>;
+}
+interface TUppercaseMapping extends TMappingType {
+    output: Uppercase<this['input']>;
+}
+export type TCapitalizeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TCapitalizeMapping, Type> : TCapitalizeDeferred<Type>> = Result;
+export declare function CapitalizeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TCapitalizeAction<Type>;
+export type TLowercaseAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TLowercaseMapping, Type> : TLowercaseDeferred<Type>> = Result;
+export declare function LowercaseAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TLowercaseAction<Type>;
+export type TUncapitalizeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TUncapitalizeMapping, Type> : TUncapitalizeDeferred<Type>> = Result;
+export declare function UncapitalizeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TUncapitalizeAction<Type>;
+export type TUppercaseAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TUppercaseMapping, Type> : TUppercaseDeferred<Type>> = Result;
+export declare function UppercaseAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TUppercaseAction<Type>;
+export type TCapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TCapitalizeAction<InstantiatedType>;
+export declare function CapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TCapitalizeInstantiate<Context, State, Type>;
+export type TLowercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TLowercaseAction<InstantiatedType>;
+export declare function LowercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TLowercaseInstantiate<Context, State, Type>;
+export type TUncapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TUncapitalizeAction<InstantiatedType>;
+export declare function UncapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TUncapitalizeInstantiate<Context, State, Type>;
+export type TUppercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TUppercaseAction<InstantiatedType>;
+export declare function UppercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TUppercaseInstantiate<Context, State, Type>;
+export {};

package/assets/types/typebox/build/type/engine/intrinsics/mapping.d.mts

@@ -0,0 +1,9 @@
+export interface TMappingType {
+    input: string;
+    output: string;
+}
+export type TApplyMapping<Mapping extends TMappingType, Value extends string> = ((Mapping & {
+    input: Value;
+})['output']);
+export type TMappingFunc = (input: string) => string;
+export declare function ApplyMapping(mapping: TMappingFunc, value: string): string;

package/assets/types/typebox/build/type/engine/keyof/from_any.d.mts

@@ -0,0 +1,6 @@
+import { type TNumber } from '../../types/number.mjs';
+import { type TString } from '../../types/string.mjs';
+import { type TSymbol } from '../../types/symbol.mjs';
+import { type TUnion } from '../../types/union.mjs';
+export type TFromAny<Result = TUnion<[TNumber, TString, TSymbol]>> = Result;
+export declare function FromAny(): TFromAny;

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

@@ -0,0 +1,4 @@
+import { type TSchema } from '../../types/index.mjs';
+import { type TNumber } from '../../types/number.mjs';
+export type TFromArray<_Type extends TSchema> = TNumber;
+export declare function FromArray<_Type extends TSchema>(_type: _Type): TFromArray<_Type>;

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

@@ -0,0 +1,10 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TSchema } from '../../types/index.mjs';
+import { type TUnionToTuple } from '../helpers/index.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TEvaluateUnionFast } from '../evaluate/evaluate.mjs';
+type TFromPropertyKeys<Keys extends PropertyKey[], Result extends TSchema[] = []> = (Keys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Left extends TLiteralValue ? TFromPropertyKeys<Right, [...Result, TLiteral<Left>]> : TUnreachable : Result);
+export type TFromObject<Properties extends TProperties, PropertyKeys extends PropertyKey[] = TUnionToTuple<keyof Properties>, Variants extends TSchema[] = TFromPropertyKeys<PropertyKeys>, Result extends TSchema = TEvaluateUnionFast<Variants>> = Result;
+export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;
+export {};

package/assets/types/typebox/build/type/engine/keyof/from_record.d.mts

@@ -0,0 +1,4 @@
+import { type TSchema } from '../../types/index.mjs';
+import { type TRecord, type TRecordKey } from '../../types/record.mjs';
+export type TFromRecord<Type extends TRecord, Result extends TSchema = TRecordKey<Type>> = Result;
+export declare function FromRecord<Type extends TRecord>(type: Type): TFromRecord<Type>;

package/assets/types/typebox/build/type/engine/keyof/from_tuple.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/index.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
+import { type TEvaluateUnionFast } from '../evaluate/evaluate.mjs';
+export type TFromTuple<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer _ extends TSchema] ? TFromTuple<Left, [TLiteral<Left['length']>, ...Result]> : TEvaluateUnionFast<Result>);
+export declare function FromTuple<Types extends TSchema[]>(types: [...Types]): TFromTuple<Types>;

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

@@ -0,0 +1,15 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TAny } from '../../types/any.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TRecord } from '../../types/record.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TFromAny } from './from_any.mjs';
+import { type TFromArray } from './from_array.mjs';
+import { type TFromObject } from './from_object.mjs';
+import { type TFromRecord } from './from_record.mjs';
+import { type TFromTuple } from './from_tuple.mjs';
+export type TFromType<Type extends TSchema> = (Type extends TAny ? TFromAny : Type extends TArray<infer Type extends TSchema> ? TFromArray<Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : Type extends TRecord ? TFromRecord<Type> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : TNever);
+export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

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

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

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

@@ -0,0 +1,16 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TKeyOfDeferred } from '../../action/keyof.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TCollapseToObject } from '../object/index.mjs';
+import { type TFromType } from './from_type.mjs';
+type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic ? TCollapseToObject<Type> : Type extends TDependent ? TCollapseToObject<Type> : Type extends TIntersect ? TCollapseToObject<Type> : Type extends TUnion ? TCollapseToObject<Type> : Type)> = Result;
+export type TKeyOfAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TNormalizeType<Type>> : TKeyOfDeferred<Type>> = Result;
+export declare function KeyOfAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TKeyOfAction<Type>;
+export type TKeyOfInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TKeyOfAction<InstantiatedType>;
+export declare function KeyOfInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TKeyOfInstantiate<Context, State, Type>;
+export {};

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

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

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

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TIdentifier } from '../../types/identifier.mjs';
+import { type TMappedDeferred } from '../../action/mapped.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TMappedOperation } from './mapped_operation.mjs';
+export type TMappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TMappedOperation<Context, State, Identifier, Type, As, Property> : TMappedDeferred<Identifier, Type, As, Property>> = Result;
+export declare function MappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, type: Type, as: As, property: Property, options: TSchemaOptions): TMappedAction<Context, State, Identifier, Type, As, Property>;
+export type TMappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, InstaniatedType extends TSchema = TInstantiateType<Context, State, Type>> = TMappedAction<Context, State, Identifier, InstaniatedType, As, Property>;
+export declare function MappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, type: Type, as: As, property: Property, options: TSchemaOptions): TMappedInstantiate<Context, State, Identifier, Type, As, Property>;

package/assets/types/typebox/build/type/engine/mapped/mapped_operation.d.mts

@@ -0,0 +1,22 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TIdentifier } from '../../types/identifier.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TInstantiateType, type TState } from '../instantiate.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+import { type TMappedVariants } from './mapped_variants.mjs';
+type TCanonicalAs<InstantiatedAs extends TSchema, Result extends TSchema = InstantiatedAs extends TTemplateLiteral<infer Pattern extends string> ? TEvaluateTemplateLiteral<Pattern> : InstantiatedAs> = Result;
+type TMappedVariant<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variant extends TSchema, As extends TSchema, Property extends TSchema, VariantContext extends TProperties = Memory.TAssign<Context, {
+    [_ in Identifier['name']]: Variant;
+}>, InstantiatedAs extends TSchema = TInstantiateType<VariantContext, State, As>, CanonicalAs extends TSchema = TCanonicalAs<InstantiatedAs>, InstantiatedProperty extends TSchema = TInstantiateType<VariantContext, State, Property>, Result extends TProperties = CanonicalAs extends TLiteral<string | number> ? {
+    [_ in CanonicalAs['const']]: InstantiatedProperty;
+} : {}> = Result;
+type TMappedProperties<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variants extends TSchema[], As extends TSchema, Property extends TSchema, Result extends TProperties[] = []> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TMappedProperties<Context, State, Identifier, Right, As, Property, [...Result, TMappedVariant<Context, State, Identifier, Left, As, Property>]> : Result);
+type TReduceProperties<Properties extends TProperties[], Result extends TSchema[] = []> = (Properties extends [infer Left extends TProperties, ...infer Right extends TProperties[]] ? TReduceProperties<Right, [...Result, TObject<Left>]> : Result);
+export type TMappedOperation<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, Variants extends TSchema[] = TMappedVariants<Type>, MappedProperties extends TProperties[] = TMappedProperties<Context, State, Identifier, Variants, As, Property>, MappedObjects extends TSchema[] = TReduceProperties<MappedProperties>, Result extends TSchema = TEvaluateIntersect<MappedObjects>> = Result;
+export declare function MappedOperation<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, type: Type, as: As, property: Property): TMappedOperation<Context, State, Identifier, Type, As, Property>;
+export {};

package/assets/types/typebox/build/type/engine/mapped/mapped_variants.d.mts

@@ -0,0 +1,17 @@
+import { type TSchema } from '../../types/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TEvaluateEnum } from '../evaluate/evaluate.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+type TFromTemplateLiteral<Pattern extends string, Evaluated extends TSchema = TEvaluateTemplateLiteral<Pattern>, Result extends TSchema[] = TFromType<Evaluated>> = Result;
+type TFromUnion<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TFromType<Left>]> : Result);
+type TFromEnum<Values extends TEnumValue[], Evaluated extends TSchema = TEvaluateEnum<Values>, Result extends TSchema[] = TFromType<Evaluated>> = Result;
+type TFromLiteral<Value extends TLiteralValue, Result extends TSchema[] = Value extends number ? [TLiteral<`${Value}`>] : [TLiteral<Value>]> = Result;
+type TFromType<Type extends TSchema, Result extends TSchema[] = (Type extends TEnum<infer Values extends TEnumValue[]> ? TFromEnum<Values> : Type extends TLiteral<infer Value extends number> ? TFromLiteral<Value> : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
+    Type
+])> = Result;
+export type TMappedVariants<Type extends TSchema, Result extends TSchema[] = TFromType<Type>> = Result;
+export declare function MappedVariants<Type extends TSchema>(type: Type): TMappedVariants<Type>;
+export {};

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

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

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

@@ -0,0 +1,19 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TState } from '../instantiate.mjs';
+import { type TCyclicCandidates } from '../cyclic/candidates.mjs';
+import { type TInstantiateCyclic } from '../cyclic/instantiate.mjs';
+import { type TInstantiateType } from '../instantiate.mjs';
+type TInstantiateCyclics<Context extends TProperties, Declarations extends TProperties, CyclicKeys extends string[], DeclarationContext extends TProperties = Memory.TAssign<Context, Declarations>, Result extends TProperties = {
+    [Key in Extract<keyof Declarations, CyclicKeys[number]>]: TInstantiateCyclic<DeclarationContext, Key, Declarations[Key]>;
+}> = Result;
+type TInstantiateNonCyclics<Context extends TProperties, Declarations extends TProperties, CyclicKeys extends string[], DeclarationContext extends TProperties = Memory.TAssign<Context, Declarations>, Result extends TProperties = {
+    [Key in Exclude<keyof Declarations, CyclicKeys[number]>]: TInstantiateType<DeclarationContext, TState<[], []>, Declarations[Key]>;
+}> = Result;
+type TInstantiateModule<Context extends TProperties, Declarations extends TProperties, CyclicCandidates extends string[] = TCyclicCandidates<Declarations>, InstantiatedCyclics extends TProperties = TInstantiateCyclics<Context, Declarations, CyclicCandidates>, InstantiatedNonCyclics extends TProperties = TInstantiateNonCyclics<Context, Declarations, CyclicCandidates>, InstantiatedModule extends TProperties = InstantiatedCyclics & InstantiatedNonCyclics> = {
+    [Key in keyof InstantiatedModule]: InstantiatedModule[Key];
+} & {};
+export type TModuleInstantiate<Context extends TProperties, _State extends TState, Declarations extends TProperties, InstantiatedModule extends TProperties = TInstantiateModule<Context, Declarations>> = InstantiatedModule;
+export declare function ModuleInstantiate<Context extends TProperties, State extends TState, Declarations extends TProperties>(context: Context, _state: State, declarations: Declarations, options: TSchemaOptions): TModuleInstantiate<Context, State, Declarations>;
+export {};

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

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

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

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TNull } from '../../types/null.mjs';
+import { type TUndefined } from '../../types/undefined.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TExcludeAction } from '../exclude/instantiate.mjs';
+import { type TNonNullableDeferred } from '../../action/non_nullable.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TNonNullableOperation<Type extends TSchema, Excluded extends TSchema = TUnion<[TNull, TUndefined]>> = TExcludeAction<Type, Excluded>;
+export type TNonNullableAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TNonNullableOperation<Type> : TNonNullableDeferred<Type>> = Result;
+export declare function NonNullableAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TNonNullableAction<Type>;
+export type TNonNullableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TNonNullableAction<InstantiatedType>;
+export declare function NonNullableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TNonNullableInstantiate<Context, State, Type>;
+export {};

package/assets/types/typebox/build/type/engine/object/collapse.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TFromType } from './from_type.mjs';
+export type TCollapseToObject<Type extends TSchema, Properties extends TProperties = TFromType<Type>, Result extends TSchema = TObject<Properties>> = Result;
+/**
+ * Collapses a type into a TObject schema. This is a lossy fast path used to
+ * normalize arbitrary TSchema types into a TObject structure. This function is
+ * primarily used in indexing operations where a normalized object structure
+ * is required. If the type cannot be collapsed, an empty object schema is returned.
+ */
+export declare function CollapseToObject<Type extends TSchema>(type: Type): TCollapseToObject<Type>;

package/assets/types/typebox/build/type/engine/object/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 TProperties = 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/object/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 TSchema = 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>;