@yaag/cli 0.1.0

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

@@ -0,0 +1,10 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TCyclic } from '../../types/cyclic.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>, Partial extends TSchema = TFromType<Target>, Result extends TSchema = TCyclic<Memory.TAssign<Defs, {
+    [_ in Ref]: Partial;
+}>, Ref>> = 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/required/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>;

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

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

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

@@ -0,0 +1,8 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TRemoveOptional } from '../../action/_remove_optional.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+export type TFromObject<Properties extends TProperties, Mapped extends TProperties = {
+    [Key in keyof Properties]: TRemoveOptional<Properties[Key]>;
+}, Result extends TSchema = TObject<Mapped>> = Result;
+export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;

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

@@ -0,0 +1,14 @@
+import { type TSchema } 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 TObject } from '../../types/object.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
+import { type TFromIntersect } from './from_intersect.mjs';
+import { type TFromUnion } from './from_union.mjs';
+import { type TFromObject } from './from_object.mjs';
+export type TFromType<Type extends TSchema> = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : TObject<{}>);
+export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

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

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

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

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

package/assets/types/typebox/build/type/engine/required/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 TFromType } from './from_type.mjs';
+import { type TRequiredDeferred } from '../../action/required.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+export type TRequiredAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<Type> : TRequiredDeferred<Type>> = Result;
+export declare function RequiredAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TRequiredAction<Type>;
+export type TRequiredInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TRequiredAction<InstantiatedType>;
+export declare function RequiredInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TRequiredInstantiate<Context, State, Type>;

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

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

package/assets/types/typebox/build/type/engine/rest/spread.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TInfer } from '../../types/infer.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TRest } from '../../types/rest.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+type TSpreadElement<Type extends TSchema, Result extends TSchema[] = (Type extends TRest<infer Rest extends TSchema> ? (Rest extends TTuple<infer Elements extends TSchema[]> ? TRestSpread<Elements> : Rest extends TInfer<string, TSchema> ? [Type] : Rest extends TRef<string> ? [Type] : [
+    TNever
+]) : [Type])> = Result;
+export type TRestSpread<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TRestSpread<Right, [...Result, ...TSpreadElement<Left>]> : Result);
+export declare function RestSpread<Types extends TSchema[]>(types: [...Types]): TRestSpread<Types>;
+export {};

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

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

package/assets/types/typebox/build/type/engine/return_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 TFunction } from '../../types/function.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TReturnTypeDeferred } from '../../action/return_type.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TReturnTypeOperation<Type extends TSchema> = (Type extends TFunction ? Type['returnType'] : TNever);
+export type TReturnTypeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TReturnTypeOperation<Type> : TReturnTypeDeferred<Type>> = Result;
+export declare function ReturnTypeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TReturnTypeAction<Type>;
+export type TReturnTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TReturnTypeAction<InstantiatedType>;
+export declare function ReturnTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options?: TSchemaOptions): TReturnTypeInstantiate<Context, State, Type>;
+export {};

package/assets/types/typebox/build/type/engine/template_literal/create.d.mts

@@ -0,0 +1 @@
+export declare function TemplateLiteralCreate<Pattern extends string>(pattern: Pattern): never;

package/assets/types/typebox/build/type/engine/template_literal/decode.d.mts

