@yaag/cli 0.1.0

package/assets/types/typebox/build/type/script/token/number.d.mts

@@ -0,0 +1,11 @@
+import { type TTrim } from './internal/trim.mjs';
+import { type TOptional } from './internal/optional.mjs';
+import { type THyphen } from './internal/char.mjs';
+import { type TUnsignedNumber } from './unsigned_number.mjs';
+type TTakeSign<Input extends string> = (TOptional<THyphen, Input>);
+type TTakeSignedNumber<Input extends string> = (TTakeSign<Input> extends [infer Sign extends string, infer SignRest extends string] ? TUnsignedNumber<SignRest> extends [infer UnsignedInteger extends string, infer UnsignedIntegerRest extends string] ? [`${Sign}${UnsignedInteger}`, UnsignedIntegerRest] : [] : []);
+/** Matches if next is a signed or unsigned Number */
+export type TNumber<Input extends string> = (TTakeSignedNumber<TTrim<Input>>);
+/** Matches if next is a signed or unsigned Number */
+export declare function Number<Input extends string>(input: Input): TNumber<Input>;
+export {};

package/assets/types/typebox/build/type/script/token/rest.d.mts

@@ -0,0 +1,4 @@
+/** Match remaining characters in the buffer until end. If no characters are in buffer, no match */
+export type TRest<Input extends string> = (Input extends '' ? [] : [Input, '']);
+/** Match remaining characters in the buffer until end. If no characters are in buffer, no match */
+export declare function Rest<Input extends string>(input: Input): TRest<Input>;

package/assets/types/typebox/build/type/script/token/span.d.mts

@@ -0,0 +1,11 @@
+import { type TTrim } from './internal/trim.mjs';
+import { type TNewLine } from './internal/char.mjs';
+import { type TTake } from './internal/take.mjs';
+import { type TUntil } from './until.mjs';
+type TMultiLine<Start extends string, End extends string, Input extends string> = (TTake<[Start], Input> extends [infer _, infer Rest extends string] ? TUntil<[End], Rest> extends [infer Until extends string, infer UntilRest extends string] ? TTake<[End], UntilRest> extends [infer _ extends string, infer Rest extends string] ? [`${Until}`, Rest] : [] : [] : []);
+type TSingleLine<Start extends string, End extends string, Input extends string> = (TTake<[Start], Input> extends [infer _ extends string, infer Rest extends string] ? TUntil<[TNewLine, End], Rest> extends [infer Until extends string, infer UntilRest extends string] ? TTake<[End], UntilRest> extends [infer _ extends string, infer EndRest extends string] ? [`${Until}`, EndRest] : [] : [] : []);
+/** Matches from Start and End capturing everything in-between. Start and End are consumed. */
+export type TSpan<Start extends string, End extends string, MultiLine extends boolean, Input extends string> = (MultiLine extends true ? TMultiLine<Start, End, TTrim<Input>> : TSingleLine<Start, End, TTrim<Input>>);
+/** Matches from Start and End capturing everything in-between. Start and End are consumed. */
+export declare function Span<Start extends string, End extends string, MultiLine extends boolean, Input extends string>(start: Start, end: End, multiLine: MultiLine, input: Input): TSpan<Start, End, MultiLine, Input>;
+export {};

package/assets/types/typebox/build/type/script/token/string.d.mts

@@ -0,0 +1,11 @@
+import { type TTake } from './internal/take.mjs';
+import { type TTrim } from './internal/trim.mjs';
+import { type TSpan } from './span.mjs';
+type TTakeInitial<Quotes extends string[], Input extends string> = (TTake<Quotes, Input>);
+type TTakeSpan<Quote extends string, Input extends string> = (TSpan<Quote, Quote, false, Input>);
+type TTakeString<Quotes extends string[], Input extends string> = (TTakeInitial<Quotes, Input> extends [infer Initial extends string, infer InitialRest extends string] ? TTakeSpan<Initial, `${Initial}${InitialRest}`> : []);
+/** Matches a literal String with the given quotes */
+export type TString<Quotes extends string[], Input extends string> = (TTakeString<Quotes, TTrim<Input>>);
+/** Matches a literal String with the given quotes */
+export declare function String<Quotes extends string[], Input extends string>(quotes: [...Quotes], input: Input): TString<Quotes, Input>;
+export {};

package/assets/types/typebox/build/type/script/token/unsigned_integer.d.mts