@@ -0,0 +1,30 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TString } from '../../types/string.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TParsePatternIntoTypes } from '../patterns/pattern.mjs';
+import { type TIsTemplateLiteralFinite } from './is_finite.mjs';
+type TFromLiteralPush<Variants extends string[], Value extends TLiteralValue, Result extends string[] = []> = Variants extends [infer Left extends string, ...infer Right extends string[]] ? TFromLiteralPush<Right, Value, [...Result, `${Left}${Value}`]> : Result;
+type TFromLiteral<Variants extends string[], Value extends TLiteralValue> = Variants extends [] ? [`${Value}`] : TFromLiteralPush<Variants, Value>;
+type TFromUnion<Variants extends string[], Types extends TSchema[], Result extends string[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Variants, Right, [...Result, ...TFromType<Variants, Left>]> : Result;
+type TFromType<Variants extends string[], Type extends TSchema, Result extends string[] = (Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Variants, Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Variants, Value> : TUnreachable)> = Result;
+type TDecodeFromSpan<Variants extends string[], Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDecodeFromSpan<TFromType<Variants, Left>, Right> : Variants;
+type TVariantsToLiterals<Variants extends string[], Result extends TSchema[] = []> = Variants extends [infer Left extends string, ...infer Right extends string[]] ? TVariantsToLiterals<Right, [...Result, TLiteral<Left>]> : Result;
+type TDecodeTypesAsUnion<Types extends TSchema[], Variants extends string[] = TDecodeFromSpan<[], Types>, Literals extends TSchema[] = TVariantsToLiterals<Variants>, Result extends TSchema = TUnion<Literals>> = Result;
+type TDecodeTypes<Types extends TSchema[], Result extends TSchema = (Types extends [] ? TUnreachable : Types extends [infer Type extends TLiteral] ? Type : TDecodeTypesAsUnion<Types>)> = Result;
+/** Decodes a TemplateLiteral into a Type. */
+export type TTemplateLiteralDecodeUnsafe<Pattern extends string, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Result extends TSchema = (Types extends [] ? TString : TIsTemplateLiteralFinite<Types> extends true ? TDecodeTypes<Types> : TTemplateLiteral<Pattern>)> = Result;
+/**
+ * (Internal) Decodes a TemplateLiteral pattern into a Type. This function is unsafe. Decoding a non-finite
+ * TemplateLiteral pattern may produce another TemplateLiteral pattern. During enumeration, this
+ * TemplateLiteral -> TemplateLiteral behavior can cause a StackOverflow. A better in-flight template-literal
+ * decoding algorithm is needed. (for review)
+ */
+export declare function TemplateLiteralDecodeUnsafe<Pattern extends string>(pattern: Pattern): TTemplateLiteralDecodeUnsafe<Pattern>;
+/** Decodes a TemplateLiteral pattern but returns TString if the pattern in non-finite. */
+export type TTemplateLiteralDecode<Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecodeUnsafe<Pattern>, Result extends TSchema = Decoded extends TTemplateLiteral ? TString : Decoded> = Result;
+/** Decodes a TemplateLiteral pattern but returns TString if the pattern in non-finite. */
+export declare function TemplateLiteralDecode<Pattern extends string>(pattern: Pattern): TTemplateLiteralDecode<Pattern>;
+export {};

package/assets/types/typebox/build/type/engine/template_literal/encode.d.mts

@@ -0,0 +1,33 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TTemplateLiteral, type TTemplateLiteralDeferred } from '../../types/template_literal.mjs';
+import { type TBigInt, BigIntPattern } from '../../types/bigint.mjs';
+import { type TString, StringPattern } from '../../types/string.mjs';
+import { type TNumber, NumberPattern } from '../../types/number.mjs';
+import { type TInteger, IntegerPattern } from '../../types/integer.mjs';
+import { type TBoolean } from '../../types/boolean.mjs';
+import { NeverPattern } from '../../types/never.mjs';
+import { type TEvaluateEnum } from '../evaluate/evaluate.mjs';
+import { type TTemplateLiteralAction } from './instantiate.mjs';
+type TJoinString<Input extends string[], Result extends string = ''> = (Input extends [infer Left extends string, ...infer Right extends string[]] ? Result extends '' ? TJoinString<Right, Left> : TJoinString<Right, `${Result}|${Left}`> : Result);
+type TUnwrapTemplateLiteralPattern<Pattern extends string> = (Pattern extends `^${infer Pattern extends string}$` ? Pattern : never);
+type TEncodeLiteral<Value extends TLiteralValue, Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${Value}`>);
+type TEncodeBigInt<Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${typeof BigIntPattern}`>);
+type TEncodeInteger<Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${typeof IntegerPattern}`>);
+type TEncodeNumber<Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${typeof NumberPattern}`>);
+type TEncodeBoolean<Right extends TSchema[], Pattern extends string> = (TEncodeType<TUnion<[TLiteral<'false'>, TLiteral<'true'>]>, Right, Pattern>);
+type TEncodeString<Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${typeof StringPattern}`>);
+type TEncodeTemplateLiteral<TemplatePattern extends string, Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${TUnwrapTemplateLiteralPattern<TemplatePattern>}`>);
+type TEncodeTemplateLiteralDeferred<Types extends TSchema[], Right extends TSchema[], Pattern extends string, TemplateLiteral extends TSchema = TTemplateLiteralAction<Types>, Result extends TSchema = TEncodeType<TemplateLiteral, Right, Pattern>> = Result;
+type TEncodeEnum<Values extends TEnumValue[], Right extends TSchema[], Pattern extends string, Evaluated extends TSchema = TEvaluateEnum<Values>> = TEncodeType<Evaluated, Right, Pattern>;
+type TEncodeUnion<Types extends TSchema[], Right extends TSchema[], Pattern extends string, Result extends string[] = []> = Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TEncodeUnion<Tail, Right, Pattern, [...Result, TEncodeType<Head, [], ''>]> : TEncodeTypes<Right, `${Pattern}(${TJoinString<Result>})`>;
+type TEncodeType<Type extends TSchema, Right extends TSchema[], Pattern extends string> = (Type extends TEnum<infer Values extends TEnumValue[]> ? TEncodeEnum<Values, Right, Pattern> : Type extends TInteger ? TEncodeInteger<Right, Pattern> : Type extends TLiteral<infer Value extends TLiteralValue> ? TEncodeLiteral<Value, Right, Pattern> : Type extends TBigInt ? TEncodeBigInt<Right, Pattern> : Type extends TBoolean ? TEncodeBoolean<Right, Pattern> : Type extends TNumber ? TEncodeNumber<Right, Pattern> : Type extends TString ? TEncodeString<Right, Pattern> : Type extends TTemplateLiteral<infer TemplatePattern extends string> ? TEncodeTemplateLiteral<TemplatePattern, Right, Pattern> : Type extends TTemplateLiteralDeferred<infer Types extends TSchema[]> ? TEncodeTemplateLiteralDeferred<Types, Right, Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TEncodeUnion<Types, Right, Pattern> : typeof NeverPattern);
+type TEncodeTypes<Types extends TSchema[], Pattern extends string> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TEncodeType<Left, Right, Pattern> : Pattern);
+type TEncodePattern<Types extends TSchema[], Encoded extends string = TEncodeTypes<Types, ''>, Result extends string = `^${Encoded}$`> = Result;
+/** Encodes a TemplateLiteral type sequence into a TemplateLiteral */
+export type TTemplateLiteralEncode<Types extends TSchema[], Pattern extends string = TEncodePattern<Types>, Result extends TSchema = TTemplateLiteral<Pattern>> = Result;
+/** Encodes a TemplateLiteral type sequence into a TemplateLiteral */
+export declare function TemplateLiteralEncode<Types extends TSchema[]>(types: [...Types]): TTemplateLiteralEncode<Types>;
+export {};

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

@@ -0,0 +1,6 @@
+export * from './create.mjs';
+export * from './decode.mjs';
+export * from './encode.mjs';
+export * from './static.mjs';
+export * from './is_finite.mjs';
+export * from './is_pattern.mjs';

package/assets/types/typebox/build/type/engine/template_literal/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 TTemplateLiteralDeferred } from '../../types/template_literal.mjs';
+import { type TTemplateLiteralEncode } from './encode.mjs';
+import { type TState, type TInstantiateTypes, type TCanInstantiate } from '../instantiate.mjs';
+export type TTemplateLiteralAction<Types extends TSchema[], Result extends TSchema = TCanInstantiate<Types> extends true ? TTemplateLiteralEncode<Types> : TTemplateLiteralDeferred<Types>> = Result;
+export declare function TemplateLiteralAction<Types extends TSchema[]>(types: [...Types], options: TSchemaOptions): TTemplateLiteralAction<Types>;
+export type TTemplateLiteralInstantiate<Context extends TProperties, State extends TState, Types extends TSchema[], InstantiatedTypes extends TSchema[] = TInstantiateTypes<Context, State, Types>> = TTemplateLiteralAction<InstantiatedTypes>;
+export declare function TemplateLiteralInstantiate<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types], options: TSchemaOptions): TTemplateLiteralInstantiate<Context, State, Types>;

package/assets/types/typebox/build/type/engine/template_literal/is_finite.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
+type TFromLiteral<_Value extends TLiteralValue> = true;
+type TFromTypesReduce<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromType<Left> extends true ? TFromTypesReduce<Right> : false : true);
+type TFromTypes<Types extends TSchema[], Result extends boolean = Types extends [] ? false : TFromTypesReduce<Types>> = Result;
+type TFromType<Type extends TSchema> = Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : false;
+/** Returns true if the given TemplateLiteral types yields a finite variant set */
+export type TIsTemplateLiteralFinite<Types extends TSchema[], Result extends boolean = TFromTypes<Types>> = Result;
+/** Returns true if the given TemplateLiteral types yields a finite variant set */
+export declare function IsTemplateLiteralFinite<Types extends TSchema[]>(types: [...Types]): TIsTemplateLiteralFinite<Types>;
+export {};

package/assets/types/typebox/build/type/engine/template_literal/is_pattern.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TParsePatternIntoTypes } from '../patterns/pattern.mjs';
+/** Returns true if this pattern is a valid Template Literal regular expression */
+export type TIsTemplateLiteralPattern<Pattern extends string, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Result extends boolean = Types extends [] ? false : true> = Result;
+/** Returns true if this pattern is a valid Template Literal regular expression */
+export declare function IsTemplateLiteralPattern<Pattern extends string>(pattern: Pattern): TIsTemplateLiteralPattern<Pattern>;

package/assets/types/typebox/build/type/engine/template_literal/static.d.mts

@@ -0,0 +1,18 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TBigInt } from '../../types/bigint.mjs';
+import { type TString } from '../../types/string.mjs';
+import { type TNumber } from '../../types/number.mjs';
+import { type TInteger } from '../../types/integer.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TParsePatternIntoTypes } from '../patterns/pattern.mjs';
+type TFromLiteral<Template extends string, Value extends TLiteralValue> = `${Template}${Value}`;
+type TFromBigInt<Template extends string> = `${Template}${bigint}`;
+type TFromString<Template extends string> = `${Template}${string}`;
+type TFromNumber<Template extends string> = `${Template}${number}`;
+type TFromInteger<Template extends string> = `${Template}${number}`;
+type TFromUnion<Template extends string, Types extends TSchema[], Result extends string = never> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Template, Right, Result | TFromType<'', Left>> : `${Template}${Result}`);
+type TFromType<Template extends string, Type extends TSchema, Result extends string = (Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Template, Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Template, Value> : Type extends TBigInt ? TFromBigInt<Template> : Type extends TString ? TFromString<Template> : Type extends TNumber ? TFromNumber<Template> : Type extends TInteger ? TFromInteger<Template> : never)> = Result;
+type TFromSpan<Template extends string, Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromSpan<TFromType<Template, Left>, Right> : Template);
+export type TTemplateLiteralStatic<Pattern extends string, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>> = TFromSpan<'', Types>;
+export {};