@@ -0,0 +1,16 @@
+import { type TTrim } from './internal/trim.mjs';
+import { type TTake } from './internal/take.mjs';
+import { type TMany } from './internal/many.mjs';
+import { type TDigit } from './internal/char.mjs';
+import { type TZero } from './internal/char.mjs';
+import { type TNonZero } from './internal/char.mjs';
+import { type TUnderScore } from './internal/char.mjs';
+type TTakeNonZero<Input extends string> = (TTake<TNonZero, Input>);
+type TAllowedDigits = [...TDigit, TUnderScore];
+type TTakeDigits<Input extends string> = (TMany<TAllowedDigits, [TUnderScore], Input>);
+type TTakeUnsignedInteger<Input extends string> = (TTake<[TZero], Input> extends [infer Zero extends string, infer ZeroRest extends string] ? [Zero, ZeroRest] : TTakeNonZero<Input> extends [infer NonZero extends string, infer NonZeroRest extends string] ? TTakeDigits<NonZeroRest> extends [infer Digits extends string, infer DigitsRest extends string] ? [`${NonZero}${Digits}`, DigitsRest] : [] : []);
+/** Matches if next is a UnsignedInteger */
+export type TUnsignedInteger<Input extends string> = (TTakeUnsignedInteger<TTrim<Input>>);
+/** Matches if next is a UnsignedInteger */
+export declare function UnsignedInteger<Input extends string>(input: Input): TUnsignedInteger<Input>;
+export {};

package/assets/types/typebox/build/type/script/token/unsigned_number.d.mts

@@ -0,0 +1,17 @@
+import { type TTrim } from './internal/trim.mjs';
+import { type TTake } from './internal/take.mjs';
+import { type TMany } from './internal/many.mjs';
+import { type TDigit, type TUnderScore } from './internal/char.mjs';
+import { type TDot } from './internal/char.mjs';
+import { type TUnsignedInteger } from './unsigned_integer.mjs';
+type TAllowedDigits = [...TDigit, TUnderScore];
+type TIsLeadingDot<Input extends string> = (TTake<[TDot], Input> extends [string, string] ? true : false);
+type TTakeFractional<Input extends string> = (TMany<TAllowedDigits, [TUnderScore], Input> extends [infer Digits extends string, infer DigitsRest extends string] ? Digits extends '' ? [] : [Digits, DigitsRest] : []);
+type TLeadingDot<Input extends string> = (TTake<[TDot], Input> extends [infer Dot extends string, infer DotRest extends string] ? TTakeFractional<DotRest> extends [infer Fractional extends string, infer FractionalRest extends string] ? [`0${Dot}${Fractional}`, FractionalRest] : [] : []);
+type TLeadingInteger<Input extends string> = (TUnsignedInteger<Input> extends [infer Integer extends string, infer IntegerRest extends string] ? TTake<[TDot], IntegerRest> extends [infer Dot extends string, infer DotRest extends string] ? TTakeFractional<DotRest> extends [infer Fractional extends string, infer FractionalRest extends string] ? [`${Integer}${Dot}${Fractional}`, FractionalRest] : [`${Integer}`, DotRest] : [`${Integer}`, IntegerRest] : []);
+type TTakeUnsignedNumber<Input extends string> = (TIsLeadingDot<Input> extends true ? TLeadingDot<Input> : TLeadingInteger<Input>);
+/** Matches if next is a UnsignedNumber */
+export type TUnsignedNumber<Input extends string> = (TTakeUnsignedNumber<TTrim<Input>>);
+/** Matches if next is a UnsignedNumber */
+export declare function UnsignedNumber<Input extends string>(input: Input): TUnsignedNumber<Input>;
+export {};

package/assets/types/typebox/build/type/script/token/until.d.mts

@@ -0,0 +1,7 @@
+type TTakeOne<Input extends string> = (Input extends `${infer Left extends string}${infer Right extends string}` ? [Left, Right] : []);
+type TIsInputMatchSentinal<End extends string[], Input extends string> = (End extends [infer Left extends string, ...infer Right extends string[]] ? Input extends `${Left}${string}` ? true : TIsInputMatchSentinal<Right, Input> : false);
+/** Match Input until but not including End. No match if End not found. */
+export type TUntil<End extends string[], Input extends string, Result extends string = ''> = (TTakeOne<Input> extends [infer One extends string, infer Rest extends string] ? TIsInputMatchSentinal<End, Input> extends true ? [Result, Input] : TUntil<End, Rest, `${Result}${One}`> : []);
+/** Match Input until but not including End. No match if End not found. */
+export declare function Until<End extends string[], Input extends string>(end: [...End], input: Input, result?: string): TUntil<End, Input>;
+export {};