package/assets/types/typebox/build/type/engine/this/expand_this.d.mts

@@ -0,0 +1,16 @@
+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 } from '../../types/properties.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TThis } from '../../types/this.mjs';
+import { type TUnion } from '../../types/union.mjs';
+type TFromTypes<Properties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Properties, Right, [...Result, TFromType<Properties, Left>]> : Result);
+export type TFromType<Properties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TArray<TFromType<Properties, Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TFromTypes<Properties, Parameters>, TFromType<Properties, InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Properties, Parameters>, TFromType<Properties, ReturnType>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Properties, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Properties, Types>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Properties, Types>> : Type extends TThis ? TObject<Properties> : Type);
+export declare function FromType<Properties extends TProperties, Type extends TSchema>(properties: Properties, type: Type): TFromType<Properties, Type>;
+export type TExpandThis<Properties extends TProperties, Type extends TSchema, Result extends TSchema = TFromType<Properties, Type>> = Result;
+export declare function ExpandThis<Properties extends TProperties, Type extends TSchema>(properties: TProperties, type: Type): TExpandThis<Properties, Type>;
+export {};

package/assets/types/typebox/build/type/engine/tuple/to_object.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+export type TTupleElementsToProperties<Types extends TSchema[], Result extends TProperties = {}> = (Types extends [...infer Left extends TSchema[], infer Right extends TSchema] ? TTupleElementsToProperties<Left, {
+    [_ in Left['length']]: Right;
+} & Result> : {
+    [Key in keyof Result]: Result[Key];
+});
+export declare function TupleElementsToProperties<Types extends TSchema[]>(types: [...Types]): TTupleElementsToProperties<Types>;
+export type TTupleToObject<Type extends TTuple, Properties extends TProperties = TTupleElementsToProperties<Type['items']>, Result extends TSchema = TObject<Properties>> = Result;
+export declare function TupleToObject<Type extends TTuple>(type: Type): TTupleToObject<Type>;

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

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

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

@@ -0,0 +1,8 @@
+import { type TProperties } from '../../types/properties.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TWithDeferred, type TWith } from '../../action/with.mjs';
+export type TWithAction<Type extends TSchema, Options extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TWith<Type, Options> : TWithDeferred<Type, Options>> = Result;
+export declare function WithAction<Type extends TSchema, Options extends TSchema>(type: Type, options: Options): TWithAction<Type, Options>;
+export type TWithInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Options extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TWithAction<InstantiatedType, Options>;
+export declare function WithInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Options extends TSchema>(context: Context, state: State, type: Type, options: Options): TWithInstantiate<Context, State, Type, Options>;

package/assets/types/typebox/build/type/extends/any.d.mts

@@ -0,0 +1,9 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TInfer } from '../types/infer.mjs';
+import { type TAny } from '../types/any.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export type TExtendsAny<Inferred extends TProperties, Left extends TAny, Right extends TSchema> = (Right extends TInfer ? TExtendsRight<Inferred, Left, Right> : Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsUnion<Inferred>);
+export declare function ExtendsAny<Inferred extends TProperties, Left extends TAny, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsAny<Inferred, Left, Right>;

package/assets/types/typebox/build/type/extends/array.d.mts

@@ -0,0 +1,20 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TArray } from '../types/array.mjs';
+import { type TImmutable } from '../types/_immutable.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+type TExtendsImmutable<Left extends TSchema, Right extends TSchema, IsImmutableLeft extends boolean = Left extends TImmutable ? true : false, IsImmutableRight extends boolean = Right extends TImmutable ? true : false, Result extends boolean = [
+    IsImmutableLeft,
+    IsImmutableRight
+] extends [true, true] ? true : [
+    IsImmutableLeft,
+    IsImmutableRight
+] extends [false, true] ? true : [
+    IsImmutableLeft,
+    IsImmutableRight
+] extends [true, false] ? false : true> = Result;
+export type TExtendsArray<Inferred extends TProperties, ArrayLeft extends TSchema, Left extends TSchema, Right extends TSchema> = (Right extends TArray<infer Type extends TSchema> ? TExtendsImmutable<ArrayLeft, Right> extends true ? TExtendsLeft<Inferred, Left, Type> : Result.TExtendsFalse : TExtendsRight<Inferred, ArrayLeft, Right>);
+export declare function ExtendsArray<Inferred extends TProperties, ArrayLeft extends TSchema, Left extends TSchema, Right extends TSchema>(inferred: Inferred, arrayLeft: ArrayLeft, left: Left, right: Right): TExtendsArray<Inferred, ArrayLeft, Left, Right>;
+export {};

package/assets/types/typebox/build/type/extends/bigint.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TBigInt } from '../types/bigint.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export type TExtendsBigInt<Inferred extends TProperties, Left extends TBigInt, Right extends TSchema> = (Right extends TBigInt ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
+export declare function ExtendsBigInt<Inferred extends TProperties, Left extends TBigInt, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsBigInt<Inferred, Left, Right>;

package/assets/types/typebox/build/type/extends/boolean.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TBoolean } from '../types/boolean.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export type TExtendsBoolean<Inferred extends TProperties, Left extends TBoolean, Right extends TSchema> = (Right extends TBoolean ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
+export declare function ExtendsBoolean<Inferred extends TProperties, Left extends TBoolean, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsBoolean<Inferred, Left, Right>;

package/assets/types/typebox/build/type/extends/constructor.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TAny } from '../types/any.mjs';
+import { type TConstructor } from '../types/constructor.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import * as Result from './result.mjs';
+import { type TExtendsParameters } from './parameters.mjs';
+import { type TExtendsReturnType } from './return_type.mjs';
+export type TExtendsConstructor<Inferred extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, Right extends TSchema> = (Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Right extends TConstructor ? TExtendsParameters<Inferred, Parameters, Right['parameters']> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsReturnType<Inferred, InstanceType, Right['instanceType']> : Result.TExtendsFalse : Result.TExtendsFalse);
+export declare function ExtendsConstructor<Inferred extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, Right extends TSchema>(inferred: Inferred, parameters: [...Parameters], returnType: InstanceType, right: Right): TExtendsConstructor<Inferred, Parameters, InstanceType, Right>;

package/assets/types/typebox/build/type/extends/dependent.d.mts

@@ -0,0 +1,6 @@
+import { type TProperties } from '../types/properties.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+export type TExtendsDependent<Inferred extends TProperties, If extends TSchema, Then extends TSchema, Else extends TSchema, Right extends TSchema> = (TExtendsLeft<Inferred, If, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsLeft<Inferred, Then, Right> : TExtendsLeft<Inferred, Else, Right>);
+export declare function ExtendsDependent<Inferred extends TProperties, If extends TSchema, Then extends TSchema, Else extends TSchema, Right extends TSchema>(inferred: Inferred, if_: If, then_: Then, else_: Else, right: Right): TExtendsDependent<Inferred, If, Then, Else, Right>;

package/assets/types/typebox/build/type/extends/enum.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TEnumValue } from '../types/enum.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import { type TEvaluateEnum } from '../engine/evaluate/evaluate.mjs';
+export type TExtendsEnum<Inferred extends TProperties, Left extends TEnumValue[], Right extends TSchema, Evaluated extends TSchema = TEvaluateEnum<Left>> = TExtendsLeft<Inferred, Evaluated, Right>;
+export declare function ExtendsEnum<Inferred extends TProperties, Left extends TEnumValue[], Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsEnum<Inferred, Left, Right>;

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

@@ -0,0 +1,13 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TCyclic } from '../types/cyclic.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TUnsafe } from '../types/unsafe.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import { type TCyclicExtends } from '../engine/cyclic/index.mjs';
+type TCanonical<Type extends TSchema> = (Type extends TCyclic ? TCyclicExtends<Type> : Type extends TUnsafe ? TUnknown : Type);
+/** Performs a structural extends check on left and right types and yields inferred types on right if specified. */
+export type TExtends<Inferred extends TProperties, Left extends TSchema, Right extends TSchema, CanonicalLeft extends TSchema = TCanonical<Left>, CanonicalRight extends TSchema = TCanonical<Right>> = TExtendsLeft<Inferred, CanonicalLeft, CanonicalRight>;
+/** Performs a structural extends check on left and right types and yields inferred types on right if specified. */
+export declare function Extends<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtends<Inferred, Left, Right>;
+export {};

package/assets/types/typebox/build/type/extends/extends_left.d.mts