package/assets/types/typebox/build/type/script/token/until_1.d.mts

@@ -0,0 +1,5 @@
+import { type TUntil } from './until.mjs';
+/** Match Input until but not including End. No match if End not found or match is zero-length. */
+export type TUntil_1<End extends string[], Input extends string> = (TUntil<End, Input> extends [infer Until extends string, infer UntilRest extends string] ? Until extends '' ? [] : [Until, UntilRest] : []);
+/** Match Input until but not including End. No match if End not found or match is zero-length. */
+export declare function Until_1<End extends string[], Input extends string>(end: [...End], input: Input): TUntil_1<End, Input>;

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

@@ -0,0 +1,30 @@
+import { type StaticDirection, type StaticDecode, type StaticType } from './static.mjs';
+import { type TSchema } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticCodec<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Decoded extends unknown> = (Direction extends 'Decode' ? Decoded : StaticType<Stack, Direction, Context, This, Omit<Type, '~codec'>>);
+export type TDecodeCallback<Encoded extends unknown, Decoded = unknown> = (input: Encoded) => Decoded;
+export type TEncodeCallback<Encoded extends unknown, Decoded = unknown> = (input: Decoded) => Encoded;
+export type TCodec<Type extends TSchema = TSchema, Decoded extends unknown = unknown> = Type & {
+    '~codec': {
+        encode: TDecodeCallback<unknown, Decoded>;
+        decode: TEncodeCallback<unknown, Decoded>;
+    };
+};
+export declare class EncodeBuilder<Type extends TSchema, Encoded extends unknown, Decoded extends unknown> {
+    private readonly type;
+    private readonly decode;
+    constructor(type: Type, decode: globalThis.Function);
+    Encode(callback: TEncodeCallback<Encoded, Decoded>): TCodec<Type, Decoded>;
+}
+export declare class DecodeBuilder<Type extends TSchema, Encoded extends unknown> {
+    private readonly type;
+    constructor(type: Type);
+    Decode<Callback extends TDecodeCallback<Encoded, unknown>>(callback: Callback): EncodeBuilder<Type, Encoded, ReturnType<Callback>>;
+}
+/** Creates a bi-directional Codec. Codec functions are called on Value.Decode and Value.Encode. */
+export declare function Codec<Type extends TSchema>(type: Type): DecodeBuilder<Type, StaticDecode<Type>>;
+/** Createsa  uni-directional Codec with Decode only. The Decode function is called on Value.Decode */
+export declare function Decode<Type extends TSchema, Callback extends TDecodeCallback<StaticDecode<Type>, unknown>>(type: Type, callback: Callback): TCodec<Type, ReturnType<Callback>>;
+/** Creates a uni-directional Codec with Encode only. The Encode function is called on Value.Encode */
+export declare function Encode<Type extends TSchema>(type: Type, callback: TEncodeCallback<StaticDecode<Type>, unknown>): TCodec<Type, unknown>;
+export declare function IsCodec(value: unknown): value is TCodec;

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

@@ -0,0 +1,9 @@
+import { type TSchema } from './schema.mjs';
+import { type TAddImmutable } from '../action/_add_immutable.mjs';
+export type TImmutable<Type extends TSchema = TSchema> = (Type & {
+    '~immutable': true;
+});
+/** Applies an Immutable modifier to the given type. */
+export declare function Immutable<Type extends TSchema>(type: Type): TAddImmutable<Type>;
+/** Returns true if the given value is a TImmutable */
+export declare function IsImmutable(value: unknown): value is TImmutable<TSchema>;

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

@@ -0,0 +1,9 @@
+import { type TSchema } from './schema.mjs';
+import { type TAddOptional } from '../action/_add_optional.mjs';
+export type TOptional<Type extends TSchema = TSchema> = (Type & {
+    '~optional': true;
+});
+/** Applies an Optional modifier to the given type. */
+export declare function Optional<Type extends TSchema>(type: Type): TAddOptional<Type>;
+/** Returns true if the given value is TOptional */
+export declare function IsOptional(value: unknown): value is TOptional<TSchema>;

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