@@ -0,0 +1,53 @@
+import { type TExtendsAny } from './any.mjs';
+import { type TExtendsArray } from './array.mjs';
+import { type TExtendsBigInt } from './bigint.mjs';
+import { type TExtendsBoolean } from './boolean.mjs';
+import { type TExtendsConstructor } from './constructor.mjs';
+import { type TExtendsDependent } from './dependent.mjs';
+import { type TExtendsEnum } from './enum.mjs';
+import { type TExtendsFunction } from './function.mjs';
+import { type TExtendsInteger } from './integer.mjs';
+import { type TExtendsIntersect } from './intersect.mjs';
+import { type TExtendsLiteral } from './literal.mjs';
+import { type TExtendsNever } from './never.mjs';
+import { type TExtendsNull } from './null.mjs';
+import { type TExtendsNumber } from './number.mjs';
+import { type TExtendsObject } from './object.mjs';
+import { type TExtendsRecord } from './record.mjs';
+import { type TExtendsString } from './string.mjs';
+import { type TExtendsSymbol } from './symbol.mjs';
+import { type TExtendsTemplateLiteral } from './template_literal.mjs';
+import { type TExtendsTuple } from './tuple.mjs';
+import { type TExtendsUndefined } from './undefined.mjs';
+import { type TExtendsUnion } from './union.mjs';
+import { type TExtendsUnknown } from './unknown.mjs';
+import { type TExtendsVoid } from './void.mjs';
+import { type TAny } from '../types/any.mjs';
+import { type TArray } from '../types/array.mjs';
+import { type TBigInt } from '../types/bigint.mjs';
+import { type TBoolean } from '../types/boolean.mjs';
+import { type TConstructor } from '../types/constructor.mjs';
+import { type TDependent } from '../types/dependent.mjs';
+import { type TEnum, type TEnumValue } from '../types/enum.mjs';
+import { type TFunction } from '../types/function.mjs';
+import { type TInteger } from '../types/integer.mjs';
+import { type TIntersect } from '../types/intersect.mjs';
+import { type TLiteral } from '../types/literal.mjs';
+import { type TNever } from '../types/never.mjs';
+import { type TNull } from '../types/null.mjs';
+import { type TNumber } from '../types/number.mjs';
+import { type TObject } from '../types/object.mjs';
+import { type TRecord } from '../types/record.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TString } from '../types/string.mjs';
+import { type TSymbol } from '../types/symbol.mjs';
+import { type TTemplateLiteral } from '../types/template_literal.mjs';
+import { type TTuple } from '../types/tuple.mjs';
+import { type TUndefined } from '../types/undefined.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TUnion } from '../types/union.mjs';
+import { type TVoid } from '../types/void.mjs';
+import * as Result from './result.mjs';
+export type TExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TAny ? TExtendsAny<Inferred, Left, Right> : Left extends TArray<infer Items extends TSchema> ? TExtendsArray<Inferred, Left, Items, Right> : Left extends TBigInt ? TExtendsBigInt<Inferred, Left, Right> : Left extends TBoolean ? TExtendsBoolean<Inferred, Left, Right> : Left extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TExtendsConstructor<Inferred, Parameters, InstanceType, Right> : Left extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TExtendsDependent<Inferred, If, Then, Else, Right> : Left extends TEnum<infer Values extends TEnumValue[]> ? TExtendsEnum<Inferred, Values, Right> : Left extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TExtendsFunction<Inferred, Parameters, ReturnType, Right> : Left extends TInteger ? TExtendsInteger<Inferred, Left, Right> : Left extends TIntersect<infer Types extends TSchema[]> ? TExtendsIntersect<Inferred, Types, Right> : Left extends TLiteral ? TExtendsLiteral<Inferred, Left, Right> : Left extends TNever ? TExtendsNever<Inferred, Left, Right> : Left extends TNull ? TExtendsNull<Inferred, Left, Right> : Left extends TNumber ? TExtendsNumber<Inferred, Left, Right> : Left extends TObject<infer Properties extends TProperties> ? TExtendsObject<Inferred, Properties, Right> : Left extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TExtendsRecord<Inferred, Pattern, Value, Right> : Left extends TString ? TExtendsString<Inferred, Left, Right> : Left extends TSymbol ? TExtendsSymbol<Inferred, Left, Right> : Left extends TTemplateLiteral<infer Pattern extends string> ? TExtendsTemplateLiteral<Inferred, Pattern, Right> : Left extends TTuple<infer Types extends TSchema[]> ? TExtendsTuple<Inferred, Types, Right> : Left extends TUndefined ? TExtendsUndefined<Inferred, Left, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtendsUnion<Inferred, Types, Right> : Left extends TUnknown ? TExtendsUnknown<Inferred, Left, Right> : Left extends TVoid ? TExtendsVoid<Inferred, Left, Right> : Result.TExtendsFalse);
+export declare function ExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsLeft<Inferred, Left, Right>;

package/assets/types/typebox/build/type/extends/extends_right.d.mts

@@ -0,0 +1,27 @@
+import { Memory } from '../../system/memory/index.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TAny } from '../types/any.mjs';
+import { type TDependent } from '../types/dependent.mjs';
+import { type TEnum, type TEnumValue } from '../types/enum.mjs';
+import { type TInfer } from '../types/infer.mjs';
+import { type TIntersect } from '../types/intersect.mjs';
+import { type TTemplateLiteral } from '../types/template_literal.mjs';
+import { type TUnion } from '../types/union.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+import { type TEvaluateEnum } from '../engine/evaluate/evaluate.mjs';
+import { type TEvaluateTemplateLiteral } from '../engine/evaluate/evaluate.mjs';
+type TExtendsRightInfer<Inferred extends TProperties, Name extends string, Left extends TSchema, Right extends TSchema, Result extends Result.TResult = (TExtendsLeft<Inferred, Left, Right> extends Result.TExtendsTrueLike<infer CheckInferred extends TProperties> ? Result.TExtendsTrue<Memory.TAssign<Memory.TAssign<Inferred, CheckInferred>, {
+    [_ in Name]: Left;
+}>> : Result.TExtendsFalse)> = Result;
+type TExtendsRightAny<Inferred extends TProperties, _Left extends TSchema, Result extends Result.TResult = Result.TExtendsTrue<Inferred>> = Result;
+type TExtendsRightDependent<Inferred extends TProperties, Left extends TSchema, If extends TSchema, Then extends TSchema, Else extends TSchema, Result extends Result.TResult = TExtendsLeft<Inferred, Left, If> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? (TExtendsLeft<Inferred, Left, Then> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse) : (TExtendsLeft<Inferred, Left, Else> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse)> = Result;
+type TExtendsRightEnum<Inferred extends TProperties, Left extends TSchema, Right extends TEnumValue[], Evaluated extends TSchema = TEvaluateEnum<Right>> = TExtendsLeft<Inferred, Left, Evaluated>;
+type TExtendsRightIntersect<Inferred extends TProperties, Left extends TSchema, Right extends TSchema[]> = (Right extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Left, Head> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsRightIntersect<Inferred, Left, Tail> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
+type TExtendsRightTemplateLiteral<Inferred extends TProperties, Left extends TSchema, Right extends string, Evaluated extends TSchema = TEvaluateTemplateLiteral<Right>> = TExtendsLeft<Inferred, Left, Evaluated>;
+type TExtendsRightUnion<Inferred extends TProperties, Left extends TSchema, Right extends TSchema[]> = (Right extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Left, Head> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? Result.TExtendsTrue<Inferred> : TExtendsRightUnion<Inferred, Left, Tail> : Result.TExtendsFalse);
+export type TExtendsRight<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TAny ? TExtendsRightAny<Inferred, Left> : Right extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TExtendsRightDependent<Inferred, Left, If, Then, Else> : Right extends TEnum<infer Values extends TEnumValue[]> ? TExtendsRightEnum<Inferred, Left, Values> : Right extends TInfer<infer Name extends string, infer Type extends TSchema> ? TExtendsRightInfer<Inferred, Name, Left, Type> : Right extends TTemplateLiteral<infer Pattern extends string> ? TExtendsRightTemplateLiteral<Inferred, Left, Pattern> : Right extends TIntersect<infer Types extends TSchema[]> ? TExtendsRightIntersect<Inferred, Left, Types> : Right extends TUnion<infer Types extends TSchema[]> ? TExtendsRightUnion<Inferred, Left, Types> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
+export declare function ExtendsRight<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsRight<Inferred, Left, Right>;
+export {};

package/assets/types/typebox/build/type/extends/function.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TAny } from '../types/any.mjs';
+import { type TFunction } from '../types/function.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import * as Result from './result.mjs';
+import { type TExtendsParameters } from './parameters.mjs';
+import { type TExtendsReturnType } from './return_type.mjs';
+export type TExtendsFunction<Inferred extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema, Right extends TSchema> = (Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Right extends TFunction ? TExtendsParameters<Inferred, Parameters, Right['parameters']> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsReturnType<Inferred, ReturnType, Right['returnType']> : Result.TExtendsFalse : Result.TExtendsFalse);
+export declare function ExtendsFunction<Inferred extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema, Right extends TSchema>(inferred: Inferred, parameters: [...Parameters], returnType: ReturnType, right: Right): TExtendsFunction<Inferred, Parameters, ReturnType, Right>;

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

@@ -0,0 +1,2 @@
+export { Extends, type TExtends } from './extends.mjs';
+export * as ExtendsResult from './result.mjs';

package/assets/types/typebox/build/type/extends/inference.d.mts

@@ -0,0 +1,34 @@
+import { type TUnreachable } from '../../system/unreachable/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TArray } from '../types/array.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TTuple } from '../types/tuple.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import { type TUnion } from '../types/union.mjs';
+import { type TInfer } from '../types/infer.mjs';
+import { type TRest } from '../types/rest.mjs';
+import * as Result from './result.mjs';
+export interface TInferable<Name extends string = string, Type extends TSchema = TSchema> {
+    '~kind': 'Inferrable';
+    name: Name;
+    type: Type;
+}
+export declare function Inferrable<Name extends string, Type extends TSchema = TSchema>(name: Name, type: Type): never;
+export declare function IsInferable(value: unknown): value is TInferable;
+export type TTryRestInferable<Type extends TSchema, Result extends TInferable | undefined = (Type extends TRest<infer RestType extends TSchema> ? RestType extends TInfer<infer Name extends string, infer Type extends TSchema> ? Type extends TArray<infer Type extends TSchema> ? TInferable<Name, Type> : Type extends TUnknown ? TInferable<Name, Type> : undefined : TUnreachable : undefined)> = Result;
+export declare function TryRestInferable<Type extends TSchema>(type: Type): TTryRestInferable<Type>;
+export type TTryInferable<Type extends TSchema, Result extends TInferable | undefined = (Type extends TInfer<infer Name extends string, infer Type extends TSchema> ? TInferable<Name, Type> : undefined)> = Result;
+export declare function TryInferable<Type extends TSchema>(type: Type): TTryInferable<Type>;
+type TryInferResults<Rest extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Rest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<{}, Head, Right> extends Result.TExtendsTrueLike ? TryInferResults<Tail, Right, [...Result, Head]> : undefined : Result);
+declare function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right, result?: TSchema[]): TryInferResults<Rest, Right>;
+export type TInferTupleResult<Inferred extends TProperties, Name extends string, Left extends TSchema[], Right extends TSchema, Results extends TSchema[] | undefined = TryInferResults<Left, Right>> = (Results extends [...infer Results extends TSchema[]] ? Result.TExtendsTrue<Memory.TAssign<Inferred, {
+    [_ in Name]: TTuple<Results>;
+}>> : Result.TExtendsFalse);
+export declare function InferTupleResult<Inferred extends TProperties, Name extends string, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, name: Name, left: Left, right: Right): TInferTupleResult<Inferred, Name, Left, Right>;
+export type TInferUnionResult<Inferred extends TProperties, Name extends string, Left extends TSchema[], Right extends TSchema, Results extends TSchema[] | undefined = TryInferResults<Left, Right>> = (Results extends [...infer Results extends TSchema[]] ? Result.TExtendsTrue<Memory.TAssign<Inferred, {
+    [_ in Name]: TUnion<Results>;
+}>> : Result.TExtendsFalse);
+export declare function InferUnionResult<Inferred extends TProperties, Name extends string, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, name: Name, left: Left, right: Right): TInferUnionResult<Inferred, Name, Left, Right>;
+export {};