@@ -0,0 +1,9 @@
+import { type TSchema } from './schema.mjs';
+import { type TAddReadonly } from '../action/_add_readonly.mjs';
+export type TReadonly<Type extends TSchema = TSchema> = (Type & {
+    '~readonly': true;
+});
+/** Applies an Readonly property modifier to the given type. */
+export declare function Readonly<Type extends TSchema>(type: Type): TAddReadonly<Type>;
+/** Returns true if the given value is a TReadonly */
+export declare function IsReadonly(value: unknown): value is TReadonly<TSchema>;

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

@@ -0,0 +1,24 @@
+import { type TSchema } from './schema.mjs';
+import { type Static } from './static.mjs';
+/** Applies a Refine check to the given type. */
+export type TRefineAdd<Type extends TSchema = TSchema> = ('~refine' extends keyof Type ? Type : TRefine<Type>);
+/** Applies a Refine check to the given type. */
+export declare function RefineAdd<Type extends TSchema>(type: Type, refinement: TRefinement<Type>): TRefineAdd<Type>;
+/** Represents a type with embedded Refine check. */
+export type TRefine<Type extends TSchema = TSchema> = (Type & {
+    '~refine': TRefinement<unknown>[];
+});
+export type TRefineCheckCallback<Value extends unknown = unknown> = (value: Value) => boolean;
+export type TRefineErrorCallback<Value extends unknown = unknown> = (value: Value) => string;
+export interface TRefinement<Value extends unknown = unknown> {
+    check: TRefineCheckCallback<Value>;
+    error: TRefineErrorCallback<Value>;
+}
+/** Refines a type with an explicit check */
+export declare function Refine<Type extends TSchema, Value = Static<Type>>(type: Type, check: TRefineCheckCallback<Value>, error: TRefineErrorCallback<Value>): TRefineAdd<Type>;
+/** Refines a type with an explicit check */
+export declare function Refine<Type extends TSchema, Value = Static<Type>>(type: Type, check: TRefineCheckCallback<Value>): TRefineAdd<Type>;
+/** Returns true if the given value is a TRefinement. */
+export declare function IsRefinement(value: unknown): value is TRefinement;
+/** Returns true if the given value is a TRefine. */
+export declare function IsRefine(value: unknown): value is TRefine;

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

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+export type StaticAny = any;
+/** Represents a Any type. */
+export interface TAny extends TSchema {
+    '~kind': 'Any';
+}
+/** Creates a Any type. */
+export declare function Any(options?: TSchemaOptions): TAny;
+/** Returns true if the given value is a TAny. */
+export declare function IsAny(value: unknown): value is TAny;

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

@@ -0,0 +1,18 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TArrayOptions } from './schema.mjs';
+import { type TImmutable } from './_immutable.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticArray<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Array extends TSchema, Item extends TSchema, Result extends readonly unknown[] = Array extends TImmutable ? readonly StaticType<Stack, Direction, Context, This, Item>[] : StaticType<Stack, Direction, Context, This, Item>[]> = Result;
+/** Represents an Array type. */
+export interface TArray<Type extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Array';
+    type: 'array';
+    items: Type;
+}
+/** Creates an Array type. */
+export declare function _Array_<Type extends TSchema>(items: Type, options?: TArrayOptions): TArray<Type>;
+export { _Array_ as Array };
+/** Returns true if the given value is a TArray. */
+export declare function IsArray(value: unknown): value is TArray;
+/** Extracts options from a TArray. */
+export declare function ArrayOptions(type: TArray): TArrayOptions;

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TNumberOptions } from './schema.mjs';
+export declare const BigIntPattern = "-?(?:0|[1-9][0-9]*)n";
+export type StaticBigInt = bigint;
+/** Represents a BigInt type. */
+export interface TBigInt extends TSchema {
+    '~kind': 'BigInt';
+    type: 'bigint';
+}
+/** Creates a BigInt type. */
+export declare function BigInt(options?: TNumberOptions): TBigInt;
+/** Returns true if the given value is a TBigInt. */
+export declare function IsBigInt(value: unknown): value is TBigInt;

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+export type StaticBoolean = boolean;
+/** Represents a Boolean type. */
+export interface TBoolean extends TSchema {
+    '~kind': 'Boolean';
+    type: 'boolean';
+}
+/** Creates a Boolean type. */
+export declare function Boolean(options?: TSchemaOptions): TBoolean;
+/** Returns true if the given value is a TBoolean. */
+export declare function IsBoolean(value: unknown): value is TBoolean;

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

@@ -0,0 +1,16 @@
+import { type TSchema } from './schema.mjs';
+import { type TCallInstantiate } from '../engine/call/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
+/** Represents a deferred generic Call */
+export interface TCall<Target extends TSchema = TSchema, Arguments extends TSchema[] = TSchema[]> extends TSchema {
+    '~kind': 'Call';
+    type: 'call';
+    target: Target;
+    arguments: Arguments;
+}
+export type TCallConstruct<Target extends TSchema, Arguments extends TSchema[], Result extends TSchema = TCall<Target, Arguments>> = Result;
+export declare function CallConstruct<Target extends TSchema, Arguments extends TSchema[]>(target: Target, arguments_: [...Arguments]): TCallConstruct<Target, Arguments>;
+/** Creates a Call type. */
+export declare function Call<Target extends TSchema, Arguments extends TSchema[]>(target: Target, arguments_: [...Arguments]): TCallInstantiate<{}, TState<[], []>, Target, Arguments>;
+/** Returns true if the given type is a TCall. */
+export declare function IsCall(value: unknown): value is TCall;

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

@@ -0,0 +1,18 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type StaticInstantiatedParameters } from './function.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticConstructor<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, StaticParameters extends unknown[] = StaticInstantiatedParameters<Stack, Direction, Context, This, Parameters>, StaticReturnType extends unknown = StaticType<Stack, Direction, Context, This, InstanceType>, Result = new (...args: StaticParameters) => StaticReturnType> = Result;
+/** Represents a Constructor type. */
+export interface TConstructor<Parameters extends TSchema[] = TSchema[], InstanceType extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Constructor';
+    type: 'constructor';
+    parameters: Parameters;
+    instanceType: InstanceType;
+}
+/** Creates a Constructor type. */
+export declare function Constructor<Parameters extends TSchema[], InstanceType extends TSchema>(parameters: [...Parameters], instanceType: InstanceType, options?: TSchemaOptions): TConstructor<Parameters, InstanceType>;
+/** Returns true if the given value is a TConstructor. */
+export declare function IsConstructor(value: unknown): value is TConstructor;
+/** Extracts options from a TConstructor. */
+export declare function ConstructorOptions(type: TConstructor): TSchemaOptions;

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

@@ -0,0 +1,16 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticCyclic<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Defs extends TProperties, Ref extends string, Result extends unknown = (Ref extends keyof Defs ? StaticType<[...Stack, Ref], Direction, Defs, This, Defs[Ref]> : never)> = Result;
+/** Represents a Cyclic type. */
+export interface TCyclic<Defs extends TProperties = TProperties, Ref extends string = string> extends TSchema {
+    '~kind': 'Cyclic';
+    $defs: Defs;
+    $ref: Ref;
+}
+/** Creates a Cyclic type. */
+export declare function Cyclic<Defs extends TProperties, Ref extends string>($defs: Defs, $ref: Ref, options?: TSchemaOptions): TCyclic<Defs, Ref>;
+/** Returns true if the given value is a TCyclic. */
+export declare function IsCyclic(value: unknown): value is TCyclic;
+/** Extracts options from a TCyclic. */
+export declare function CyclicOptions(type: TCyclic): TSchemaOptions;

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

@@ -0,0 +1,13 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+/** Represents a deferred action. */
+export interface TDeferred<Action extends string = string, Types extends TSchema[] = TSchema[]> extends TSchema {
+    '~kind': 'Deferred';
+    type: 'deferred';
+    action: Action;
+    parameters: Types;
+    options: TSchemaOptions;
+}
+/** Creates a Deferred action. */
+export declare function Deferred<Action extends string, Types extends TSchema[]>(action: Action, parameters: [...Types], options: TSchemaOptions): TDeferred<Action, Types>;
+/** Returns true if the given value is a TDeferred. */
+export declare function IsDeferred(value: unknown): value is TDeferred;

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

@@ -0,0 +1,17 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticDependent<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, If extends TSchema, Then extends TSchema, Else extends TSchema, StaticIf extends unknown = StaticType<Stack, Direction, Context, This, If>, StaticThen extends unknown = StaticType<Stack, Direction, Context, This, Then>, StaticElse extends unknown = StaticType<Stack, Direction, Context, This, Else>, Result extends unknown = (StaticIf & StaticThen) | Exclude<StaticElse, StaticIf>> = Result;
+/** Represents a Dependent Type */
+export interface TDependent<If extends TSchema = TSchema, Then extends TSchema = TSchema, Else extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Dependent';
+    if: If;
+    then: Then;
+    else: Else;
+}
+/** Creates a Dependent type */
+export declare function Dependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else, options?: TSchemaOptions): TDependent<If, Then, Else>;
+/** Returns true if the given value is TDependent. */
+export declare function IsDependent(value: unknown): value is TDependent;
+/** Extracts options from a IsDependent. */
+export declare function DependentOptions(type: TDependent): TSchemaOptions;

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