package/assets/types/typebox/build/type/extends/integer.d.mts

@@ -0,0 +1,8 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TInteger } from '../types/integer.mjs';
+import { type TNumber } from '../types/number.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export type TExtendsInteger<Inferred extends TProperties, Left extends TInteger, Right extends TSchema> = (Right extends TInteger ? Result.TExtendsTrue<Inferred> : Right extends TNumber ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
+export declare function ExtendsInteger<Inferred extends TProperties, Left extends TInteger, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsInteger<Inferred, Left, Right>;

package/assets/types/typebox/build/type/extends/intersect.d.mts

@@ -0,0 +1,6 @@
+import { type TProperties } from '../types/properties.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import { type TEvaluateIntersect } from '../engine/evaluate/index.mjs';
+export type TExtendsIntersect<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Evaluated extends TSchema = TEvaluateIntersect<Left>> = TExtendsLeft<Inferred, Evaluated, Right>;
+export declare function ExtendsIntersect<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsIntersect<Inferred, Left, Right>;

package/assets/types/typebox/build/type/extends/literal.d.mts

@@ -0,0 +1,18 @@
+import { type TUnreachable } from '../../system/unreachable/unreachable.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TLiteral, type TLiteralValue } from '../types/literal.mjs';
+import { type TBigInt } from '../types/bigint.mjs';
+import { type TBoolean } from '../types/boolean.mjs';
+import { type TNumber } from '../types/number.mjs';
+import { type TString } from '../types/string.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+type TExtendsLiteralValue<Inferred extends TProperties, Left extends TLiteralValue, Right extends TLiteralValue> = (Left extends Right ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
+type TExtendsLiteralBigInt<Inferred extends TProperties, Left extends bigint, Right extends TSchema> = (Right extends TLiteral<infer Value extends bigint> ? TExtendsLiteralValue<Inferred, Left, Value> : Right extends TBigInt ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, TLiteral<Left>, Right>);
+type TExtendsLiteralBoolean<Inferred extends TProperties, Left extends boolean, Right extends TSchema> = (Right extends TLiteral<infer Value extends boolean> ? TExtendsLiteralValue<Inferred, Left, Value> : Right extends TBoolean ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, TLiteral<Left>, Right>);
+type TExtendsLiteralNumber<Inferred extends TProperties, Left extends number, Right extends TSchema> = (Right extends TLiteral<infer Value extends number> ? TExtendsLiteralValue<Inferred, Left, Value> : Right extends TNumber ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, TLiteral<Left>, Right>);
+type TExtendsLiteralString<Inferred extends TProperties, Left extends string, Right extends TSchema> = (Right extends TLiteral<infer Value extends string> ? TExtendsLiteralValue<Inferred, Left, Value> : Right extends TString ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, TLiteral<Left>, Right>);
+export type TExtendsLiteral<Inferred extends TProperties, Left extends TLiteral, Right extends TSchema> = (Left extends TLiteral<infer Value extends bigint> ? TExtendsLiteralBigInt<Inferred, Value, Right> : Left extends TLiteral<infer Value extends boolean> ? TExtendsLiteralBoolean<Inferred, Value, Right> : Left extends TLiteral<infer Value extends number> ? TExtendsLiteralNumber<Inferred, Value, Right> : Left extends TLiteral<infer Value extends string> ? TExtendsLiteralString<Inferred, Value, Right> : TUnreachable);
+export declare function ExtendsLiteral<Inferred extends TProperties, Left extends TLiteral, Right extends TSchema>(inferred: TProperties, left: Left, right: Right): TExtendsLiteral<Inferred, Left, Right>;
+export {};