@@ -0,0 +1,18 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TTypeScriptEnumLike } from '../engine/enum/typescript_enum_to_enum_values.mjs';
+import { type TTypeScriptEnumToEnumValues } from '../engine/enum/typescript_enum_to_enum_values.mjs';
+export type StaticEnum<Values extends TEnumValue[]> = (Values[number]);
+export type TEnumValue = string | number;
+/** Returns true if the given value is a EnumValue */
+export declare function IsEnumValue(value: unknown): value is TEnumValue;
+/** Represents an Enum type. */
+export interface TEnum<Values extends TEnumValue[] = TEnumValue[]> extends TSchema {
+    '~kind': 'Enum';
+    enum: Values;
+}
+/** Creates an Enum type. */
+export declare function Enum<Values extends TEnumValue[]>(values: readonly [...Values], options?: TSchemaOptions): TEnum<Values>;
+/** Creates an Enum type from a TypeScript enum declaration. */
+export declare function Enum<Enum extends TTypeScriptEnumLike>(value: Enum, options?: TSchemaOptions): TEnum<TTypeScriptEnumToEnumValues<Enum>>;
+/** Returns true if the given value is a TEnum. */
+export declare function IsEnum(value: unknown): value is TEnum;

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

@@ -0,0 +1,21 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+import { type TTuple } from './tuple.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+export type StaticInstantiatedParameters<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Parameters extends TSchema[], Evaluated extends TSchema = TInstantiate<Context, TTuple<Parameters>>, Static extends unknown = StaticType<Stack, Direction, Context, This, Evaluated>, Result extends unknown[] = Static extends unknown[] ? Static : []> = Result;
+export type StaticFunction<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema, StaticParameters extends unknown[] = StaticInstantiatedParameters<Stack, Direction, Context, This, Parameters>, StaticReturnType extends unknown = StaticType<Stack, Direction, Context, This, ReturnType>, Result = (...args: StaticParameters) => StaticReturnType> = Result;
+/** Represents a Function type. */
+export interface TFunction<Parameters extends TSchema[] = TSchema[], ReturnType extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Function';
+    type: 'function';
+    parameters: Parameters;
+    returnType: ReturnType;
+}
+/** Creates a Function type. */
+export declare function _Function_<Parameters extends TSchema[], ReturnType extends TSchema>(parameters: [...Parameters], returnType: ReturnType, options?: TSchemaOptions): TFunction<Parameters, ReturnType>;
+export { _Function_ as Function };
+/** Returns true if the given value is TFunction. */
+export declare function IsFunction(value: unknown): value is TFunction;
+/** Extracts options from a TFunction. */
+export declare function FunctionOptions(type: TFunction): TSchemaOptions;

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

@@ -0,0 +1,13 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TParameter } from './parameter.mjs';
+/** Represents a callable Generic type. */
+export interface TGeneric<Parameters extends TParameter[] = TParameter[], Expression extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Generic';
+    type: 'generic';
+    parameters: Parameters;
+    expression: Expression;
+}
+/** Creates a Generic type. */
+export declare function Generic<Parameters extends TParameter[], Expression extends TSchema>(parameters: [...Parameters], expression: Expression): TGeneric<Parameters, Expression>;
+/** Returns true if the given value is a TGeneric. */
+export declare function IsGeneric(value: unknown): value is TGeneric;

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

@@ -0,0 +1,11 @@
+import { type TSchema } from '../types/schema.mjs';
+/** Represents a Identifier. */
+export interface TIdentifier<Name extends string = string> extends TSchema {
+    '~kind': 'Identifier';
+    type: 'identifier';
+    name: Name;
+}
+/** Creates an Identifier. */
+export declare function Identifier<Name extends string>(name: Name): TIdentifier<Name>;
+/** Returns true if the given value is a TIdentifier. */
+export declare function IsIdentifier(value: unknown): value is TIdentifier;

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

@@ -0,0 +1,45 @@
+export * from './_codec.mjs';
+export * from './_immutable.mjs';
+export * from './_optional.mjs';
+export * from './_readonly.mjs';
+export * from './_refine.mjs';
+export * from './any.mjs';
+export * from './array.mjs';
+export * from './bigint.mjs';
+export * from './boolean.mjs';
+export * from './call.mjs';
+export * from './constructor.mjs';
+export * from './cyclic.mjs';
+export * from './deferred.mjs';
+export * from './enum.mjs';
+export * from './function.mjs';
+export * from './generic.mjs';
+export * from './identifier.mjs';
+export * from './dependent.mjs';
+export * from './infer.mjs';
+export * from './integer.mjs';
+export * from './intersect.mjs';
+export * from './literal.mjs';
+export * from './never.mjs';
+export * from './null.mjs';
+export * from './number.mjs';
+export * from './unknown.mjs';
+export * from './symbol.mjs';
+export * from './object.mjs';
+export * from './parameter.mjs';
+export * from './properties.mjs';
+export * from './record.mjs';
+export * from './ref.mjs';
+export * from './rest.mjs';
+export * from './schema.mjs';
+export * from './static.mjs';
+export * from './string.mjs';
+export * from './symbol.mjs';
+export * from './template_literal.mjs';
+export * from './this.mjs';
+export * from './tuple.mjs';
+export * from './undefined.mjs';
+export * from './union.mjs';
+export * from './unknown.mjs';
+export * from './unsafe.mjs';
+export * from './void.mjs';

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

@@ -0,0 +1,15 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+/** Represents an Infer instruction. */
+export interface TInfer<Name extends string = string, Extends extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Infer';
+    type: 'infer';
+    name: Name;
+    extends: Extends;
+}
+/** Creates an Infer instruction. */
+export declare function Infer<Name extends string, Extends extends TSchema>(name: Name, extends_: Extends): TInfer<Name, Extends>;
+/** Creates an Infer instruction. */
+export declare function Infer<Name extends string>(name: Name): TInfer<Name, TUnknown>;
+/** Returns true if the given value is TInfer. */
+export declare function IsInfer(value: unknown): value is TInfer;

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TNumberOptions } from './schema.mjs';
+export declare const IntegerPattern = "-?(?:0|[1-9][0-9]*)";
+export type StaticInteger = number;
+/** Represents an integer type. */
+export interface TInteger extends TSchema {
+    '~kind': 'Integer';
+    type: 'integer';
+}
+/** Creates a Integer type. */
+export declare function Integer(options?: TNumberOptions): TInteger;
+/** Returns true if the given value is TInteger. */
+export declare function IsInteger(value: unknown): value is TInteger;

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

@@ -0,0 +1,15 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TIntersectOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticIntersect<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Types extends TSchema[], Result extends unknown = unknown> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? StaticIntersect<Stack, Direction, Context, This, Right, Result & StaticType<Stack, Direction, Context, This, Left>> : Result);
+/** Represents a logical Intersect type. */
+export interface TIntersect<Types extends TSchema[] = TSchema[]> extends TSchema {
+    '~kind': 'Intersect';
+    allOf: Types;
+}
+/** Creates a Intersect type. */
+export declare function Intersect<Types extends TSchema[]>(types: [...Types], options?: TIntersectOptions): TIntersect<Types>;
+/** Returns true if the given value is TIntersect. */
+export declare function IsIntersect(value: unknown): value is TIntersect;
+/** Extracts options from a TIntersect. */
+export declare function IntersectOptions(type: TIntersect): TIntersectOptions;

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

@@ -0,0 +1,31 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+export declare class InvalidLiteralValue extends Error {
+    readonly cause: {
+        value: unknown;
+    };
+    constructor(value: unknown);
+}
+export type StaticLiteral<Value extends TLiteralValue> = (Value);
+export type TLiteralTypeName<Value extends TLiteralValue> = (Value extends bigint ? 'bigint' : Value extends boolean ? 'boolean' : Value extends number ? 'number' : Value extends string ? 'string' : never);
+export declare function LiteralTypeName<Value extends TLiteralValue>(value: Value): TLiteralTypeName<Value>;
+export type TLiteralValue = string | number | boolean | bigint;
+/** Represents a Literal type. */
+export interface TLiteral<Value extends TLiteralValue = TLiteralValue> extends TSchema {
+    '~kind': 'Literal';
+    type: TLiteralTypeName<Value>;
+    const: Value;
+}
+/** Creates a Literal type. */
+export declare function Literal<Value extends TLiteralValue>(value: Value, options?: TSchemaOptions): TLiteral<Value>;
+/** Returns true if the given value is a TLiteralValue. */
+export declare function IsLiteralValue(value: unknown): value is TLiteralValue;
+/** Returns true if the given value is TLiteral<bigint>. */
+export declare function IsLiteralBigInt(value: unknown): value is TLiteral<bigint>;
+/** Returns true if the given value is TLiteral<boolean>. */
+export declare function IsLiteralBoolean(value: unknown): value is TLiteral<boolean>;
+/** Returns true if the given value is TLiteral<number>. */
+export declare function IsLiteralNumber(value: unknown): value is TLiteral<number>;
+/** Returns true if the given value is TLiteral<string>. */
+export declare function IsLiteralString(value: unknown): value is TLiteral<string>;
+/** Returns true if the given value is TLiteral. */
+export declare function IsLiteral(value: unknown): value is TLiteral;

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+export declare const NeverPattern = "(?!)";
+export type StaticNever = never;
+/** Represents a Never type. */
+export interface TNever extends TSchema {
+    '~kind': 'Never';
+    not: {};
+}
+/** Creates a Never type. */
+export declare function Never(options?: TSchemaOptions): TNever;
+/** Returns true if the given value is TNever. */
+export declare function IsNever(value: unknown): value is TNever;

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+export type StaticNull = null;
+/** Represents a Null type. */
+export interface TNull extends TSchema {
+    '~kind': 'Null';
+    type: 'null';
+}
+/** Creates a Null type. */
+export declare function Null(options?: TSchemaOptions): TNull;
+/** Returns true if the given value is TNull. */
+export declare function IsNull(value: unknown): value is TNull;

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TNumberOptions } from './schema.mjs';
+export declare const NumberPattern = "-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?";
+export type StaticNumber = number;
+/** Represents a Number type. */
+export interface TNumber extends TSchema {
+    '~kind': 'Number';
+    type: 'number';
+}
+/** Creates a Number type. */
+export declare function Number(options?: TNumberOptions): TNumber;
+/** Returns true if the given value is a TNumber. */
+export declare function IsNumber(value: unknown): value is TNumber;

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

@@ -0,0 +1,18 @@
+import { type StaticDirection } from './static.mjs';
+import { type TSchema, type TObjectOptions } from './schema.mjs';
+import { type TProperties, type TRequiredArray, type StaticProperties } from './properties.mjs';
+export type StaticObject<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, _This extends TProperties, Properties extends TProperties, Result = keyof Properties extends never ? object : StaticProperties<Stack, Direction, Context, Properties, Properties>> = Result;
+/** Represents an Object type. */
+export interface TObject<Properties extends TProperties = TProperties> extends TSchema {
+    '~kind': 'Object';
+    type: 'object';
+    properties: Properties;
+    required: TRequiredArray<Properties>;
+}
+/** Creates an Object type. */
+export declare function _Object_<Properties extends TProperties>(properties: Properties, options?: TObjectOptions): TObject<Properties>;
+export { _Object_ as Object };
+/** Returns true if the given value is TObject. */
+export declare function IsObject(value: unknown): value is TObject;
+/** Extracts options from a TObject. */
+export declare function ObjectOptions(type: TObject): TObjectOptions;

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

@@ -0,0 +1,17 @@
+import { type TSchema } from './schema.mjs';
+import { type TUnknown } from './unknown.mjs';
+/** Represents a Generic parameter. */
+export interface TParameter<Name extends string = string, Extends extends TSchema = TSchema, Equals extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Parameter';
+    name: Name;
+    extends: Extends;
+    equals: Equals;
+}
+/** Creates a Parameter type. */
+export declare function Parameter<Name extends string, Extends extends TSchema, Equals extends TSchema>(name: Name, extends_: Extends, equals: Equals): TParameter<Name, Extends, Equals>;
+/** Creates a Parameter type. */
+export declare function Parameter<Name extends string, Extends extends TSchema, Equals extends TSchema>(name: Name, extends_: Extends): TParameter<Name, Extends, Extends>;
+/** Creates a Parameter type. */
+export declare function Parameter<Name extends string>(name: Name): TParameter<Name, TUnknown, TUnknown>;
+/** Returns true if the given value is TParameter. */
+export declare function IsParameter(value: unknown): value is TParameter;