@m1212e/rumble 0.16.12 → 0.16.16

package/out/index.d.cts

@@ -1,19 +1,21 @@
+/// <reference types="urlpattern-polyfill" />
 import { GraphQLError } from "graphql";
 import { MySqlDatabase } from "drizzle-orm/mysql-core";
 import * as drizzle_orm_pg_core0 from "drizzle-orm/pg-core";
-import { PgDatabase } from "drizzle-orm/pg-core";
+import { PgAsyncDatabase } from "drizzle-orm/pg-core";
 import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
 import * as drizzle_orm0 from "drizzle-orm";
 import * as graphql_yoga0 from "graphql-yoga";
 import { YogaServerOptions, createPubSub } from "graphql-yoga";
-import * as fets0 from "fets";
+import { IncomingMessage, RequestListener, ServerResponse } from "node:http";
+import { Http2ServerRequest, Http2ServerResponse } from "node:http2";
+import { Socket } from "node:net";
 import * as _pothos_plugin_drizzle0 from "@pothos/plugin-drizzle";
 import * as _pothos_core0 from "@pothos/core";
 import SchemaBuilder from "@pothos/core";
 import { useSofa } from "sofa-api";
 
 //#region lib/helpers/asserts.d.ts
-
 /**
  *
  * Helper function to map a drizzle findFirst query result,
@@ -44,7 +46,7 @@ import { useSofa } from "sofa-api";
  });
  * ```
  */
-declare const assertFindFirstExists: <T$1>(value: T$1 | undefined) => T$1;
+declare const assertFindFirstExists: <T>(value: T | undefined) => T;
 /**
  *
  * Helper function to map a drizzle findFirst query result,
@@ -84,7 +86,7 @@ declare const assertFindFirstExists: <T$1>(value: T$1 | undefined) => T$1;
   });
  * ```
  */
-declare const assertFirstEntryExists: <T$1>(value: T$1[]) => T$1;
+declare const assertFirstEntryExists: <T>(value: T[]) => T;
 //#endregion
 //#region lib/helpers/mapNullFieldsToUndefined.d.ts
 /**
@@ -145,10 +147,10 @@ declare const assertFirstEntryExists: <T$1>(value: T$1[]) => T$1;
  *
  * ```
  */
-declare function mapNullFieldsToUndefined<T$1 extends object>(obj: T$1): { [K in keyof T$1]: T$1[K] extends null ? undefined : Exclude<T$1[K], null> };
+declare function mapNullFieldsToUndefined<T extends object>(obj: T): { [K in keyof T]: T[K] extends null ? undefined : Exclude<T[K], null> };
 //#endregion
 //#region lib/types/drizzleInstanceType.d.ts
-type DrizzleInstance = PgDatabase<any, any, any, any> | BaseSQLiteDatabase<any, any, any, any> | MySqlDatabase<any, any, any, any>;
+type DrizzleInstance = PgAsyncDatabase<any, any, any, any> | BaseSQLiteDatabase<any, any, any, any> | MySqlDatabase<any, any, any, any>;
 /**
  * Type representing the query function of a Drizzle instance.
  */
@@ -163,10 +165,10 @@ type DrizzleQueryFunctionInput<DB extends DrizzleInstance, QueryField extends ke
 type DrizzleTableValueType<DB extends DrizzleInstance, QueryField extends keyof DrizzleQueryFunction<DB>> = NonNullable<Awaited<ReturnType<DrizzleQueryFunction<DB>[QueryField]["findFirst"]>>>;
 //#endregion
 //#region lib/runtimeFiltersPlugin/filterTypes.d.ts
-type Filter<Context, T$1> = (p: {
+type Filter<Context, T> = (p: {
   context: Context;
-  entities: T$1[];
-}) => T$1[] | Promise<T$1[]>;
+  entities: T[];
+}) => T[] | Promise<T[]>;
 //#endregion
 //#region lib/args/whereArgsImplementer.d.ts
 type NumberWhereInputArgument = {
@@ -236,60 +238,4047 @@ type DateWhereInputArgument = {
   NOT?: DateWhereInputArgument;
 };
 //#endregion
-//#region lib/types/rumbleInput.d.ts
-type CustomRumblePothosConfig = Omit<ConstructorParameters<typeof SchemaBuilder>[0], "smartSubscriptions" | "drizzle">;
-type RumbleInput<UserContext extends Record<string, any>, DB extends DrizzleInstance, RequestEvent extends Record<string, any>, Action extends string, PothosConfig extends CustomRumblePothosConfig> = {
+//#region node_modules/hotscript/dist/internals/helpers.d.ts
+type Equal$1<a, b> = (<T>() => T extends a ? 1 : 2) extends (<T>() => T extends b ? 1 : 2) ? true : false;
+/**
+ * HACK:
+ * Special function for never because `Equal<T, never>` doesn't
+ * work when called deep in the call stack (for a reason I don't understand
+ * probably a TS bug).
+ */
+type IsNever$1<T> = [T] extends [never] ? true : false;
+type Not$2<a extends boolean> = a extends true ? false : true;
+/**
+ * trick to combine multiple unions of objects into a single object
+ * only works with objects not primitives
+ * @param union - Union of objects
+ * @returns Intersection of objects
+ */
+type UnionToIntersection<union> = (union extends any ? (k: union) => void : never) extends ((k: infer intersection) => void) ? intersection : never;
+type Prettify$1<T> = { [K in keyof T]: T[K] } | never;
+declare namespace Iterator$1 {
+  type Get<it extends readonly any[]> = it["length"];
+  type Iterator<n extends number, it extends any[] = []> = it["length"] extends n ? it : Iterator$1<n, [any, ...it]>;
+  type Next<it extends any[]> = [any, ...it];
+  type Prev<it extends any[]> = it extends readonly [any, ...infer tail] ? tail : [];
+}
+type UppercaseLetter = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z";
+type KebabToCamel<str> = str extends `${infer first}-${infer rest}` ? `${first}${KebabToCamel<Capitalize<rest>>}` : str;
+type SnakeToCamel<str> = str extends `${infer first}_${infer rest}` ? `${first}${SnakeToCamel<Capitalize<rest>>}` : str;
+/**
+ * Converts string casing from snake_case or kebab-case to camelCase.
+ */
+type CamelCase<str> = KebabToCamel<SnakeToCamel<str>>;
+/**
+ * Converts string casing from camelCase or kebab-case to snake_case.
+ */
+type SnakeCase<str, output extends string = ""> = str extends `${infer first}${infer rest}` ? first extends UppercaseLetter ? output extends "" ? SnakeCase<rest, Lowercase<first>> : SnakeCase<rest, `${output}_${Lowercase<first>}`> : first extends "-" ? SnakeCase<rest, `${output}_`> : SnakeCase<rest, `${output}${first}`> : output extends "" ? str : output;
+/**
+ * Converts string casing from camelCase or snake_case to kebab-case.
+ */
+type KebabCase<str, output extends string = ""> = str extends `${infer first}${infer rest}` ? first extends UppercaseLetter ? output extends "" ? KebabCase<rest, Lowercase<first>> : KebabCase<rest, `${output}-${Lowercase<first>}`> : first extends "_" ? KebabCase<rest, `${output}-`> : KebabCase<rest, `${output}${first}`> : output extends "" ? str : output;
+type IsTuple<a extends readonly any[]> = a extends readonly [] | readonly [any, ...any] | readonly [...any, any] ? true : false;
+type IsArrayStrict<a> = a extends readonly any[] ? Not$2<IsTuple<a>> : false;
+/**
+ * get last element of union
+ * @param Union - Union of any types
+ * @returns Last element of union
+ */
+type GetUnionLast<Union> = UnionToIntersection<Union extends any ? () => Union : never> extends (() => infer Last) ? Last : never;
+/**
+ * Convert union to tuple
+ * @param Union - Union of any types, can be union of complex, composed or primitive types
+ * @returns Tuple of each elements in the union
+ */
+type UnionToTuple<Union, Tuple extends unknown[] = []> = [Union] extends [never] ? Tuple : UnionToTuple<Exclude<Union, GetUnionLast<Union>>, [GetUnionLast<Union>, ...Tuple]>;
+/**
+ * Split string into a tuple, using a simple string literal separator
+ * @description - This is a simple implementation of split, it does not support multiple separators
+ *  A more complete implementation is built on top of this one
+ * @param Str - String to split
+ * @param Sep - Separator, must be a string literal not a union of string literals
+ * @returns Tuple of strings
+ */
+type Split$2<Str, Sep extends string, Acc extends string[] = []> = Str extends "" ? Acc : Str extends `${infer T}${Sep}${infer U}` ? Split$2<U, Sep, [...Acc, T]> : [...Acc, Str];
+type Stringifiable = string | number | boolean | bigint | null | undefined;
+type Primitive$1 = string | number | boolean | bigint | null | undefined | symbol;
+type Head<xs> = xs extends [infer first, ...any] ? first : never;
+//#endregion
+//#region node_modules/hotscript/dist/internals/core/impl/MergeArgs.d.ts
+type ExcludePlaceholders<xs, output extends any[] = []> = xs extends [infer first, ...infer rest] ? Equal$1<first, _> extends true ? ExcludePlaceholders<rest, output> : ExcludePlaceholders<rest, [...output, first]> : output;
+type MergeArgsRec<pipedArgs extends any[], partialArgs extends any[], output extends any[] = []> = partialArgs extends [infer partialFirst, ...infer partialRest] ? IsNever$1<partialFirst> extends true ? MergeArgsRec<pipedArgs, partialRest, [...output, partialFirst]> : [partialFirst] extends [_] ? pipedArgs extends [infer pipedFirst, ...infer pipedRest] ? MergeArgsRec<pipedRest, partialRest, [...output, pipedFirst]> : [...output, ...ExcludePlaceholders<partialRest>] : MergeArgsRec<pipedArgs, partialRest, [...output, partialFirst]> : [...output, ...pipedArgs];
+type EmptyIntoPlaceholder<x> = IsNever$1<x> extends true ? never : [x] extends [unset] ? _ : x;
+type MapEmptyIntoPlaceholder<xs, output extends any[] = []> = xs extends [infer first, ...infer rest] ? MapEmptyIntoPlaceholder<rest, [...output, EmptyIntoPlaceholder<first>]> : output;
+type MergeArgs<pipedArgs extends any[], partialArgs extends any[]> = MergeArgsRec<pipedArgs, MapEmptyIntoPlaceholder<partialArgs>>;
+//#endregion
+//#region node_modules/hotscript/dist/internals/core/Core.d.ts
+declare const rawArgs: unique symbol;
+type rawArgs = typeof rawArgs;
+/**
+ * Base interface for all functions.
+ *
+ * @description You need to extend this interface to create a function
+ * that can be composed with other HOTScript functions.
+ * Usually you will just convert some utility type you already have
+ * by wrapping it inside a HOTScript function.
+ *
+ * Use `this['args']`, `this['arg0']`, `this['arg1']` etc to access
+ * function arguments.
+ *
+ * The `return` property is the value returned by your function.
+ *
+ * @example
+ * ```ts
+ * export interface CustomOmitFn extends Fn {
+ *  return: Omit<this['arg0'], this['arg1']>
+ * }
+ *
+ * type T = Call<CustomOmitFn, { a, b, c }, 'a'> // { b, c }
+ * ```
+ */
+interface Fn {
+  [rawArgs]: unknown;
+  args: this[rawArgs] extends infer args extends unknown[] ? args : never;
+  arg0: this[rawArgs] extends [infer arg, ...any] ? arg : never;
+  arg1: this[rawArgs] extends [any, infer arg, ...any] ? arg : never;
+  arg2: this[rawArgs] extends [any, any, infer arg, ...any] ? arg : never;
+  arg3: this[rawArgs] extends [any, any, any, infer arg, ...any] ? arg : never;
+  return: unknown;
+}
+declare const unset: unique symbol;
+declare const _: unique symbol;
+/**
+ * A placeholder type that can be used to indicate that a parameter is not set.
+ */
+type unset = typeof unset;
+/**
+ * A placeholder type that can be used to indicate that a parameter is to partially applied.
+ */
+type _ = typeof _;
+interface args$1<Constraint extends unknown[] = unknown[]> extends Fn {
+  return: this["args"] extends infer args extends Constraint ? args : never;
+}
+/**
+ * Call a HOTScript function with the given arguments.
+ *
+ * @param fn - The function to call.
+ * @param args - The arguments to pass to the function.
+ * @returns The result of the function.
+ *
+ * @example
+ * ```ts
+ * type T0 = Apply<Numbers.Add, [1, 2]>; // 3
+ * ```
+ */
+type Apply<fn extends Fn, args extends unknown[]> = (fn & {
+  [rawArgs]: args;
+})["return"];
+/**
+ * Calls a HOTScript function.
+ *
+ * @param fn - The function to call.
+ * @param ...args - optional arguments
+ *
+ * @example
+ * ```ts
+ * type T0 = Call<Numbers.Add<1, 2>>; // 3
+ * type T1 = Call<Numbers.Add<1>, 2>; // 3
+ * type T2 = Call<Numbers.Add, 1, 2>; // 3
+ * type T3 = Call<
+ *    Tuples.Map<Strings.Split<".">, ["a.b", "b.c"]>
+ * >; // [["a", "b"], ["b", "c"]]
+ * ```
+ */
+type Call<fn extends Fn, arg0 = _, arg1 = _, arg2 = _, arg3 = _> = (fn & {
+  [rawArgs]: ExcludePlaceholders<[arg0, arg1, arg2, arg3]>;
+})["return"];
+/**
+ * Pipe a value through a list of functions.
+ * @description This is the same as the pipe operator in other languages.
+ * Calls the first function with the initial value, then passes the result to the second function, and so on.
+ *
+ * @param acc - The initial value to pass to the first function.
+ * @param xs - The list of functions to pipe the value through.
+ * @returns The result of the last function.
+ *
+ * @example
+ * ```ts
+ * type T0 = Pipe<1, [Numbers.Add<1>, Numbers.Negate]>; // -2
+ * ```
+ */
+type Pipe<acc, xs extends Fn[]> = xs extends [infer first extends Fn, ...infer rest extends Fn[]] ? Pipe<Call<first, acc>, rest> : acc;
+/**
+ * Composes a list of functions into a single function that passes the result of each function to the next.
+ * Executes the functions from left to right.
+ *
+ * @param fns - The list of functions to compose.
+ * @returns The composed function.
+ *
+ * @example
+ * ```ts
+ * type T0 = Call<ComposeLeft< [S.Split<'.'>,T.Join<'-'> ]>, 'a.b.c'>; // 'a-b-c'
+ * ```
+ */
+interface ComposeLeft<fns extends Fn[]> extends Fn {
+  return: ComposeLeftImpl<fns, this["args"]>;
+}
+type ComposeLeftImpl<fns extends Fn[], args extends any[]> = fns extends [infer first extends Fn, ...infer rest extends Fn[]] ? ComposeLeftImpl<rest, [Apply<first, args>]> : Head<args>;
+/**
+ * `PartialApply` Pre applies some arguments to a function.
+ * it takes a `Fn`, and a list of pre applied arguments,
+ * and returns a new function taking the rest of these arguments.
+ *
+ * Most functions in HOTScript are already partially applicable (curried).
+ *
+ * @param fn - The function to partially apply.
+ * @param partialArgs - The arguments to partially apply.
+ * @returns The partially applied function.
+ *
+ * @example
+ * ```ts
+ * interface Append extends Fn {
+ *    return: [...this['arg1'], this['arg0']]
+ * }
+ *
+ * type Append1 = PartialApply<Append, [1]>
+ * type T0 = Call<Append1, [0]>; // [0, 1]
+ *
+ * type AppendTo123 = PartialApply<Append, [_, [1, 2, 3]]>
+ * type T1 = Call<AppendTo123, 4>; // [1, 2, 3, 4]
+ */
+interface PartialApply<fn extends Fn, partialArgs extends unknown[]> extends Fn {
+  return: MergeArgs<this["args"], partialArgs> extends infer args extends unknown[] ? Apply<fn, args$1> : never;
+}
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/impl/absolute.d.ts
+type Abs<T extends number | bigint> = `${T}` extends `-${infer U extends number | bigint}` ? U : T;
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/impl/utils.d.ts
+type ToNumber<T extends string> = T extends `${infer N extends number | bigint}` ? N : never;
+type ToString<T extends number | bigint> = `${T}`;
+type Digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+type Digit = Digits[number];
+type DigitNumber = {
+  sign: "-" | "";
+  num: Digit[];
+};
+type MakeDigitNumber<S extends "-" | "", N extends Digit[]> = {
+  sign: S;
+  num: N;
+};
+type ToDigits<T extends string, Acc extends Digit[] = []> = T extends `${infer N extends Digit}${infer R}` ? ToDigits<R, [...Acc, N]> : Acc;
+type ToDigitNumber<T extends string> = T extends `-${infer R}` ? {
+  sign: "-";
+  num: ToDigits<R>;
+} : {
+  sign: "";
+  num: ToDigits<T>;
+};
+type FromDigits<T, Acc extends string = ""> = T extends [infer N extends Digit, ...infer R] ? FromDigits<R, `${Acc}${N}`> : Acc;
+type Sign<T extends DigitNumber> = T["sign"];
+type InvertSign<T extends DigitNumber> = Sign<T> extends "-" ? "" : "-";
+type MulSign<S1 extends "-" | "", S2 extends "-" | ""> = S1 extends "-" ? S2 extends "-" ? "" : "-" : S2 extends "-" ? "-" : "";
+type Num<T extends DigitNumber> = T["num"];
+type FromDigitNumber<T extends DigitNumber> = `${Sign<T>}${FromDigits<Num<T>>}`;
+type TrimZeros<T extends Digit[]> = T extends [0] ? [0] : T extends [0, ...infer R extends Digit[]] ? TrimZeros<R> : T;
+type Normalize<T extends DigitNumber, Trim extends Digit[] = TrimZeros<Num<T>>> = Trim extends [0] ? MakeDigitNumber<"", Trim> : MakeDigitNumber<Sign<T>, Trim>;
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/impl/digits/addition.d.ts
+type AddDigitTable = [[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9, 0], [2, 3, 4, 5, 6, 7, 8, 9, 0, 1], [3, 4, 5, 6, 7, 8, 9, 0, 1, 2], [4, 5, 6, 7, 8, 9, 0, 1, 2, 3], [5, 6, 7, 8, 9, 0, 1, 2, 3, 4], [6, 7, 8, 9, 0, 1, 2, 3, 4, 5], [7, 8, 9, 0, 1, 2, 3, 4, 5, 6], [8, 9, 0, 1, 2, 3, 4, 5, 6, 7], [9, 0, 1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 3, 4, 5, 6, 7, 8, 9, 0], [2, 3, 4, 5, 6, 7, 8, 9, 0, 1], [3, 4, 5, 6, 7, 8, 9, 0, 1, 2], [4, 5, 6, 7, 8, 9, 0, 1, 2, 3], [5, 6, 7, 8, 9, 0, 1, 2, 3, 4], [6, 7, 8, 9, 0, 1, 2, 3, 4, 5], [7, 8, 9, 0, 1, 2, 3, 4, 5, 6], [8, 9, 0, 1, 2, 3, 4, 5, 6, 7], [9, 0, 1, 2, 3, 4, 5, 6, 7, 8], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]];
+type AddDigitCarryTable = [[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 0, 1, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 1, 1, 1, 1]], [[0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 0, 1, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]];
+type AddDigit<T extends Digit, U extends Digit, Carry extends 0 | 1 = 0> = AddDigitTable[Carry][T][U];
+type AddCarryDigit<T extends Digit, U extends Digit, Carry extends 0 | 1 = 0> = AddDigitCarryTable[Carry][T][U];
+type AddDigits<T extends Digit[], U extends Digit[], Carry extends 0 | 1 = 0, Acc extends Digit[] = []> = T extends [...infer R extends Digit[], infer N extends Digit] ? U extends [...infer S extends Digit[], infer M extends Digit] ? AddDigits<R, S, AddCarryDigit<N, M, Carry>, [AddDigit<N, M, Carry>, ...Acc]> : AddDigits<R, [], AddCarryDigit<N, 0, Carry>, [AddDigit<N, 0, Carry>, ...Acc]> : U extends [...infer S extends Digit[], infer M extends Digit] ? AddDigits<[], S, AddCarryDigit<0, M, Carry>, [AddDigit<0, M, Carry>, ...Acc]> : Carry extends 1 ? [1, ...Acc] : Acc;
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/impl/compare.d.ts
+type CompareLength<T extends any[], U extends any[]> = T["length"] extends U["length"] ? 1 : 0;
+type DigitCompareTable = [[0, -1, -1, -1, -1, -1, -1, -1, -1, -1], [1, 0, -1, -1, -1, -1, -1, -1, -1, -1], [1, 1, 0, -1, -1, -1, -1, -1, -1, -1], [1, 1, 1, 0, -1, -1, -1, -1, -1, -1], [1, 1, 1, 1, 0, -1, -1, -1, -1, -1], [1, 1, 1, 1, 1, 0, -1, -1, -1, -1], [1, 1, 1, 1, 1, 1, 0, -1, -1, -1], [1, 1, 1, 1, 1, 1, 1, 0, -1, -1], [1, 1, 1, 1, 1, 1, 1, 1, 0, -1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 0]];
+type DigitCompare<D1 extends Digit, D2 extends Digit> = DigitCompareTable[D1][D2];
+type CompareDigitsWithEqualLength<T extends Digit[], U extends Digit[]> = [T, U] extends [[infer N1 extends Digit, ...infer R1 extends Digit[]], [infer N2 extends Digit, ...infer R2 extends Digit[]]] ? DigitCompare<N1, N2> extends 0 ? CompareDigitsWithEqualLength<R1, R2> : DigitCompare<N1, N2> : 0;
+type CompareDigits<T extends Digit[], U extends Digit[]> = CompareLength<T, U> extends 1 ? CompareDigitsWithEqualLength<T, U> : keyof U extends keyof T ? 1 : -1;
+type CompareDigitNumbers<T extends DigitNumber, U extends DigitNumber> = Sign<T> extends Sign<U> ? Sign<T> extends "" ? CompareDigits<Num<T>, Num<U>> : CompareDigits<Num<U>, Num<T>> : Sign<T> extends "-" ? -1 : 1;
+/**
+ * Compare two numbers
+ * @param T - First number
+ * @param U - Second number
+ * @returns 0 if T = U, 1 if T > U, -1 if T < U
+ */
+type Compare$1<T extends number | bigint, U extends number | bigint> = Equal$1<T, U> extends true ? 0 : CompareDigitNumbers<ToDigitNumber<ToString<T>>, ToDigitNumber<ToString<U>>>;
+type LessThan$1<T extends number | bigint, U extends number | bigint> = Compare$1<T, U> extends -1 ? true : false;
+type GreaterThan$1<T extends number | bigint, U extends number | bigint> = Compare$1<T, U> extends 1 ? true : false;
+type Equal<T extends number | bigint, U extends number | bigint> = Equal$1<T, U>;
+type NotEqual<T extends number | bigint, U extends number | bigint> = Equal$1<T, U> extends true ? false : true;
+type LessThanOrEqual$1<T extends number | bigint, U extends number | bigint> = Compare$1<T, U> extends -1 | 0 ? true : false;
+type GreaterThanOrEqual$1<T extends number | bigint, U extends number | bigint> = Compare$1<T, U> extends 1 | 0 ? true : false;
+type Max<T extends number | bigint, U extends number | bigint> = Compare$1<T, U> extends 1 | 0 ? T : U;
+type Min<T extends number | bigint, U extends number | bigint> = Compare$1<T, U> extends 1 | 0 ? U : T;
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/impl/digits/substraction.d.ts
+type SubDigitTable = [[[0, 9, 8, 7, 6, 5, 4, 3, 2, 1], [1, 0, 9, 8, 7, 6, 5, 4, 3, 2], [2, 1, 0, 9, 8, 7, 6, 5, 4, 3], [3, 2, 1, 0, 9, 8, 7, 6, 5, 4], [4, 3, 2, 1, 0, 9, 8, 7, 6, 5], [5, 4, 3, 2, 1, 0, 9, 8, 7, 6], [6, 5, 4, 3, 2, 1, 0, 9, 8, 7], [7, 6, 5, 4, 3, 2, 1, 0, 9, 8], [8, 7, 6, 5, 4, 3, 2, 1, 0, 9], [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]], [[9, 8, 7, 6, 5, 4, 3, 2, 1, 0], [0, 9, 8, 7, 6, 5, 4, 3, 2, 1], [1, 0, 9, 8, 7, 6, 5, 4, 3, 2], [2, 1, 0, 9, 8, 7, 6, 5, 4, 3], [3, 2, 1, 0, 9, 8, 7, 6, 5, 4], [4, 3, 2, 1, 0, 9, 8, 7, 6, 5], [5, 4, 3, 2, 1, 0, 9, 8, 7, 6], [6, 5, 4, 3, 2, 1, 0, 9, 8, 7], [7, 6, 5, 4, 3, 2, 1, 0, 9, 8], [8, 7, 6, 5, 4, 3, 2, 1, 0, 9]]];
+type SubDigitCarryTable = [[[0, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1]]];
+type SubDigit<T extends Digit, U extends Digit, Carry extends 0 | 1 = 0> = SubDigitTable[Carry][T][U];
+type SubCarryDigit<T extends Digit, U extends Digit, Carry extends 0 | 1 = 0> = SubDigitCarryTable[Carry][T][U];
+type SubDigits<T extends Digit[], U extends Digit[], Carry extends 0 | 1 = 0, Acc extends Digit[] = []> = T extends [...infer R extends Digit[], infer N extends Digit] ? U extends [...infer S extends Digit[], infer M extends Digit] ? SubDigits<R, S, SubCarryDigit<N, M, Carry>, [SubDigit<N, M, Carry>, ...Acc]> : SubDigits<R, [], SubCarryDigit<N, 0, Carry>, [SubDigit<N, 0, Carry>, ...Acc]> : U extends [...infer S extends Digit[], infer M extends Digit] ? SubDigits<[], S, SubCarryDigit<0, M, Carry>, [SubDigit<0, M, Carry>, ...Acc]> : Carry extends 1 ? [...Acc, 9] : Acc;
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/impl/addition.d.ts
+type AddDigitNumbers<T extends DigitNumber, U extends DigitNumber> = Sign<T> extends Sign<U> ? MakeDigitNumber<Sign<T>, AddDigits<Num<T>, Num<U>>> : CompareDigits<Num<T>, Num<U>> extends 1 ? MakeDigitNumber<Sign<T>, SubDigits<Num<T>, Num<U>>> : MakeDigitNumber<InvertSign<T>, SubDigits<Num<U>, Num<T>>>;
+type Add<T extends number | bigint, U extends number | bigint> = ToNumber<FromDigitNumber<Normalize<AddDigitNumbers<ToDigitNumber<ToString<T>>, ToDigitNumber<ToString<U>>>>>>;
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/impl/substraction.d.ts
+type SubDigitNumbers<T extends DigitNumber, U extends DigitNumber> = Sign<T> extends Sign<U> ? CompareDigits<Num<T>, Num<U>> extends 1 ? MakeDigitNumber<Sign<T>, SubDigits<Num<T>, Num<U>>> : MakeDigitNumber<InvertSign<T>, SubDigits<Num<U>, Num<T>>> : MakeDigitNumber<Sign<T>, AddDigits<Num<T>, Num<U>>>;
+type Sub<T extends number | bigint, U extends number | bigint> = ToNumber<FromDigitNumber<Normalize<SubDigitNumbers<ToDigitNumber<ToString<T>>, ToDigitNumber<ToString<U>>>>>>;
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/impl/negate.d.ts
+type Negate<T extends number | bigint> = `${T}` extends `-${infer U extends number | bigint}` ? U : `-${T}` extends `${infer U extends number | bigint}` ? U : never;
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/impl/digits/multiply.d.ts
+type MulX2<T extends Digit[]> = AddDigits<T, T>;
+type MulX3<T extends Digit[]> = AddDigits<T, MulX2<T>>;
+type MulX4<T extends Digit[]> = MulX2<MulX2<T>>;
+type MulX5<T extends Digit[]> = AddDigits<T, MulX4<T>>;
+type MulX6<T extends Digit[]> = MulX2<MulX3<T>>;
+type MulX7<T extends Digit[]> = SubDigits<MulX10<T>, MulX3<T>>;
+type MulX8<T extends Digit[]> = SubDigits<MulX10<T>, MulX2<T>>;
+type MulX9<T extends Digit[]> = SubDigits<MulX10<T>, T>;
+type MulX10<T extends Digit[]> = [...T, 0];
+type MulByDigit<T extends Digit[], U extends Digit> = U extends 0 ? [0] : U extends 1 ? T : U extends 2 ? MulX2<T> : U extends 3 ? MulX3<T> : U extends 4 ? MulX4<T> : U extends 5 ? MulX5<T> : U extends 6 ? MulX6<T> : U extends 7 ? MulX7<T> : U extends 8 ? MulX8<T> : MulX9<T>;
+type MulDigits<T extends Digit[], U extends Digit[], Acc extends Digit[] = []> = U extends [infer N extends Digit, ...infer R extends Digit[]] ? MulDigits<T, R, AddDigits<MulByDigit<T, N>, MulX10<Acc>>> : Acc;
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/impl/multiply.d.ts
+type MulDigitNumbers<T extends DigitNumber, U extends DigitNumber> = MakeDigitNumber<MulSign<Sign<T>, Sign<U>>, MulDigits<Num<T>, Num<U>>>;
+type Mul<T extends number | bigint, U extends number | bigint> = ToNumber<FromDigitNumber<Normalize<MulDigitNumbers<ToDigitNumber<ToString<T>>, ToDigitNumber<ToString<U>>>>>>;
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/impl/digits/division.d.ts
+type Rest$1<T extends Digit[]> = T extends [Digit, ...infer R extends Digit[]] ? R : never;
+type TruncateWith<T extends Digit[], U extends Digit[], Acc extends Digit[] = []> = U extends [] ? [T, Acc] : T extends [infer D extends Digit, ...infer DR extends Digit[]] ? TruncateWith<DR, Rest$1<U>, [...Acc, D]> : [T, Acc];
+type DivModByDigit<D extends Digit[], M extends Digit[], Mul extends Digit[] = [0], IterTable extends Digit[] = Digits, NextMul extends Digit[] = AddDigits<M, Mul>, Comp = CompareDigits<D, NextMul>> = IterTable extends [infer Iteration extends Digit, ...infer Next extends Digit[]] ? Comp extends 0 ? {
+  Quotient: Next[0];
+  Remainder: [0];
+} : Comp extends 1 ? DivModByDigit<D, M, NextMul, Next> : {
+  Quotient: Iteration;
+  Remainder: SubDigits<D, Mul>;
+} : never;
+/**
+ * compute the long division of a number by a divisor
+ * @param A the Numerator Cut after M digits
+ * @param D the Numerator Cut with M first digits
+ * @param M the Divisor
+ * @param Q the Quotient
+ * @see https://en.wikipedia.org/wiki/Long_division#Algorithm_for_arbitrary_base
+ */
+type _DivModDigits<A extends Digit[], D extends Digit[], M extends Digit[], Q extends Digit[] = []> = DivModByDigit<D, M> extends {
+  Quotient: infer B extends Digit;
+  Remainder: infer R extends Digit[];
+} ? A extends [infer A1 extends Digit, ...infer AR extends Digit[]] ? _DivModDigits<AR, TrimZeros<[...R, A1]>, M, [...Q, B]> : {
+  Quotient: [...Q, B];
+  Remainder: R;
+} : never;
+type DivDigits<N extends Digit[], M extends Digit[]> = TruncateWith<N, M> extends [infer A extends Digit[], infer D extends Digit[]] ? _DivModDigits<A, D, M>["Quotient"] : never;
+type ModDigits<N extends Digit[], M extends Digit[]> = TruncateWith<N, M> extends [infer A extends Digit[], infer D extends Digit[]] ? _DivModDigits<A, D, M>["Remainder"] : never;
+type DivModDigits<N extends Digit[], M extends Digit[]> = TruncateWith<N, M> extends [infer A extends Digit[], infer D extends Digit[]] ? _DivModDigits<A, D, M> : never;
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/impl/division.d.ts
+type DivDigitNumbers<T extends DigitNumber, U extends DigitNumber> = MakeDigitNumber<MulSign<Sign<T>, Sign<U>>, DivDigits<Num<T>, Num<U>>>;
+type Div<T extends number | bigint, U extends number | bigint> = ToNumber<FromDigitNumber<Normalize<DivDigitNumbers<ToDigitNumber<ToString<T>>, ToDigitNumber<ToString<U>>>>>>;
+type ModDigitNumbers<T extends DigitNumber, U extends DigitNumber> = MakeDigitNumber<Sign<T>, ModDigits<Num<T>, Num<U>>>;
+type Mod<T extends number | bigint, U extends number | bigint> = ToNumber<FromDigitNumber<Normalize<ModDigitNumbers<ToDigitNumber<ToString<T>>, ToDigitNumber<ToString<U>>>>>>;
+type DivModDigitNumbers<T extends DigitNumber, U extends DigitNumber, DivMod extends {
+  Quotient: Digit[];
+  Remainder: Digit[];
+} = DivModDigits<Num<T>, Num<U>>> = {
+  Quotient: MakeDigitNumber<MulSign<Sign<T>, Sign<U>>, DivMod["Quotient"]>;
+  Remainder: MakeDigitNumber<Sign<T>, DivMod["Remainder"]>;
+};
+type DivMod<T extends number | bigint, U extends number | bigint, DivModNumbers extends {
+  Quotient: DigitNumber;
+  Remainder: DigitNumber;
+} = DivModDigitNumbers<ToDigitNumber<ToString<T>>, ToDigitNumber<ToString<U>>>> = {
+  Quotient: ToNumber<FromDigitNumber<Normalize<DivModNumbers["Quotient"]>>>;
+  Remainder: ToNumber<FromDigitNumber<Normalize<DivModNumbers["Remainder"]>>>;
+};
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/impl/digits/power.d.ts
+type PowerDigits<T extends Digit[], U extends Digit[], Acc extends Digit[] = [1]> = U extends [0] ? [1] : U extends [1] ? MulDigits<T, Acc> : U extends [infer UN extends Digit, ...infer UR extends Digit[]] ? _DivModDigits<UR, [UN], [2]> extends {
+  Quotient: infer Q extends Digit[];
+  Remainder: infer R extends Digit[];
+} ? TrimZeros<R> extends [0] ? PowerDigits<MulDigits<T, T>, TrimZeros<Q>, Acc> : PowerDigits<MulDigits<T, T>, TrimZeros<Q>, MulDigits<T, Acc>> : never : Acc;
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/impl/power.d.ts
+type PowerSign<S extends "" | "-", U extends DigitNumber> = S extends "-" ? Num<U> extends [...Digit[], 0 | 2 | 4 | 6 | 8] ? "" : "-" : "";
+type PowerDigitNumbers<T extends DigitNumber, U extends DigitNumber> = Sign<U> extends "-" ? MakeDigitNumber<Sign<T>, [0]> : MakeDigitNumber<PowerSign<Sign<T>, U>, PowerDigits<Num<T>, Num<U>>>;
+type Power<T extends number | bigint, U extends number | bigint> = ToNumber<FromDigitNumber<Normalize<PowerDigitNumbers<ToDigitNumber<ToString<T>>, ToDigitNumber<ToString<U>>>>>>;
+//#endregion
+//#region node_modules/hotscript/dist/internals/numbers/Numbers.d.ts
+declare namespace Numbers {
   /**
-   * Your drizzle database instance
+   * Add two numbers together
+   * @description the two numbers can be of different types (bigint or number) and handle really large numbers
+   * @param n1 - the first number
+   * @param n2 - the second number
+   * @returns the sum of the two numbers
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.Add<1, 2>>; // 3
+   * type T1 = Call<Numbers.Add<999999999999999999999999999n, 2>>; // 1000000000000000000000000001n
+   * ```
    */
-  db: DB;
+  export type Add<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<AddFn, [n1, n2]>;
+  interface AddFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? Add<a, b> : never;
+  }
   /**
-   * A function for providing context for each request based on the incoming HTTP Request.
-   * The type of the parameter equals the HTTPRequest type of your chosen server.
+   * Subtract two numbers
+   * @description the two numbers can be of different types (bigint or number) and handle really large numbers
+   * @param n1 - the first number
+   * @param n2 - the second number to subtract from the first
+   * @returns the difference of the two numbers
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.Sub<1, 2>>; // -1
+   * type T1 = Call<Numbers.Sub<1000000000000000000000000001n, 2>>; // 999999999999999999999999999n
+   * ```
    */
-  context?: ((event: RequestEvent) => Promise<UserContext> | UserContext) | undefined;
+  export type Sub<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<SubFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface SubFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? Sub<a, b> : never;
+  }
   /**
-   * If you only want to disable query, mutation or subscription default objects, you can do so here
+   * Multiply two numbers together
+   * @description the two numbers can be of different types (bigint or number) and handle really large numbers
+   * @param n1 - the first number
+   * @param n2 - the second number
+   * @returns the product of the two numbers
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.Mul<99, 3>>; // 297
+   * type T1 = Call<Numbers.Mul<999999999999999999999999999n, 2>>; // 1999999999999999999999999998n
+   * ```
    */
-  disableDefaultObjects?: {
-    mutation?: boolean;
-    subscription?: boolean;
-    query?: boolean;
-  };
+  export type Mul<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<MulFn, [n1, n2]>;
+  interface MulFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? Mul<a, b> : never;
+  }
   /**
-   * The actions that are available
+   * Divide two numbers
+   * @description the two numbers can be of different types (bigint or number) and handle really large numbers
+   * @param n1 - the first number
+   * @param n2 - the second number to divide the first by
+   * @returns the quotient of the two numbers
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.Div<99, 3>>; // 33
+   * type T1 = Call<Numbers.Div<999999999999999999999999999n, 4>>; // 249999999999999999999999999n
+   * ```
    */
-  actions?: Action[];
+  export type Div<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<DivFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface DivFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? Div<a, b> : never;
+  }
   /**
-   * Customization for subscriptions. See https://the-guild.dev/graphql/yoga-server/docs/features/subscriptions#distributed-pubsub-for-production
+   * Modulo of two numbers
+   * @description the two numbers can be of different types (bigint or number) and handle really large numbers
+   * @param n1 - the first number
+   * @param n2 - the second number to divide the first by
+   * @returns the remainder of the two numbers
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.Mod<100, 3>>; // 1
+   * type T1 = Call<Numbers.Mod<999999999999999999999999999n, 4>>; // 3n
+   * ```
    */
-  subscriptions?: Parameters<typeof createPubSub>;
+  export type Mod<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<ModFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface ModFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? Mod<a, b> : never;
+  }
   /**
-   * Options passed along to the pothos schema builder.
+   * Negate a number
+   * @description the number can be of different types (bigint or number) and handle really large numbers
+   * @param n - the number to negate
+   * @returns the negated number
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.Negate<1>>; // -1
+   * type T1 = Call<Numbers.Negate<999999999999999999999999999n>>; // -999999999999999999999999999n
+   * ```
    */
-  pothosConfig?: PothosConfig;
+  export type Negate<n extends number | bigint | _ | unset = unset> = PartialApply<NegateFn, [n]>;
+  interface NegateFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, ...any] ? Negate<a> : never;
+  }
   /**
-   * Limits the returned amount when querying lists. Set to null to disable.
-   * @default 100
+   * Absolute value of a number
+   * @description the number can be of different types (bigint or number) and handle really large numbers
+   * @param n - the number to get the absolute value of
+   * @returns the absolute value of the number
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.Abs<-1>>; // 1
+   * type T1 = Call<Numbers.Abs<999999999999999999999999999n>>; // 999999999999999999999999999n
+   * ```
    */
-  defaultLimit?: number | undefined | null;
+  export type Abs<n extends number | bigint | _ | unset = unset> = PartialApply<AbsFn, [n]>;
+  export interface AbsFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, ...any] ? Abs<a> : never;
+  }
   /**
-   * rumble supports fuzzy search for the query helpers. This enables the users of your API to search for entities via fuzzy search inputs.
-   * This currently only is supported by postgres databases and will fail if enabled on other dialects.
+   * Returns the max between 2 numbers.
+   * @param n1 - first number or bigint
+   * @param n2 - second number or bigint
+   * @returns the maximum values between the two
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.Max<1, 2>>; // 2
+   * ```
+   */
+  export type Max<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<MaxFn, [n1, n2]>;
+  export interface MaxFn extends Fn {
+    return: Max<Extract<this["arg0"], number | bigint>, Extract<this["arg1"], number | bigint>>;
+  }
+  /**
+   * Returns the min between 2 numbers.
+   * @param n1 - first number or bigint
+   * @param n2 - second number or bigint
+   * @returns the minimum values between the two
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.Min<1, 2>>; // 1
+   * ```
+   */
+  export type Min<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<MinFn, [n1, n2]>;
+  export interface MinFn extends Fn {
+    return: Min<Extract<this["arg0"], number | bigint>, Extract<this["arg1"], number | bigint>>;
+  }
+  /**
+   * Power of a number
+   * @description the number can be of different types (bigint or number) and handle really large numbers
+   * @param n1 - the base number
+   * @param n2 - the exponent
+   * @returns the power of the two numbers
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.Power<2, 128>>; // 340282366920938463463374607431768211456
+   * ```
+   */
+  export type Power<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<PowerFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface PowerFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? Power<a, b> : never;
+  }
+  /**
+   * Compare two numbers
+   * @description the two numbers can be of different types (bigint or number) and handle really large numbers
+   * @param n1 - the first number
+   * @param n2 - the second number to compare the first to
+   * @returns -1 if n1 < n2, 0 if n1 === n2, 1 if n1 > n2
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.Compare<1, 2>>; // -1
+   * type T1 = Call<Numbers.Compare<999999999999999999999999999n, 4>>; // 1
+   * type T2 = Call<Numbers.Compare<999999999999999999999999999n, 999999999999999999999999999n>>; // 0
+   * ```
+   */
+  export type Compare<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<CompareFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface CompareFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? Compare$1<a, b> : never;
+  }
+  /**
+   * Check if two numbers are equal
+   * @description the two numbers can be of different types (bigint or number) and handle really large numbers
+   * @param n1 - the first number
+   * @param n2 - the second number to compare the first to
+   * @returns true if n1 === n2, false otherwise
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.Equal<1, 2>>; // false
+   * type T1 = Call<Numbers.Equal<2, 2>>; // true
+   * ```
+   */
+  export type Equal<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<EqualFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface EqualFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? Equal<a, b> : never;
+  }
+  /**
+   * Check if two numbers are not equal
+   * @description the two numbers can be of different types (bigint or number) and handle really large numbers
+   * @param n1 - the first number
+   * @param n2 - the second number to compare the first to
+   * @returns true if n1 !== n2, false otherwise
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.NotEqual<1, 2>>; // true
+   * type T1 = Call<Numbers.NotEqual<2, 2>>; // false
+   * ```
+   */
+  export type NotEqual<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<NotEqualFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface NotEqualFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? NotEqual<a, b> : never;
+  }
+  /**
+   * Check if a number is less than another
+   * @description the two numbers can be of different types (bigint or number) and handle really large numbers
+   * @param n1 - the first number
+   * @param n2 - the second number to compare the first to
+   * @returns true if n1 < n2, false otherwise
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.LessThan<1, 2>>; // true
+   * type T1 = Call<Numbers.LessThan<2, 2>>; // false
+   * type T2 = Call<Numbers.LessThan<3, 2>>; // false
+   * ```
+   */
+  export type LessThan<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<LessThanFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface LessThanFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? LessThan$1<a, b> : never;
+  }
+  /**
+   * Check if a number is less than or equal to another
+   * @description the two numbers can be of different types (bigint or number) and handle really large numbers
+   * @param n1 - the first number
+   * @param n2 - the second number to compare the first to
+   * @returns true if n1 <= n2, false otherwise
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.LessThanOrEqual<1, 2>>; // true
+   * type T1 = Call<Numbers.LessThanOrEqual<2, 2>>; // true
+   * type T2 = Call<Numbers.LessThanOrEqual<3, 2>>; // false
+   * ```
+   */
+  export type LessThanOrEqual<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<LessThanOrEqualFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface LessThanOrEqualFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? LessThanOrEqual$1<a, b> : never;
+  }
+  /**
+   * Check if a number is greater than another
+   * @description the two numbers can be of different types (bigint or number) and handle really large numbers
+   * @param n1 - the first number
+   * @param n2 - the second number to compare the first to
+   * @returns true if n1 > n2, false otherwise
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.GreaterThan<1, 2>>; // false
+   * type T1 = Call<Numbers.GreaterThan<2, 2>>; // false
+   * type T2 = Call<Numbers.GreaterThan<3, 2>>; // true
+   * ```
+   */
+  export type GreaterThan<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<GreaterThanFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface GreaterThanFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? GreaterThan$1<a, b> : never;
+  }
+  /**
+   * Check if a number is greater than or equal to another
+   * @description the two numbers can be of different types (bigint or number) and handle really large numbers
+   * @param n1 - the first number
+   * @param n2 - the second number to compare the first to
+   * @returns true if n1 >= n2, false otherwise
+   * @example
+   * ```ts
+   * type T0 = Call<Numbers.GreaterThanOrEqual<1, 2>>; // false
+   * type T1 = Call<Numbers.GreaterThanOrEqual<2, 2>>; // true
+   * type T2 = Call<Numbers.GreaterThanOrEqual<3, 2>>; // true
+   * ```
+   */
+  export type GreaterThanOrEqual<n1 extends number | bigint | _ | unset = unset, n2 extends number | bigint | _ | unset = unset> = PartialApply<GreaterThanOrEqualFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface GreaterThanOrEqualFn extends Fn {
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? GreaterThanOrEqual$1<a, b> : never;
+  }
+  export {};
+}
+//#endregion
+//#region node_modules/hotscript/dist/internals/std/Std.d.ts
+declare namespace Std {
+  type _Pick<a, k extends keyof a> = Pick<a, k>;
+  type _Omit<a, k extends PropertyKey> = Omit<a, k>;
+  type _Extract<a, b> = Extract<a, b>;
+  type _Exclude<a, b> = Exclude<a, b>;
+  type _Uppercase<a extends string> = Uppercase<a>;
+  type _Lowercase<a extends string> = Lowercase<a>;
+  type _Capitalize<a extends string> = Capitalize<a>;
+  type _Uncapitalize<a extends string> = Uncapitalize<a>;
+  type _Record<k extends PropertyKey, v> = Record<k, v>;
+  type _Readonly<a> = Readonly<a>;
+  type _Required<a> = Required<a>;
+  type _Partial<a> = Partial<a>;
+  type _NonNullable<a> = NonNullable<a>;
+}
+//#endregion
+//#region node_modules/hotscript/dist/internals/tuples/Tuples.d.ts
+declare namespace Tuples {
+  type HeadImpl<xs> = xs extends readonly [infer head, ...any] ? head : never;
+  /**
+   * Get an element from a tuple at a given index.
+   * @param args[0] - The index of the element to get.
+   * @param args[1] - The tuple to get the element from.
+   * @param index - The index of the element to get.
+   * @param tuple - The tuple to get the element from.
+   * @returns The element at the specified index.
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.At, 1, ["a", "b", "c"]>; // "b"
+   * type T1 = Call<Tuples.At<1, ["a", "b", "c"]>>; // "b"
+   * type T2 = Call<Tuples.At<1>, ["a", "b", "c"]>; // "b"
+   * ```
+   */
+  export type At<index extends number | _ | unset = unset, tuple = unset> = PartialApply<AtFn, [index, tuple]>;
+  interface AtFn extends Fn {
+    return: Extract<this["arg1"], readonly any[]>[Extract<this["arg0"], number>];
+  }
+  type IsEmptyImpl<tuple extends unknown[]> = [] extends tuple ? true : false;
+  interface IsEmptyFn extends Fn {
+    return: IsEmptyImpl<Extract<this["arg0"], unknown[]>>;
+  }
+  /**
+   * Check if a tuple is empty.
+   * @param args[0] - The tuple to check.
+   * @param tuple - The tuple to check.
+   * @returns `true` if the tuple is empty, `false` otherwise.
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.IsEmpty, []>; // true
+   * type T1 = Call<Tuples.IsEmpty, [1, 2, 3]>; // false
+   * type T2 = Call<Tuples.IsEmpty<[]>>; // true
+   * ```
+   */
+  export type IsEmpty<tuple = unset> = PartialApply<IsEmptyFn, [tuple]>;
+  interface ToUnionFn extends Fn {
+    return: this["arg0"][number];
+  }
+  /**
+   * Convert a tuple to a union of its elements.
+   * @param tuple - The tuple to convert.
+   * @returns A union of the tuple's elements.
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.ToUnion, [1, 2, 3]>; // 1 | 2 | 3
+   * type T1 = Call<Tuples.ToUnion<[1, 2, 3]>>; // 1 | 2 | 3
+   * ```
+   */
+  export type ToUnion<tuple extends readonly any[] | _ | unset = unset> = PartialApply<ToUnionFn, [tuple]>;
+  /**
+   * `Unions.ToIntersection` turns a tuple into an intersection type.
+   * @param tuple - any tuple.
+   * @returns an intersection of all member of the tuple
+   * @example
+   * ```ts
+   * type T0 = Call<Unions.ToIntersection, [{a: string}, {b: number}]>; // {a: string} & {b: number}
+   * ```
+   */
+  export type ToIntersection<tuple = unset> = PartialApply<ToIntersectionFn, [tuple]>;
+  interface ToIntersectionFn extends Fn {
+    return: this["args"] extends [infer tuples extends readonly any[], ...any] ? Call<Tuples.Reduce<IntersectFn, unknown, tuples>> : never;
+  }
+  interface IntersectFn extends Fn {
+    return: this["arg0"] & this["arg1"];
+  }
+  /**
+   * Returns the first element of a tuple.
+   * @params args[0] - A tuple.
+   * @return The first element of a tuple.
+   * @example
+   * ```ts
+   * type T0 = Call<T.Head,[1, 2, 3]>; // 1
+   * type T1 = Call<T.Head,[]>; // never
+   * type T2 = Call<T.Head,[1]>; // 1
+   * ```
+   */
+  export type Head<tuple extends readonly any[] | unset = unset> = PartialApply<HeadFn, [tuple]>;
+  interface HeadFn extends Fn {
+    return: HeadImpl<this["arg0"]>;
+  }
+  type TailImpl<xs> = xs extends readonly [any, ...infer tail] ? tail : [];
+  /**
+   * Returns a tuple with all elements except the first.
+   * @params args[0] - A tuple.
+   * @return A tuple with all elements except the first.
+   * @example
+   * ```ts
+   * type T0 = Call<T.Tail,[1, 2, 3]>; // [2, 3]
+   * type T1 = Call<T.Tail,[]>; // []
+   * type T2 = Call<T.Tail,[1]>; // []
+   * ```
+   */
+  export type Tail<tuple extends readonly any[] | unset = unset> = PartialApply<TailFn, [tuple]>;
+  export interface TailFn extends Fn {
+    return: TailImpl<this["arg0"]>;
+  }
+  type LastImpl<xs> = xs extends readonly [...any, infer last] ? last : never;
+  /**
+   * Returns the last element of a tuple.
+   * @params args[0] - A tuple.
+   * @return The last element of a tuple.
+   * @example
+   * ```ts
+   * type T0 = Call<T.Last,[1, 2, 3]>; // 3
+   * type T1 = Call<T.Last,[]>; // never
+   * type T2 = Call<T.Last,[1]>; // 1
+   * ```
+   */
+  export type Last<tuple extends readonly any[] | unset = unset> = PartialApply<LastFn, [tuple]>;
+  export interface LastFn extends Fn {
+    return: LastImpl<this["arg0"]>;
+  }
+  /**
+   * Apply a function to each element of a tuple and return a new tuple with the results.
+   * @params args[0] - A tuple of elements to be transformed.
+   * @param fn - A function that takes an element of the tuple and transforms it.
+   * @returns A tuple with the results of applying the function to each element of the input tuple.
+   * @example
+   * ```ts
+   * type T0 = Call<T.Map<S.ToString>,[1,2,3]>; // ["1","2","3"]
+   * type T1 = Call<T.Map<S.ToString>,[]>; // []
+   * ```
+   */
+  export type Map<fn extends Fn | unset | _ = unset, tuple extends readonly any[] | unset = unset> = PartialApply<MapFn, [fn, tuple]>;
+  interface MapFn extends Fn {
+    return: this["args"] extends [infer fn extends Fn, infer tuple extends unknown[]] ? { [key in keyof tuple]: Call<fn, tuple[key]> } : never;
+  }
+  interface FlatMapReducer<fn extends Fn> extends Fn {
+    return: this["args"] extends [infer acc extends any[], infer item] ? [...acc, ...Extract<Call<fn, item>, readonly any[]>] : never;
+  }
+  /**
+   * Apply a function to each element of a tuple and return a new tuple with the results flattened by one level.
+   * @params args[0] - A tuple of elements to be transformed.
+   * @param fn - A function that takes an element of the tuple and transforms it.
+   * @returns A tuple with the results of applying the function to each element of the input tuple flattened by one level.
+   * @example
+   * ```ts
+   * type T0 = Call<T.FlatMap<S.ToTuple>,["hello","world"]>; // ["h","e","l","l","o","w","o","r","l","d"]
+   * type T1 = Call<T.FlatMap<S.ToTuple>,[]>; // []
+   * ```
+   */
+  export type FlatMap<fn extends Fn, tuple extends readonly any[] | unset = unset> = PartialApply<FlatMapFn, [fn, tuple]>;
+  interface FlatMapFn extends Fn {
+    return: ReduceImpl<FlatMapReducer<Extract<this["arg0"], Fn>>, [], this["arg1"]>;
+  }
+  type ReduceImpl<fn extends Fn, acc, xs> = xs extends [infer first, ...infer rest] ? ReduceImpl<fn, Call<fn, acc, first>, rest> : xs extends readonly [infer first, ...infer rest] ? ReduceImpl<fn, Call<fn, acc, first>, rest> : acc;
+  /**
+   * Apply a reducer function to each element of a tuple starting from the first and return the accumulated result.
+   * @params args[0] - A tuple of elements to be transformed.
+   * @params fn - A reducer function that takes the accumulated result and the current element and returns a new accumulated result.
+   * @params init - The initial value of the accumulated result.
+   * @returns The accumulated result.
+   * @example
+   * ```ts
+   * type T0 = Call<T.Reduce<N.Add,0>,[1,2,3]>; // 6
+   * type T1 = Call<T.Reduce<N.Add,0>,[]>; // 0
+   * ```
+   */
+  export type Reduce<fn extends Fn, init = unset, tuple extends readonly any[] | unset = unset> = PartialApply<ReduceFn, [fn, init, tuple]>;
+  interface ReduceFn extends Fn {
+    return: ReduceImpl<Extract<this["arg0"], Fn>, this["arg1"], this["arg2"]>;
+  }
+  type ReverseImpl<tuple> = any[] extends tuple ? tuple : ReverseRecImpl<tuple, []>;
+  type ReverseRecImpl<tuple, acc extends unknown[]> = tuple extends [infer first, ...infer rest] ? ReverseRecImpl<rest, [first, ...acc]> : acc;
+  /**
+   * Reverse a tuple.
+   * @params args[0] - A tuple.
+   * @return Reversed tuple.
+   * @example
+   * ```ts
+   * type T0 = Call<T.Reverse,[1,2,3]>; // [3,2,1]
+   * ```
+   */
+  export type Reverse<tuple extends readonly unknown[] | unset = unset> = PartialApply<ReverseFn, [tuple]>;
+  interface ReverseFn extends Fn {
+    return: ReverseImpl<this["arg0"]>;
+  }
+  type ReduceRightImpl<xs, acc, fn extends Fn> = xs extends [...infer rest, infer last] ? ReduceRightImpl<rest, Call<fn, acc, last>, fn> : acc;
+  /**
+   * Apply a reducer function to each element of a tuple starting from the last and return the accumulated result.
+   * @params args[0] - A tuple of elements to be transformed.
+   * @params fn - A reducer function that takes the accumulated result and the current element and returns a new accumulated result.
+   * @params init - The initial value of the accumulated result.
+   * @returns The accumulated result.
+   * @example
+   * ```ts
+   * type T0 = Call<T.ReduceRight<N.Add,0>,[1,2,3]>; // 6
+   * type T1 = Call<T.ReduceRight<N.Add,0>,[]>; // 0
+   * ```
+   */
+  export type ReduceRight<fn extends Fn, init = unset, tuple extends readonly any[] | unset = unset> = PartialApply<ReduceRightFn, [fn, init, tuple]>;
+  interface ReduceRightFn extends Fn {
+    return: ReduceRightImpl<this["arg2"], this["arg1"], Extract<this["arg0"], Fn>>;
+  }
+  interface FilterReducer<fn extends Fn> extends Fn {
+    return: this["args"] extends [infer acc extends any[], infer item] ? Call<fn, item> extends true ? [...acc, item] : acc : never;
+  }
+  /**
+   * Apply a predicate function to each element of a tuple and return a new tuple with the elements that satisfy the predicate.
+   * @params args[0] - A tuple of elements to be filtered.
+   * @param fn - A predicate function that takes an element of the tuple and returns a boolean.
+   * @returns A tuple with the elements that satisfy the predicate.
+   * @example
+   * ```ts
+   * type T0 = Call<T.Filter<B.Extends<string>>,[1,2,"3"]>; // ["3"]
+   * type T1 = Call<T.Filter<B.Extends<string>>,[]>; // []
+   * ```
+   */
+  export type Filter<fn extends Fn, tuple extends readonly any[] | unset = unset> = PartialApply<FilterFn, [fn, tuple]>;
+  export interface FilterFn extends Fn {
+    return: ReduceImpl<FilterReducer<Extract<this["arg0"], Fn>>, [], this["arg1"]>;
+  }
+  type FindImpl<xs, fn extends Fn, index extends any[] = []> = xs extends [infer first, ...infer rest] ? Call<fn, first, index["length"]> extends true ? first : FindImpl<rest, fn, [...index, any]> : never;
+  /**
+   * Apply a predicate function to each element of a tuple and return the first element that satisfies the predicate.
+   * @params args[0] - A tuple of elements to be filtered.
+   * @param fn - A predicate function that takes an element of the tuple and returns a boolean.
+   * @returns The first element that satisfies the predicate.
+   * @example
+   * ```ts
+   * type T0 = Call<T.Find<B.Extends<string>>,[1,2,"3",4,"5"]>; // "3"
+   * type T1 = Call<T.Find<B.Extends<string>>,[1,2]>; // never
+   * ```
+   */
+  export type Find<fn extends Fn, tuple extends readonly any[] | unset = unset> = PartialApply<FindFn, [fn, tuple]>;
+  export interface FindFn extends Fn {
+    return: FindImpl<this["arg1"], Extract<this["arg0"], Fn>>;
+  }
+  /**
+   * Sum the elements of a tuple of numbers.
+   * @params args[0] - A tuple of numbers.
+   * @returns The sum of the elements of the tuple.
+   * @example
+   * ```ts
+   * type T0 = Call<T.Sum,[1,2,3]>; // 6
+   * type T1 = Call<T.Sum,[]>; // 0
+   * ```
+   */
+  export type Sum<tuple extends readonly any[] | unset = unset> = PartialApply<SumFn, [tuple]>;
+  interface SumFn extends Fn {
+    return: ReduceImpl<Numbers.Add, 0, this["arg0"]>;
+  }
+  type DropImpl<xs extends readonly any[], n extends any[]> = Iterator$1.Get<n> extends 0 ? xs : xs extends readonly [any, ...infer tail] ? DropImpl<tail, Iterator$1.Prev<n>> : [];
+  /**
+   * Drop the first n elements of a tuple.
+   * @params args[0] - A tuple of elements.
+   * @params n - The number of elements to drop.
+   * @returns A tuple with the first n elements dropped.
+   * @example
+   * ```ts
+   * type T0 = Call<T.Drop<2>,[1,2,3,4]>; // [3,4]
+   * type T1 = Call<T.Drop<2>,[1,2]>; // []
+   * type T2 = Call<T.Drop<2>,[]>; // []
+   * ```
+   */
+  export type Drop<n extends number | unset | _ = unset, tuple = unset> = PartialApply<DropFn, [n, tuple]>;
+  export interface DropFn extends Fn {
+    return: this["args"] extends [infer N extends number, infer T extends readonly any[]] ? DropImpl<T, Iterator$1.Iterator<Numbers>> : never;
+  }
+  type TakeImpl<xs extends readonly any[], it extends any[], output extends any[] = []> = Iterator$1.Get<it> extends 0 ? output : xs extends readonly [infer head, ...infer tail] ? TakeImpl<tail, Iterator$1.Prev<it>, [...output, head]> : output;
+  /**
+   * Take the first n elements of a tuple.
+   * @params args[0] - A tuple of elements.
+   * @params n - The number of elements to take.
+   * @returns A tuple with the first n elements.
+   * @example
+   * ```ts
+   * type T0 = Call<T.Take<2>,[1,2,3,4]>; // [1,2]
+   * type T1 = Call<T.Take<2>,[1,2]>; // [1,2]
+   * type T2 = Call<T.Take<2>,[]>; // []
+   * ```
+   */
+  export type Take<n extends number | unset | _ = unset, tuple = unset> = PartialApply<TakeFn, [n, tuple]>;
+  interface TakeFn extends Fn {
+    return: this["args"] extends [infer N extends number, infer T extends readonly any[]] ? TakeImpl<T, Iterator$1.Iterator<Numbers>> : never;
+  }
+  type TakeWhileImpl<xs extends readonly any[], fn extends Fn, index extends any[] = [], output extends any[] = []> = xs extends readonly [infer head, ...infer tail] ? Call<fn, head, index["length"]> extends true ? TakeWhileImpl<tail, fn, [...index, any], [...output, head]> : output : output;
+  /**
+   * Take the first elements of a tuple that satisfy a predicate function.
+   * @params args[0] - A tuple of elements.
+   * @param fn - A predicate function that takes an element of the tuple and returns a boolean.
+   * @returns A tuple with the first elements that satisfy the predicate.
+   * @example
+   * ```ts
+   * type T0 = Call<T.TakeWhile<B.Extends<number>>,[1,2,"3",4,"5"]>; // [1,2]
+   * type T1 = Call<T.TakeWhile<B.Extends<number>>,["1", 2]>; // []
+   * ```
+   */
+  export type TakeWhile<fn extends Fn, tuple = unset> = PartialApply<TakeWhileFn, [fn, tuple]>;
+  export interface TakeWhileFn extends Fn {
+    return: TakeWhileImpl<Extract<this["arg1"], readonly any[]>, Extract<this["arg0"], Fn>>;
+  }
+  /**
+   * Check if a tuple staisfies a predicate function for at least one element.
+   * @params args[0] - A tuple of elements.
+   * @param fn - A predicate function that takes an element of the tuple and returns a boolean.
+   * @returns A boolean indicating whether the predicate is satisfied by at least one element.
+   * @example
+   * ```ts
+   * type T0 = Call<T.Some<B.Extends<number>>,[1,2,"3",4,"5"]>; // true
+   * type T1 = Call<T.Some<B.Extends<number>>,["1", "2"]>; // false
+   * ```
+   */
+  export type Some<fn extends Fn, tuple = unset> = PartialApply<SomeFn, [fn, tuple]>;
+  export interface SomeFn extends Fn {
+    return: true extends Call<Tuples.Map<Extract<this["arg0"], Fn>>, this["arg1"]>[number] ? true : false;
+  }
+  /**
+   * Check if a tuple staisfies a predicate function for all elements.
+   * @params args[0] - A tuple of elements.
+   * @param fn - A predicate function that takes an element of the tuple and returns a boolean.
+   * @returns A boolean indicating whether the predicate is satisfied by all elements.
+   * @example
+   * ```ts
+   * type T0 = Call<T.Every<B.Extends<number>>,[1,2,"3",4,"5"]>; // false
+   * type T1 = Call<T.Every<B.Extends<number>>,["1", "2"]>; // false
+   * type T2 = Call<T.Every<B.Extends<number>>,[1, 2]>; // true
+   * ```
+   */
+  export type Every<fn extends Fn, tuple = unset> = PartialApply<EveryFn, [fn, tuple]>;
+  export interface EveryFn extends Fn {
+    return: false extends Call<Tuples.Map<Extract<this["arg0"], Fn>>, this["arg1"]>[number] ? false : true;
+  }
+  type SortImpl<xs extends any[], predicateFn extends Fn> = xs extends [infer head, ...infer tail] ? Call<Tuples.Partition<PartialApply<predicateFn, [_, head]>, tail>> extends [infer left extends any[], infer right extends any[]] ? [...SortImpl<left, predicateFn>, head, ...SortImpl<right, predicateFn>] : never : [];
+  /**
+   * Sort a tuple.
+   * @param args[0] - The tuple to sort.
+   * @param predicateFn - The predicate function to use for sorting. should compare 2 items and return a boolean.
+   * @returns The sorted tuple.
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.Sort,[3,2,1]>; // [1,2,3]
+   * type T1 = Call<Tuples.Sort<Strings.LessThan>,["b","c","a"]>; // ["a","b","c"]
+   * ```
+   */
+  export interface Sort<predicateFn extends Fn = Numbers.LessThanOrEqual> extends Fn {
+    return: this["args"] extends [infer xs extends any[]] ? SortImpl<xs, predicateFn> : never;
+  }
+  interface JoinReducer<sep extends string> extends Fn {
+    return: this["args"] extends [infer acc extends Stringifiable, infer item extends Stringifiable] ? `${acc extends "" ? "" : `${acc}${sep}`}${item}` : never;
+  }
+  /**
+   * Join a tuple into a single string.
+   * @param args[0] - The tuple to join.
+   * @param sep - The separator to join the strings with.
+   * @returns The joined string.
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.Join<",">,["a","b","c"]>; // "a,b,c"
+   * type T1 = Call<Tuples.Join,",",["a","b","c"]>; // "a,b,c"
+   * type T2 = Call<Tuples.Join<",",["a","b","c"]>>; // "a,b,c"
+   * ```
+   */
+  export type Join<Sep extends string | _ | unset = unset, Tuple = unset> = PartialApply<JoinFn, [Sep, Tuple]>;
+  interface JoinFn extends Fn {
+    return: this["args"] extends [infer Sep extends string, infer Tuple] ? ReduceImpl<JoinReducer<Sep>, "", Tuple> : never;
+  }
+  /**
+   * Adds a new element to the start of a tuple
+   * @param args[0] - The tuple to update.
+   * @param element - The element to add to our tuple
+   * @returns The updated tuple.
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.Prepend<"new">, ["a", "b", "c"]>; // ["new", "a", "b", "c"]
+   * ```
+   */
+  export type Prepend<element = unset, tuple = unset> = PartialApply<PrependFn, [element, tuple]>;
+  interface PrependFn extends Fn {
+    return: this["args"] extends [infer element, infer tuple extends any[]] ? [element, ...tuple] : never;
+  }
+  /**
+   * Adds a new element to the end of a tuple
+   * @param args[0] - The tuple to update.
+   * @param element - The element to add to our tuple
+   * @returns The updated tuple.
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.Append<"new">, ["a", "b", "c"]>; // ["a", "b", "c", "new"]
+   * ```
+   */
+  export type Append<element = unset, tuple = unset> = PartialApply<AppendFn, [element, tuple]>;
+  interface AppendFn extends Fn {
+    return: this["args"] extends [infer element, infer tuple extends any[]] ? [...tuple, element] : never;
+  }
+  /**
+   * Concatenate two tuples together
+   * @param tuple1 - A list of types
+   * @param tuple2 - Another list of types
+   * @returns [...tuple1, ...tuple2]
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.Concat, [1], [2, 3]>; // [1, 2, 3]
+   * ```
+   */
+  export type Concat<tuple1 = unset, tuple2 = unset> = PartialApply<ConcatFn, [tuple1, tuple2]>;
+  interface ConcatFn extends Fn {
+    return: this["args"] extends [infer t1 extends readonly any[], infer t2 extends readonly any[], ...any] ? [...t1, ...t2] : never;
+  }
+  /**
+   * Splits a tuple into two groups based on a predicate:
+   * - The first group contains elements predicate returns true for.
+   * - The second group contains elements predicate returns false for.
    *
-   * Please note that this will install the pg_trgm extension on startup if your database does not have it already installed.
-   * https://www.postgresql.org/docs/current/pgtrgm.html
+   * @param predicate - The tuple to update.
+   * @param element - The element to add to our tuple
+   * @returns - a tuple containing two tuples: one for each groupe
+   * @example
+   * ```ts
+   * type T0 = Call<T.Partition<B.Extends<number>>, [1, "a", 2, "b", 3, "c"]>;
+   * //   ^? [[1, 2, 3], ["a", "b", "c"]]
+   * ```
    */
-  search?: {
-    /**
-     * Whether search is enabled
-     */
-    enabled?: boolean;
-    /**
-     * The cuttoff factor to reduce the amount of returned results.
-     * Defaults to 0.3. Lower values will return more results.
-     */
-    threshold?: number;
+  export type Partition<fn extends Fn, tuple = unset> = PartialApply<PartitionFn, [fn, tuple]>;
+  type PartitionImpl<fn extends Fn, tuple extends any[], left extends any[] = [], right extends any[] = []> = tuple extends [infer first, ...infer rest] ? Call<fn, first> extends true ? PartitionImpl<fn, rest, [...left, first], right> : PartitionImpl<fn, rest, left, [...right, first]> : [left, right];
+  interface PartitionFn extends Fn {
+    return: PartitionImpl<Extract<this["arg0"], Fn>, Extract<this["arg1"], any[]>>;
+  }
+  /**
+   * SplitAt takes an index and a tuple, splits the tuple
+   * at the provided index and returns the list of elements
+   * before this index and the list of elements after this
+   * index as a [before[], after[]] tuple.
+   *
+   * @param index - the index at which to split the list
+   * @param tuple - The list to split
+   * @returns A [before[], after[]] tuple.
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.SplitAt<2>, [1, 2, 3, 4]>; // [[1, 2], [3, 4]]
+   * type T1 = Call<Tuples.SplitAt<2>, [1]>; // [[1], []]
+   * ```
+   */
+  export type SplitAt<index extends number | unset | _ = unset, tuple extends unknown[] | unset | _ = unset> = PartialApply<SplitAtFn, [index, tuple]>;
+  export interface SplitAtFn extends Fn {
+    return: this["args"] extends [infer index extends number, infer tuple extends any[], ...any] ? [TakeImpl<tuple, Iterator$1.Iterator<index>>, DropImpl<tuple, Iterator$1.Iterator<index>>] : never;
+  }
+  interface ZipWithMapper<fn extends Fn, arrs extends unknown[][]> extends Fn {
+    return: this["args"] extends [infer Index extends number, ...any] ? Apply<fn, Call<Tuples.Map<Tuples.At<Index>, arrs>>> : never;
+  }
+  interface ZipWithFn<fn extends Fn> extends Fn {
+    return: this["args"] extends infer arrays extends unknown[][] ? Pipe<arrays, [Tuples.Map<Objects.Get<"length">>, Tuples.Min, Numbers.Abs, Numbers.Sub<_, 1>, Tuples.Range<0, _>, Tuples.Map<ZipWithMapper<fn, arrays>>]> : never;
+  }
+  /**
+   * Zip two tuples together.
+   * @param args[0] - The first tuple to zip.
+   * @param args[1] - The second tuple to zip.
+   * @param arr1 - The first tuple to zip.
+   * @param arr2 - The second tuple to zip.
+   * @returns The zipped tuple.
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.Zip, [1, 2, 3], [10, 2, 5]>; // [[1, 10], [2, 2], [3, 5]]
+   * type T1 = Call<Tuples.Zip<[1, 2, 3], [10, 2, 5]>>; // [[1, 10], [2, 2], [3, 5]]
+   * ```
+   */
+  export type Zip<arr0 extends unknown[] | _ | unset = unset, arr1 extends unknown[] | _ | unset = unset, arr2 extends unknown[] | _ | unset = unset, arr3 extends unknown[] | _ | unset = unset, arr4 extends unknown[] | _ | unset = unset, arr5 extends unknown[] | _ | unset = unset, arr6 extends unknown[] | _ | unset = unset, arr7 extends unknown[] | _ | unset = unset, arr8 extends unknown[] | _ | unset = unset, arr9 extends unknown[] | _ | unset = unset> = PartialApply<ZipWithFn<args$1>, [arr0, arr1, arr2, arr3, arr4, arr5, arr6, arr7, arr8, arr9]>;
+  /**
+   * Zip two tuples together using a function.
+   * @description The function should take a 2 elements and return a value.
+   * Using the identity function will return a 2-tuple and have the same effect as `Zip`.
+   * @param args[0] - The first tuple to zip.
+   * @param args[1] - The second tuple to zip.
+   * @param fn - The function to use to zip the tuples.
+   * @param arr1 - The first tuple to zip.
+   * @param arr2 - The second tuple to zip.
+   * @returns The zipped tuple.
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.ZipWith<args>, [1, 2, 3], [10, 2, 5]>; // [[1, 10], [2, 2], [3, 5]]
+   * type T1 = Call<Tuples.ZipWith<args, [1, 2, 3], [10, 2, 5]>>; // [[1, 10], [2, 2], [3, 5]]
+   * type T3 = Call<Tuples.ZipWith<N.Add>, [1, 2, 3], [10, 2, 5]>; // [11, 4, 8]
+   * ```
+   */
+  export type ZipWith<fn extends Fn, arr0 extends unknown[] | _ | unset = unset, arr1 extends unknown[] | _ | unset = unset, arr2 extends unknown[] | _ | unset = unset, arr3 extends unknown[] | _ | unset = unset, arr4 extends unknown[] | _ | unset = unset, arr5 extends unknown[] | _ | unset = unset, arr6 extends unknown[] | _ | unset = unset, arr7 extends unknown[] | _ | unset = unset, arr8 extends unknown[] | _ | unset = unset, arr9 extends unknown[] | _ | unset = unset> = PartialApply<ZipWithFn<fn>, [arr0, arr1, arr2, arr3, arr4, arr5, arr6, arr7, arr8, arr9]>;
+  /**
+   * Group values in a tuple into an object, using a predicate
+   * to compute the key of each group.
+   * @param fn - function applied to all values in the tuple to get a key.
+   * @param tuple - A list of element
+   * @returns an object containing a list of element for each key.
+   * @example
+   * ```ts
+   * interface IsNumber extends Fn {
+   *   return: this["arg0"] extends number ? true : false;
+   * }
+   *
+   * type T0 = Call<Tuples.GroupBy<IsNumber>, [1, "str", 2]>;
+   * //   ^? { true: [1, 2], false: ["str"] }
+   * type T2 = Call<Tuples.GroupBy<Strings.StartsWith<"a">>, ["alice", "bob", "carl"]>;
+   * //   ^? { true: ["alice"], false: ["bob", "carl"] }
+   * ```
+   */
+  export interface GroupBy<fn extends Fn> extends Fn {
+    return: GroupByImpl<this["arg0"], fn>;
+  }
+  type GroupByImplRec<xs, fn extends Fn, acc = {}> = xs extends [infer first, ...infer rest] ? Call<fn, first> extends infer key extends PropertyKey ? GroupByImplRec<rest, fn, Std._Omit<acc, key> & { [K in key]: [...(key extends keyof acc ? Extract<acc[key], readonly any[]> : []), first] }> : never : acc;
+  export type GroupByImpl<xs, fn extends Fn> = Prettify$1<GroupByImplRec<xs, fn>>;
+  /**
+   * Range takes a `start` and an `end` integer and produces
+   * a tuple containing integer ranging from `start` to `end`
+   * @param start - the start of the range (included)
+   * @param end - the end of the range (included)
+   * @returns a tuple of integers
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.Range<3>, 7>; // [3, 4, 5, 6, 7]
+   * type T1 = Call<Tuples.Range<_, 10>, 5>; // [5, 6, 7, 8, 9, 10]
+   * type T3 = Call<Tuples.Range< -2, 2>, 5>; // [-2, 1, 0, 1, 2]
+   * type T4 = Call<Tuples.Range< -5, -2>, 5>; // [-5, -4, -3, -2]
+   * ```
+   */
+  export type Range<start extends number | _ | unset = unset, end extends number | _ | unset = unset> = PartialApply<RangeFn, [start, end]>;
+  interface RangeFn extends Fn {
+    return: this["args"] extends [infer start extends number, infer end extends number] ? Call<Numbers.LessThanOrEqual, start, end> extends true ? Pipe<start, [Numbers.Sub<end, _>, Numbers.Add<1>, Numbers.Abs]> extends infer length extends number ? RangeImpl<start, length> : never : never : never;
+  }
+  type RangeImpl<start extends number, length extends number, output extends any[] = []> = output["length"] extends length ? output : RangeImpl<start, length, [...output, Call<Numbers.Add<start, output["length"]>>]>;
+  /**
+   * Returns the length of a tuple
+   * @param tuple - any tuple
+   * @returns a number
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.Length, [1, 2, 3]>; // 3
+   * type T1 = Call<Tuples.Length, []>; 0
+   * type T2 = Call<Tuples.Length, ['a']>; 1
+   * ```
+   */
+  export type Length<tuple extends readonly any[] | _ | unset = unset> = PartialApply<LengthFn, [tuple]>;
+  interface LengthFn extends Fn {
+    return: this["args"] extends [infer tuple extends readonly any[], ...any] ? tuple["length"] : never;
+  }
+  /**
+   * Takes a tuple of numbers and returns the smallest one
+   * @param tuple - a tuple of numbers
+   * @returns a number
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.Min, [1, 2, 3]>; // 1
+   * type T1 = Call<Tuples.Min, [-1, -2, -3]>; // -3
+   * type T2 = Call<Tuples.Min, []>; never
+   * ```
+   */
+  export type Min<tuple extends readonly any[] | _ | unset = unset> = PartialApply<MinFn, [tuple]>;
+  interface MinFn extends Fn {
+    return: this["args"] extends [infer tuple extends readonly (number | bigint)[], ...any] ? MinImpl<tuple> : never;
+  }
+  type MinImpl<xs, min extends number | bigint = never> = xs extends [infer first extends number | bigint, ...infer rest] ? MinImpl<rest, [min] extends [never] ? first : Min<first, min>> : min;
+  /**
+   * Takes a tuple of numbers and returns the smallest one
+   * @param tuple - a tuple of numbers
+   * @returns a number
+   * @example
+   * ```ts
+   * type T0 = Call<Tuples.Max, [1, 2, 3]>; // 3
+   * type T1 = Call<Tuples.Max, [-1, -2, -3]>; // -1
+   * type T2 = Call<Tuples.Max, []>; never
+   * ```
+   */
+  export type Max<tuple extends readonly any[] | _ | unset = unset> = PartialApply<MaxFn, [tuple]>;
+  interface MaxFn extends Fn {
+    return: this["args"] extends [infer tuple extends readonly (number | bigint)[], ...any] ? MaxImpl<tuple> : never;
+  }
+  type MaxImpl<xs, min extends number | bigint = never> = xs extends [infer first extends number | bigint, ...infer rest] ? MaxImpl<rest, [min] extends [never] ? first : Max<first, min>> : min;
+  export {};
+}
+//#endregion
+//#region node_modules/hotscript/dist/internals/strings/impl/split.d.ts
+type ConcatSplits<Parts extends string[], Seps extends string[], Acc extends string[] = []> = Parts extends [infer First extends string, ...infer Rest extends string[]] ? ConcatSplits<Rest, Seps, [...Acc, ...SplitManySep<First, Seps>]> : Acc;
+type SplitManySep<Str extends string, Sep extends string[], Acc extends string[] = []> = Sep extends [infer FirstSep extends string, ...infer RestSep extends string[]] ? ConcatSplits<Split$2<Str, FirstSep>, RestSep> : [Str, ...Acc];
+/**
+ * Split a string into a tuple.
+ * @param Str - The string to split.
+ * @param Sep - The separator to split on, can be a union of strings of more than one character.
+ * @returns The tuple of each split. if sep is an empty string, returns a tuple of each character.
+ */
+type Split$1<Str, Sep extends string, Seps = UnionToTuple<Sep>> = Seps extends string[] ? Str extends string ? SplitManySep<Str, Seps> : [] : [];
+/**
+ * Split a string into a tuple with each character.
+ * @param Str - The string to split.
+ * @returns The tuple of each character.
+ */
+type StringToTuple<Str, Acc extends string[] = []> = Str extends string ? Str extends `${infer First}${infer Rest}` ? StringToTuple<Rest, [...Acc, First]> : Acc : [];
+//#endregion
+//#region node_modules/hotscript/dist/internals/strings/impl/trim.d.ts
+/**
+ * Trim the left side of a string.
+ * @param Str - The string to trim.
+ * @param Sep - The separator to trim.
+ * @returns The trimmed string.
+ */
+type TrimLeft<Str, Sep extends string> = Str extends `${Sep}${infer Rest}` ? TrimLeft<Rest, Sep> : Str;
+/**
+ * Trim the right side of a string.
+ * @param Str - The string to trim.
+ * @param Sep - The separator to trim.
+ * @returns The trimmed string.
+ */
+type TrimRight<Str, Sep extends string> = Str extends `${infer Rest}${Sep}` ? TrimRight<Rest, Sep> : Str;
+/**
+ * Trim a string.
+ * @param Str - The string to trim.
+ * @param Sep - The separator to trim.
+ * @returns The trimmed string.
+ */
+type Trim<Str, Sep extends string> = TrimLeft<TrimRight<Str, Sep>, Sep>;
+//#endregion
+//#region node_modules/hotscript/dist/internals/strings/impl/replace.d.ts
+type Replace<Str, From extends string, To extends string> = Str extends string ? Str extends `${infer Before}${From}${infer After}` ? Replace<`${Before}${To}${After}`, From, To> : Str : Str;
+interface ReplaceReducer<To extends string> extends Fn {
+  return: this["args"] extends [infer Str extends string, infer From extends string, ...any] ? Replace<Str, From, To> : never;
+}
+//#endregion
+//#region node_modules/hotscript/dist/internals/strings/impl/repeat.d.ts
+type RepeatX2<T extends string> = `${T}${T}`;
+type Repeat<T extends string, N extends number, Acc extends string = "", Calc extends {
+  Quotient: number;
+  Remainder: number;
+} = DivMod<N, 2>> = N extends 0 ? Acc : N extends 1 ? `${Acc}${T}` : Calc["Remainder"] extends 0 ? Repeat<RepeatX2<T>, Calc["Quotient"], Acc> : Repeat<T, Sub<N, 1>, `${Acc}${T}`>;
+//#endregion
+//#region node_modules/hotscript/dist/internals/strings/impl/compare.d.ts
+type ascii = {
+  " ": 32;
+  "!": 33;
+  '"': 34;
+  "#": 35;
+  $: 36;
+  "%": 37;
+  "&": 38;
+  "'": 39;
+  "(": 40;
+  ")": 41;
+  "*": 42;
+  "+": 43;
+  ",": 44;
+  "-": 45;
+  ".": 46;
+  "/": 47;
+  "0": 48;
+  "1": 49;
+  "2": 50;
+  "3": 51;
+  "4": 52;
+  "5": 53;
+  "6": 54;
+  "7": 55;
+  "8": 56;
+  "9": 57;
+  ":": 58;
+  ";": 59;
+  "<": 60;
+  "=": 61;
+  ">": 62;
+  "?": 63;
+  "@": 64;
+  A: 65;
+  B: 66;
+  C: 67;
+  D: 68;
+  E: 69;
+  F: 70;
+  G: 71;
+  H: 72;
+  I: 73;
+  J: 74;
+  K: 75;
+  L: 76;
+  M: 77;
+  N: 78;
+  O: 79;
+  P: 80;
+  Q: 81;
+  R: 82;
+  S: 83;
+  T: 84;
+  U: 85;
+  V: 86;
+  W: 87;
+  X: 88;
+  Y: 89;
+  Z: 90;
+  "[": 91;
+  "\\": 92;
+  "]": 93;
+  "^": 94;
+  _: 95;
+  "`": 96;
+  a: 97;
+  b: 98;
+  c: 99;
+  d: 100;
+  e: 101;
+  f: 102;
+  g: 103;
+  h: 104;
+  i: 105;
+  j: 106;
+  k: 107;
+  l: 108;
+  m: 109;
+  n: 110;
+  o: 111;
+  p: 112;
+  q: 113;
+  r: 114;
+  s: 115;
+  t: 116;
+  u: 117;
+  v: 118;
+  w: 119;
+  x: 120;
+  y: 121;
+  z: 122;
+  "{": 123;
+  "|": 124;
+  "}": 125;
+  "~": 126;
+  é: 130;
+  â: 131;
+  ä: 132;
+  à: 133;
+  å: 134;
+  ç: 135;
+  ê: 136;
+  ë: 137;
+  è: 138;
+  ï: 139;
+  î: 140;
+  ì: 141;
+  Ä: 142;
+  Å: 143;
+  É: 144;
+  æ: 145;
+  Æ: 146;
+  ô: 147;
+  ö: 148;
+  ò: 149;
+  û: 150;
+  ù: 151;
+  ÿ: 152;
+  Ö: 153;
+  Ü: 154;
+  ø: 155;
+  "£": 156;
+  Ø: 157;
+  "×": 158;
+  ƒ: 159;
+  á: 160;
+  í: 161;
+  ó: 162;
+  ú: 163;
+  ñ: 164;
+  Ñ: 165;
+  ª: 166;
+  º: 167;
+  "¿": 168;
+  "®": 169;
+  "½": 171;
+  "¼": 172;
+  "¡": 173;
+  "«": 174;
+  "»": 175;
+  "░": 176;
+  "▒": 177;
+  "▓": 178;
+  "│": 179;
+  "┤": 180;
+  Á: 181;
+  Â: 182;
+  À: 183;
+  "©": 184;
+  "╣": 185;
+  "║": 186;
+  "╗": 187;
+  "╝": 188;
+  "¢": 189;
+  "¥": 190;
+  "┐": 191;
+  "└": 192;
+  "┴": 193;
+  "┬": 194;
+  "├": 195;
+  "─": 196;
+  "┼": 197;
+  ã: 198;
+  Ã: 199;
+  "╚": 200;
+  "╔": 201;
+  "╩": 202;
+  "╦": 203;
+  "╠": 204;
+  "═": 205;
+  "╬": 206;
+  "¤": 207;
+  ð: 208;
+  Ð: 209;
+  Ê: 210;
+  Ë: 211;
+  È: 212;
+  ı: 213;
+  Í: 214;
+  Î: 215;
+  Ï: 216;
+  "┘": 217;
+  "┌": 218;
+  "█": 219;
+  "▄": 220;
+  "¦": 221;
+  Ì: 222;
+  "▀": 223;
+  Ó: 224;
+  ß: 225;
+  Ô: 226;
+  Ò: 227;
+  õ: 228;
+  Õ: 229;
+  µ: 230;
+  þ: 231;
+  Þ: 232;
+  Ú: 233;
+  Û: 234;
+  Ù: 235;
+  ý: 236;
+  Ý: 237;
+  "¯": 238;
+  "´": 239;
+  "¬": 240;
+  "±": 241;
+  "‗": 242;
+  "¾": 243;
+  "¶": 244;
+  "§": 245;
+  "÷": 246;
+  "¸": 247;
+  "°": 248;
+  "¨": 249;
+  "•": 250;
+  "¹": 251;
+  "³": 252;
+  "²": 253;
+  "■": 254;
+};
+type CharacterCompare<Char1 extends string, Char2 extends string> = Char1 extends Char2 ? 0 : Char1 extends keyof ascii ? Char2 extends keyof ascii ? Call<Numbers.Compare, ascii[Char1], ascii[Char2]> : 1 : -1;
+type CharactersCompare<T extends string[], U extends string[]> = T extends [infer N1 extends string, ...infer R1 extends string[]] ? U extends [infer N2 extends string, ...infer R2 extends string[]] ? CharacterCompare<N1, N2> extends 0 ? CharactersCompare<R1, R2> : CharacterCompare<N1, N2> : 1 : U extends [string, ...string[]] ? -1 : 0;
+type Compare<T extends string, U extends string> = Equal$1<T, U> extends true ? 0 : CharactersCompare<StringToTuple<T>, StringToTuple<U>>;
+type LessThan<T extends string, U extends string> = Compare<T, U> extends -1 ? true : false;
+type LessThanOrEqual<T extends string, U extends string> = Compare<T, U> extends 1 ? false : true;
+type GreaterThan<T extends string, U extends string> = Compare<T, U> extends 1 ? true : false;
+type GreaterThanOrEqual<T extends string, U extends string> = Compare<T, U> extends -1 ? false : true;
+//#endregion
+//#region node_modules/hotscript/dist/internals/strings/impl/utils.d.ts
+declare namespace StringIterator {
+  type Iter = [string, number | bigint];
+  /**
+   * Iterator over the string is a linked list of [string, number] pairs
+   * where the string is the pattern to match any character in the string 'N' times
+   * and the number is the value 'N' of the pattern
+   * the linked list allows to easily add iterate and reverse iterate
+   */
+  export type Iterator = [Iter, ...Iter[]];
+  /**
+   * The initial iterator is a list of one element
+   *
+   * @description we need to prefix the pattern with '$'
+   *
+   * to avoid typescript to merge multiple patterns into one
+   */
+  export type Init = [[`$${string}`, 1]];
+  /**
+   * The string is the pattern to match any character in the string 'N' times
+   *
+   * @param It - the iterator to get the string from
+   * @returns the string
+   */
+  export type String<It extends Iterator> = It[0][0];
+  /**
+   * The value is the number 'N' of the pattern
+   *
+   * @param It - the iterator to get the value from
+   * @returns the value
+   */
+  export type Value<It extends Iterator> = It[0][1];
+  /**
+   * The size is the number of elements in the linked list
+   *
+   * @param It - the iterator to get the size from
+   * @returns the size
+   */
+  export type Size<It extends Iterator> = It["length"];
+  /**
+   * Get the next iterator
+   *
+   * @param It - the iterator to get the next iterator from
+   * @returns the next iterator
+   */
+  export type Next<It extends Iterator> = [[`${String<It>}${string}`, Add<Value<It>, 1>], ...It];
+  /**
+   * Get the previous iterator
+   * @param It - the iterator to get the previous iterator from
+   * @returns the previous iterator
+   */
+  export type Prev<It extends Iterator> = It extends [unknown, ...infer Rest extends Iterator] ? Rest : undefined;
+  /**
+   * Double the iterator to match any character in the string '2N' times
+   * This allows the algorithm to be O(log(N)) instead of O(N)
+   *
+   * @description we need to prefix the pattern with '$' and suffix it with '_'
+   * to avoid typescript to merge multiple patterns into one
+   *
+   * @param It - the iterator to double
+   * @returns the doubled iterator
+   */
+  export type Double<It extends Iterator> = `${String<It>}_` extends `$${infer pattern}` ? `${String<It>}${pattern}` extends `${infer double}_` ? [[double, Mul<Value<It>, 2>], ...It] : never : never;
+  /**
+   * Cut the string at the iterator
+   *
+   * @param T - the string to cut
+   * @param It - the iterator to cut at
+   * @returns the rest of the string
+   */
+  export type CutAt<T extends string, It extends Iterator> = `$${T}` extends `${String<It>}${infer $Rest}` ? $Rest : undefined;
+  export {};
+}
+//#endregion
+//#region node_modules/hotscript/dist/internals/strings/impl/length.d.ts
+type LengthUp<Str extends string, Length extends number | bigint = 0, It extends StringIterator.Iterator = StringIterator.Init> = StringIterator.Double<It> extends infer $DoubleIt extends StringIterator.Iterator ? StringIterator.CutAt<Str, $DoubleIt> extends `${infer $Rest}` ? StringIterator.Size<It> extends 12 ? LengthDown<$Rest, Add<Length, StringIterator.Value<$DoubleIt>>, $DoubleIt> : LengthUp<$Rest, Add<Length, StringIterator.Value<$DoubleIt>>, $DoubleIt> : StringIterator.CutAt<Str, It> extends `${infer $Rest}` ? LengthUp<$Rest, Add<Length, StringIterator.Value<It>>, It> : LengthDown<Str, Length, StringIterator.Prev<It>> : never;
+type LengthDown<Str extends string, Length extends number | bigint, It> = It extends StringIterator.Iterator ? StringIterator.CutAt<Str, It> extends `${infer $Rest}` ? LengthDown<$Rest, Add<Length, StringIterator.Value<It>>, It> : LengthDown<Str, Length, StringIterator.Prev<It>> : Length;
+type Length<T extends string> = T extends "" ? 0 : LengthUp<T>;
+//#endregion
+//#region node_modules/hotscript/dist/internals/strings/Strings.d.ts
+declare namespace Strings {
+  export type Stringifiable = string | number | boolean | bigint | null | undefined;
+  /**
+   * Get the length of a string.
+   * @param args[0] - The string to get the length of.
+   * @returns The length of the string.
+   * @warning - 🔥 does not work with emojis since they are multiple characters 🔥
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.Length,"abc">; // 3
+   * ```
+   */
+  export type Length<Str = unset> = PartialApply<LengthFn, [Str]>;
+  /**
+   * Get the length of a string.
+   * @param args[0] - The string to get the length of.
+   * @returns The length of the string.
+   * @warning - 🔥 does not work with emojis since they are multiple characters 🔥
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.Length,"abc">; // 3
+   * ```
+   */
+  export interface LengthFn extends Fn {
+    return: this["arg0"] extends string ? Length<this["arg0"]> : never;
+  }
+  /**
+   * Trim the left side of a string.
+   * @param args[0] - The string to trim.
+   * @param Sep - The separator to trim.
+   * @returns The trimmed string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.TrimLeft,"  abc">; // "abc"
+   * ```
+   */
+  export type TrimLeft<Sep extends string | _ = " ", Str = unset> = PartialApply<TrimLeftFn, [Sep, Str]>;
+  interface TrimLeftFn extends Fn {
+    return: this["args"] extends [infer Sep extends string, infer Str extends string, ...any] ? TrimLeft<Str, Sep> : never;
+  }
+  /**
+   * Trim the right side of a string.
+   * @param args[0] - The string to trim.
+   * @param Sep - The separator to trim.
+   * @returns The trimmed string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.TrimRight,"abc  ">; // "abc"
+   * ```
+   */
+  export type TrimRight<Sep extends string | _ = " ", Str = unset> = PartialApply<TrimRightFn, [Sep, Str]>;
+  interface TrimRightFn extends Fn {
+    return: this["args"] extends [infer Sep extends string, infer Str extends string, ...any] ? TrimRight<Str, Sep> : never;
+  }
+  /**
+   * Trim a string.
+   * @param args[0] - The string to trim.
+   * @param Sep - The separator to trim.
+   * @returns The trimmed string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.Trim,"  abc  ">; // "abc"
+   * ```
+   */
+  export type Trim<Sep extends string | _ = " ", Str = unset> = PartialApply<TrimFn, [Sep, Str]>;
+  interface TrimFn extends Fn {
+    return: this["args"] extends [infer Sep extends string, infer Str extends string, ...any] ? Trim<Str, Sep> : never;
+  }
+  /**
+   * Replace all instances of a substring in a string.
+   * @param args[0] - The string to replace.
+   * @param from - The substring to replace.
+   * @param to - The substring to replace with.
+   * @returns The replaced string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.Replace<".","/">,"a.b.c.d">; // "a/b/c/d"
+   */
+  export type Replace<from extends string | unset | _ = unset, to extends string | unset | _ = unset, str = unset> = PartialApply<ReplaceFn, [from, to, str]>;
+  interface ReplaceFn extends Fn {
+    return: this["args"] extends [infer From extends string, infer To extends string, infer Str, ...any] ? Call<Tuples.Reduce<ReplaceReducer<To>, Str>, UnionToTuple<From>> : never;
+  }
+  /**
+   * Cut a slice of a string out from a start index to an end index.
+   * @param args[0] - The string to slice.
+   * @param start - The start index.
+   * @param end - The end index.
+   * @returns The sliced string.
+   * @warning - 🔥 does not work with emojis since they are multiple characters 🔥
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.Slice<1,9>,"1234567890">; // "23456789"
+   */
+  export type Slice<start extends number | unset | _ = unset, end extends number | unset | _ = unset> = ComposeLeft<[Strings.Split<"">, Tuples.Take<end>, Tuples.Drop<start>, Tuples.Join<"">]>;
+  /**
+   * Split a string into a tuple of strings.
+   * @param args[0] - The string to split.
+   * @param sep - The separator to split the string with.
+   * @returns The split string.
+   * @warning - 🔥 using an empty sep with emojis in the string will destroy the emoji 🔥
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.Split<",">,"a,b,c">; // ["a","b","c"]
+   * ```
+   */
+  export type Split<Sep extends string | unset | _ = unset, Str extends string | unset | _ = unset> = PartialApply<SplitFn, [Sep, Str]>;
+  export interface SplitFn extends Fn {
+    return: this["args"] extends [infer Sep extends string, infer Str, ...any] ? Split$1<Str, Sep> : never;
+  }
+  /**
+   * Repeat a string a number of times.
+   * @param args[0] - The string to repeat.
+   * @param times - The number of times to repeat the string.
+   * @returns The repeated string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.Repeat<3>,"Hello! ">; // "Hello! Hello! Hello! "
+   * ```
+   */
+  export type Repeat<Times extends number | _ | unset = unset, Str extends string | _ | unset = unset> = PartialApply<RepeatFn, [Times, Str]>;
+  interface RepeatFn extends Fn {
+    return: this["args"] extends [infer Times extends number, infer Str extends string] ? Repeat<Str, Times> : never;
+  }
+  /**
+   * Check if a string starts with a substring.
+   * @param args[0] - The string to check.
+   * @param str - The substring to check for.
+   * @returns Whether the string starts with the substring.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.StartsWith<"abc">,"abcdef">; // true
+   * type T1 = Call<Strings.StartsWith<"abc">,"defabc">; // false
+   * ```
+   */
+  export type StartsWith<Start extends string | _ | unset = unset, Str extends string | _ | unset = unset> = PartialApply<StartsWithFn, [Start, Str]>;
+  interface StartsWithFn extends Fn {
+    return: this["args"] extends [infer Start extends string, infer Str] ? Str extends `${Start}${string}` ? true : false : never;
+  }
+  /**
+   * Check if a string ends with a substring.
+   * @param args[0] - The string to check.
+   * @param str - The substring to check for.
+   * @returns Whether the string ends with the substring.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.EndsWith<"abc">,"abcdef">; // false
+   * type T1 = Call<Strings.EndsWith<"abc">,"defabc">; // true
+   * ```
+   */
+  export type EndsWith<End extends string | _ | unset = unset, Str extends string | _ | unset = unset> = PartialApply<EndsWithFn, [End, Str]>;
+  interface EndsWithFn extends Fn {
+    return: this["args"] extends [infer End extends string, infer Str] ? Str extends `${string}${End}` ? true : false : never;
+  }
+  /**
+   * Split a string into a tuple of each character.
+   * @param args[0] - The string to split.
+   * @returns The splited string.
+   * @warning - 🔥 does not work with emojis since they are multiple characters 🔥
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.ToTuple,"abc">; // ["a","b","c"]
+   * ```
+   */
+  export interface ToTuple extends Fn {
+    return: StringToTuple<this["arg0"]>;
+  }
+  /**
+   * Convert a string to a number or bigint.
+   * @param args[0] - The string to convert.
+   * @returns The converted number or bigint.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.ToNumber,"123">; // 123
+   * type T1 = Call<Strings.ToNumber,"12367543547677078675456656790">; // 12367543547677078675456656790n
+   * ```
+   */
+  export interface ToNumber extends Fn {
+    return: this["arg0"] extends `${infer n extends number | bigint}` ? n : never;
+  }
+  /**
+   * Convert a stringifiable literal to a string.
+   * @param args[0] - The stringifiable literal to convert.
+   * @returns The converted string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.ToString,123>; // "123"
+   * type T1 = Call<Strings.ToString,true>; // "true"
+   * type T2 = Call<Strings.ToString,null>; // "null"
+   * ```
+   */
+  export interface ToString extends Fn {
+    return: `${Extract<this["arg0"], Strings.Stringifiable>}`;
+  }
+  /**
+   * Prepend a string to another string.
+   * @param args[0] - The string to be prepended to.
+   * @param str - The string to prepend.
+   * @returns The prepended string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.Prepend<"abc">,"def">; // "abcdef"
+   * ```
+   */
+  export type Prepend<Start extends string | _ | unset = unset, Str extends string | _ | unset = unset> = PartialApply<PrependFn, [Start, Str]>;
+  interface PrependFn extends Fn {
+    return: `${Extract<this["arg0"], Strings.Stringifiable>}${Extract<this["arg1"], Strings.Stringifiable>}`;
+  }
+  /**
+   * Append a string to another string.
+   * @param args[0] - The string to be appended to.
+   * @param str - The string to append.
+   * @returns The appended string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.Append<"abc">,"def">; // "defabc"
+   * ```
+   */
+  export type Append<End extends string | _ | unset = unset, Str extends string | _ | unset = unset> = PartialApply<AppendFn, [End, Str]>;
+  interface AppendFn extends Fn {
+    return: `${Extract<this["arg1"], Strings.Stringifiable>}${Extract<this["arg0"], Strings.Stringifiable>}`;
+  }
+  /**
+   * Transform a string to uppercase.
+   * @param args[0] - The string to transform.
+   * @returns The transformed string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.Uppercase,"abc">; // "ABC"
+   * ```
+   */
+  export interface Uppercase extends Fn {
+    return: Std._Uppercase<Extract<this["arg0"], string>>;
+  }
+  /**
+   * Transform a string to lowercase.
+   * @param args[0] - The string to transform.
+   * @returns The transformed string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.Lowercase,"ABC">; // "abc"
+   * ```
+   */
+  export interface Lowercase extends Fn {
+    return: Std._Lowercase<Extract<this["arg0"], string>>;
+  }
+  /**
+   * Capitalize a string.
+   * @param args[0] - The string to capitalize.
+   * @returns The capitalized string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.Capitalize,"abc">; // "Abc"
+   * ```
+   */
+  export interface Capitalize extends Fn {
+    return: Std._Capitalize<Extract<this["arg0"], string>>;
+  }
+  /**
+   * Uncapitalize a string.
+   * @param args[0] - The string to uncapitalize.
+   * @returns The uncapitalized string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.Uncapitalize,"AddTop">; // "addTop"
+   * ```
+   */
+  export interface Uncapitalize extends Fn {
+    return: Std._Uncapitalize<Extract<this["arg0"], string>>;
+  }
+  /**
+   * Convert a string to snake case.
+   * @param args[0] - The string to convert.
+   * @returns The converted string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.SnakeCase,"AddTop">; // "add_top"
+   * ```
+   */
+  export interface SnakeCase extends Fn {
+    return: SnakeCase<this["arg0"]>;
+  }
+  /**
+   * Convert a string to camel case.
+   * @param args[0] - The string to convert.
+   * @returns The converted string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.CamelCase,"add_top">; // "addTop"
+   * ```
+   */
+  export interface CamelCase extends Fn {
+    return: CamelCase<this["arg0"]>;
+  }
+  /**
+   * Convert a string to kebab case.
+   * @param args[0] - The string to convert.
+   * @returns The converted string.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.KebabCase,"add_top">; // "add-top"
+   * type T1 = Call<Strings.KebabCase,"AddTop">; // "add-top"
+   * type T2 = Call<Strings.KebabCase,"addTop">; // "add-top"
+   * ```
+   */
+  export interface KebabCase extends Fn {
+    return: KebabCase<this["arg0"]>;
+  }
+  /**
+   * Compare two strings. (only works with ascii extended characters)
+   * @param args[0] - The first string to compare.
+   * @param args[1] - The second string to compare.
+   * @n1 - The first string to compare or _.
+   * @n2 - The second string to compare or _.
+   * @returns The result of the comparison.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.Compare,"abc","def">; // -1
+   * type T1 = Call<Strings.Compare,"def","abc">; // 1
+   * type T2 = Call<Strings.Compare,"abc","abc">; // 0
+   * ```
+   */
+  export type Compare<n1 extends string | _ | unset = unset, n2 extends string | _ | unset = unset> = PartialApply<CompareFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface CompareFn extends Fn {
+    return: this["args"] extends [infer a extends string, infer b extends string, ...any] ? Compare<a, b> : never;
+  }
+  /**
+   * Check if a string is lexically less than another string. (only works with ascii extended characters)
+   * @param args[0] - The first string to compare.
+   * @param args[1] - The second string to compare.
+   * @n1 - The first string to compare or _.
+   * @n2 - The second string to compare or _.
+   * @returns True if the first string is lexically less than the second string, false otherwise.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.LessThan,"abc","def">; // true
+   * type T1 = Call<Strings.LessThan,"def","abc">; // false
+   * type T2 = Call<Strings.LessThan,"abc","abc">; // false
+   * ```
+   */
+  export type LessThan<n1 extends string | _ | unset = unset, n2 extends string | _ | unset = unset> = PartialApply<LessThanFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface LessThanFn extends Fn {
+    return: this["args"] extends [infer a extends string, infer b extends string, ...any] ? LessThan<a, b> : never;
+  }
+  /**
+   * Check if a string is lexically less than or equal to another string. (only works with ascii extended characters)
+   * @param args[0] - The first string to compare.
+   * @param args[1] - The second string to compare.
+   * @n1 - The first string to compare or _.
+   * @n2 - The second string to compare or _.
+   * @returns True if the first string is lexically less than or equal to the second string, false otherwise.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.LessThanOrEqual,"abc","def">; // true
+   * type T1 = Call<Strings.LessThanOrEqual,"def","abc">; // false
+   * type T2 = Call<Strings.LessThanOrEqual,"abc","abc">; // true
+   */
+  export type LessThanOrEqual<n1 extends string | _ | unset = unset, n2 extends string | _ | unset = unset> = PartialApply<LessThanOrEqualFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface LessThanOrEqualFn extends Fn {
+    return: this["args"] extends [infer a extends string, infer b extends string, ...any] ? LessThanOrEqual<a, b> : never;
+  }
+  /**
+   * Check if a string is lexically greater than another string. (only works with ascii extended characters)
+   * @param args[0] - The first string to compare.
+   * @param args[1] - The second string to compare.
+   * @n1 - The first string to compare or _.
+   * @n2 - The second string to compare or _.
+   * @returns True if the first string is lexically greater than the second string, false otherwise.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.GreaterThan,"abc","def">; // false
+   * type T1 = Call<Strings.GreaterThan,"def","abc">; // true
+   * type T2 = Call<Strings.GreaterThan,"abc","abc">; // false
+   * ```
+   */
+  export type GreaterThan<n1 extends string | _ | unset = unset, n2 extends string | _ | unset = unset> = PartialApply<GreaterThanFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface GreaterThanFn extends Fn {
+    return: this["args"] extends [infer a extends string, infer b extends string, ...any] ? GreaterThan<a, b> : never;
+  }
+  /**
+   * Check if a string is lexically greater than or equal to another string. (only works with ascii extended characters)
+   * @param args[0] - The first string to compare.
+   * @param args[1] - The second string to compare.
+   * @n1 - The first string to compare or _.
+   * @n2 - The second string to compare or _.
+   * @returns True if the first string is lexically greater than or equal to the second string, false otherwise.
+   * @example
+   * ```ts
+   * type T0 = Call<Strings.GreaterThanOrEqual,"abc","def">; // false
+   * type T1 = Call<Strings.GreaterThanOrEqual,"def","abc">; // true
+   * type T2 = Call<Strings.GreaterThanOrEqual,"abc","abc">; // true
+   * ```
+   */
+  export type GreaterThanOrEqual<n1 extends string | _ | unset = unset, n2 extends string | _ | unset = unset> = PartialApply<GreaterThanOrEqualFn, n2 extends unset ? [unset, n1] : [n1, n2]>;
+  interface GreaterThanOrEqualFn extends Fn {
+    return: this["args"] extends [infer a extends string, infer b extends string, ...any] ? GreaterThanOrEqual<a, b> : never;
+  }
+  export {};
+}
+//#endregion
+//#region node_modules/hotscript/dist/internals/objects/impl/objects.d.ts
+type Keys<src> = src extends readonly unknown[] ? { [key in keyof src]: key }[number] extends infer res ? res extends string ? Call<Strings.ToNumber, res> & keyof src : res & keyof src : never : keyof src;
+type Values<src> = Keys<src> extends infer keys extends keyof src ? src[keys] : never;
+type FromEntries<entries extends [PropertyKey, any]> = { [entry in entries as entry[0]]: entry[1] } | never;
+type Entries<T> = Keys<T> extends infer keys extends keyof T ? { [K in keys]: [K, T[K]] }[keys] : never;
+type Assign<xs extends readonly any[]> = Prettify$1<UnionToIntersection<xs[number]>>;
+type GetFromPath<Obj, path> = RecursiveGet<Obj, ParsePath<path>>;
+type ParsePath<path, output extends string[] = [], currentChunk extends string = ""> = path extends number ? [`${path}`] : path extends `${infer first}${infer rest}` ? first extends "." | "[" | "]" ? ParsePath<rest, [...output, ...(currentChunk extends "" ? [] : [currentChunk])], ""> : ParsePath<rest, output, `${currentChunk}${first}`> : [...output, ...(currentChunk extends "" ? [] : [currentChunk])];
+type RecursiveGet<Obj, pathList> = Obj extends any ? pathList extends [infer first, ...infer rest] ? first extends keyof Obj ? RecursiveGet<Obj[first], rest> : [first, Obj] extends [`${number}` | "number", readonly any[]] ? RecursiveGet<Extract<Obj, any[]>[number], rest> : undefined : Obj : never;
+type TransformObjectDeep<fn extends Fn, type> = type extends Function | Date ? type : type extends Map<infer keys, infer values> ? Map<TransformObjectDeep<fn, keys>, TransformObjectDeep<fn, values>> : type extends ReadonlyMap<infer keys, infer values> ? ReadonlyMap<TransformObjectDeep<fn, keys>, TransformObjectDeep<fn, values>> : type extends WeakMap<infer keys, infer values> ? WeakMap<Extract<TransformObjectDeep<fn, keys>, object>, TransformObjectDeep<fn, values>> : type extends Set<infer values> ? Set<TransformObjectDeep<fn, values>> : type extends ReadonlySet<infer values> ? ReadonlySet<TransformObjectDeep<fn, values>> : type extends WeakSet<infer values> ? WeakSet<Extract<TransformObjectDeep<fn, values>, object>> : type extends Array<infer values> ? IsTuple<type> extends true ? Call<fn, { [Key in keyof type]: TransformObjectDeep<fn, type[Key]> }> : Array<TransformObjectDeep<fn, values> | undefined> : type extends Promise<infer value> ? Promise<TransformObjectDeep<fn, value>> : type extends object ? Call<fn, { [Key in keyof type]: TransformObjectDeep<fn, type[Key]> }> : Equal$1<type, unknown> extends true ? unknown : Partial<type>;
+type Update<obj, path, fnOrValue> = RecursiveUpdate<obj, ParsePath<path>, fnOrValue>;
+type RecursiveUpdate<obj, pathList, fnOrValue> = obj extends any ? pathList extends [infer first, ...infer rest] ? first extends keyof obj ? { [K in keyof obj]: Equal$1<first, K> extends true ? RecursiveUpdate<obj[K], rest, fnOrValue> : obj[K] } : [first, obj] extends ["number", readonly any[]] ? RecursiveUpdate<Extract<obj, any[]>[number], rest, fnOrValue>[] : Assign<[obj, { [K in Extract<first, PropertyKey>]: RecursiveUpdate<{}, rest, fnOrValue> }]> : fnOrValue extends Fn ? Call<Extract<fnOrValue, Fn>, obj> : fnOrValue : never;
+type Create<pattern, args extends unknown[]> = pattern extends infer p extends Fn ? Apply<p, args> : pattern extends Primitive$1 ? pattern : pattern extends readonly [any, ...any] ? { [key in keyof pattern]: Create<pattern[key], args> } : pattern extends readonly (infer V)[] ? Create<V, args>[] : pattern extends object ? { [key in keyof pattern]: Create<pattern[key], args> } : pattern;
+type JoinPath<A extends string, B extends string, Sep extends string = ""> = [A] extends [never] ? B : [B] extends [never] ? A : `${A}${Sep}${B}`;
+type AllPaths<T, ParentPath extends string = never> = T extends Primitive$1 ? ParentPath : unknown extends T ? JoinPath<ParentPath, string, "."> : T extends readonly any[] ? Keys<T> extends infer key extends string | number ? JoinPath<ParentPath, `[${key}]`> | AllPaths<T[number], JoinPath<ParentPath, `[${key}]`>> : never : keyof T extends infer key extends keyof T & string ? key extends any ? JoinPath<ParentPath, key, "."> | AllPaths<T[key], JoinPath<ParentPath, key, ".">> : never : ParentPath;
+//#endregion
+//#region node_modules/hotscript/dist/internals/objects/Objects.d.ts
+declare namespace Objects {
+  /**
+   * Create an object from a union of `[key, value]` entries.
+   * @param entries - union of entries to convert to an object
+   * @returns an object
+   * @example
+   * ```ts
+   * type T0 = Call<Objects.FromEntries, ["a", 1] | ["b", true]>; // { a: 1; b: true }
+   * ```
+   */
+  export interface FromEntries extends Fn {
+    return: FromEntries<Extract<this["arg0"], [PropertyKey, any]>>;
+  }
+  /**
+   * Turn an object into a union of entries
+   * @param obj - The object to transform to entries
+   * @returns a union of `[key, value]` entry tuples.
+   * @example
+   * ```ts
+   * type T0 = Call<Objects.Entries, { a: 1; b: true }>; // ["a", 1] | ["b", true]
+   * ```
+   */
+  export interface Entries extends Fn {
+    return: Entries<this["arg0"]>;
+  }
+  type MapValuesImpl<T, fn extends Fn> = { [K in keyof T]: Call<fn, T[K], K> };
+  /**
+   * Map over values in an object type.
+   * @param fn - The function to run on every object value
+   * @param obj - The object to transform
+   * @returns a new object with updated values
+   * @example
+   * ```ts
+   * type T0 = Call<
+   *   Objects.MapValues<Strings.ToNumber>,
+   *   { a: "1"; b: "2" }
+   * >; // { a: 1, b: 2 }
+   * ```
+   */
+  export interface MapValues<fn extends Fn> extends Fn {
+    return: MapValuesImpl<this["arg0"], fn>;
+  }
+  type MapKeysImpl<T, fn extends Fn> = { [K in keyof T as Extract<Call<fn, K>, PropertyKey>]: T[K] };
+  /**
+   * Map over keys in an object type.
+   * @param fn - The function to run on every object key
+   * @param obj - The object to transform
+   * @returns a new object with updated keys
+   * @example
+   * ```ts
+   * type T0 = Call<
+   *   Objects.MapKeys<Strings.Uppercase>,
+   *   { a: 1; b: 2 }
+   * >; // { A: 1, B: 2 }
+   * ```
+   */
+  export interface MapKeys<fn extends Fn> extends Fn {
+    return: MapKeysImpl<this["arg0"], fn>;
+  }
+  /**
+   * Turn object keys into kebab-case
+   * @param obj - The object to transform
+   * @returns a new object with updated keys
+   * @example
+   * ```ts
+   * type T0 = Call<
+   *   Objects.KebabCase,
+   *   { userName: "Bob" }
+   * >; // { "user-name": "Bob" }
+   * ```
+   */
+  export interface KebabCase extends Fn {
+    return: Call<MapKeys<Strings.KebabCase>, this["arg0"]>;
+  }
+  /**
+   * Turn object keys into snake_case
+   * @param obj - The object to transform
+   * @returns a new object with updated keys
+   * @example
+   * ```ts
+   * type T0 = Call<
+   *   Objects.SnakeCase,
+   *   { userName: "Bob" }
+   * >; // { user_name: "Bob" }
+   * ```
+   */
+  export interface SnakeCase extends Fn {
+    return: Call<MapKeys<Strings.SnakeCase>, this["arg0"]>;
+  }
+  /**
+   * Turn object keys into camelCase
+   * @param obj - The object to transform
+   * @returns a new object with updated keys
+   * @example
+   * ```ts
+   * type T0 = Call<
+   *   Objects.CamelCase,
+   *   { user_name: "Bob" }
+   * >; // { userName: "Bob" }
+   * ```
+   */
+  export interface CamelCase extends Fn {
+    return: Call<MapKeys<Strings.CamelCase>, this["arg0"]>;
+  }
+  type MapKeysDeepImpl<T, fn extends Fn> = IsArrayStrict<T> extends true ? MapKeysDeepImpl<Extract<T, readonly any[]>[number], fn>[] : T extends object ? { [K in keyof T as Extract<Call<fn, K>, PropertyKey>]: Prettify$1<MapKeysDeepImpl<T[K], fn>> } : T;
+  /**
+   * Recursively transform all keys in a structure of object types
+   * @param fn - The function to apply to every key
+   * @param obj - The object to transform
+   * @returns a new object with updated keys
+   * @example
+   * ```ts
+   * type T0 = Call<
+   *   Objects.MapKeysDeep<Strings.Prepend<'_'>>,
+   *   { a: { b: { c: string } } }
+   * >; // { _a: { _b: { _c: string } } }
+   * ```
+   */
+  export interface MapKeysDeep<fn extends Fn> extends Fn {
+    return: MapKeysDeepImpl<this["arg0"], fn>;
+  }
+  /**
+   * Recursively transform all keys of a deeply nested object
+   * to kebab-case.
+   * @param obj - The object to transform
+   * @returns a new object with updated keys
+   * @example
+   * ```ts
+   * type T0 = Call<
+   *   Objects.KebabCaseDeep,
+   *   { currentUser: { firstName: string } }
+   * >; // { "current-user": { "first-name": string } }
+   * ```
+   */
+  export interface KebabCaseDeep extends Fn {
+    return: Call<MapKeysDeep<Strings.KebabCase>, this["arg0"]>;
+  }
+  /**
+   * Recursively transform all keys of a deeply nested object
+   * to snake_case.
+   * @param obj - The object to transform
+   * @returns a new object with updated keys
+   * @example
+   * ```ts
+   * type T0 = Call<
+   *   Objects.SnakeCaseDeep,
+   *   { currentUser: { firstName: string } }
+   * >; // { current_user: { first_name: string } }
+   * ```
+   */
+  export interface SnakeCaseDeep extends Fn {
+    return: Call<MapKeysDeep<Strings.SnakeCase>, this["arg0"]>;
+  }
+  /**
+   * Recursively transform all keys of a deeply nested object
+   * to camelCase.
+   * @param obj - The object to transform
+   * @returns a new object with updated keys
+   * @example
+   * ```ts
+   * type T0 = Call<
+   *   Objects.CamelCaseDeep,
+   *   { current_user: { first_name: string } }
+   * >; // { currentUser: { firstName: string } }
+   * ```
+   */
+  export interface CamelCaseDeep extends Fn {
+    return: Call<MapKeysDeep<Strings.CamelCase>, this["arg0"]>;
+  }
+  /**
+   * Only keep keys of an object if they are
+   * assignable to some type.
+   * @param key - The type remaining keys should be assignable to
+   * @param obj - The object to filter
+   * @returns a filtered object
+   * @example
+   * ```ts
+   * type T0 = Call<
+   *   Objects.Pick<"a" | "b">,
+   *   { a: 1, b: 1, c: 1 }
+   * >; // { a: 1, b: 1 }
+   * ```
+   */
+  export type Pick<key = unset, obj = unset> = PartialApply<PickFn, [key, obj]>;
+  interface PickFn extends Fn {
+    return: PickImpl<this["arg1"], this["arg0"]>;
+  }
+  type PickImpl<obj, keys> = { [key in Extract<keyof obj, keys>]: obj[key] };
+  /**
+   * Only keep keys of an object if they aren't
+   * assignable to some type.
+   * @param key - The type remaining keys should _not_ be assignable to
+   * @param obj - The object to filter
+   * @returns a filtered object
+   * @example
+   * ```ts
+   * type T0 = Call<
+   *   Objects.Pick<"a" | "b">,
+   *   { a: 1, b: 1, c: 1 }
+   * >; // { c: 1 }
+   * ```
+   */
+  export type Omit<key = unset, obj = unset> = PartialApply<OmitFn, [key, obj]>;
+  interface OmitFn extends Fn {
+    return: OmitImpl<this["arg1"], this["arg0"]>;
+  }
+  type OmitImpl<obj, keys> = { [key in Exclude<keyof obj, keys>]: obj[key] };
+  /**
+   * Only keep keys of an object if the predicate function
+   * returns true
+   * @param fn - The predicate function, taking (value, key) as arguments
+   * @param obj - The object to filter
+   * @returns a filtered object
+   * @example
+   * ```ts
+   * type T0 = Call<
+   *   Objects.PickBy<Strings.StartsWith<"a">>,
+   *   { a: "ab", b: "ac", c: "bc" }
+   * >; // { a: "ab", b: "ac" }
+   * ```
+   */
+  export interface PickBy<fn extends Fn> extends Fn {
+    return: PickByImpl<this["arg0"], fn>;
+  }
+  type PickByImpl<T, fn extends Fn> = FromEntries<PickEntriesImpl<Entries<T>, fn>>;
+  type PickEntriesImpl<entries extends [PropertyKey, any], fn extends Fn> = entries extends any ? Call<fn, entries[1], entries[0]> extends true ? entries : never : never;
+  /**
+   * Only keep keys of an object if the predicate function
+   * returns false
+   * @param fn - The predicate function, taking (value, key) as arguments
+   * @param obj - The object to filter
+   * @returns a filtered object
+   * @example
+   * ```ts
+   * type T0 = Call<
+   *   Objects.PickBy<Strings.StartsWith<"a">>,
+   *   { a: "ab", b: "ac", c: "bc" }
+   * >; // { c: "bc" }
+   * ```
+   */
+  export interface OmitBy<fn extends Fn> extends Fn {
+    return: OmitByImpl<this["arg0"], fn>;
+  }
+  type OmitByImpl<T, fn extends Fn> = FromEntries<OmitEntriesImpl<Entries<T>, fn>>;
+  type OmitEntriesImpl<entries extends [PropertyKey, any], fn extends Fn> = entries extends any ? Call<fn, entries[1], entries[0]> extends true ? never : entries : never;
+  /**
+   * Merge several objects together
+   * @param {...objects} - Objects to merge
+   * @returns a merged object
+   * @example
+   * ```ts
+   * type T0 = Call<Objects.Assign<{ a: string }>, { b: number }>; // { a: string, b: number }
+   * type T1 = Call<Objects.Assign<{ a: string }, { b: number }>>; // { a: string, b: number }
+   * type T2 = Call<Objects.Assign<{ a: 1 }, { b: 1 }, { c: 1 }>>; // { a: 1, b: 1, c: 1 }
+   * ```
+   */
+  export type Assign<arg1 = unset, arg2 = unset, arg3 = unset, arg4 = unset, arg5 = unset> = PartialApply<AssignFn, [arg1, arg2, arg3, arg4, arg5]>;
+  interface AssignFn extends Fn {
+    return: Assign<this["args"]>;
+  }
+  /**
+   * Make all properties of an object readonly
+   * @description This function is used to make properties of an object readonly
+   * @param value - The object to make properties readonly
+   * @returns The object with its properties made readonly
+   * @example
+   * ```ts
+   * type T0 = Call<Objects.Readonly, { a: 1; b: true }>; // { readonly a:1; readonly b: true}
+   * type T1 = Call<Objects.Readonly<{ a: 1; b: true }>>; // { readonly a:1; readonly b: true}
+   * ```
+   */
+  export type Readonly<value = unset> = PartialApply<ReadonlyFn, [value]>;
+  interface ReadonlyFn extends Fn {
+    return: this["args"] extends [infer value] ? Std._Readonly<value> : never;
+  }
+  /**
+   * Make all properties of an object required
+   * @description This function is used to make properties of an object required
+   * @param value - The object to make properties required
+   * @returns The object with its properties made required
+   * @example
+   * ```ts
+   * type T0 = Call<Objects.Required, { a?: 1; b?: true }>; // { a:1; b: true}
+   * type T1 = Call<Objects.Required<{ a?: 1; b?: true }>>; // { a:1; b: true}
+   * ```
+   */
+  export type Required<value = unset> = PartialApply<RequiredFn, [value]>;
+  interface RequiredFn extends Fn {
+    return: this["args"] extends [infer value] ? Std._Required<value> : never;
+  }
+  /**
+   * Make all properties of an object optional
+   * @description This function is used to make properties of an object optional
+   * @param value - The object to make properties optional
+   * @returns The object with its properties made optional
+   * @example
+   * ```ts
+   * type T0 = Call<Objects.Partial, { a: 1; b: true }>; // { a?:1; b?: true}
+   * type T1 = Call<Objects.Partial<{ a: 1; b: true }>>; // { a?:1; b?: true}
+   * ```
+   */
+  export type Partial<value = unset> = PartialApply<PartialFn, [value]>;
+  interface PartialFn extends Fn {
+    return: this["args"] extends [infer value] ? Std._Partial<value> : never;
+  }
+  /**
+   * Make all properties of an object mutable
+   * @param value - The object to make properties mutable
+   * @returns The object with its properties made mutable
+   * @example
+   * ```ts
+   * type T0 = Call<Objects.Mutable, { readonly a: 1; readonly b: true }>; // { a:1; b: true }
+   * ```
+   */
+  export type Mutable<obj = unset> = PartialApply<MutableFn, [obj]>;
+  interface MutableFn extends Fn {
+    return: this["args"] extends [infer obj, ...any] ? { -readonly [key in keyof obj]: obj[key] } : never;
+  }
+  /**
+   * Makes all levels of an object optional
+   * @description This function is used to make all levels of an object optional
+   * @param obj - The object to make levels optional
+   * @returns The object with its levels made optional
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Objects.PartialDeep, { a: 1; b: true }>;
+   * //   ^? { a?:1; b?: true}
+   * type T1 = Call<Objects.PartialDeep, { a: 1; b: { c: true } }>;
+   * //   ^? { a?:1; b?: { c?: true } }
+   * type T2 = Call<Objects.PartialDeep, { a: 1; b: { c: true, d: { e: false } } }>;
+   * //   ^? { a?:1; b?: { c?: true, d?: { e?: false } } }
+   */
+  export type PartialDeep<obj = unset> = PartialApply<PartialDeepFn, [obj]>;
+  interface PartialDeepFn extends Fn {
+    return: this["args"] extends [infer obj] ? TransformObjectDeep<PartialFn, obj> : never;
+  }
+  /**
+   * Makes all levels of an object required
+   * @description This function is used to make all levels of an object required
+   * @param obj - The object to make levels required
+   * @returns The object with its levels made required
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Objects.RequiredDeep, { a?:1; b?: true }>;
+   * //   ^? { a: 1; b: true }
+   * type T1 = Call<Objects.RequiredDeep, { a?:1; b?: { c?: true } }>;
+   * //   ^? { a: 1; b: { c: true } }
+   * type T2 = Call<Objects.RequiredDeep, { a?:1; b?: { c?: true, d?: { e?: false } } }>;
+   * //   ^? { a: 1; b: { c: true, d: { e: false } } }
+   */
+  export type RequiredDeep<obj = unset> = PartialApply<RequiredDeepFn, [obj]>;
+  interface RequiredDeepFn extends Fn {
+    return: this["args"] extends [infer obj] ? TransformObjectDeep<RequiredFn, obj> : never;
+  }
+  /**
+   * Makes all levels of an object readonly
+   * @description This function is used to make all levels of an object readonly
+   * @param obj - The object to make levels readonly
+   * @returns The object with its levels made readonly
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Objects.ReadonlyDeep, { a:1; b: true }>;
+   * //   ^? { readonly a: 1; readonly b: true }
+   * type T1 = Call<Objects.ReadonlyDeep, { a:1; b: { c: true } }>;
+   * //   ^? { readonly a: 1; readonly b: { readonly c: true } }
+   * type T2 = Call<Objects.ReadonlyDeep, { a:1; b: { c: true, d: { e: false } } }>;
+   * //   ^? { readonly a: 1; readonly b: { readonly c: true, d: { readonly e: false } } }
+   */
+  export type ReadonlyDeep<obj = unset> = PartialApply<ReadonlyDeepFn, [obj]>;
+  interface ReadonlyDeepFn extends Fn {
+    return: this["args"] extends [infer obj] ? TransformObjectDeep<ReadonlyFn, obj> : never;
+  }
+  /**
+   * Makes all levels of an object mutable
+   * @description This function is used to make all levels of an object mutable
+   * @param obj - The object to make levels mutable
+   * @returns The object with its levels made mutable
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<Objects.MutableDeep, { readonly a: 1; readonly b: true }>;
+   * //   ^? { a:1; b: true }
+   * type T1 = Call<Objects.MutableDeep, { readonly a: 1; readonly b: { readonly c: true } }>;
+   * //   ^? { a:1; b: { c: true } }
+   * type T2 = Call<Objects.MutableDeep, { readonly a: 1; readonly b: { readonly c: true, d: { readonly e: false } } }>;
+   * //   ^? { a:1; b: { c: true, d: { e: false } } }
+   */
+  export type MutableDeep<obj = unset> = PartialApply<MutableDeepFn, [obj]>;
+  interface MutableDeepFn extends Fn {
+    return: this["args"] extends [infer obj] ? TransformObjectDeep<MutableFn, obj> : never;
+  }
+  /**
+   * Get a value within an object or a tuple type.
+   * @description This function takes an object, a path to one of its properties,
+   * and returns the property under that path.
+   * @param path - the path to the property to get.
+   * @param obj - the object to read from.
+   * @returns The value under that path
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<O.Get<'a'>, { a: 1, b: 1 }>; // 1
+   * type T1 = Call<O.Get<'a[0]'>, { a: [1, 2, 3] }>; // 1
+   * type T2 = Call<O.Get<'a.b'>, { a: { b: 1 }, c: '' }>; // 1
+   * ```
+   */
+  export type Get<path extends string | number | _ | unset = unset, obj = unset> = PartialApply<GetFn, [path, obj]>;
+  export interface GetFn extends Fn {
+    return: this["args"] extends [infer path extends string | number, infer obj, ...any] ? GetFromPath<obj, path> : never;
+  }
+  /**
+   * Updates an object or a tuple type.
+   * @description This function takes an object, a path to one of its properties,
+   * a new value or a function to apply to this property, and returns a new version
+   * of this object with this property updated.
+   * @param path - the path to the property to update
+   * @param valueOrFn - a value to set, or a function to apply on the target property
+   * @param obj - the object to update.
+   * @returns The updated object.
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<O.Update<'a', Numbers.Add<1>>, { a: 1, b: 1 }>; // { a: 2, b: 1 }
+   * type T1 = Call<O.Update<'a[0]', 4>, { a: [1, 2, 3] }>; // { a: [4, 2, 3] }
+   * type T2 = Call<O.Update<'a.b', Numbers.Add<1>>, { a: { b: 1 }, c: '' }>; // { a: { b: 2 }, c: '' }
+   * type T3 = Call<O.Update<'a.b', "Hello">, { a: { b: 1 } }>; // { a: { b: "Hello" } }
+   * ```
+   */
+  export type Update<path extends string | number | _ | unset = unset, fnOrValue = unset, obj = unset> = PartialApply<UpdateFn, [path, fnOrValue, obj]>;
+  export interface UpdateFn extends Fn {
+    return: this["args"] extends [infer path extends string | number, infer fnOrValue, infer obj, ...any] ? Update<obj, path, fnOrValue> : never;
+  }
+  /**
+   * Create an object from parameters
+   * @description This function is used to make an object from parameters
+   * And allows to place the parameters in any object property
+   * @param args - The parameters to make the object from
+   * @returns The object made from the parameters
+   *
+   * @example
+   * ```ts
+   * type T0 = Apply<O.Create<{ a: arg0, b: arg1 }>, [1, 2]>; // { a: 1, b: 2 }
+   * ```
+   */
+  interface CreateFn extends Fn {
+    return: this["args"] extends [infer pattern, ...infer args] ? Create<pattern, args> : never;
+  }
+  export type Create<pattern = unset, arg0 = unset, arg1 = unset, arg2 = unset, arg3 = unset> = PartialApply<CreateFn, [pattern, arg0, arg1, arg2, arg3]>;
+  interface RecordFn extends Fn {
+    return: this["args"] extends [infer union extends string, infer value] ? Std._Record<union, value> : never;
+  }
+  /**
+   * Create a record from a union of strings and a value type
+   * @description This function is used to create a record from a union of strings
+   * @param union - The union of strings to create the record from
+   * @param value - The value to assign to each property
+   * @returns The record created from the union of strings
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<O.Record<'a' | 'b' | 'c'>, 1>; // { a: 1, b: 1, c: 1 }
+   * ```
+   */
+  export type Record<union extends string | _ | unset = unset, value = unset> = PartialApply<RecordFn, [union, value]>;
+  /**
+   * Smarter version of keyof that also works with tuples
+   * @params args[0] - The type to extract keys from
+   * @returns An union of all the types's keys
+   * @example
+   * ```ts
+   * type T0 = Call<O.Keys, ['a', 'b', 'c']>; // 0 | 1 | 2
+   * ```
+   */
+  export interface Keys extends Fn {
+    return: Keys<this["arg0"]>;
+  }
+  /**
+   * Smarter version of Values that also works with tuples
+   * @params args[0] - The type to extract values from
+   * @returns An union of all the types's values
+   * @example
+   * ```ts
+   * type T0 = Call<O.Values, ['a', 'b', 'c']>; // 'a' | 'b' | 'c'
+   * ```
+   */
+  export interface Values extends Fn {
+    return: Values<this["arg0"]>;
+  }
+  /**
+   * Create a union of all deep paths the object has
+   * @description This function is used to create a union from an object with keys
+   * @param obj - The object from which the union will be generated
+   * @returns An union with all the possible deep paths
+   *
+   * @example
+   * ```ts
+   * type T0 = Call<O.AllPaths, { a: { b: number } }>; // 'a' | 'a.b'
+   * ```
+   */
+  export interface AllPaths extends Fn {
+    return: AllPaths<this["arg0"]>;
+  }
+  export {};
+}
+//#endregion
+//#region node_modules/ts-algebra/lib/utils/and.d.ts
+declare type And$1<BOOL_A, BOOL_B> = BOOL_A extends true ? BOOL_B extends true ? true : false : false;
+//#endregion
+//#region node_modules/ts-algebra/lib/utils/extends.d.ts
+declare type DoesExtend$1<TYPE_A, TYPE_B> = [TYPE_A] extends [TYPE_B] ? true : false;
+declare type ArrayKeys = keyof [];
+declare type IsObject<TYPE> = TYPE extends object ? ArrayKeys extends Extract<keyof TYPE, ArrayKeys> ? false : true : false;
+declare type IsArray<TYPE> = TYPE extends object ? ArrayKeys extends Extract<keyof TYPE, ArrayKeys> ? true : false : false;
+//#endregion
+//#region node_modules/ts-algebra/lib/utils/if.d.ts
+declare type If<CONDITION extends boolean, THEN, ELSE = never> = CONDITION extends true ? THEN : ELSE;
+//#endregion
+//#region node_modules/ts-algebra/lib/utils/intersectUnion.d.ts
+declare type IntersectUnion$1<UNION> = (UNION extends unknown ? (arg: UNION) => void : never) extends ((arg: infer INTERSECTION) => void) ? INTERSECTION : never;
+//#endregion
+//#region node_modules/ts-algebra/lib/utils/isNever.d.ts
+declare type IsNever<TYPE> = [TYPE] extends [never] ? true : false;
+//#endregion
+//#region node_modules/ts-algebra/lib/utils/merge.d.ts
+declare type DeepMergeUnsafe<TYPE_A, TYPE_B> = IsObject<TYPE_A> extends true ? IsObject<TYPE_B> extends true ? { [KEY in keyof (TYPE_A & TYPE_B)]: KEY extends keyof TYPE_B ? KEY extends keyof TYPE_A ? DeepMergeUnsafe<TYPE_A[KEY], TYPE_B[KEY]> : TYPE_B[KEY] : KEY extends keyof TYPE_A ? TYPE_A[KEY] : never } : TYPE_B : IsArray<TYPE_A> extends true ? IsArray<TYPE_B> extends true ? TYPE_B extends unknown[] ? [...(TYPE_A extends unknown[] ? TYPE_A : never), TYPE_B] : never : TYPE_B : TYPE_B;
+//#endregion
+//#region node_modules/ts-algebra/lib/utils/not.d.ts
+declare type Not$1<BOOL extends boolean> = BOOL extends false ? true : BOOL extends true ? false : never;
+//#endregion
+//#region node_modules/ts-algebra/lib/utils/or.d.ts
+declare type Or<BOOL_A extends boolean, BOOL_B extends boolean> = BOOL_A extends true ? true : BOOL_B extends true ? true : false;
+//#endregion
+//#region node_modules/ts-algebra/lib/utils/prettify.d.ts
+declare type Prettify<TYPE> = IsObject<TYPE> extends true ? { [KEY in keyof TYPE]: KEY extends keyof TYPE ? TYPE[KEY] : never } : TYPE;
+//#endregion
+//#region node_modules/ts-algebra/lib/utils/tail.d.ts
+declare type Tail$1<ARRAY extends unknown[]> = ARRAY extends readonly [] ? ARRAY : ARRAY extends readonly [unknown?, ...infer TAIL] ? TAIL : ARRAY;
+//#endregion
+//#region node_modules/ts-algebra/lib/utils/unionLast.d.ts
+declare type UnionLast<UNION> = IntersectUnion$1<UNION extends unknown ? (x: UNION) => void : never> extends ((x: infer LAST) => void) ? LAST : never;
+//#endregion
+//#region node_modules/ts-algebra/lib/utils/unionPop.d.ts
+declare type UnionPop<UNION> = Exclude<UNION, UnionLast<UNION>>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/never.d.ts
+declare type NeverTypeId = "never";
+declare type Never = {
+  type: NeverTypeId;
+};
+declare type NeverType = Never;
+declare type ResolveNever = never;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/utils.d.ts
+declare type IsSerialized<SERIALIZABLE_META_TYPE extends SerializableType> = SERIALIZABLE_META_TYPE["isSerialized"];
+declare type Deserialized<SERIALIZABLE_META_TYPE extends SerializableType> = SERIALIZABLE_META_TYPE["deserialized"];
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/const.d.ts
+declare type ConstTypeId = "const";
+declare type Const<VALUE, IS_SERIALIZED extends boolean = false, DESERIALIZED = never> = If<IsNever<VALUE>, Never, {
+  type: ConstTypeId;
+  value: VALUE;
+  isSerialized: IS_SERIALIZED;
+  deserialized: DESERIALIZED;
+}>;
+declare type ConstType = {
+  type: ConstTypeId;
+  value: unknown;
+  isSerialized: boolean;
+  deserialized: unknown;
+};
+declare type ConstValue<META_CONST extends ConstType> = META_CONST["value"];
+declare type ResolveConst<META_CONST extends ConstType, OPTIONS extends ResolveOptions> = If<And$1<OPTIONS["deserialize"], IsSerialized<META_CONST>>, Deserialized<META_CONST>, ConstValue<META_CONST>>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/enum.d.ts
+declare type EnumTypeId = "enum";
+declare type Enum<VALUES, IS_SERIALIZED extends boolean = false, DESERIALIZED = never> = If<IsNever<VALUES>, Never, {
+  type: EnumTypeId;
+  values: VALUES;
+  isSerialized: IS_SERIALIZED;
+  deserialized: DESERIALIZED;
+}>;
+declare type EnumType = {
+  type: EnumTypeId;
+  values: unknown;
+  isSerialized: boolean;
+  deserialized: unknown;
+};
+declare type EnumValues<META_ENUM extends EnumType> = META_ENUM["values"];
+declare type ResolveEnum<META_ENUM extends EnumType, OPTIONS extends ResolveOptions> = If<And$1<OPTIONS["deserialize"], IsSerialized<META_ENUM>>, Deserialized<META_ENUM>, EnumValues<META_ENUM>>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/object.d.ts
+declare type ObjectTypeId = "object";
+declare type _Object<VALUES extends Record<string, Type> = {}, REQUIRED_KEYS extends string = never, OPEN_PROPS extends Type = Never, CLOSE_ON_RESOLVE extends boolean = false, IS_SERIALIZED extends boolean = false, DESERIALIZED = never> = _$Object<VALUES, REQUIRED_KEYS, OPEN_PROPS, CLOSE_ON_RESOLVE, IS_SERIALIZED, DESERIALIZED>;
+declare type _$Object<VALUES = {}, REQUIRED_KEYS = never, OPEN_PROPS = Never, CLOSE_ON_RESOLVE = false, IS_SERIALIZED = false, DESERIALIZED = never> = DoesExtend$1<true, { [KEY in Extract<REQUIRED_KEYS, string>]: KEY extends keyof VALUES ? DoesExtend$1<VALUES[KEY], NeverType> : DoesExtend$1<OPEN_PROPS, NeverType> }[Extract<REQUIRED_KEYS, string>]> extends true ? Never : {
+  type: ObjectTypeId;
+  values: VALUES;
+  required: REQUIRED_KEYS;
+  isOpen: Not$1<DoesExtend$1<OPEN_PROPS, NeverType>>;
+  openProps: OPEN_PROPS;
+  closeOnResolve: CLOSE_ON_RESOLVE;
+  isSerialized: IS_SERIALIZED;
+  deserialized: DESERIALIZED;
+};
+declare type ObjectType = {
+  type: ObjectTypeId;
+  values: Record<string, Type>;
+  required: string;
+  isOpen: boolean;
+  openProps: Type;
+  closeOnResolve: boolean;
+  isSerialized: boolean;
+  deserialized: unknown;
+};
+declare type ObjectValues<META_OBJECT extends ObjectType> = META_OBJECT["values"];
+declare type ObjectValue<META_OBJECT extends ObjectType, KEY extends string> = KEY extends keyof ObjectValues<META_OBJECT> ? ObjectValues<META_OBJECT>[KEY] : IsObjectOpen<META_OBJECT> extends true ? ObjectOpenProps<META_OBJECT> : Never;
+declare type ObjectRequiredKeys<META_OBJECT extends ObjectType> = META_OBJECT["required"];
+declare type IsObjectOpen<META_OBJECT extends ObjectType> = META_OBJECT["isOpen"];
+declare type ObjectOpenProps<META_OBJECT extends ObjectType> = META_OBJECT["openProps"];
+declare type IsObjectClosedOnResolve<META_OBJECT extends ObjectType> = META_OBJECT["closeOnResolve"];
+declare type IsObjectEmpty<META_OBJECT extends ObjectType> = IsNever<keyof ObjectValues<META_OBJECT>>;
+declare type ResolveObject<META_OBJECT extends ObjectType, OPTIONS extends ResolveOptions> = If<And$1<OPTIONS["deserialize"], IsSerialized<META_OBJECT>>, Deserialized<META_OBJECT>, DeepMergeUnsafe<If<And$1<IsObjectOpen<META_OBJECT>, Not$1<IsObjectClosedOnResolve<META_OBJECT>>>, If<IsObjectEmpty<META_OBJECT>, {
+  [KEY: string]: Resolve<ObjectOpenProps<META_OBJECT>, OPTIONS>;
+}, {
+  [KEY: string]: Resolve<Any, OPTIONS>;
+}>, {}>, DeepMergeUnsafe<{ [KEY in Exclude<keyof ObjectValues<META_OBJECT>, ObjectRequiredKeys<META_OBJECT>>]?: Resolve<ObjectValues<META_OBJECT>[KEY], OPTIONS> }, { [KEY in ObjectRequiredKeys<META_OBJECT>]: KEY extends keyof ObjectValues<META_OBJECT> ? Resolve<ObjectValues<META_OBJECT>[KEY], OPTIONS> : Resolve<Any, OPTIONS> }>>>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/primitive.d.ts
+declare type PrimitiveTypeId = "primitive";
+declare type Primitive<VALUE extends null | boolean | number | string, IS_SERIALIZED extends boolean = false, DESERIALIZED = never> = $Primitive<VALUE, IS_SERIALIZED, DESERIALIZED>;
+declare type $Primitive<VALUE, IS_SERIALIZED = false, DESERIALIZED = never> = If<IsNever<VALUE>, Never, {
+  type: PrimitiveTypeId;
+  value: VALUE;
+  isSerialized: IS_SERIALIZED;
+  deserialized: DESERIALIZED;
+}>;
+declare type PrimitiveType = {
+  type: PrimitiveTypeId;
+  value: null | boolean | number | string;
+  isSerialized: boolean;
+  deserialized: unknown;
+};
+declare type PrimitiveValue<META_PRIMITIVE extends PrimitiveType> = META_PRIMITIVE["value"];
+declare type ResolvePrimitive<META_PRIMITIVE extends PrimitiveType, OPTIONS extends ResolveOptions> = If<And$1<OPTIONS["deserialize"], IsSerialized<META_PRIMITIVE>>, Deserialized<META_PRIMITIVE>, PrimitiveValue<META_PRIMITIVE>>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/tuple.d.ts
+declare type TupleTypeId = "tuple";
+declare type Tuple<VALUES extends Type[], OPEN_PROPS extends Type = Never, IS_SERIALIZED extends boolean = false, DESERIALIZED = never> = $Tuple<VALUES, OPEN_PROPS, IS_SERIALIZED, DESERIALIZED>;
+declare type $Tuple<VALUES, OPEN_PROPS = Never, IS_SERIALIZED = false, DESERIALIZED = never> = IsAnyValueNever<VALUES> extends true ? Never : {
+  type: TupleTypeId;
+  values: VALUES;
+  isOpen: Not$1<DoesExtend$1<OPEN_PROPS, NeverType>>;
+  openProps: OPEN_PROPS;
+  isSerialized: IS_SERIALIZED;
+  deserialized: DESERIALIZED;
+};
+declare type IsAnyValueNever<TUPLE> = TUPLE extends [infer TUPLE_HEAD, ...infer TUPLE_TAIL] ? TUPLE_HEAD extends NeverType ? true : IsAnyValueNever<TUPLE_TAIL> : false;
+declare type TupleType = {
+  type: TupleTypeId;
+  values: Type[];
+  isOpen: boolean;
+  openProps: Type;
+  isSerialized: boolean;
+  deserialized: unknown;
+};
+declare type TupleValues<META_TUPLE extends TupleType> = META_TUPLE["values"];
+declare type IsTupleOpen<META_TUPLE extends TupleType> = META_TUPLE["isOpen"];
+declare type TupleOpenProps<META_TUPLE extends TupleType> = META_TUPLE["openProps"];
+declare type ResolveTuple<META_TUPLE extends TupleType, OPTIONS extends ResolveOptions> = If<And$1<OPTIONS["deserialize"], IsSerialized<META_TUPLE>>, Deserialized<META_TUPLE>, If<IsTupleOpen<META_TUPLE>, [...RecurseOnTuple<TupleValues<META_TUPLE>, OPTIONS>, ...Resolve<TupleOpenProps<META_TUPLE>, OPTIONS>[]], RecurseOnTuple<TupleValues<META_TUPLE>, OPTIONS>>>;
+declare type RecurseOnTuple<VALUES extends Type[], OPTIONS extends ResolveOptions, RESULT extends unknown[] = []> = VALUES extends [infer VALUES_HEAD, ...infer VALUES_TAIL] ? VALUES_HEAD extends Type ? VALUES_TAIL extends Type[] ? RecurseOnTuple<VALUES_TAIL, OPTIONS, [...RESULT, Resolve<VALUES_HEAD, OPTIONS>]> : never : never : RESULT;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/union.d.ts
+declare type UnionTypeId = "union";
+declare type Union<VALUES extends Type> = $Union<VALUES>;
+declare type $Union<VALUES> = If<IsNever<VALUES>, Never, DoesExtend$1<VALUES, NeverType> extends true ? Never : {
+  type: UnionTypeId;
+  values: VALUES;
+}>;
+declare type UnionType = {
+  type: UnionTypeId;
+  values: Type;
+};
+declare type UnionValues<META_UNION extends UnionType> = META_UNION["values"];
+declare type ResolveUnion<META_UNION extends UnionType, OPTIONS extends ResolveOptions> = RecurseOnUnion<UnionValues<META_UNION>, OPTIONS>;
+declare type RecurseOnUnion<VALUES extends Type, OPTIONS extends ResolveOptions> = VALUES extends infer META_TYPE ? $Resolve<META_TYPE, OPTIONS> : never;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/type.d.ts
+declare type Type = NeverType | AnyType | ConstType | EnumType | PrimitiveType | ArrayType | TupleType | ObjectType | UnionType;
+declare type SerializableType = Type extends infer META_TYPE ? META_TYPE extends {
+  isSerialized: boolean;
+  deserialized: unknown;
+} ? META_TYPE : never : never;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/array.d.ts
+declare type ArrayTypeId = "array";
+declare type _Array<VALUES extends Type = Any, IS_SERIALIZED extends boolean = false, DESERIALIZED = never> = _$Array<VALUES, IS_SERIALIZED, DESERIALIZED>;
+declare type _$Array<VALUES = Any, IS_SERIALIZED = false, DESERIALIZED = never> = {
+  type: ArrayTypeId;
+  values: VALUES;
+  isSerialized: IS_SERIALIZED;
+  deserialized: DESERIALIZED;
+};
+declare type ArrayType = {
+  type: ArrayTypeId;
+  values: Type;
+  isSerialized: boolean;
+  deserialized: unknown;
+};
+declare type ArrayValues<META_ARRAY extends ArrayType> = META_ARRAY["values"];
+declare type ResolveArray<META_ARRAY extends ArrayType, OPTIONS extends ResolveOptions> = If<And$1<OPTIONS["deserialize"], IsSerialized<META_ARRAY>>, Deserialized<META_ARRAY>, ArrayValues<META_ARRAY> extends NeverType ? [] : Prettify<Resolve<ArrayValues<META_ARRAY>, OPTIONS>[]>>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/resolve.d.ts
+declare type ResolveOptions = {
+  deserialize: boolean;
+};
+declare type ResolveDefaultOptions = {
+  deserialize: true;
+};
+declare type Resolve<META_TYPE extends Type, OPTIONS extends ResolveOptions = ResolveDefaultOptions> = $Resolve<META_TYPE, OPTIONS>;
+declare type $Resolve<META_TYPE, OPTIONS extends ResolveOptions = ResolveDefaultOptions> = META_TYPE extends AnyType ? ResolveAny<META_TYPE, OPTIONS> : META_TYPE extends NeverType ? ResolveNever : META_TYPE extends ConstType ? ResolveConst<META_TYPE, OPTIONS> : META_TYPE extends EnumType ? ResolveEnum<META_TYPE, OPTIONS> : META_TYPE extends PrimitiveType ? ResolvePrimitive<META_TYPE, OPTIONS> : META_TYPE extends ArrayType ? ResolveArray<META_TYPE, OPTIONS> : META_TYPE extends TupleType ? ResolveTuple<META_TYPE, OPTIONS> : META_TYPE extends ObjectType ? ResolveObject<META_TYPE, OPTIONS> : META_TYPE extends UnionType ? ResolveUnion<META_TYPE, OPTIONS> : never;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/any.d.ts
+declare type AnyTypeId = "any";
+declare type Any<IS_SERIALIZED extends boolean = false, DESERIALIZED = never> = {
+  type: AnyTypeId;
+  isSerialized: IS_SERIALIZED;
+  deserialized: DESERIALIZED;
+};
+declare type AnyType = {
+  type: AnyTypeId;
+  isSerialized: boolean;
+  deserialized: unknown;
+};
+declare type ResolveAny<META_ANY extends AnyType, OPTIONS extends ResolveOptions> = If<And$1<OPTIONS["deserialize"], IsSerialized<META_ANY>>, Deserialized<META_ANY>, unknown>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/intersection/union.d.ts
+declare type IntersectUnion<META_UNION extends UnionType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_TYPE : META_TYPE extends AnyType ? META_UNION : META_TYPE extends ConstType ? DistributeIntersection<META_UNION, META_TYPE> : META_TYPE extends EnumType ? DistributeIntersection<META_UNION, META_TYPE> : META_TYPE extends PrimitiveType ? DistributeIntersection<META_UNION, META_TYPE> : META_TYPE extends ArrayType ? DistributeIntersection<META_UNION, META_TYPE> : META_TYPE extends TupleType ? DistributeIntersection<META_UNION, META_TYPE> : META_TYPE extends ObjectType ? DistributeIntersection<META_UNION, META_TYPE> : META_TYPE extends UnionType ? DistributeIntersection<META_UNION, META_TYPE> : Never : Never;
+declare type DistributeIntersection<META_UNION extends UnionType, META_TYPE> = $Union<UnionValues<META_UNION> extends infer UNION_VALUE ? $Intersect<UNION_VALUE, META_TYPE> : never>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/intersection/utils.d.ts
+declare type IntersectIsSerialized<SERIALIZABLE_META_TYPE_A extends SerializableType, SERIALIZABLE_META_TYPE_B extends SerializableType> = Or<IsSerialized<SERIALIZABLE_META_TYPE_A>, IsSerialized<SERIALIZABLE_META_TYPE_B>>;
+declare type IntersectDeserialized<SERIALIZABLE_META_TYPE_A extends SerializableType, SERIALIZABLE_META_TYPE_B extends SerializableType> = If<IsSerialized<SERIALIZABLE_META_TYPE_A>, If<IsSerialized<SERIALIZABLE_META_TYPE_B>, Deserialized<SERIALIZABLE_META_TYPE_A> & Deserialized<SERIALIZABLE_META_TYPE_B>, Deserialized<SERIALIZABLE_META_TYPE_A>>, If<IsSerialized<SERIALIZABLE_META_TYPE_B>, Deserialized<SERIALIZABLE_META_TYPE_B>>>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/intersection/const.d.ts
+declare type IntersectConstSerializationParams<META_CONST extends ConstType, SERIALIZABLE_META_TYPE extends SerializableType> = Const<ConstValue<META_CONST>, IntersectIsSerialized<META_CONST, SERIALIZABLE_META_TYPE>, IntersectDeserialized<META_CONST, SERIALIZABLE_META_TYPE>>;
+declare type IntersectConst<META_CONST extends ConstType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_TYPE : META_TYPE extends AnyType ? IntersectConstSerializationParams<META_CONST, META_TYPE> : META_TYPE extends ConstType ? CheckExtendsResolved<META_CONST, META_TYPE> : META_TYPE extends EnumType ? IntersectConstToEnum<META_CONST, META_TYPE> : META_TYPE extends PrimitiveType ? IntersectConstToPrimitive<META_CONST, META_TYPE> : META_TYPE extends ArrayType ? IntersectConstToArray<META_CONST, META_TYPE> : META_TYPE extends TupleType ? IntersectConstToTuple<META_CONST, META_TYPE> : META_TYPE extends ObjectType ? IntersectConstToObject<META_CONST, META_TYPE> : META_TYPE extends UnionType ? DistributeIntersection<META_TYPE, META_CONST> : Never : Never;
+declare type CheckExtendsResolved<META_CONST extends ConstType, SERIALIZABLE_META_TYPE extends SerializableType> = ConstValue<META_CONST> extends Resolve<SERIALIZABLE_META_TYPE, {
+  deserialize: false;
+}> ? IntersectConstSerializationParams<META_CONST, SERIALIZABLE_META_TYPE> : Never;
+declare type IntersectConstToEnum<META_CONST extends ConstType, META_ENUM extends EnumType> = CheckExtendsResolved<META_CONST, META_ENUM>;
+declare type IntersectConstToPrimitive<META_CONST extends ConstType, META_PRIMITIVE extends PrimitiveType> = CheckExtendsResolved<META_CONST, META_PRIMITIVE>;
+declare type IntersectConstToArray<META_CONST extends ConstType, META_ARRAY extends ArrayType> = CheckExtendsResolved<META_CONST, META_ARRAY>;
+declare type IntersectConstToTuple<META_CONST extends ConstType, META_TUPLE extends TupleType> = CheckExtendsResolved<META_CONST, META_TUPLE>;
+declare type IntersectConstToObject<META_CONST extends ConstType, META_OBJECT extends ObjectType> = If<IsObject<ConstValue<META_CONST>>, IntersectObjectConstToObject<META_CONST, META_OBJECT>, Never>;
+declare type IntersectObjectConstToObject<META_CONST extends ConstType, META_OBJECT extends ObjectType, INTERSECTED_META_OBJECT = IntersectConstValuesToObjectValues<ConstValue<META_CONST>, META_OBJECT>> = If<IsNever<NeverKeys<INTERSECTED_META_OBJECT>>, IntersectConstSerializationParams<META_CONST, META_OBJECT>, Never>;
+declare type IntersectConstValuesToObjectValues<CONST_VALUE, META_OBJECT extends ObjectType> = { [KEY in Extract<keyof CONST_VALUE | ObjectRequiredKeys<META_OBJECT>, string>]: KEY extends keyof CONST_VALUE ? Intersect<Const<CONST_VALUE[KEY]>, ObjectValue<META_OBJECT, KEY>> : Never };
+declare type NeverKeys<META_OBJECT> = { [KEY in keyof META_OBJECT]: META_OBJECT[KEY] extends Never ? KEY : never }[keyof META_OBJECT];
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/intersection/enum.d.ts
+declare type IntersectEnumSerializationParams<META_ENUM_VALUES, META_ENUM extends EnumType, SERIALIZABLE_META_TYPE extends SerializableType> = Enum<META_ENUM_VALUES, IntersectIsSerialized<META_ENUM, SERIALIZABLE_META_TYPE>, IntersectDeserialized<META_ENUM, SERIALIZABLE_META_TYPE>>;
+declare type IntersectEnum<META_ENUM extends EnumType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_TYPE : META_TYPE extends AnyType ? IntersectEnumSerializationParams<EnumValues<META_ENUM>, META_ENUM, META_TYPE> : META_TYPE extends ConstType ? IntersectConstToEnum<META_TYPE, META_ENUM> : META_TYPE extends EnumType ? FilterEnum<META_ENUM, META_TYPE> : META_TYPE extends PrimitiveType ? IntersectEnumToPrimitive<META_ENUM, META_TYPE> : META_TYPE extends ArrayType ? FilterEnum<META_ENUM, META_TYPE> : META_TYPE extends TupleType ? FilterEnum<META_ENUM, META_TYPE> : META_TYPE extends ObjectType ? FilterEnum<META_ENUM, META_TYPE> : META_TYPE extends UnionType ? DistributeIntersection<META_TYPE, META_ENUM> : Never : Never;
+declare type FilterEnum<META_ENUM extends EnumType, SERIALIZABLE_META_TYPE extends SerializableType> = IntersectEnumSerializationParams<FilterEnumValues<EnumValues<META_ENUM>, SERIALIZABLE_META_TYPE>, META_ENUM, SERIALIZABLE_META_TYPE>;
+declare type FilterEnumValues<ENUM_VALUES, SERIALIZABLE_META_TYPE> = ENUM_VALUES extends infer ENUM_VALUE ? $Intersect<Const<ENUM_VALUE>, SERIALIZABLE_META_TYPE> extends Never ? never : ENUM_VALUE : never;
+declare type IntersectEnumToPrimitive<META_ENUM extends EnumType, META_PRIMITIVE extends PrimitiveType> = FilterEnum<META_ENUM, META_PRIMITIVE>;
+declare type IntersectEnumToArray<META_ENUM extends EnumType, META_ARRAY extends ArrayType> = FilterEnum<META_ENUM, META_ARRAY>;
+declare type IntersectEnumToTuple<META_ENUM extends EnumType, META_TUPLE extends TupleType> = FilterEnum<META_ENUM, META_TUPLE>;
+declare type IntersectEnumToObject<META_ENUM extends EnumType, META_OBJECT extends ObjectType> = FilterEnum<META_ENUM, META_OBJECT>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/intersection/tuple.d.ts
+declare type IntersectTupleSerializationParams<VALUES extends Type[], OPEN_PROPS extends Type, META_TUPLE extends TupleType, SERIALIZABLE_META_TYPE extends SerializableType> = $MergeTuplePropsToSerializable<VALUES, OPEN_PROPS, META_TUPLE, SERIALIZABLE_META_TYPE>;
+declare type $MergeTuplePropsToSerializable<VALUES, OPEN_PROPS, META_TUPLE extends TupleType, SERIALIZABLE_META_TYPE extends SerializableType> = $Tuple<VALUES, OPEN_PROPS, IntersectIsSerialized<META_TUPLE, SERIALIZABLE_META_TYPE>, IntersectDeserialized<META_TUPLE, SERIALIZABLE_META_TYPE>>;
+declare type IntersectTuple<META_TUPLE extends TupleType, META_TYPE> = META_TYPE extends NeverType ? META_TYPE : META_TYPE extends AnyType ? IntersectTupleSerializationParams<TupleValues<META_TUPLE>, TupleOpenProps<META_TUPLE>, META_TUPLE, META_TYPE> : META_TYPE extends ConstType ? IntersectConstToTuple<META_TYPE, META_TUPLE> : META_TYPE extends EnumType ? IntersectEnumToTuple<META_TYPE, META_TUPLE> : META_TYPE extends PrimitiveType ? Never : META_TYPE extends ArrayType ? IntersectTupleToArray<META_TUPLE, META_TYPE> : META_TYPE extends TupleType ? IntersectTuples<META_TUPLE, META_TYPE> : META_TYPE extends ObjectType ? Never : META_TYPE extends UnionType ? DistributeIntersection<META_TYPE, META_TUPLE> : Never;
+declare type IntersectTupleToArray<META_TUPLE extends TupleType, META_ARRAY extends ArrayType, INTERSECTED_VALUES extends unknown[] = IntersectTupleToArrayValues<TupleValues<META_TUPLE>, ArrayValues<META_ARRAY>>, INTERSECTED_OPEN_PROPS = $Intersect<TupleOpenProps<META_TUPLE>, ArrayValues<META_ARRAY>>> = $MergeTuplePropsToSerializable<INTERSECTED_VALUES, INTERSECTED_OPEN_PROPS, META_TUPLE, META_ARRAY>;
+declare type IntersectTupleToArrayValues<TUPLE_VALUES extends Type[], ARRAY_VALUES extends Type, RESULT extends unknown[] = []> = TUPLE_VALUES extends [infer TUPLE_VALUES_HEAD, ...infer TUPLE_VALUES_TAIL] ? TUPLE_VALUES_HEAD extends Type ? TUPLE_VALUES_TAIL extends Type[] ? IntersectTupleToArrayValues<TUPLE_VALUES_TAIL, ARRAY_VALUES, [...RESULT, Intersect<TUPLE_VALUES_HEAD, ARRAY_VALUES>]> : never : never : RESULT;
+declare type IntersectTuples<META_TUPLE_A extends TupleType, META_TUPLE_B extends TupleType, INTERSECTED_VALUES extends unknown[] = IntersectTupleValues<TupleValues<META_TUPLE_A>, TupleValues<META_TUPLE_B>, IsTupleOpen<META_TUPLE_A>, IsTupleOpen<META_TUPLE_B>, TupleOpenProps<META_TUPLE_A>, TupleOpenProps<META_TUPLE_B>>, INTERSECTED_OPEN_PROPS = $Intersect<TupleOpenProps<META_TUPLE_A>, TupleOpenProps<META_TUPLE_B>>> = $MergeTuplePropsToSerializable<INTERSECTED_VALUES, INTERSECTED_OPEN_PROPS, META_TUPLE_A, META_TUPLE_B>;
+declare type IntersectTupleValues<TUPLE_A_VALUES extends Type[], TUPLE_B_VALUES extends Type[], TUPLE_A_IS_OPEN extends boolean, TUPLE_B_IS_OPEN extends boolean, TUPLE_A_OPEN_PROPS extends Type, TUPLE_B_OPEN_PROPS extends Type, RESULT extends unknown[] = []> = TUPLE_A_VALUES extends [infer TUPLE_A_VALUES_HEAD, ...infer TUPLE_A_VALUES_TAIL] ? TUPLE_A_VALUES_HEAD extends Type ? TUPLE_A_VALUES_TAIL extends Type[] ? TUPLE_B_VALUES extends [infer TUPLE_B_VALUES_HEAD, ...infer TUPLE_B_VALUES_TAIL] ? TUPLE_B_VALUES_HEAD extends Type ? TUPLE_B_VALUES_TAIL extends Type[] ? IntersectTupleValues<TUPLE_A_VALUES_TAIL, TUPLE_B_VALUES_TAIL, TUPLE_A_IS_OPEN, TUPLE_B_IS_OPEN, TUPLE_A_OPEN_PROPS, TUPLE_B_OPEN_PROPS, [...RESULT, Intersect<TUPLE_A_VALUES_HEAD, TUPLE_B_VALUES_HEAD>]> : never : never : IntersectTupleValues<TUPLE_A_VALUES_TAIL, TUPLE_B_VALUES, TUPLE_A_IS_OPEN, TUPLE_B_IS_OPEN, TUPLE_A_OPEN_PROPS, TUPLE_B_OPEN_PROPS, [...RESULT, TUPLE_B_IS_OPEN extends true ? Intersect<TUPLE_A_VALUES_HEAD, TUPLE_B_OPEN_PROPS> : Never]> : never : never : TUPLE_B_VALUES extends [infer TUPLE_B_VALUES_HEAD, ...infer TUPLE_B_VALUES_TAIL] ? TUPLE_B_VALUES_HEAD extends Type ? TUPLE_B_VALUES_TAIL extends Type[] ? IntersectTupleValues<TUPLE_A_VALUES, TUPLE_B_VALUES_TAIL, TUPLE_A_IS_OPEN, TUPLE_B_IS_OPEN, TUPLE_A_OPEN_PROPS, TUPLE_B_OPEN_PROPS, [...RESULT, TUPLE_A_IS_OPEN extends true ? Intersect<TUPLE_B_VALUES_HEAD, TUPLE_A_OPEN_PROPS> : Never]> : never : never : RESULT;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/intersection/array.d.ts
+declare type IntersectArraySerializationParams<VALUES extends Type, META_ARRAY extends ArrayType, SERIALIZABLE_META_TYPE extends SerializableType> = $MergeArrayValuesToSerializable<VALUES, META_ARRAY, SERIALIZABLE_META_TYPE>;
+declare type $MergeArrayValuesToSerializable<VALUES, META_ARRAY extends ArrayType, SERIALIZABLE_META_TYPE extends SerializableType> = _$Array<VALUES, IntersectIsSerialized<META_ARRAY, SERIALIZABLE_META_TYPE>, IntersectDeserialized<META_ARRAY, SERIALIZABLE_META_TYPE>>;
+declare type IntersectArray<META_ARRAY extends ArrayType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_TYPE : META_TYPE extends AnyType ? IntersectArraySerializationParams<ArrayValues<META_ARRAY>, META_ARRAY, META_TYPE> : META_TYPE extends ConstType ? IntersectConstToArray<META_TYPE, META_ARRAY> : META_TYPE extends EnumType ? IntersectEnumToArray<META_TYPE, META_ARRAY> : META_TYPE extends PrimitiveType ? Never : META_TYPE extends ArrayType ? IntersectArrays<META_ARRAY, META_TYPE> : META_TYPE extends TupleType ? IntersectTupleToArray<META_TYPE, META_ARRAY> : META_TYPE extends ObjectType ? Never : META_TYPE extends UnionType ? DistributeIntersection<META_TYPE, META_ARRAY> : Never : Never;
+declare type IntersectArrays<META_ARRAY_A extends ArrayType, META_ARRAY_B extends ArrayType> = $MergeArrayValuesToSerializable<Intersect<ArrayValues<META_ARRAY_A>, ArrayValues<META_ARRAY_B>>, META_ARRAY_A, META_ARRAY_B>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/intersection/object.d.ts
+declare type IntersectObjectSerializationParams<VALUES extends Record<string, Type>, REQUIRED_KEYS extends string, OPEN_PROPS extends Type, CLOSE_ON_RESOLVE extends boolean, META_OBJECT extends ObjectType, SERIALIZABLE_META_TYPE extends SerializableType> = $MergeObjectPropsToSerializable<VALUES, REQUIRED_KEYS, OPEN_PROPS, CLOSE_ON_RESOLVE, META_OBJECT, SERIALIZABLE_META_TYPE>;
+declare type $MergeObjectPropsToSerializable<VALUES, REQUIRED_KEYS, OPEN_PROPS, CLOSE_ON_RESOLVE, META_OBJECT extends ObjectType, SERIALIZABLE_META_TYPE extends SerializableType> = _$Object<VALUES, REQUIRED_KEYS, OPEN_PROPS, CLOSE_ON_RESOLVE, IntersectIsSerialized<META_OBJECT, SERIALIZABLE_META_TYPE>, IntersectDeserialized<META_OBJECT, SERIALIZABLE_META_TYPE>>;
+declare type IntersectObject<META_OBJECT extends ObjectType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_TYPE : META_TYPE extends AnyType ? IntersectObjectSerializationParams<ObjectValues<META_OBJECT>, ObjectRequiredKeys<META_OBJECT>, ObjectOpenProps<META_OBJECT>, IsObjectClosedOnResolve<META_OBJECT>, META_OBJECT, META_TYPE> : META_TYPE extends ConstType ? IntersectConstToObject<META_TYPE, META_OBJECT> : META_TYPE extends EnumType ? IntersectEnumToObject<META_TYPE, META_OBJECT> : META_TYPE extends PrimitiveType ? Never : META_TYPE extends ArrayType ? Never : META_TYPE extends TupleType ? Never : META_TYPE extends ObjectType ? IntersectObjects<META_OBJECT, META_TYPE> : META_TYPE extends UnionType ? DistributeIntersection<META_TYPE, META_OBJECT> : Never : Never;
+declare type IntersectObjects<META_OBJECT_A extends ObjectType, META_OBJECT_B extends ObjectType, INTERSECTED_VALUES extends Record<string, unknown> = IntersectObjectsValues<META_OBJECT_A, META_OBJECT_B>, INTERSECTED_OPEN_PROPS = Intersect<ObjectOpenProps<META_OBJECT_A>, ObjectOpenProps<META_OBJECT_B>>, INTERSECTED_CLOSE_ON_RESOLVE = Or<IsObjectClosedOnResolve<META_OBJECT_A>, IsObjectClosedOnResolve<META_OBJECT_B>>> = $MergeObjectPropsToSerializable<{ [KEY in keyof INTERSECTED_VALUES]: INTERSECTED_VALUES[KEY] }, ObjectRequiredKeys<META_OBJECT_A> | ObjectRequiredKeys<META_OBJECT_B>, INTERSECTED_OPEN_PROPS, INTERSECTED_CLOSE_ON_RESOLVE, META_OBJECT_A, META_OBJECT_B>;
+declare type IntersectObjectsValues<META_OBJECT_A extends ObjectType, META_OBJECT_B extends ObjectType> = { [KEY in Extract<keyof ObjectValues<META_OBJECT_A> | keyof ObjectValues<META_OBJECT_B>, string>]: $Intersect<ObjectValue<META_OBJECT_A, KEY>, ObjectValue<META_OBJECT_B, KEY>> };
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/intersection/primitive.d.ts
+declare type IntersectPrimitiveSerializationParams<META_PRIMITIVE extends PrimitiveType, SERIALIZABLE_META_TYPE extends SerializableType> = Primitive<PrimitiveValue<META_PRIMITIVE>, IntersectIsSerialized<META_PRIMITIVE, SERIALIZABLE_META_TYPE>, IntersectDeserialized<META_PRIMITIVE, SERIALIZABLE_META_TYPE>>;
+declare type IntersectPrimitive<META_PRIMITIVE extends PrimitiveType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_TYPE : META_TYPE extends AnyType ? IntersectPrimitiveSerializationParams<META_PRIMITIVE, META_TYPE> : META_TYPE extends ConstType ? IntersectConstToPrimitive<META_TYPE, META_PRIMITIVE> : META_TYPE extends EnumType ? IntersectEnumToPrimitive<META_TYPE, META_PRIMITIVE> : META_TYPE extends PrimitiveType ? If<And$1<DoesExtend$1<PrimitiveValue<META_PRIMITIVE>, PrimitiveValue<META_TYPE>>, DoesExtend$1<PrimitiveValue<META_TYPE>, PrimitiveValue<META_PRIMITIVE>>>, IntersectPrimitiveSerializationParams<META_PRIMITIVE, META_TYPE>, Never> : META_TYPE extends ArrayType ? Never : META_TYPE extends TupleType ? Never : META_TYPE extends ObjectType ? Never : META_TYPE extends UnionType ? DistributeIntersection<META_TYPE, META_PRIMITIVE> : Never : Never;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/intersection/any.d.ts
+declare type IntersectAny<META_ANY extends AnyType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_TYPE : META_TYPE extends AnyType ? Any<IntersectIsSerialized<META_ANY, META_TYPE>, IntersectDeserialized<META_ANY, META_TYPE>> : META_TYPE extends ConstType ? IntersectConstSerializationParams<META_TYPE, META_ANY> : META_TYPE extends EnumType ? IntersectEnumSerializationParams<EnumValues<META_TYPE>, META_TYPE, META_ANY> : META_TYPE extends PrimitiveType ? IntersectPrimitiveSerializationParams<META_TYPE, META_ANY> : META_TYPE extends ArrayType ? IntersectArraySerializationParams<ArrayValues<META_TYPE>, META_TYPE, META_ANY> : META_TYPE extends TupleType ? IntersectTupleSerializationParams<TupleValues<META_TYPE>, TupleOpenProps<META_TYPE>, META_TYPE, META_ANY> : META_TYPE extends ObjectType ? IntersectObjectSerializationParams<ObjectValues<META_TYPE>, ObjectRequiredKeys<META_TYPE>, ObjectOpenProps<META_TYPE>, IsObjectClosedOnResolve<META_TYPE>, META_TYPE, META_ANY> : META_TYPE extends UnionType ? DistributeIntersection<META_TYPE, META_ANY> : Never : Never;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/intersection/index.d.ts
+declare type Intersect<META_TYPE_A extends Type, META_TYPE_B extends Type> = $Intersect<META_TYPE_A, META_TYPE_B>;
+declare type $Intersect<META_TYPE_A, META_TYPE_B> = META_TYPE_A extends NeverType ? META_TYPE_A : META_TYPE_A extends AnyType ? IntersectAny<META_TYPE_A, META_TYPE_B> : META_TYPE_A extends ConstType ? IntersectConst<META_TYPE_A, META_TYPE_B> : META_TYPE_A extends EnumType ? IntersectEnum<META_TYPE_A, META_TYPE_B> : META_TYPE_A extends PrimitiveType ? IntersectPrimitive<META_TYPE_A, META_TYPE_B> : META_TYPE_A extends ArrayType ? IntersectArray<META_TYPE_A, META_TYPE_B> : META_TYPE_A extends TupleType ? IntersectTuple<META_TYPE_A, META_TYPE_B> : META_TYPE_A extends ObjectType ? IntersectObject<META_TYPE_A, META_TYPE_B> : META_TYPE_A extends UnionType ? IntersectUnion<META_TYPE_A, META_TYPE_B> : Never;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/exclusion/union.d.ts
+declare type ExcludeFromUnion<META_UNION extends UnionType, META_TYPE> = $Union<UnionValues<META_UNION> extends infer META_UNION_VALUE ? _$Exclude<META_UNION_VALUE, META_TYPE> : never>;
+declare type ExcludeUnion<META_TYPE, META_UNION extends UnionType> = If<IsNever<UnionValues<META_UNION>>, META_TYPE, RecurseOnUnionValues<META_TYPE, UnionLast<UnionValues<META_UNION>>, META_UNION>>;
+declare type RecurseOnUnionValues<META_TYPE, META_UNION_VALUE, META_UNION extends UnionType> = $Intersect<_$Exclude<META_TYPE, META_UNION_VALUE>, _$Exclude<META_TYPE, $Union<Exclude<UnionValues<META_UNION>, META_UNION_VALUE>>>>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/exclusion/any.d.ts
+declare type ExcludeFromAny<META_ANY extends AnyType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_ANY : META_TYPE extends AnyType ? Never : META_TYPE extends ConstType ? META_ANY : META_TYPE extends EnumType ? META_ANY : META_TYPE extends PrimitiveType ? META_ANY : META_TYPE extends ArrayType ? META_ANY : META_TYPE extends TupleType ? META_ANY : META_TYPE extends ObjectType ? META_ANY : META_TYPE extends UnionType ? ExcludeUnion<META_ANY, META_TYPE> : Never : Never;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/exclusion/array.d.ts
+declare type ExcludeFromArray<META_ARRAY extends ArrayType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_ARRAY : META_TYPE extends AnyType ? Never : META_TYPE extends ConstType ? META_ARRAY : META_TYPE extends EnumType ? META_ARRAY : META_TYPE extends PrimitiveType ? META_ARRAY : META_TYPE extends ArrayType ? ExcludeArrays<META_ARRAY, META_TYPE> : META_TYPE extends TupleType ? And$1<DoesExtend$1<TupleValues<META_TYPE>, []>, IsTupleOpen<META_TYPE>> extends true ? ExcludeArrays<META_ARRAY, _Array<TupleOpenProps<META_TYPE>>> : META_ARRAY : META_TYPE extends ObjectType ? META_ARRAY : META_TYPE extends UnionType ? ExcludeUnion<META_ARRAY, META_TYPE> : Never : Never;
+declare type ExcludeArrays<META_ARRAY_A extends ArrayType, META_ARRAY_B extends ArrayType> = _Exclude<ArrayValues<META_ARRAY_A>, ArrayValues<META_ARRAY_B>> extends NeverType ? NeverType : META_ARRAY_A;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/exclusion/const.d.ts
+declare type ExcludeFromConst<META_CONST extends ConstType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_CONST : META_TYPE extends AnyType ? Never : META_TYPE extends ConstType ? CheckNotExtendsResolved<META_CONST, META_TYPE> : META_TYPE extends EnumType ? CheckNotExtendsResolved<META_CONST, META_TYPE> : META_TYPE extends PrimitiveType ? CheckNotExtendsResolved<META_CONST, META_TYPE> : META_TYPE extends ArrayType ? CheckNotExtendsResolved<META_CONST, META_TYPE> : META_TYPE extends TupleType ? CheckNotExtendsResolved<META_CONST, META_TYPE> : META_TYPE extends ObjectType ? ExcludeObject<META_CONST, META_TYPE> : META_TYPE extends UnionType ? ExcludeUnion<META_CONST, META_TYPE> : Never : Never;
+declare type CheckNotExtendsResolved<META_CONST extends ConstType, META_TYPE extends Type> = ConstValue<META_CONST> extends Resolve<META_TYPE, {
+  deserialize: false;
+}> ? Never : META_CONST;
+declare type ExcludeObject<META_CONST extends ConstType, META_OBJECT extends ObjectType> = If<IsObject<ConstValue<META_CONST>>, ObjectRequiredKeys<META_OBJECT> extends keyof ConstValue<META_CONST> ? ExcludeObjectFromConst<META_CONST, META_OBJECT> : META_CONST, META_CONST>;
+declare type ExcludeObjectFromConst<META_CONST extends ConstType, META_OBJECT extends ObjectType, EXCLUDED_CONST_VALUES = ExcludeConstValues<ConstValue<META_CONST>, META_OBJECT>> = If<IsNever<RepresentableKeys$1<EXCLUDED_CONST_VALUES>>, Never, META_CONST>;
+declare type ExcludeConstValues<VALUE, META_OBJECT extends ObjectType> = { [KEY in keyof VALUE]: KEY extends keyof ObjectValues<META_OBJECT> ? _Exclude<Const<VALUE[KEY]>, ObjectValues<META_OBJECT>[KEY]> : IsObjectOpen<META_OBJECT> extends true ? _Exclude<Const<VALUE[KEY]>, ObjectOpenProps<META_OBJECT>> : Const<VALUE[KEY]> };
+declare type RepresentableKeys$1<VALUES> = { [KEY in keyof VALUES]: VALUES[KEY] extends Never ? never : KEY }[keyof VALUES];
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/exclusion/enum.d.ts
+declare type ExcludeFromEnum<META_ENUM extends EnumType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_ENUM : META_TYPE extends AnyType ? Never : META_TYPE extends ConstType ? FilterEnumExcluded<META_ENUM, META_TYPE> : META_TYPE extends EnumType ? FilterEnumExcluded<META_ENUM, META_TYPE> : META_TYPE extends PrimitiveType ? FilterEnumExcluded<META_ENUM, META_TYPE> : META_TYPE extends ArrayType ? FilterEnumExcluded<META_ENUM, META_TYPE> : META_TYPE extends TupleType ? FilterEnumExcluded<META_ENUM, META_TYPE> : META_TYPE extends ObjectType ? FilterEnumExcluded<META_ENUM, META_TYPE> : META_TYPE extends UnionType ? ExcludeUnion<META_ENUM, META_TYPE> : Never : Never;
+declare type FilterEnumExcluded<META_ENUM extends EnumType, META_TYPE extends Type> = Enum<FilterEnumExcludedValues<EnumValues<META_ENUM>, META_TYPE>>;
+declare type FilterEnumExcludedValues<ENUM_VALUES, META_TYPE extends Type> = ENUM_VALUES extends infer ENUM_VALUE ? _Exclude<Const<ENUM_VALUE>, META_TYPE> extends NeverType ? never : ENUM_VALUE : never;
+declare type ExcludeEnum<META_TYPE extends Type, ENUM_TYPE extends EnumType, ENUM_VALUES = EnumValues<ENUM_TYPE>> = ExcludeEnumValue<META_TYPE, UnionLast<ENUM_VALUES>, ENUM_VALUES>;
+declare type ExcludeEnumValue<META_TYPE extends Type, LAST_ENUM_VALUE, ENUM_VALUES> = $Intersect<_Exclude<META_TYPE, Const<LAST_ENUM_VALUE>>, _Exclude<META_TYPE, Enum<Exclude<ENUM_VALUES, LAST_ENUM_VALUE>>>>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/exclusion/utils.d.ts
+declare type ValueExclusionResult<VALUE_A extends Type, IS_ALLOWED_IN_A extends boolean, IS_REQUIRED_IN_A extends boolean, VALUE_B extends Type, IS_ALLOWED_IN_B extends boolean, IS_REQUIRED_IN_B extends boolean> = {
+  sourceValue: VALUE_A;
+  isAllowedInSource: IS_ALLOWED_IN_A;
+  isRequiredInSource: IS_REQUIRED_IN_A;
+  isAllowedInExcluded: IS_ALLOWED_IN_B;
+  isRequiredInExcluded: IS_REQUIRED_IN_B;
+  exclusionResult: _$Exclude<VALUE_A, VALUE_B>;
+};
+declare type ValueExclusionResultType = {
+  sourceValue: Type;
+  isAllowedInSource: boolean;
+  isRequiredInSource: boolean;
+  isAllowedInExcluded: boolean;
+  isRequiredInExcluded: boolean;
+  exclusionResult: any;
+};
+declare type SourceValue<VALUE_EXCLUSION_RESULT extends ValueExclusionResultType> = VALUE_EXCLUSION_RESULT["sourceValue"];
+declare type IsAllowedInSource<VALUE_EXCLUSION_RESULT extends ValueExclusionResultType> = VALUE_EXCLUSION_RESULT["isAllowedInSource"];
+declare type IsRequiredInSource<VALUE_EXCLUSION_RESULT extends ValueExclusionResultType> = VALUE_EXCLUSION_RESULT["isRequiredInSource"];
+declare type ExclusionResult<VALUE_EXCLUSION_RESULT extends ValueExclusionResultType> = VALUE_EXCLUSION_RESULT["exclusionResult"];
+declare type IsAllowedInExcluded<VALUE_EXCLUSION_RESULT extends ValueExclusionResultType> = VALUE_EXCLUSION_RESULT["isAllowedInExcluded"];
+declare type IsRequiredInExcluded<VALUE_EXCLUSION_RESULT extends ValueExclusionResultType> = VALUE_EXCLUSION_RESULT["isRequiredInExcluded"];
+declare type IsOutsideOfSourceScope<VALUE_EXCLUSION_RESULT extends ValueExclusionResultType> = And$1<Not$1<IsAllowedInSource<VALUE_EXCLUSION_RESULT>>, IsRequiredInExcluded<VALUE_EXCLUSION_RESULT>>;
+declare type IsOutsideOfExcludedScope<VALUE_EXCLUSION_RESULT extends ValueExclusionResultType> = And$1<IsRequiredInSource<VALUE_EXCLUSION_RESULT>, Not$1<IsAllowedInExcluded<VALUE_EXCLUSION_RESULT>>>;
+declare type IsOmittable<VALUE_EXCLUSION_RESULT extends ValueExclusionResultType> = And$1<Not$1<IsRequiredInSource<VALUE_EXCLUSION_RESULT>>, IsRequiredInExcluded<VALUE_EXCLUSION_RESULT>>;
+declare type PropagateExclusion<VALUE_EXCLUSION_RESULT extends ValueExclusionResultType> = ExclusionResult<VALUE_EXCLUSION_RESULT> extends NeverType ? SourceValue<VALUE_EXCLUSION_RESULT> : ExclusionResult<VALUE_EXCLUSION_RESULT>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/exclusion/object.d.ts
+declare type ExcludeFromObject<META_OBJECT extends ObjectType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_OBJECT : META_TYPE extends AnyType ? Never : META_TYPE extends ConstType ? ExcludeConstFromObject<META_OBJECT, META_TYPE> : META_TYPE extends EnumType ? ExcludeEnum<META_OBJECT, META_TYPE> : META_TYPE extends PrimitiveType ? META_OBJECT : META_TYPE extends ArrayType ? META_OBJECT : META_TYPE extends TupleType ? META_OBJECT : META_TYPE extends ObjectType ? ExcludeObjects<META_OBJECT, META_TYPE> : META_TYPE extends UnionType ? ExcludeUnion<META_OBJECT, META_TYPE> : Never : Never;
+declare type ExcludeObjects<META_OBJECT_A extends ObjectType, META_OBJECT_B extends ObjectType, VALUE_EXCLUSION_RESULTS extends Record<string, ValueExclusionResultType> = ExcludeObjectValues<META_OBJECT_A, META_OBJECT_B>, REPRESENTABLE_KEYS extends string = RepresentableKeys<VALUE_EXCLUSION_RESULTS>, OPEN_PROPS_EXCLUSION = _Exclude<ObjectOpenProps<META_OBJECT_A>, ObjectOpenProps<META_OBJECT_B>>> = DoesObjectSizesMatch<META_OBJECT_A, META_OBJECT_B, VALUE_EXCLUSION_RESULTS> extends true ? {
+  moreThanTwo: META_OBJECT_A;
+  onlyOne: PropagateExclusions$1<META_OBJECT_A, VALUE_EXCLUSION_RESULTS>;
+  none: OmitOmittableKeys<META_OBJECT_A, VALUE_EXCLUSION_RESULTS>;
+}[And$1<IsObjectOpen<META_OBJECT_A>, Not$1<DoesExtend$1<OPEN_PROPS_EXCLUSION, NeverType>>> extends true ? "moreThanTwo" : GetUnionLength<REPRESENTABLE_KEYS>] : META_OBJECT_A;
+declare type ExcludeObjectValues<META_OBJECT_A extends ObjectType, META_OBJECT_B extends ObjectType> = { [KEY in Extract<keyof ObjectValues<META_OBJECT_A> | keyof ObjectValues<META_OBJECT_B> | ObjectRequiredKeys<META_OBJECT_A> | ObjectRequiredKeys<META_OBJECT_B>, string>]: ValueExclusionResult<ObjectValue<META_OBJECT_A, KEY>, IsAllowedIn<META_OBJECT_A, KEY>, IsRequiredIn<META_OBJECT_A, KEY>, ObjectValue<META_OBJECT_B, KEY>, IsAllowedIn<META_OBJECT_B, KEY>, IsRequiredIn<META_OBJECT_B, KEY>> };
+declare type GetUnionLength<UNION> = If<IsNever<UNION>, "none", If<IsNever<UnionPop<UNION>>, "onlyOne", "moreThanTwo">>;
+declare type IsAllowedIn<META_OBJECT extends ObjectType, KEY extends string> = Or<DoesExtend$1<KEY, keyof ObjectValues<META_OBJECT>>, IsObjectOpen<META_OBJECT>>;
+declare type IsRequiredIn<META_OBJECT extends ObjectType, KEY extends string> = DoesExtend$1<KEY, ObjectRequiredKeys<META_OBJECT>>;
+declare type DoesObjectSizesMatch<META_OBJECT_A extends ObjectType, META_OBJECT_B extends ObjectType, VALUE_EXCLUSION_RESULTS extends Record<string, ValueExclusionResultType>> = If<And$1<IsObjectOpen<META_OBJECT_A>, Not$1<IsObjectOpen<META_OBJECT_B>>>, false, And$1<IsExcludedSmallEnough$1<VALUE_EXCLUSION_RESULTS>, IsExcludedBigEnough$1<VALUE_EXCLUSION_RESULTS>>>;
+declare type IsExcludedSmallEnough$1<VALUE_EXCLUSION_RESULTS extends Record<string, ValueExclusionResultType>> = Not$1<DoesExtend$1<true, { [KEY in keyof VALUE_EXCLUSION_RESULTS]: IsOutsideOfSourceScope<VALUE_EXCLUSION_RESULTS[KEY]> }[keyof VALUE_EXCLUSION_RESULTS]>>;
+declare type IsExcludedBigEnough$1<VALUE_EXCLUSION_RESULTS extends Record<string, ValueExclusionResultType>> = Not$1<DoesExtend$1<true, { [KEY in keyof VALUE_EXCLUSION_RESULTS]: IsOutsideOfExcludedScope<VALUE_EXCLUSION_RESULTS[KEY]> }[keyof VALUE_EXCLUSION_RESULTS]>>;
+declare type RepresentableKeys<VALUE_EXCLUSION_RESULTS extends Record<string, ValueExclusionResultType>> = { [KEY in Extract<keyof VALUE_EXCLUSION_RESULTS, string>]: ExclusionResult<VALUE_EXCLUSION_RESULTS[KEY]> extends NeverType ? never : KEY }[Extract<keyof VALUE_EXCLUSION_RESULTS, string>];
+declare type PropagateExclusions$1<META_OBJECT extends ObjectType, VALUE_EXCLUSION_RESULTS extends Record<string, ValueExclusionResultType>> = _Object<{ [KEY in keyof VALUE_EXCLUSION_RESULTS]: PropagateExclusion<VALUE_EXCLUSION_RESULTS[KEY]> }, ObjectRequiredKeys<META_OBJECT>, ObjectOpenProps<META_OBJECT>, IsObjectClosedOnResolve<META_OBJECT>, IsSerialized<META_OBJECT>, Deserialized<META_OBJECT>>;
+declare type OmitOmittableKeys<META_OBJECT extends ObjectType, VALUE_EXCLUSION_RESULTS extends Record<string, ValueExclusionResultType>, OMITTABLE_KEYS extends string = OmittableKeys<VALUE_EXCLUSION_RESULTS>, OMITTABLE_KEYS_COUNT extends string = GetUnionLength<OMITTABLE_KEYS>> = OMITTABLE_KEYS_COUNT extends "moreThanTwo" ? META_OBJECT : OMITTABLE_KEYS_COUNT extends "onlyOne" ? _Object<{ [KEY in keyof VALUE_EXCLUSION_RESULTS]: KEY extends OMITTABLE_KEYS ? Never : SourceValue<VALUE_EXCLUSION_RESULTS[KEY]> }, ObjectRequiredKeys<META_OBJECT>, ObjectOpenProps<META_OBJECT>, IsObjectClosedOnResolve<META_OBJECT>, IsSerialized<META_OBJECT>, Deserialized<META_OBJECT>> : Never;
+declare type OmittableKeys<VALUE_EXCLUSION_RESULTS extends Record<string, ValueExclusionResultType>> = { [KEY in Extract<keyof VALUE_EXCLUSION_RESULTS, string>]: IsOmittable<VALUE_EXCLUSION_RESULTS[KEY]> extends true ? KEY : never }[Extract<keyof VALUE_EXCLUSION_RESULTS, string>];
+declare type ExcludeConstFromObject<META_OBJECT extends ObjectType, META_CONST extends ConstType, CONST_VALUE = ConstValue<META_CONST>> = If<IsObject<CONST_VALUE>, _$Exclude<META_OBJECT, _Object<{ [KEY in Extract<keyof CONST_VALUE, string>]: Const<CONST_VALUE[KEY]> }, Extract<keyof CONST_VALUE, string>, Never, IsObjectClosedOnResolve<META_OBJECT>, IsSerialized<META_CONST>, Deserialized<META_CONST>>>, META_OBJECT>;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/exclusion/primitive.d.ts
+declare type ExcludeFromPrimitive<META_PRIMITIVE extends PrimitiveType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_PRIMITIVE : META_TYPE extends AnyType ? Never : META_TYPE extends ConstType ? META_PRIMITIVE : META_TYPE extends EnumType ? META_PRIMITIVE : META_TYPE extends PrimitiveType ? PrimitiveValue<META_PRIMITIVE> extends PrimitiveValue<META_TYPE> ? Never : META_PRIMITIVE : META_TYPE extends ArrayType ? META_PRIMITIVE : META_TYPE extends TupleType ? META_PRIMITIVE : META_TYPE extends ObjectType ? META_PRIMITIVE : META_TYPE extends UnionType ? ExcludeUnion<META_PRIMITIVE, META_TYPE> : Never : Never;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/exclusion/tuple.d.ts
+declare type ExcludeFromTuple<META_TUPLE extends TupleType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_TUPLE : META_TYPE extends AnyType ? Never : META_TYPE extends ConstType ? ExcludeConst<META_TUPLE, META_TYPE> : META_TYPE extends EnumType ? ExcludeEnum<META_TUPLE, META_TYPE> : META_TYPE extends PrimitiveType ? META_TUPLE : META_TYPE extends ArrayType ? ExcludeArray<META_TUPLE, META_TYPE> : META_TYPE extends TupleType ? ExcludeTuples<META_TUPLE, META_TYPE> : META_TYPE extends ObjectType ? META_TUPLE : META_TYPE extends UnionType ? ExcludeUnion<META_TUPLE, META_TYPE> : Never : Never;
+declare type ExcludeArray<META_TUPLE extends TupleType, META_ARRAY extends ArrayType> = ExcludeTuples<META_TUPLE, Tuple<[], ArrayValues<META_ARRAY>, IsSerialized<META_ARRAY>, Deserialized<META_ARRAY>>>;
+declare type ExcludeTuples<META_TUPLE_A extends TupleType, META_TUPLE_B extends TupleType, VALUE_EXCLUSION_RESULTS extends ValueExclusionResultType[] = ExcludeTupleValues<TupleValues<META_TUPLE_A>, TupleValues<META_TUPLE_B>, IsTupleOpen<META_TUPLE_A>, IsTupleOpen<META_TUPLE_B>, TupleOpenProps<META_TUPLE_A>, TupleOpenProps<META_TUPLE_B>>, REPRESENTABLE_VALUE_EXCLUSION_RESULTS extends ValueExclusionResultType[] = RepresentableExcludedValues<VALUE_EXCLUSION_RESULTS>, EXCLUDED_OPEN_PROPS = _Exclude<TupleOpenProps<META_TUPLE_A>, TupleOpenProps<META_TUPLE_B>>, IS_OPEN_PROPS_EXCLUSION_REPRESENTABLE = Not$1<DoesExtend$1<EXCLUDED_OPEN_PROPS, NeverType>>> = If<DoesTupleSizesMatch<META_TUPLE_A, META_TUPLE_B, VALUE_EXCLUSION_RESULTS>, {
+  moreThanTwo: META_TUPLE_A;
+  onlyOne: $Tuple<PropagateExclusions<VALUE_EXCLUSION_RESULTS>, TupleOpenProps<META_TUPLE_A>, IsSerialized<META_TUPLE_A>, Deserialized<META_TUPLE_A>>;
+  none: OmitOmittableExcludedItems<META_TUPLE_A, VALUE_EXCLUSION_RESULTS>;
+}[And$1<IsTupleOpen<META_TUPLE_A>, IS_OPEN_PROPS_EXCLUSION_REPRESENTABLE> extends true ? "moreThanTwo" : GetTupleLength<REPRESENTABLE_VALUE_EXCLUSION_RESULTS>], META_TUPLE_A>;
+declare type ExcludeTupleValues<META_TUPLE_A_VALUES extends Type[], META_TUPLE_B_VALUES extends Type[], IS_META_TUPLE_A_OPEN extends boolean, IS_META_TUPLE_B_OPEN extends boolean, META_TUPLE_A_OPEN_PROPS extends Type, META_TUPLE_B_OPEN_PROPS extends Type, VALUE_EXCLUSION_RESULTS extends ValueExclusionResultType[] = []> = META_TUPLE_A_VALUES extends [infer META_TUPLE_A_VALUES_HEAD, ...infer META_TUPLE_A_VALUES_TAIL] ? META_TUPLE_A_VALUES_HEAD extends Type ? META_TUPLE_A_VALUES_TAIL extends Type[] ? META_TUPLE_B_VALUES extends [infer META_TUPLE_B_VALUES_HEAD, ...infer META_TUPLE_B_VALUES_TAIL] ? META_TUPLE_B_VALUES_HEAD extends Type ? META_TUPLE_B_VALUES_TAIL extends Type[] ? ExcludeTupleValues<META_TUPLE_A_VALUES_TAIL, META_TUPLE_B_VALUES_TAIL, IS_META_TUPLE_A_OPEN, IS_META_TUPLE_B_OPEN, META_TUPLE_A_OPEN_PROPS, META_TUPLE_B_OPEN_PROPS, [...VALUE_EXCLUSION_RESULTS, ValueExclusionResult<META_TUPLE_A_VALUES_HEAD, true, true, META_TUPLE_B_VALUES_HEAD, true, true>]> : never : never : ExcludeTupleValues<META_TUPLE_A_VALUES_TAIL, [], IS_META_TUPLE_A_OPEN, IS_META_TUPLE_B_OPEN, META_TUPLE_A_OPEN_PROPS, META_TUPLE_B_OPEN_PROPS, [...VALUE_EXCLUSION_RESULTS, ValueExclusionResult<META_TUPLE_A_VALUES_HEAD, true, true, META_TUPLE_B_OPEN_PROPS, IS_META_TUPLE_B_OPEN, false>]> : never : never : META_TUPLE_B_VALUES extends [infer META_TUPLE_B_VALUES_HEAD, ...infer META_TUPLE_B_VALUES_TAIL] ? META_TUPLE_B_VALUES_HEAD extends Type ? META_TUPLE_B_VALUES_TAIL extends Type[] ? ExcludeTupleValues<[], META_TUPLE_B_VALUES_TAIL, IS_META_TUPLE_A_OPEN, IS_META_TUPLE_B_OPEN, META_TUPLE_A_OPEN_PROPS, META_TUPLE_B_OPEN_PROPS, [...VALUE_EXCLUSION_RESULTS, ValueExclusionResult<META_TUPLE_A_OPEN_PROPS, IS_META_TUPLE_A_OPEN, false, META_TUPLE_B_VALUES_HEAD, true, true>]> : never : never : VALUE_EXCLUSION_RESULTS;
+declare type GetTupleLength<ANY_TUPLE extends unknown[], TAIL extends unknown[] = Tail$1<ANY_TUPLE>> = If<DoesExtend$1<ANY_TUPLE, []>, "none", If<DoesExtend$1<TAIL, []>, "onlyOne", "moreThanTwo">>;
+declare type DoesTupleSizesMatch<META_TUPLE_A extends TupleType, META_TUPLE_B extends TupleType, VALUE_EXCLUSION_RESULTS extends ValueExclusionResultType[]> = If<And$1<IsTupleOpen<META_TUPLE_A>, Not$1<IsTupleOpen<META_TUPLE_B>>>, false, And$1<IsExcludedSmallEnough<VALUE_EXCLUSION_RESULTS>, IsExcludedBigEnough<VALUE_EXCLUSION_RESULTS>>>;
+declare type IsExcludedSmallEnough<VALUE_EXCLUSION_RESULTS extends ValueExclusionResultType[]> = VALUE_EXCLUSION_RESULTS extends [infer VALUE_EXCLUSION_RESULTS_HEAD, ...infer VALUE_EXCLUSION_RESULTS_TAIL] ? VALUE_EXCLUSION_RESULTS_HEAD extends ValueExclusionResultType ? VALUE_EXCLUSION_RESULTS_TAIL extends ValueExclusionResultType[] ? If<IsOutsideOfSourceScope<VALUE_EXCLUSION_RESULTS_HEAD>, false, IsExcludedSmallEnough<VALUE_EXCLUSION_RESULTS_TAIL>> : never : never : true;
+declare type IsExcludedBigEnough<VALUE_EXCLUSION_RESULTS extends ValueExclusionResultType[]> = VALUE_EXCLUSION_RESULTS extends [infer VALUE_EXCLUSION_RESULTS_HEAD, ...infer VALUE_EXCLUSION_RESULTS_TAIL] ? VALUE_EXCLUSION_RESULTS_HEAD extends ValueExclusionResultType ? VALUE_EXCLUSION_RESULTS_TAIL extends ValueExclusionResultType[] ? If<IsOutsideOfExcludedScope<VALUE_EXCLUSION_RESULTS_HEAD>, false, IsExcludedBigEnough<VALUE_EXCLUSION_RESULTS_TAIL>> : never : never : true;
+declare type RepresentableExcludedValues<VALUE_EXCLUSION_RESULTS extends ValueExclusionResultType[], REPRESENTABLE_VALUE_EXCLUSION_RESULTS extends ValueExclusionResultType[] = []> = VALUE_EXCLUSION_RESULTS extends [infer VALUE_EXCLUSION_RESULTS_HEAD, ...infer VALUE_EXCLUSION_RESULTS_TAIL] ? VALUE_EXCLUSION_RESULTS_HEAD extends ValueExclusionResultType ? VALUE_EXCLUSION_RESULTS_TAIL extends ValueExclusionResultType[] ? ExclusionResult<VALUE_EXCLUSION_RESULTS_HEAD> extends NeverType ? RepresentableExcludedValues<VALUE_EXCLUSION_RESULTS_TAIL, REPRESENTABLE_VALUE_EXCLUSION_RESULTS> : RepresentableExcludedValues<VALUE_EXCLUSION_RESULTS_TAIL, [...REPRESENTABLE_VALUE_EXCLUSION_RESULTS, VALUE_EXCLUSION_RESULTS_HEAD]> : never : never : REPRESENTABLE_VALUE_EXCLUSION_RESULTS;
+declare type PropagateExclusions<VALUE_EXCLUSION_RESULTS extends ValueExclusionResultType[], RESULT extends unknown[] = []> = VALUE_EXCLUSION_RESULTS extends [infer VALUE_EXCLUSION_RESULTS_HEAD, ...infer VALUE_EXCLUSION_RESULTS_TAIL] ? VALUE_EXCLUSION_RESULTS_HEAD extends ValueExclusionResultType ? VALUE_EXCLUSION_RESULTS_TAIL extends ValueExclusionResultType[] ? PropagateExclusions<VALUE_EXCLUSION_RESULTS_TAIL, [...RESULT, PropagateExclusion<VALUE_EXCLUSION_RESULTS_HEAD>]> : never : never : RESULT;
+declare type OmitOmittableExcludedItems<META_TUPLE extends TupleType, ITEM_EXCLUSION_RESULTS extends ValueExclusionResultType[], OMITTABLE_ITEM_EXCLUSION_RESULTS extends ValueExclusionResultType[] = OmittableExcludedItems<ITEM_EXCLUSION_RESULTS>, OMITTABLE_ITEMS_COUNT extends string = GetTupleLength<OMITTABLE_ITEM_EXCLUSION_RESULTS>> = OMITTABLE_ITEMS_COUNT extends "moreThanTwo" ? META_TUPLE : OMITTABLE_ITEMS_COUNT extends "onlyOne" ? $Tuple<RequiredExcludedItems<ITEM_EXCLUSION_RESULTS>, Never, IsSerialized<META_TUPLE>, Deserialized<META_TUPLE>> : Never;
+declare type OmittableExcludedItems<ITEM_EXCLUSION_RESULTS extends ValueExclusionResultType[], RESULT extends ValueExclusionResultType[] = []> = ITEM_EXCLUSION_RESULTS extends [infer VALUE_EXCLUSION_RESULTS_HEAD, ...infer VALUE_EXCLUSION_RESULTS_TAIL] ? VALUE_EXCLUSION_RESULTS_HEAD extends ValueExclusionResultType ? VALUE_EXCLUSION_RESULTS_TAIL extends ValueExclusionResultType[] ? If<IsOmittable<VALUE_EXCLUSION_RESULTS_HEAD>, OmittableExcludedItems<VALUE_EXCLUSION_RESULTS_TAIL, [...RESULT, VALUE_EXCLUSION_RESULTS_HEAD]>, OmittableExcludedItems<VALUE_EXCLUSION_RESULTS_TAIL, RESULT>> : never : never : RESULT;
+declare type RequiredExcludedItems<ITEM_EXCLUSION_RESULTS extends ValueExclusionResultType[], RESULT extends Type[] = []> = ITEM_EXCLUSION_RESULTS extends [infer VALUE_EXCLUSION_RESULTS_HEAD, ...infer VALUE_EXCLUSION_RESULTS_TAIL] ? VALUE_EXCLUSION_RESULTS_HEAD extends ValueExclusionResultType ? VALUE_EXCLUSION_RESULTS_TAIL extends ValueExclusionResultType[] ? IsOmittable<VALUE_EXCLUSION_RESULTS_HEAD> extends true ? RESULT : RequiredExcludedItems<VALUE_EXCLUSION_RESULTS_TAIL, [...RESULT, SourceValue<VALUE_EXCLUSION_RESULTS_HEAD>]> : never : never : RESULT;
+declare type ExcludeConst<META_TUPLE extends TupleType, META_CONST extends ConstType, META_CONST_VALUE = ConstValue<META_CONST>> = META_CONST_VALUE extends unknown[] ? _Exclude<META_TUPLE, $Tuple<ExtractConstValues<META_CONST_VALUE>, Never, IsSerialized<META_CONST>, Deserialized<META_CONST>>> : META_TUPLE;
+declare type ExtractConstValues<CONST_VALUES extends unknown[], RESULT extends unknown[] = []> = CONST_VALUES extends [infer CONST_VALUES_HEAD, ...infer CONST_VALUES_TAIL] ? ExtractConstValues<CONST_VALUES_TAIL, [...RESULT, Const<CONST_VALUES_HEAD>]> : RESULT;
+//#endregion
+//#region node_modules/ts-algebra/lib/meta-types/exclusion/index.d.ts
+declare type _Exclude<META_TYPE_A extends Type, META_TYPE_B extends Type> = _$Exclude<META_TYPE_A, META_TYPE_B>;
+declare type _$Exclude<META_TYPE_A, META_TYPE_B> = META_TYPE_A extends NeverType ? META_TYPE_A : META_TYPE_A extends AnyType ? ExcludeFromAny<META_TYPE_A, META_TYPE_B> : META_TYPE_A extends ConstType ? ExcludeFromConst<META_TYPE_A, META_TYPE_B> : META_TYPE_A extends EnumType ? ExcludeFromEnum<META_TYPE_A, META_TYPE_B> : META_TYPE_A extends PrimitiveType ? ExcludeFromPrimitive<META_TYPE_A, META_TYPE_B> : META_TYPE_A extends ArrayType ? ExcludeFromArray<META_TYPE_A, META_TYPE_B> : META_TYPE_A extends TupleType ? ExcludeFromTuple<META_TYPE_A, META_TYPE_B> : META_TYPE_A extends ObjectType ? ExcludeFromObject<META_TYPE_A, META_TYPE_B> : META_TYPE_A extends UnionType ? ExcludeFromUnion<META_TYPE_A, META_TYPE_B> : Never;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/definitions/deserializationPattern.d.ts
+type DeserializationPattern = Readonly<{
+  pattern: unknown;
+  output: unknown;
+}>;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/definitions/jsonSchema.d.ts
+declare const $JSONSchema: unique symbol;
+type $JSONSchema = typeof $JSONSchema;
+type JSONSchemaType = "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
+type JSONSchema$1 = boolean | Readonly<{
+  [$JSONSchema]?: $JSONSchema;
+  $id?: string | undefined;
+  $ref?: string | undefined;
+  $schema?: string | undefined;
+  $comment?: string | undefined;
+  type?: JSONSchemaType | readonly JSONSchemaType[];
+  const?: unknown;
+  enum?: unknown;
+  multipleOf?: number | undefined;
+  maximum?: number | undefined;
+  exclusiveMaximum?: number | undefined;
+  minimum?: number | undefined;
+  exclusiveMinimum?: number | undefined;
+  maxLength?: number | undefined;
+  minLength?: number | undefined;
+  pattern?: string | undefined;
+  items?: JSONSchema$1 | readonly JSONSchema$1[];
+  additionalItems?: JSONSchema$1;
+  contains?: JSONSchema$1;
+  maxItems?: number | undefined;
+  minItems?: number | undefined;
+  uniqueItems?: boolean | undefined;
+  maxProperties?: number | undefined;
+  minProperties?: number | undefined;
+  required?: readonly string[];
+  properties?: Readonly<Record<string, JSONSchema$1>>;
+  patternProperties?: Readonly<Record<string, JSONSchema$1>>;
+  additionalProperties?: JSONSchema$1;
+  unevaluatedProperties?: JSONSchema$1;
+  dependencies?: Readonly<Record<string, JSONSchema$1 | readonly string[]>>;
+  propertyNames?: JSONSchema$1;
+  if?: JSONSchema$1;
+  then?: JSONSchema$1;
+  else?: JSONSchema$1;
+  allOf?: readonly JSONSchema$1[];
+  anyOf?: readonly JSONSchema$1[];
+  oneOf?: readonly JSONSchema$1[];
+  not?: JSONSchema$1;
+  format?: string | undefined;
+  contentMediaType?: string | undefined;
+  contentEncoding?: string | undefined;
+  definitions?: Readonly<Record<string, JSONSchema$1>>;
+  title?: string | undefined;
+  description?: string | undefined;
+  default?: unknown;
+  readOnly?: boolean | undefined;
+  writeOnly?: boolean | undefined;
+  examples?: readonly unknown[];
+  nullable?: boolean;
+}>;
+type JSONSchemaReference = JSONSchema$1 & Readonly<{
+  $id: string;
+}>;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/definitions/fromSchemaOptions.d.ts
+type FromSchemaOptions = {
+  parseNotKeyword?: boolean;
+  parseIfThenElseKeywords?: boolean;
+  keepDefaultedPropertiesOptional?: boolean;
+  references?: JSONSchemaReference[] | false;
+  deserialize?: DeserializationPattern[] | false;
+};
+type FromSchemaDefaultOptions = {
+  parseNotKeyword: false;
+  parseIfThenElseKeywords: false;
+  keepDefaultedPropertiesOptional: false;
+  references: false;
+  deserialize: false;
+};
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-options.d.ts
+type IndexReferencesById<SCHEMA_REFERENCES extends readonly JSONSchemaReference[]> = { [REF_SCHEMA in SCHEMA_REFERENCES[number] as REF_SCHEMA["$id"]]: REF_SCHEMA };
+type ParseOptions<ROOT_SCHEMA extends JSONSchema$1, OPTIONS extends FromSchemaOptions> = {
+  parseNotKeyword: OPTIONS["parseNotKeyword"] extends boolean ? OPTIONS["parseNotKeyword"] : FromSchemaDefaultOptions["parseNotKeyword"];
+  parseIfThenElseKeywords: OPTIONS["parseIfThenElseKeywords"] extends boolean ? OPTIONS["parseIfThenElseKeywords"] : FromSchemaDefaultOptions["parseIfThenElseKeywords"];
+  keepDefaultedPropertiesOptional: OPTIONS["keepDefaultedPropertiesOptional"] extends boolean ? OPTIONS["keepDefaultedPropertiesOptional"] : FromSchemaDefaultOptions["keepDefaultedPropertiesOptional"];
+  rootSchema: ROOT_SCHEMA;
+  references: OPTIONS["references"] extends JSONSchemaReference[] ? IndexReferencesById<OPTIONS["references"]> : {};
+  deserialize: OPTIONS["deserialize"] extends DeserializationPattern[] | false ? OPTIONS["deserialize"] : FromSchemaDefaultOptions["deserialize"];
+};
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/type-utils/and.d.ts
+type And<CONDITION_A, CONDITION_B> = CONDITION_A extends true ? CONDITION_B extends true ? true : false : false;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/type-utils/extends.d.ts
+type DoesExtend<TYPE_A, TYPE_B> = [TYPE_A] extends [TYPE_B] ? true : false;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/type-utils/get.d.ts
+type DeepGet<OBJECT, PATH extends string[], DEFAULT = undefined> = PATH extends [infer PATH_HEAD, ...infer PATH_TAIL] ? PATH_HEAD extends string ? PATH_TAIL extends string[] ? PATH_HEAD extends keyof OBJECT ? DeepGet<OBJECT[PATH_HEAD], PATH_TAIL, DEFAULT> : DEFAULT : never : never : OBJECT;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/type-utils/join.d.ts
+type Join<STRINGS extends string[], SEPARATOR extends string = ","> = STRINGS extends [] ? "" : STRINGS extends [string] ? `${STRINGS[0]}` : STRINGS extends [string, ...infer STRINGS_TAIL] ? STRINGS_TAIL extends string[] ? `${STRINGS[0]}${SEPARATOR}${Join<STRINGS_TAIL, SEPARATOR>}` : never : string;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/type-utils/not.d.ts
+type Not<BOOL> = BOOL extends false ? true : BOOL extends true ? false : never;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/type-utils/pop.d.ts
+type Pop<ARRAY extends unknown[]> = ARRAY extends readonly [...infer ARRAY_BODY, unknown] | readonly [...infer ARRAY_BODY, unknown?] ? ARRAY_BODY : ARRAY;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/type-utils/split.d.ts
+type RecursiveSplit<STRING extends string, SEPARATOR extends string = ""> = STRING extends `${infer BEFORE}${SEPARATOR}${infer AFTER}` ? [BEFORE, ...RecursiveSplit<AFTER, SEPARATOR>] : [STRING];
+type Split<STRING extends string, SEPARATOR extends string = "", RESULT extends string[] = RecursiveSplit<STRING, SEPARATOR>> = SEPARATOR extends "" ? Pop<RESULT> : RESULT;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/type-utils/tail.d.ts
+type Tail<ARRAY extends unknown[]> = ARRAY extends readonly [] ? ARRAY : ARRAY extends readonly [unknown?, ...infer ARRAY_TAIL] ? ARRAY_TAIL : ARRAY;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/type-utils/writable.d.ts
+type Writable<TYPE> = TYPE extends ((...args: unknown[]) => unknown) | Date | RegExp ? TYPE : TYPE extends ReadonlyMap<infer KEYS, infer VALUES> ? Map<Writable<KEYS>, Writable<VALUES>> : TYPE extends ReadonlySet<infer VALUES> ? Set<Writable<VALUES>> : TYPE extends ReadonlyArray<unknown> ? `${bigint}` extends `${keyof TYPE & any}` ? { -readonly [KEY in keyof TYPE]: Writable<TYPE[KEY]> } : Writable<TYPE[number]>[] : TYPE extends object ? { -readonly [KEY in keyof TYPE]: Writable<TYPE[KEY]> } : TYPE;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/utils.d.ts
+type RemoveInvalidAdditionalItems<SCHEMA extends JSONSchema$1> = SCHEMA extends Readonly<{
+  items: JSONSchema$1 | readonly JSONSchema$1[];
+}> ? SCHEMA extends Readonly<{
+  additionalItems: JSONSchema$1;
+}> ? SCHEMA : SCHEMA & Readonly<{
+  additionalItems: true;
+}> : SCHEMA extends boolean ? SCHEMA : Omit<SCHEMA, "additionalItems">;
+type RemoveInvalidAdditionalProperties<SCHEMA extends JSONSchema$1> = SCHEMA extends Readonly<{
+  additionalProperties: JSONSchema$1;
+}> ? SCHEMA extends Readonly<{
+  properties: Readonly<Record<string, JSONSchema$1>>;
+}> ? SCHEMA : SCHEMA & Readonly<{
+  properties: {};
+}> : SCHEMA extends boolean ? SCHEMA : Omit<SCHEMA, "additionalProperties">;
+type MergeSubSchema<PARENT_SCHEMA extends JSONSchema$1, SUB_SCHEMA extends JSONSchema$1, CLEANED_SUB_SCHEMA extends JSONSchema$1 = RemoveInvalidAdditionalProperties<RemoveInvalidAdditionalItems<SUB_SCHEMA>>> = Omit<PARENT_SCHEMA, keyof CLEANED_SUB_SCHEMA | "additionalProperties" | "patternProperties" | "unevaluatedProperties" | "required" | "additionalItems"> & CLEANED_SUB_SCHEMA;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/allOf.d.ts
+type AllOfSchema = JSONSchema$1 & Readonly<{
+  allOf: readonly JSONSchema$1[];
+}>;
+type ParseAllOfSchema<ALL_OF_SCHEMA extends AllOfSchema, OPTIONS extends ParseSchemaOptions> = RecurseOnAllOfSchema<ALL_OF_SCHEMA["allOf"], ALL_OF_SCHEMA, OPTIONS, ParseSchema<Omit<ALL_OF_SCHEMA, "allOf">, OPTIONS>>;
+type RecurseOnAllOfSchema<SUB_SCHEMAS extends readonly JSONSchema$1[], ROOT_ALL_OF_SCHEMA extends AllOfSchema, OPTIONS extends ParseSchemaOptions, PARSED_ROOT_ALL_OF_SCHEMA> = SUB_SCHEMAS extends readonly [infer SUB_SCHEMAS_HEAD, ...infer SUB_SCHEMAS_TAIL] ? SUB_SCHEMAS_HEAD extends JSONSchema$1 ? SUB_SCHEMAS_TAIL extends readonly JSONSchema$1[] ? RecurseOnAllOfSchema<SUB_SCHEMAS_TAIL, ROOT_ALL_OF_SCHEMA, OPTIONS, $Intersect<ParseSchema<MergeSubSchema<Omit<ROOT_ALL_OF_SCHEMA, "allOf">, SUB_SCHEMAS_HEAD>, OPTIONS>, PARSED_ROOT_ALL_OF_SCHEMA>> : never : never : PARSED_ROOT_ALL_OF_SCHEMA;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/anyOf.d.ts
+type AnyOfSchema = JSONSchema$1 & Readonly<{
+  anyOf: readonly JSONSchema$1[];
+}>;
+type ParseAnyOfSchema<ANY_OF_SCHEMA extends AnyOfSchema, OPTIONS extends ParseSchemaOptions> = $Union<RecurseOnAnyOfSchema<ANY_OF_SCHEMA["anyOf"], ANY_OF_SCHEMA, OPTIONS>>;
+type RecurseOnAnyOfSchema<SUB_SCHEMAS extends readonly JSONSchema$1[], ROOT_ANY_OF_SCHEMA extends AnyOfSchema, OPTIONS extends ParseSchemaOptions, RESULT = never> = SUB_SCHEMAS extends readonly [infer SUB_SCHEMAS_HEAD, ...infer SUB_SCHEMAS_TAIL] ? SUB_SCHEMAS_HEAD extends JSONSchema$1 ? SUB_SCHEMAS_TAIL extends readonly JSONSchema$1[] ? RecurseOnAnyOfSchema<SUB_SCHEMAS_TAIL, ROOT_ANY_OF_SCHEMA, OPTIONS, RESULT | $Intersect<ParseSchema<Omit<ROOT_ANY_OF_SCHEMA, "anyOf">, OPTIONS>, ParseSchema<MergeSubSchema<Omit<ROOT_ANY_OF_SCHEMA, "anyOf">, SUB_SCHEMAS_HEAD>, OPTIONS>>> : never : never : RESULT;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/const.d.ts
+type ConstSchema = JSONSchema$1 & Readonly<{
+  const: unknown;
+}>;
+type ParseConstSchema<CONST_SCHEMA extends ConstSchema, OPTIONS extends ParseSchemaOptions> = $Intersect<ParseConst<CONST_SCHEMA>, ParseSchema<Omit<CONST_SCHEMA, "const">, OPTIONS>>;
+type ParseConst<CONST_SCHEMA extends ConstSchema> = Const<Writable<CONST_SCHEMA["const"]>>;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/deserialize.d.ts
+type DeserializeSchema<SCHEMA extends JSONSchema$1, OPTIONS extends Omit<ParseSchemaOptions, "deserialize"> & {
+  deserialize: DeserializationPattern[];
+}> = RecurseOnDeserializationPatterns<SCHEMA, OPTIONS["deserialize"]>;
+type RecurseOnDeserializationPatterns<SCHEMA extends JSONSchema$1, DESERIALIZATION_PATTERNS extends DeserializationPattern[], RESULT = Any> = DESERIALIZATION_PATTERNS extends [infer DESERIALIZATION_PATTERNS_HEAD, ...infer DESERIALIZATION_PATTERNS_TAIL] ? DESERIALIZATION_PATTERNS_HEAD extends DeserializationPattern ? DESERIALIZATION_PATTERNS_TAIL extends DeserializationPattern[] ? RecurseOnDeserializationPatterns<SCHEMA, DESERIALIZATION_PATTERNS_TAIL, SCHEMA extends DESERIALIZATION_PATTERNS_HEAD["pattern"] ? $Intersect<Any<true, DESERIALIZATION_PATTERNS_HEAD["output"]>, RESULT> : RESULT> : never : never : RESULT;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/enum.d.ts
+type EnumSchema = JSONSchema$1 & Readonly<{
+  enum: readonly unknown[];
+}>;
+type ParseEnumSchema<ENUM_SCHEMA extends EnumSchema, OPTIONS extends ParseSchemaOptions> = $Intersect<ParseEnum<ENUM_SCHEMA>, ParseSchema<Omit<ENUM_SCHEMA, "enum">, OPTIONS>>;
+type ParseEnum<ENUM_SCHEMA extends EnumSchema> = Enum<Writable<ENUM_SCHEMA["enum"][number]>>;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/ifThenElse.d.ts
+type IfThenElseSchema = JSONSchema$1 & {
+  if: JSONSchema$1;
+  then?: JSONSchema$1;
+  else?: JSONSchema$1;
+};
+type ParseIfThenElseSchema<IF_THEN_ELSE_SCHEMA extends IfThenElseSchema, OPTIONS extends ParseSchemaOptions, REST_SCHEMA extends JSONSchema$1 = Omit<IF_THEN_ELSE_SCHEMA, "if" | "then" | "else">, IF_SCHEMA extends JSONSchema$1 = MergeSubSchema<REST_SCHEMA, IF_THEN_ELSE_SCHEMA["if"]>, PARSED_THEN_SCHEMA = (IF_THEN_ELSE_SCHEMA extends {
+  then: JSONSchema$1;
+} ? $Intersect<ParseSchema<IF_SCHEMA, OPTIONS>, ParseSchema<MergeSubSchema<REST_SCHEMA, IF_THEN_ELSE_SCHEMA["then"]>, OPTIONS>> : ParseSchema<IF_SCHEMA, OPTIONS>), PARSED_ELSE_SCHEMA = (IF_THEN_ELSE_SCHEMA extends {
+  else: JSONSchema$1;
+} ? $Intersect<_$Exclude<ParseSchema<REST_SCHEMA, OPTIONS>, ParseSchema<IF_SCHEMA, OPTIONS>>, ParseSchema<MergeSubSchema<REST_SCHEMA, IF_THEN_ELSE_SCHEMA["else"]>, OPTIONS>> : _$Exclude<ParseSchema<REST_SCHEMA, OPTIONS>, ParseSchema<IF_SCHEMA, OPTIONS>>)> = $Intersect<$Union<PARSED_THEN_SCHEMA | PARSED_ELSE_SCHEMA>, ParseSchema<REST_SCHEMA, OPTIONS>>;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/multipleTypes.d.ts
+type MultipleTypesSchema = JSONSchema$1 & Readonly<{
+  type: readonly JSONSchemaType[];
+}>;
+type ParseMultipleTypesSchema<MULTI_TYPE_SCHEMA extends MultipleTypesSchema, OPTIONS extends ParseSchemaOptions> = $Union<RecurseOnMixedSchema<MULTI_TYPE_SCHEMA["type"], MULTI_TYPE_SCHEMA, OPTIONS>>;
+type RecurseOnMixedSchema<TYPES extends readonly JSONSchemaType[], ROOT_MULTI_TYPE_SCHEMA extends MultipleTypesSchema, OPTIONS extends ParseSchemaOptions, RESULT = never> = TYPES extends readonly [infer TYPES_HEAD, ...infer TYPES_TAIL] ? TYPES_HEAD extends JSONSchemaType ? TYPES_TAIL extends readonly JSONSchemaType[] ? RecurseOnMixedSchema<TYPES_TAIL, ROOT_MULTI_TYPE_SCHEMA, OPTIONS, RESULT | ParseSchema<Omit<ROOT_MULTI_TYPE_SCHEMA, "type"> & {
+  type: TYPES_HEAD;
+}, OPTIONS>> : never : never : RESULT;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/not.d.ts
+type NotSchema = JSONSchema$1 & Readonly<{
+  not: JSONSchema$1;
+}>;
+type AllTypes = Union<Primitive<null> | Primitive<boolean> | Primitive<number> | Primitive<string> | _Array | _Object<{}, never, Any>>;
+type ParseNotSchema<NOT_SCHEMA extends NotSchema, OPTIONS extends ParseSchemaOptions, PARSED_REST_SCHEMA = ParseSchema<Omit<NOT_SCHEMA, "not">, OPTIONS>, EXCLUSION = _$Exclude<PARSED_REST_SCHEMA extends AnyType ? $Intersect<AllTypes, PARSED_REST_SCHEMA> : PARSED_REST_SCHEMA, ParseSchema<MergeSubSchema<Omit<NOT_SCHEMA, "not">, NOT_SCHEMA["not"]>, OPTIONS>>> = EXCLUSION extends Never ? PARSED_REST_SCHEMA : EXCLUSION;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/nullable.d.ts
+type NullableSchema = JSONSchema$1 & Readonly<{
+  nullable: boolean;
+}>;
+type ParseNullableSchema<NULLABLE_SCHEMA extends NullableSchema, OPTIONS extends ParseSchemaOptions, PARSED_REST_SCHEMA = ParseSchema<Omit<NULLABLE_SCHEMA, "nullable">, OPTIONS>> = NULLABLE_SCHEMA extends Readonly<{
+  nullable: true;
+}> ? $Union<Primitive<null> | PARSED_REST_SCHEMA> : PARSED_REST_SCHEMA;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/oneOf.d.ts
+type OneOfSchema = JSONSchema$1 & Readonly<{
+  oneOf: readonly JSONSchema$1[];
+}>;
+type ParseOneOfSchema<ONE_OF_SCHEMA extends OneOfSchema, OPTIONS extends ParseSchemaOptions> = $Union<RecurseOnOneOfSchema<ONE_OF_SCHEMA["oneOf"], ONE_OF_SCHEMA, OPTIONS>>;
+type RecurseOnOneOfSchema<SUB_SCHEMAS extends readonly JSONSchema$1[], ROOT_ONE_OF_SCHEMA extends OneOfSchema, OPTIONS extends ParseSchemaOptions, RESULT = never> = SUB_SCHEMAS extends readonly [infer SUB_SCHEMAS_HEAD, ...infer SUB_SCHEMAS_TAIL] ? SUB_SCHEMAS_HEAD extends JSONSchema$1 ? SUB_SCHEMAS_TAIL extends readonly JSONSchema$1[] ? RecurseOnOneOfSchema<SUB_SCHEMAS_TAIL, ROOT_ONE_OF_SCHEMA, OPTIONS, RESULT | $Intersect<ParseSchema<Omit<ROOT_ONE_OF_SCHEMA, "oneOf">, OPTIONS>, ParseSchema<MergeSubSchema<Omit<ROOT_ONE_OF_SCHEMA, "oneOf">, SUB_SCHEMAS_HEAD>, OPTIONS>>> : never : never : RESULT;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/references/utils.d.ts
+type ParseReference<SCHEMA extends JSONSchema$1, OPTIONS extends ParseSchemaOptions, REFERENCE_SOURCE extends JSONSchema$1, PATH_IN_SOURCE extends string | undefined, MATCHING_REFERENCE extends JSONSchema$1 = (PATH_IN_SOURCE extends string ? DeepGet<REFERENCE_SOURCE, Tail<Split<PATH_IN_SOURCE, "/">>, false> : REFERENCE_SOURCE)> = $Intersect<ParseSchema<MATCHING_REFERENCE, OPTIONS>, ParseSchema<MergeSubSchema<MATCHING_REFERENCE, SCHEMA>, OPTIONS>>;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/references/external.d.ts
+type ParseExternalReferenceSchema<REF_SCHEMA extends ReferencingSchema, OPTIONS extends ParseSchemaOptions, EXTERNAL_REFERENCE_ID extends string, SUB_PATH extends string | undefined> = OPTIONS["references"] extends { [KEY in EXTERNAL_REFERENCE_ID]: JSONSchema$1 } ? ParseReference<Omit<REF_SCHEMA, "$ref">, OPTIONS, OPTIONS["references"][EXTERNAL_REFERENCE_ID], SUB_PATH> : OPTIONS extends {
+  rootSchema: IdSchema;
+} ? ParseExternalReferenceWithoutDirectorySchema<Omit<REF_SCHEMA, "$ref">, OPTIONS, EXTERNAL_REFERENCE_ID, SUB_PATH> : Never;
+type ParseDirectory<REFERENCE extends string> = Join<Pop<Split<REFERENCE, "/">>, "/">;
+type IdSchema = JSONSchema$1 & {
+  $id: string;
+};
+type ParseExternalReferenceWithoutDirectorySchema<SUB_SCHEMA extends JSONSchema$1, OPTIONS extends ParseSchemaOptions & {
+  rootSchema: IdSchema;
+}, EXTERNAL_REFERENCE_ID extends string, SUB_PATH extends string | undefined, DIRECTORY extends string = ParseDirectory<OPTIONS["rootSchema"]["$id"]>, COMPLETE_REFERENCE extends string = Join<[DIRECTORY, EXTERNAL_REFERENCE_ID], "/">> = COMPLETE_REFERENCE extends keyof OPTIONS["references"] ? ParseReference<SUB_SCHEMA, OPTIONS, OPTIONS["references"][COMPLETE_REFERENCE], SUB_PATH> : Never;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/references/internal.d.ts
+type ParseInternalReferenceSchema<REFERENCING_SCHEMA extends ReferencingSchema, OPTIONS extends ParseSchemaOptions, PATH extends string> = ParseReference<Omit<REFERENCING_SCHEMA, "$ref">, OPTIONS, OPTIONS["rootSchema"], PATH>;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/references/index.d.ts
+type ReferencingSchema = JSONSchema$1 & {
+  $ref: string;
+};
+type ParseReferenceSchema<REFERENCING_SCHEMA extends ReferencingSchema, OPTIONS extends ParseSchemaOptions, REFERENCE_ID_AND_PATH extends string[] = Split<REFERENCING_SCHEMA["$ref"], "#">> = REFERENCE_ID_AND_PATH[0] extends "" ? ParseInternalReferenceSchema<REFERENCING_SCHEMA, OPTIONS, REFERENCE_ID_AND_PATH[1]> : ParseExternalReferenceSchema<REFERENCING_SCHEMA, OPTIONS, REFERENCE_ID_AND_PATH[0], REFERENCE_ID_AND_PATH[1]>;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/array.d.ts
+type ArrayOrTupleSchema = JSONSchema$1 & Readonly<{
+  type: "array";
+}>;
+type ArraySchema = Omit<JSONSchema$1, "items"> & Readonly<{
+  type: "array";
+  items: JSONSchema$1;
+}>;
+type TupleSchema = JSONSchema$1 & Readonly<{
+  type: "array";
+  items: readonly JSONSchema$1[];
+}>;
+type ParseArrayOrTupleSchema<ARRAY_OR_TUPLE_SCHEMA extends ArrayOrTupleSchema, OPTIONS extends ParseSchemaOptions> = ARRAY_OR_TUPLE_SCHEMA extends ArraySchema ? _$Array<ParseSchema<ARRAY_OR_TUPLE_SCHEMA["items"], OPTIONS>> : ARRAY_OR_TUPLE_SCHEMA extends TupleSchema ? $Union<ApplyMinMaxAndAdditionalItems<ParseTupleItems<ARRAY_OR_TUPLE_SCHEMA["items"], OPTIONS>, ARRAY_OR_TUPLE_SCHEMA, OPTIONS>> : _$Array;
+type ParseTupleItems<ITEM_SCHEMAS extends readonly JSONSchema$1[], OPTIONS extends ParseSchemaOptions> = ITEM_SCHEMAS extends readonly [infer ITEM_SCHEMAS_HEAD, ...infer ITEM_SCHEMAS_TAIL] ? ITEM_SCHEMAS_HEAD extends JSONSchema$1 ? ITEM_SCHEMAS_TAIL extends readonly JSONSchema$1[] ? [ParseSchema<ITEM_SCHEMAS_HEAD, OPTIONS>, ...ParseTupleItems<ITEM_SCHEMAS_TAIL, OPTIONS>] : never : never : [];
+type ApplyMinMaxAndAdditionalItems<PARSED_ITEM_SCHEMAS extends any[], ROOT_SCHEMA extends ArrayOrTupleSchema, OPTIONS extends ParseSchemaOptions> = ApplyAdditionalItems<ApplyMinMax<PARSED_ITEM_SCHEMAS, ROOT_SCHEMA extends Readonly<{
+  minItems: number;
+}> ? ROOT_SCHEMA["minItems"] : 0, ROOT_SCHEMA extends Readonly<{
+  maxItems: number;
+}> ? ROOT_SCHEMA["maxItems"] : undefined>, ROOT_SCHEMA extends Readonly<{
+  additionalItems: JSONSchema$1;
+}> ? ROOT_SCHEMA["additionalItems"] : true, OPTIONS>;
+type ApplyMinMax<RECURSED_PARSED_ITEM_SCHEMAS extends any[], MIN extends number, MAX extends number | undefined, RESULT = never, HAS_ENCOUNTERED_MIN extends boolean = false, HAS_ENCOUNTERED_MAX extends boolean = false, INITIAL_PARSED_ITEM_SCHEMAS extends any[] = RECURSED_PARSED_ITEM_SCHEMAS> = And<Not<DoesExtend<MIN, RECURSED_PARSED_ITEM_SCHEMAS["length"]>>, DoesExtend<RECURSED_PARSED_ITEM_SCHEMAS, [any, ...any[]]>> extends true ? RECURSED_PARSED_ITEM_SCHEMAS extends [...infer RECURSED_PARSED_ITEM_SCHEMAS_BODY, unknown] ? ApplyMinMax<RECURSED_PARSED_ITEM_SCHEMAS_BODY, MIN, MAX, RECURSED_PARSED_ITEM_SCHEMAS["length"] extends MAX ? $Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : RESULT | $Tuple<RECURSED_PARSED_ITEM_SCHEMAS>, HAS_ENCOUNTERED_MIN extends true ? true : DoesExtend<MIN, RECURSED_PARSED_ITEM_SCHEMAS["length"]>, HAS_ENCOUNTERED_MAX extends true ? true : DoesExtend<MAX, RECURSED_PARSED_ITEM_SCHEMAS["length"]>, INITIAL_PARSED_ITEM_SCHEMAS> : never : {
+  result: MAX extends undefined ? RESULT | $Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : HAS_ENCOUNTERED_MAX extends true ? RESULT | $Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : MAX extends RECURSED_PARSED_ITEM_SCHEMAS["length"] ? $Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : IsLongerThan<Tail<RECURSED_PARSED_ITEM_SCHEMAS>, MAX> extends true ? never : RESULT | $Tuple<RECURSED_PARSED_ITEM_SCHEMAS>;
+  hasEncounteredMin: DoesExtend<MIN, RECURSED_PARSED_ITEM_SCHEMAS["length"]>;
+  hasEncounteredMax: HAS_ENCOUNTERED_MAX extends true ? true : MAX extends RECURSED_PARSED_ITEM_SCHEMAS["length"] ? true : IsLongerThan<Tail<RECURSED_PARSED_ITEM_SCHEMAS>, MAX>;
+  completeTuple: INITIAL_PARSED_ITEM_SCHEMAS;
+};
+type IsLongerThan<TUPLE extends any[], LENGTH extends number | undefined, RESULT extends boolean = false> = LENGTH extends undefined ? false : TUPLE["length"] extends LENGTH ? true : TUPLE extends [any, ...infer TUPLE_TAIL] ? IsLongerThan<TUPLE_TAIL, LENGTH> : RESULT;
+type ApplyAdditionalItems<APPLY_MIN_MAX_RESULT extends {
+  result: any;
+  hasEncounteredMin: boolean;
+  hasEncounteredMax: boolean;
+  completeTuple: any[];
+}, ADDITIONAL_ITEMS_SCHEMA extends JSONSchema$1, OPTIONS extends ParseSchemaOptions> = APPLY_MIN_MAX_RESULT extends {
+  hasEncounteredMax: true;
+} ? APPLY_MIN_MAX_RESULT extends {
+  hasEncounteredMin: true;
+} ? APPLY_MIN_MAX_RESULT["result"] : Never : ADDITIONAL_ITEMS_SCHEMA extends false ? APPLY_MIN_MAX_RESULT extends {
+  hasEncounteredMin: true;
+} ? APPLY_MIN_MAX_RESULT["result"] : Never : ADDITIONAL_ITEMS_SCHEMA extends true ? APPLY_MIN_MAX_RESULT extends {
+  hasEncounteredMin: true;
+} ? APPLY_MIN_MAX_RESULT["result"] | $Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], Any> : $Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], Any> : APPLY_MIN_MAX_RESULT extends {
+  hasEncounteredMin: true;
+} ? APPLY_MIN_MAX_RESULT["result"] | $Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], ParseSchema<ADDITIONAL_ITEMS_SCHEMA, OPTIONS>> : $Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], ParseSchema<ADDITIONAL_ITEMS_SCHEMA, OPTIONS>>;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/object.d.ts
+type ObjectSchema$1 = JSONSchema$1 & Readonly<{
+  type: "object";
+}>;
+type ParseObjectSchema<OBJECT_SCHEMA extends ObjectSchema$1, OPTIONS extends ParseSchemaOptions> = OBJECT_SCHEMA extends Readonly<{
+  properties: Readonly<Record<string, JSONSchema$1>>;
+}> ? _$Object<{ [KEY in keyof OBJECT_SCHEMA["properties"]]: ParseSchema<OBJECT_SCHEMA["properties"][KEY], OPTIONS> }, GetRequired<OBJECT_SCHEMA, OPTIONS>, GetOpenProps<OBJECT_SCHEMA, OPTIONS>, GetClosedOnResolve<OBJECT_SCHEMA>> : _$Object<{}, GetRequired<OBJECT_SCHEMA, OPTIONS>, GetOpenProps<OBJECT_SCHEMA, OPTIONS>, GetClosedOnResolve<OBJECT_SCHEMA>>;
+type GetRequired<OBJECT_SCHEMA extends ObjectSchema$1, OPTIONS extends ParseSchemaOptions> = (OBJECT_SCHEMA extends Readonly<{
+  required: ReadonlyArray<string>;
+}> ? OBJECT_SCHEMA["required"][number] : never) | (OPTIONS["keepDefaultedPropertiesOptional"] extends true ? never : OBJECT_SCHEMA extends Readonly<{
+  properties: Readonly<Record<string, JSONSchema$1>>;
+}> ? { [KEY in keyof OBJECT_SCHEMA["properties"] & string]: OBJECT_SCHEMA["properties"][KEY] extends Readonly<{
+  default: unknown;
+}> ? KEY : never }[keyof OBJECT_SCHEMA["properties"] & string] : never);
+type GetOpenProps<OBJECT_SCHEMA extends ObjectSchema$1, OPTIONS extends ParseSchemaOptions> = OBJECT_SCHEMA extends Readonly<{
+  additionalProperties: JSONSchema$1;
+}> ? OBJECT_SCHEMA extends Readonly<{
+  patternProperties: Record<string, JSONSchema$1>;
+}> ? AdditionalAndPatternProps<OBJECT_SCHEMA["additionalProperties"], OBJECT_SCHEMA["patternProperties"], OPTIONS> : ParseSchema<OBJECT_SCHEMA["additionalProperties"], OPTIONS> : OBJECT_SCHEMA extends Readonly<{
+  patternProperties: Record<string, JSONSchema$1>;
+}> ? PatternProps<OBJECT_SCHEMA["patternProperties"], OPTIONS> : Any;
+type GetClosedOnResolve<OBJECT_SCHEMA extends ObjectSchema$1> = OBJECT_SCHEMA extends Readonly<{
+  unevaluatedProperties: false;
+}> ? true : false;
+type PatternProps<PATTERN_PROPERTY_SCHEMAS extends Readonly<Record<string, JSONSchema$1>>, OPTIONS extends ParseSchemaOptions> = $Union<{ [KEY in keyof PATTERN_PROPERTY_SCHEMAS]: ParseSchema<PATTERN_PROPERTY_SCHEMAS[KEY], OPTIONS> }[keyof PATTERN_PROPERTY_SCHEMAS]>;
+type AdditionalAndPatternProps<ADDITIONAL_PROPERTIES_SCHEMA extends JSONSchema$1, PATTERN_PROPERTY_SCHEMAS extends Readonly<Record<string, JSONSchema$1>>, OPTIONS extends ParseSchemaOptions> = ADDITIONAL_PROPERTIES_SCHEMA extends boolean ? PatternProps<PATTERN_PROPERTY_SCHEMAS, OPTIONS> : $Union<ParseSchema<ADDITIONAL_PROPERTIES_SCHEMA, OPTIONS> | { [KEY in keyof PATTERN_PROPERTY_SCHEMAS]: ParseSchema<PATTERN_PROPERTY_SCHEMAS[KEY], OPTIONS> }[keyof PATTERN_PROPERTY_SCHEMAS]>;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/singleType.d.ts
+type SingleTypeSchema = JSONSchema$1 & Readonly<{
+  type: JSONSchemaType;
+}>;
+type ParseSingleTypeSchema<SINGLE_TYPE_SCHEMA extends SingleTypeSchema, OPTIONS extends ParseSchemaOptions> = SINGLE_TYPE_SCHEMA extends Readonly<{
+  type: "null";
+}> ? Primitive<null> : SINGLE_TYPE_SCHEMA extends Readonly<{
+  type: "boolean";
+}> ? Primitive<boolean> : SINGLE_TYPE_SCHEMA extends Readonly<{
+  type: "integer";
+}> ? Primitive<number> : SINGLE_TYPE_SCHEMA extends Readonly<{
+  type: "number";
+}> ? Primitive<number> : SINGLE_TYPE_SCHEMA extends Readonly<{
+  type: "string";
+}> ? Primitive<string> : SINGLE_TYPE_SCHEMA extends ArrayOrTupleSchema ? ParseArrayOrTupleSchema<SINGLE_TYPE_SCHEMA, OPTIONS> : SINGLE_TYPE_SCHEMA extends ObjectSchema$1 ? ParseObjectSchema<SINGLE_TYPE_SCHEMA, OPTIONS> : Never;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/parse-schema/index.d.ts
+type ParseSchemaOptions = {
+  parseNotKeyword: boolean;
+  parseIfThenElseKeywords: boolean;
+  keepDefaultedPropertiesOptional: boolean;
+  rootSchema: JSONSchema$1;
+  references: Record<string, JSONSchema$1>;
+  deserialize: DeserializationPattern[] | false;
+};
+type ParseSchema<SCHEMA extends JSONSchema$1, OPTIONS extends ParseSchemaOptions, RESULT = (JSONSchema$1 extends SCHEMA ? Any : SCHEMA extends true | string ? Any : SCHEMA extends false ? Never : SCHEMA extends NullableSchema ? ParseNullableSchema<SCHEMA, OPTIONS> : SCHEMA extends ReferencingSchema ? ParseReferenceSchema<SCHEMA, OPTIONS> : And<DoesExtend<OPTIONS["parseIfThenElseKeywords"], true>, DoesExtend<SCHEMA, IfThenElseSchema>> extends true ? SCHEMA extends IfThenElseSchema ? ParseIfThenElseSchema<SCHEMA, OPTIONS> : never : And<DoesExtend<OPTIONS["parseNotKeyword"], true>, DoesExtend<SCHEMA, NotSchema>> extends true ? SCHEMA extends NotSchema ? ParseNotSchema<SCHEMA, OPTIONS> : never : SCHEMA extends AllOfSchema ? ParseAllOfSchema<SCHEMA, OPTIONS> : SCHEMA extends OneOfSchema ? ParseOneOfSchema<SCHEMA, OPTIONS> : SCHEMA extends AnyOfSchema ? ParseAnyOfSchema<SCHEMA, OPTIONS> : SCHEMA extends EnumSchema ? ParseEnumSchema<SCHEMA, OPTIONS> : SCHEMA extends ConstSchema ? ParseConstSchema<SCHEMA, OPTIONS> : SCHEMA extends MultipleTypesSchema ? ParseMultipleTypesSchema<SCHEMA, OPTIONS> : SCHEMA extends SingleTypeSchema ? ParseSingleTypeSchema<SCHEMA, OPTIONS> : Any)> = OPTIONS extends {
+  deserialize: DeserializationPattern[];
+} ? $Intersect<DeserializeSchema<SCHEMA, OPTIONS>, RESULT> : RESULT;
+//#endregion
+//#region node_modules/json-schema-to-ts/lib/types/index.d.ts
+type FromSchema$1<SCHEMA extends JSONSchema$1, OPTIONS extends FromSchemaOptions = FromSchemaDefaultOptions> = $Resolve<ParseSchema<SCHEMA, ParseOptions<SCHEMA, OPTIONS>>>;
+//#endregion
+//#region node_modules/fets/node_modules/@whatwg-node/fetch/dist/index.d.ts
+/// <reference lib="dom" />
+/// <reference lib="dom.iterable" />
+declare type _URLPattern = typeof URLPattern;
+declare module '@whatwg-node/fetch' {
+  export const fetch: typeof globalThis.fetch;
+  export const Request: typeof globalThis.Request;
+  export const Response: typeof globalThis.Response & {
+    json(data: any, init?: ResponseInit): globalThis.Response;
+  };
+  export const Headers: typeof globalThis.Headers;
+  export const FormData: typeof globalThis.FormData;
+  export const ReadableStream: typeof globalThis.ReadableStream;
+  export const WritableStream: typeof globalThis.WritableStream;
+  export const TransformStream: typeof globalThis.TransformStream;
+  export const CompressionStream: typeof globalThis.CompressionStream;
+  export const DecompressionStream: typeof globalThis.DecompressionStream;
+  export const TextDecoderStream: typeof globalThis.TextDecoderStream;
+  export const TextEncoderStream: typeof globalThis.TextEncoderStream;
+  export const Blob: typeof globalThis.Blob;
+  export const File: typeof globalThis.File;
+  export const crypto: typeof globalThis.crypto;
+  export const btoa: typeof globalThis.btoa;
+  export const TextDecoder: typeof globalThis.TextDecoder;
+  export const TextEncoder: typeof globalThis.TextEncoder;
+  export const URL: typeof globalThis.URL;
+  export const URLSearchParams: typeof globalThis.URLSearchParams;
+  export const URLPattern: _URLPattern;
+  export interface FormDataLimits {
+    /* Max field name size (in bytes). Default: 100. */
+    fieldNameSize?: number;
+    /* Max field value size (in bytes). Default: 1MB. */
+    fieldSize?: number;
+    /* Max number of fields. Default: Infinity. */
+    fields?: number;
+    /* For multipart forms, the max file size (in bytes). Default: Infinity. */
+    fileSize?: number;
+    /* For multipart forms, the max number of file fields. Default: Infinity. */
+    files?: number;
+    /* For multipart forms, the max number of parts (fields + files). Default: Infinity. */
+    parts?: number;
+    /* For multipart forms, the max number of header key-value pairs to parse. Default: 2000. */
+    headerSize?: number;
+  }
+  export const createFetch: (opts?: {
+    useNodeFetch?: boolean;
+    formDataLimits?: FormDataLimits;
+    skipPonyfill?: boolean;
+  }) => {
+    fetch: typeof fetch;
+    Request: typeof Request;
+    Response: typeof Response;
+    Headers: typeof Headers;
+    FormData: typeof FormData;
+    ReadableStream: typeof ReadableStream;
+    WritableStream: typeof WritableStream;
+    TransformStream: typeof TransformStream;
+    CompressionStream: typeof CompressionStream;
+    DecompressionStream: typeof DecompressionStream;
+    TextDecoderStream: typeof TextDecoderStream;
+    TextEncoderStream: typeof TextEncoderStream;
+    Blob: typeof Blob;
+    File: typeof File;
+    crypto: typeof crypto;
+    btoa: typeof btoa;
+    TextEncoder: typeof TextEncoder;
+    TextDecoder: typeof TextDecoder;
+    URLPattern: typeof URLPattern;
+    URL: typeof URL;
+    URLSearchParams: typeof URLSearchParams;
+  };
+}
+//#endregion
+//#region node_modules/@whatwg-node/promise-helpers/typings/index.d.cts
+type MaybePromise<T> = Promise<T> | T;
+type MaybePromiseLike<T> = PromiseLike<T> | T;
+//#endregion
+//#region node_modules/fets/node_modules/@whatwg-node/server/typings/utils.d.cts
+interface NodeRequest {
+  protocol?: string | undefined;
+  hostname?: string | undefined;
+  body?: any | undefined;
+  url?: string | undefined;
+  originalUrl?: string | undefined;
+  method?: string | undefined;
+  headers?: any | undefined;
+  req?: IncomingMessage | Http2ServerRequest | undefined;
+  raw?: IncomingMessage | Http2ServerRequest | undefined;
+  socket?: Socket | undefined;
+  query?: any | undefined;
+  once?(event: string, listener: (...args: any[]) => void): void;
+  aborted?: boolean | undefined;
+}
+type NodeResponse = ServerResponse | Http2ServerResponse;
+//#endregion
+//#region node_modules/fets/node_modules/@whatwg-node/server/typings/uwebsockets.d.cts
+interface UWSRequest {
+  getMethod(): string;
+  forEach(callback: (key: string, value: string) => void): void;
+  getUrl(): string;
+  getQuery(): string;
+  getHeader(key: string): string | undefined;
+  setYield(y: boolean): void;
+}
+interface UWSResponse {
+  onData(callback: (chunk: ArrayBuffer, isLast: boolean) => void): void;
+  onAborted(callback: () => void): void;
+  writeStatus(status: string): void;
+  writeHeader(key: string, value: string): void;
+  end(body?: any): void;
+  close(): void;
+  write(body: any): boolean;
+  cork(callback: () => void): void;
+}
+type UWSHandler = (res: UWSResponse, req: UWSRequest) => void | Promise<void>;
+//#endregion
+//#region node_modules/fets/node_modules/@whatwg-node/server/typings/types.d.cts
+interface FetchEvent extends Event {
+  waitUntil(f: MaybePromise<void>): void;
+  request: Request;
+  respondWith(r: MaybePromiseLike<Response>): void;
+}
+interface ServerAdapterBaseObject<TServerContext, THandleRequest extends ServerAdapterRequestHandler<TServerContext> = ServerAdapterRequestHandler<TServerContext>> {
+  /**
+   * An async function that takes `Request` and the server context and returns a `Response`.
+   * If you use `requestListener`, the server context is `{ req: IncomingMessage, res: ServerResponse }`.
+   */
+  handle: THandleRequest;
+}
+interface ServerAdapterObject<TServerContext> extends EventListenerObject, AsyncDisposable {
+  /**
+   * A basic request listener that takes a `Request` with the server context and returns a `Response`.
+   */
+  handleRequest: (request: Request, ctx: TServerContext & Partial<ServerAdapterInitialContext>) => MaybePromise<Response>;
+  /**
+   * WHATWG Fetch spec compliant `fetch` function that can be used for testing purposes.
+   */
+  fetch(request: Request, ctx: TServerContext): MaybePromise<Response>;
+  fetch(request: Request, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+  fetch(urlStr: string, ctx: TServerContext): MaybePromise<Response>;
+  fetch(urlStr: string, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+  fetch(urlStr: string, init: RequestInit, ctx: TServerContext): MaybePromise<Response>;
+  fetch(urlStr: string, init: RequestInit, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+  fetch(url: URL, ctx: TServerContext): MaybePromise<Response>;
+  fetch(url: URL, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+  fetch(url: URL, init: RequestInit, ctx: TServerContext): MaybePromise<Response>;
+  fetch(url: URL, init: RequestInit, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+  /**
+   * This function takes Node's request object and returns a WHATWG Fetch spec compliant `Response` object.
+   *
+   * @deprecated Use `handleNodeRequestAndResponse` instead.
+   **/
+  handleNodeRequest(nodeRequest: NodeRequest, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+  /**
+   * This function takes Node's request and response objects and returns a WHATWG Fetch spec compliant `Response` object.
+   */
+  handleNodeRequestAndResponse(nodeRequest: NodeRequest, nodeResponseOrContainer: {
+    raw: NodeResponse;
+  } | NodeResponse, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+  /**
+   * A request listener function that can be used with any Node server variation.
+   */
+  requestListener: RequestListener;
+  handleUWS: UWSHandler;
+  handle(req: NodeRequest, res: NodeResponse, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<void>;
+  handle(requestLike: RequestLike, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+  handle(request: Request, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+  handle(fetchEvent: FetchEvent & Partial<TServerContext & ServerAdapterInitialContext>, ...ctx: Partial<TServerContext>[]): void;
+  handle(res: UWSResponse, req: UWSRequest, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<void>;
+  handle(container: {
+    request: Request;
+  } & Partial<TServerContext & ServerAdapterInitialContext>, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+  disposableStack: AsyncDisposableStack;
+  dispose(): Promise<void> | void;
+  /**
+   * Register a promise that should be waited in the background for before the server process is exited.
+   *
+   * This also avoids unhandled promise rejections, which would otherwise cause the process to exit on some environment like Node.
+   * @param promise The promise to wait for
+   * @returns
+   */
+  waitUntil: WaitUntilFn;
+}
+interface RequestLike {
+  url: string;
+  method: string;
+  headers: HeadersLike;
+  body?: AsyncIterable<Uint8Array> | null;
+}
+interface HeadersLike extends Iterable<[string, string]> {
+  get(name: string): string | null | undefined;
+  set(name: string, value: string): void;
+  has(name: string): boolean;
+}
+type ServerAdapter<TServerContext, TBaseObject extends ServerAdapterBaseObject<TServerContext>> = TBaseObject & ServerAdapterObject<TServerContext>['handle'] & ServerAdapterObject<TServerContext>;
+type ServerAdapterRequestHandler<TServerContext> = (request: Request, ctx: TServerContext & ServerAdapterInitialContext) => MaybePromise<Response>;
+type WaitUntilFn = (promise: Promise<void> | void) => void;
+type ServerAdapterInitialContext = {
+  /**
+   * Register a promise that should be waited in the background for before the server process is exited.
+   *
+   * This also avoids unhandled promise rejections, which would otherwise cause the process to exit on some environment like Node.
+   * @param promise The promise to wait for
+   * @returns
+   */
+  waitUntil: WaitUntilFn;
+};
+//#endregion
+//#region node_modules/fets/typings/types.d.ts
+type StatusCodeMap$1<T> = { [TKey in StatusCode$1]?: T };
+//#endregion
+//#region node_modules/fets/typings/typed-fetch.d.ts
+type OkStatusCode$1 = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+type RedirectStatusCode$1 = 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;
+type ClientErrorStatusCode$1 = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
+type ServerErrorStatusCode$1 = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+type StatusCode$1 = OkStatusCode$1 | RedirectStatusCode$1 | ClientErrorStatusCode$1 | ServerErrorStatusCode$1;
+type TypedBody$1<TJSON, TFormData extends Record<string, FormDataEntryValue | undefined>, THeaders extends Record<string, string | undefined>> = Omit<Body, 'json' | 'formData' | 'headers'> & {
+  /**
+   * The `json()` method takes the stream and reads it to completion.
+   * It returns a promise which resolves with the result of parsing the body text as JSON.
+   *
+   * Note that despite the method being named `json()`, the result is not JSON but is instead the result of taking JSON as input and parsing it to produce a JavaScript object.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/json
+   */
+  json(): Promise<TJSON>;
+  /**
+   * The formData() method takes the stream and reads it to completion. It returns a promise that resolves with a `FormData` object.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/formData
+   */
+  formData(): Promise<TypedFormData$1<TFormData>>;
+  /**
+   * The headers read-only property of the Response interface contains the Headers object associated with the response.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/headers
+   */
+  headers: TypedHeaders$1<THeaders>;
+};
+type DefaultHTTPHeaders$1 = 'accept' | 'accept-language' | 'content-language' | 'content-type' | 'content-length';
+type Maybe$1 = undefined | null;
+type UndefinedToNull$1<T> = T extends undefined ? Exclude<T, undefined> | null : T;
+interface TypedHeaders$1<TMap extends Record<string, string | undefined>> {
+  append<TName extends DefaultHTTPHeaders$1 | keyof TMap>(name: TName, value: TName extends keyof TMap ? TMap[TName] : string): void;
+  delete<TName extends DefaultHTTPHeaders$1 | keyof TMap>(name: TName): void;
+  get<TName extends DefaultHTTPHeaders$1 | keyof TMap>(name: TName): TName extends keyof TMap ? UndefinedToNull$1<TMap[TName]> : TName extends DefaultHTTPHeaders$1 ? string | null : never;
+  has<TName extends DefaultHTTPHeaders$1 | keyof TMap>(name: TName): TName extends DefaultHTTPHeaders$1 ? boolean : TName extends keyof TMap ? TMap[TName] extends Maybe$1 ? boolean : true : never;
+  set<TName extends DefaultHTTPHeaders$1 | keyof TMap>(name: TName, value: TName extends keyof TMap ? TMap[TName] : string): void;
+  forEach(callbackfn: <TName extends keyof TMap>(value: TMap[TName], key: TName, parent: TypedHeaders$1<TMap>) => void, thisArg?: any): void;
+  entries(): IterableIterator<[keyof TMap, TMap[keyof TMap]]>;
+  keys(): IterableIterator<keyof TMap>;
+  values(): IterableIterator<TMap[keyof TMap]>;
+  [Symbol.iterator](): IterableIterator<[keyof TMap, TMap[keyof TMap]]>;
+  getSetCookie(): string[];
+}
+type StatusTextMap$1 = {
+  100: 'Continue';
+  101: 'Switching Protocols';
+  102: 'Processing';
+  103: 'Early Hints';
+  200: 'OK';
+  201: 'Created';
+  202: 'Accepted';
+  203: 'Non-Authoritative Information';
+  204: 'No Content';
+  205: 'Reset Content';
+  206: 'Partial Content';
+  207: 'Multi-Status';
+  208: 'Already Reported';
+  226: 'IM Used';
+  300: 'Multiple Choices';
+  301: 'Moved Permanently';
+  302: 'Found';
+  303: 'See Other';
+  304: 'Not Modified';
+  305: 'Use Proxy';
+  307: 'Temporary Redirect';
+  308: 'Permanent Redirect';
+  400: 'Bad Request';
+  401: 'Unauthorized';
+  402: 'Payment Required';
+  403: 'Forbidden';
+  404: 'Not Found';
+  405: 'Method Not Allowed';
+  406: 'Not Acceptable';
+  407: 'Proxy Authentication Required';
+  408: 'Request Timeout';
+  409: 'Conflict';
+  410: 'Gone';
+  411: 'Length Required';
+  412: 'Precondition Failed';
+  413: 'Payload Too Large';
+  414: 'URI Too Long';
+  415: 'Unsupported Media Type';
+  416: 'Range Not Satisfiable';
+  417: 'Expectation Failed';
+  418: "I'm a Teapot";
+  421: 'Misdirected Request';
+  422: 'Unprocessable Entity';
+  423: 'Locked';
+  424: 'Failed Dependency';
+  425: 'Too Early';
+  426: 'Upgrade Required';
+  428: 'Precondition Required';
+  429: 'Too Many Requests';
+  431: 'Request Header Fields Too Large';
+  451: 'Unavailable For Legal Reasons';
+  500: 'Internal Server Error';
+  501: 'Not Implemented';
+  502: 'Bad Gateway';
+  503: 'Service Unavailable';
+  504: 'Gateway Timeout';
+  505: 'HTTP Version Not Supported';
+  506: 'Variant Also Negotiates';
+  507: 'Insufficient Storage';
+  508: 'Loop Detected';
+  509: 'Bandwidth Limit Exceeded';
+  510: 'Not Extended';
+  511: 'Network Authentication Required';
+};
+type TypedResponse$1<TJSON = unknown, THeaders extends Record<string, string> = Record<string, string>, TStatusCode extends StatusCode$1 = StatusCode$1> = Omit<Response, 'json' | 'status' | 'ok'> & Omit<TypedBody$1<TJSON, any, THeaders>, 'formData'> & {
+  /**
+   * The status read-only property of the Response interface contains the HTTP status codes of the response.
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/status
+   *
+   * You can use `Response.ok` to check if the status is in the range 200-299.
+   */
+  status: TStatusCode;
+  /**
+   * The statusText read-only property of the Response interface contains the status message corresponding to the HTTP status code in Response.status.
+   * For example, this would be OK for a status code 200, Continue for 100, Not Found for 404.
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/statusText
+   */
+  statusText: TStatusCode extends keyof StatusTextMap$1 ? StatusTextMap$1[TStatusCode] : string;
+} & {
+  /**
+   * The ok read-only property of the Response interface contains a Boolean stating whether the response was successful (status in the range 200-299) or not.
+   */
+  ok: TStatusCode extends OkStatusCode$1 ? true : false;
+};
+type JSONofResponse<TResponse extends TypedResponse$1> = TResponse extends TypedResponse$1<infer TJSON> ? TJSON : never;
+interface TypedFormData$1<TMap extends Record<string, FormDataEntryValue | undefined> = Record<string, FormDataEntryValue | undefined>> {
+  append<TName extends keyof TMap>(name: TName, value: TMap[TName] extends any[] ? TMap[TName][0] : TMap[TName], fileName?: string): void;
+  delete(name: keyof TMap): void;
+  get<TName extends keyof TMap>(name: TName): TMap[TName] extends any[] ? TMap[TName][0] : TMap[TName];
+  getAll<TName extends keyof TMap>(name: TName): TMap[TName] extends any[] ? TMap[TName] : TMap[TName][];
+  has<TName extends string>(name: TName): TName extends keyof TMap ? (TMap[TName] extends Maybe$1 ? boolean : true) : false;
+  set<TName extends keyof TMap>(name: TName, value: TMap[TName] extends any[] ? TMap[TName][0] : TMap[TName], fileName?: string): void;
+  forEach(callbackfn: <TName extends keyof TMap>(value: TMap[TName], key: TName, parent: this) => void, thisArg?: any): void;
+  entries(): IterableIterator<[keyof TMap, TMap[keyof TMap]]>;
+  keys(): IterableIterator<keyof TMap>;
+  values(): IterableIterator<TMap[keyof TMap]>;
+  [Symbol.iterator](): IterableIterator<[keyof TMap, TMap[keyof TMap]]>;
+}
+//#endregion
+//#region node_modules/fets/typings/client/clientResponse.d.cts
+type ClientTypedResponsePromise<TTypedResponse extends Response> = Promise<TTypedResponse> & {
+  json(): Promise<TTypedResponse extends TypedResponse$1 ? JSONofResponse<TTypedResponse> : any>;
+};
+//#endregion
+//#region node_modules/fets/typings/typed-fetch.d.cts
+type OkStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;
+type ClientErrorStatusCode = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
+type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+type StatusCode = OkStatusCode | RedirectStatusCode | ClientErrorStatusCode | ServerErrorStatusCode;
+type TypedBody<TJSON, TFormData extends Record<string, FormDataEntryValue | undefined>, THeaders extends Record<string, string | undefined>> = Omit<Body, 'json' | 'formData' | 'headers'> & {
+  /**
+   * The `json()` method takes the stream and reads it to completion.
+   * It returns a promise which resolves with the result of parsing the body text as JSON.
+   *
+   * Note that despite the method being named `json()`, the result is not JSON but is instead the result of taking JSON as input and parsing it to produce a JavaScript object.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/json
+   */
+  json(): Promise<TJSON>;
+  /**
+   * The formData() method takes the stream and reads it to completion. It returns a promise that resolves with a `FormData` object.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/formData
+   */
+  formData(): Promise<TypedFormData<TFormData>>;
+  /**
+   * The headers read-only property of the Response interface contains the Headers object associated with the response.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/headers
+   */
+  headers: TypedHeaders<THeaders>;
+};
+type DefaultHTTPHeaders = 'accept' | 'accept-language' | 'content-language' | 'content-type' | 'content-length';
+type Maybe = undefined | null;
+type UndefinedToNull<T> = T extends undefined ? Exclude<T, undefined> | null : T;
+interface TypedHeaders<TMap extends Record<string, string | undefined>> {
+  append<TName extends DefaultHTTPHeaders | keyof TMap>(name: TName, value: TName extends keyof TMap ? TMap[TName] : string): void;
+  delete<TName extends DefaultHTTPHeaders | keyof TMap>(name: TName): void;
+  get<TName extends DefaultHTTPHeaders | keyof TMap>(name: TName): TName extends keyof TMap ? UndefinedToNull<TMap[TName]> : TName extends DefaultHTTPHeaders ? string | null : never;
+  has<TName extends DefaultHTTPHeaders | keyof TMap>(name: TName): TName extends DefaultHTTPHeaders ? boolean : TName extends keyof TMap ? TMap[TName] extends Maybe ? boolean : true : never;
+  set<TName extends DefaultHTTPHeaders | keyof TMap>(name: TName, value: TName extends keyof TMap ? TMap[TName] : string): void;
+  forEach(callbackfn: <TName extends keyof TMap>(value: TMap[TName], key: TName, parent: TypedHeaders<TMap>) => void, thisArg?: any): void;
+  entries(): IterableIterator<[keyof TMap, TMap[keyof TMap]]>;
+  keys(): IterableIterator<keyof TMap>;
+  values(): IterableIterator<TMap[keyof TMap]>;
+  [Symbol.iterator](): IterableIterator<[keyof TMap, TMap[keyof TMap]]>;
+  getSetCookie(): string[];
+}
+type StatusTextMap = {
+  100: 'Continue';
+  101: 'Switching Protocols';
+  102: 'Processing';
+  103: 'Early Hints';
+  200: 'OK';
+  201: 'Created';
+  202: 'Accepted';
+  203: 'Non-Authoritative Information';
+  204: 'No Content';
+  205: 'Reset Content';
+  206: 'Partial Content';
+  207: 'Multi-Status';
+  208: 'Already Reported';
+  226: 'IM Used';
+  300: 'Multiple Choices';
+  301: 'Moved Permanently';
+  302: 'Found';
+  303: 'See Other';
+  304: 'Not Modified';
+  305: 'Use Proxy';
+  307: 'Temporary Redirect';
+  308: 'Permanent Redirect';
+  400: 'Bad Request';
+  401: 'Unauthorized';
+  402: 'Payment Required';
+  403: 'Forbidden';
+  404: 'Not Found';
+  405: 'Method Not Allowed';
+  406: 'Not Acceptable';
+  407: 'Proxy Authentication Required';
+  408: 'Request Timeout';
+  409: 'Conflict';
+  410: 'Gone';
+  411: 'Length Required';
+  412: 'Precondition Failed';
+  413: 'Payload Too Large';
+  414: 'URI Too Long';
+  415: 'Unsupported Media Type';
+  416: 'Range Not Satisfiable';
+  417: 'Expectation Failed';
+  418: "I'm a Teapot";
+  421: 'Misdirected Request';
+  422: 'Unprocessable Entity';
+  423: 'Locked';
+  424: 'Failed Dependency';
+  425: 'Too Early';
+  426: 'Upgrade Required';
+  428: 'Precondition Required';
+  429: 'Too Many Requests';
+  431: 'Request Header Fields Too Large';
+  451: 'Unavailable For Legal Reasons';
+  500: 'Internal Server Error';
+  501: 'Not Implemented';
+  502: 'Bad Gateway';
+  503: 'Service Unavailable';
+  504: 'Gateway Timeout';
+  505: 'HTTP Version Not Supported';
+  506: 'Variant Also Negotiates';
+  507: 'Insufficient Storage';
+  508: 'Loop Detected';
+  509: 'Bandwidth Limit Exceeded';
+  510: 'Not Extended';
+  511: 'Network Authentication Required';
+};
+type TypedResponse<TJSON = unknown, THeaders extends Record<string, string> = Record<string, string>, TStatusCode extends StatusCode = StatusCode> = Omit<Response, 'json' | 'status' | 'ok'> & Omit<TypedBody<TJSON, any, THeaders>, 'formData'> & {
+  /**
+   * The status read-only property of the Response interface contains the HTTP status codes of the response.
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/status
+   *
+   * You can use `Response.ok` to check if the status is in the range 200-299.
+   */
+  status: TStatusCode;
+  /**
+   * The statusText read-only property of the Response interface contains the status message corresponding to the HTTP status code in Response.status.
+   * For example, this would be OK for a status code 200, Continue for 100, Not Found for 404.
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/statusText
+   */
+  statusText: TStatusCode extends keyof StatusTextMap ? StatusTextMap[TStatusCode] : string;
+} & {
+  /**
+   * The ok read-only property of the Response interface contains a Boolean stating whether the response was successful (status in the range 200-299) or not.
+   */
+  ok: TStatusCode extends OkStatusCode ? true : false;
+};
+type TypedResponseWithJSONStatusMap<TResponseJSONStatusMap extends StatusCodeMap$1<any>> = { [TStatusCode in keyof TResponseJSONStatusMap]: TStatusCode extends StatusCode ? TypedResponse<TResponseJSONStatusMap[TStatusCode], Record<string, string>, TStatusCode> : never }[keyof TResponseJSONStatusMap];
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE';
+type TypedRequest<TJSON = any, TFormData extends Record<string, FormDataEntryValue | undefined> = Record<string, FormDataEntryValue | undefined>, THeaders extends Record<string, string | undefined> = Record<string, string | undefined>, TMethod extends HTTPMethod = HTTPMethod, TQueryParams = any, TPathParams extends Record<string, any> = Record<string, any>> = Omit<Request, 'json' | 'method' | 'headers' | 'formData'> & TypedBody<TJSON, TFormData, THeaders> & {
+  parsedUrl: URL;
+  method: TMethod;
+  params: TPathParams;
+  query: TQueryParams;
+};
+interface TypedFormData<TMap extends Record<string, FormDataEntryValue | undefined> = Record<string, FormDataEntryValue | undefined>> {
+  append<TName extends keyof TMap>(name: TName, value: TMap[TName] extends any[] ? TMap[TName][0] : TMap[TName], fileName?: string): void;
+  delete(name: keyof TMap): void;
+  get<TName extends keyof TMap>(name: TName): TMap[TName] extends any[] ? TMap[TName][0] : TMap[TName];
+  getAll<TName extends keyof TMap>(name: TName): TMap[TName] extends any[] ? TMap[TName] : TMap[TName][];
+  has<TName extends string>(name: TName): TName extends keyof TMap ? (TMap[TName] extends Maybe ? boolean : true) : false;
+  set<TName extends keyof TMap>(name: TName, value: TMap[TName] extends any[] ? TMap[TName][0] : TMap[TName], fileName?: string): void;
+  forEach(callbackfn: <TName extends keyof TMap>(value: TMap[TName], key: TName, parent: this) => void, thisArg?: any): void;
+  entries(): IterableIterator<[keyof TMap, TMap[keyof TMap]]>;
+  keys(): IterableIterator<keyof TMap>;
+  values(): IterableIterator<TMap[keyof TMap]>;
+  [Symbol.iterator](): IterableIterator<[keyof TMap, TMap[keyof TMap]]>;
+}
+//#endregion
+//#region node_modules/fets/typings/client/types.d.cts
+type ClientRequestInit = Omit<RequestInit, 'body' | 'method' | 'headers'>;
+//#endregion
+//#region node_modules/fets/typings/types.d.cts
+type Simplify<T> = { [KeyType in keyof T]: Simplify<T[KeyType]> } & {};
+type JSONSchema = Exclude<JSONSchema$1, boolean>;
+interface OpenAPIInfo {
+  title?: string;
+  description?: string;
+  version?: string;
+  license?: {
+    name?: string;
+    url?: string;
+  };
+  termsOfService?: string;
+  contact?: {
+    name?: string;
+    url?: string;
+    email?: string;
+  };
+}
+type OpenAPIPathObject = Record<string, OpenAPIOperationObject> & {
+  parameters?: OpenAPIParameterObject[];
+};
+interface OpenAPIParameterObject {
+  name: string;
+  in: 'path' | 'query' | 'header' | 'cookie';
+  required?: boolean;
+  schema?: any;
+}
+interface OpenAPIRequestBodyObject {
+  content?: Record<string, OpenAPIMediaTypeObject>;
+}
+interface OpenAPIOperationObject {
+  operationId?: string;
+  description?: string;
+  tags?: string[];
+  parameters?: OpenAPIParameterObject[];
+  requestBody?: OpenAPIRequestBodyObject;
+  responses?: Record<string | number, OpenAPIResponseObject>;
+  security?: any[];
+}
+interface OpenAPIResponseObject {
+  description?: string;
+  content?: Record<string, OpenAPIMediaTypeObject>;
+}
+interface OpenAPIMediaTypeObject {
+  schema?: any;
+}
+type OpenAPIDocument = {
+  openapi?: string;
+  info?: OpenAPIInfo;
+  servers?: {
+    url: string;
+  }[] | string[];
+  paths?: Record<string, OpenAPIPathObject>;
+  components?: unknown;
+};
+type RouterComponentsBase = {
+  schemas?: Record<string, JSONSchema>;
+  securitySchemes?: Record<string, SecurityScheme>;
+};
+type BasicAuthSecurityScheme = {
+  type: 'http';
+  scheme: 'basic';
+};
+type BearerAuthSecurityScheme = {
+  type: 'http';
+  scheme: 'bearer';
+};
+type ApiKeySecurityScheme = {
+  type: 'apiKey';
+  name: string;
+  in: 'header' | 'query' | 'cookie';
+};
+type SecurityScheme = BasicAuthSecurityScheme | BearerAuthSecurityScheme | ApiKeySecurityScheme;
+type Circular<TJSONSchema extends JSONSchema> = TJSONSchema extends {
+  properties: {
+    [key: string]: JSONSchema;
+  };
+} ? TJSONSchema extends PropertyValue<TJSONSchema, Property<TJSONSchema>> ? true : Circular<PropertyValue<TJSONSchema, Property<TJSONSchema>>> : false;
+type Property<TJSONSchema extends JSONSchema> = keyof TJSONSchema['properties'];
+type PropertyValue<TJSONSchema extends JSONSchema, TProperty extends keyof TJSONSchema['properties']> = TJSONSchema['properties'][TProperty];
+type FromSchema<T> = T extends {
+  static: infer U;
+} ? U : T extends JSONSchema ? FromSchema$1<T, {
+  deserialize: Circular<T> extends false ? [{
+    pattern: {
+      type: 'string';
+      format: 'binary';
+    };
+    output: File;
+  }, {
+    pattern: {
+      type: 'number';
+      format: 'int64';
+    };
+    output: bigint | number;
+  }, {
+    pattern: {
+      type: 'integer';
+      format: 'int64';
+    };
+    output: bigint | number;
+  }] : false;
+}> : never;
+type PromiseOrValue<T> = T | Promise<T>;
+type StatusCodeMap<T> = { [TKey in StatusCode]?: T };
+interface RouterBaseObject<TServerContext, TComponents extends RouterComponentsBase, TRouterSDK extends RouterSDK<string, TypedRequest, TypedResponse>> {
+  openAPIDocument: OpenAPIDocument;
+  handle: ServerAdapterRequestHandler<TServerContext>;
+  route<const TRouteSchemas extends RouteSchemas, TMethod extends HTTPMethod, TPath extends string, TTypedRequest extends TypedRequestFromRouteSchemas<TComponents, TRouteSchemas, TMethod, TPath>, TTypedResponse extends TypedResponseFromRouteSchemas<TComponents, TRouteSchemas>>(opts: RouteWithSchemasOpts<TServerContext, TComponents, TRouteSchemas, TMethod, TPath, TTypedRequest, TTypedResponse>): Router<TServerContext, TComponents, TRouterSDK & RouterSDK<TPath, TTypedRequest, TTypedResponse>>;
+  route<TMethod extends HTTPMethod, TPath extends string, TTypedRequest extends TypedRequest<any, Record<string, FormDataEntryValue | undefined>, Record<string, string | undefined>, TMethod, any, Record<ExtractPathParamsWithPattern<TPath>, string>>, TTypedResponse extends TypedResponse>(opts: RouteWithTypesOpts<TServerContext, TMethod, TPath, TTypedRequest, TTypedResponse>): Router<TServerContext, TComponents, TRouterSDK & RouterSDK<TPath, TTypedRequest, TTypedResponse>>;
+  __client: TRouterSDK;
+  __onRouterInitHooks: OnRouterInitHook<TServerContext>[];
+}
+type Router<TServerContext, TComponents extends RouterComponentsBase, TRouterSDK extends RouterSDK<string, TypedRequest, TypedResponse>> = ServerAdapter<TServerContext, RouterBaseObject<TServerContext, TComponents, TRouterSDK>>;
+type RouteHandler<TServerContext = {}, TTypedRequest extends TypedRequest = TypedRequest, TTypedResponse extends TypedResponse = TypedResponse> = (
+/**
+ * The request object represents the incoming HTTP request.
+ * This object implements [Request](https://developer.mozilla.org/en-US/docs/Web/API/Request) interface.
+ */
+
+request: TTypedRequest, context: TServerContext) => PromiseOrValue<TTypedResponse>;
+type OnRouterInitHook<TServerContext> = (router: Router<TServerContext, any, any>) => void;
+type ObjectSchemaWithPrimitiveProperties = JSONSchema & {
+  type: 'object';
+  properties: Record<string, {
+    type: 'string' | 'number' | 'integer' | 'boolean' | 'null';
+  }>;
+};
+type ObjectSchema = JSONSchema & {
+  type: 'object';
+};
+type RouteSchemas = {
+  request?: {
+    headers?: ObjectSchemaWithPrimitiveProperties;
+    params?: ObjectSchemaWithPrimitiveProperties;
+    query?: ObjectSchema;
+    json?: JSONSchema;
+    formData?: ObjectSchema;
+  };
+  responses?: StatusCodeMap<JSONSchema>;
+};
+type RouterSDKOpts<TTypedRequest extends TypedRequest = TypedRequest, TMethod extends HTTPMethod = HTTPMethod> = TTypedRequest extends TypedRequest<infer TJSONBody, infer TFormData, infer THeaders, TMethod, infer TQueryParams, infer TPathParam> ? Simplify<(Partial<TJSONBody> extends TJSONBody ? {
+  json?: TJSONBody;
+} : {
+  json: TJSONBody;
+}) & (Partial<THeaders> extends THeaders ? {
+  headers?: THeaders;
+} : {
+  headers: THeaders;
+}) & (Partial<TQueryParams> extends TQueryParams ? {
+  query?: TQueryParams;
+} : {
+  query: TQueryParams;
+}) & (Partial<TPathParam> extends TPathParam ? {
+  params?: TPathParam;
+} : {
+  params: TPathParam;
+})> & (Partial<TFormData> extends TFormData ? {
+  formData?: TFormData;
+} : {
+  formData: TFormData;
+}) : never;
+type RouterSDK<TPath extends string = string, TTypedRequest extends TypedRequest = TypedRequest, TTypedResponse extends TypedResponse = TypedResponse> = { [TPathKey in TPath]: { [TMethod in Lowercase<TTypedRequest['method']>]: Partial<RouterSDKOpts<TTypedRequest, TTypedRequest['method']>> extends RouterSDKOpts<TTypedRequest, TTypedRequest['method']> ? (opts?: RouterSDKOpts<TTypedRequest, TTypedRequest['method']> & ClientRequestInit) => ClientTypedResponsePromise<Exclude<TTypedResponse, undefined>> : (opts: RouterSDKOpts<TTypedRequest, TTypedRequest['method']> & ClientRequestInit) => ClientTypedResponsePromise<Exclude<TTypedResponse, undefined>> } };
+type FromSchemaWithComponents<TComponents, TSchema extends JSONSchema> = TComponents extends {
+  schemas: Record<string, JSONSchema>;
+} ? FromSchema<{
+  components: TComponents;
+} & TSchema> : FromSchema<TSchema>;
+type TypedRequestFromRouteSchemas<TComponents extends RouterComponentsBase, TRouteSchemas extends RouteSchemas, TMethod extends HTTPMethod, TPath extends string> = TRouteSchemas extends {
+  request: Required<RouteSchemas>['request'];
+} ? TypedRequest<TRouteSchemas['request'] extends {
+  json: JSONSchema;
+} ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['json']> : {}, TRouteSchemas['request'] extends {
+  formData: JSONSchema;
+} ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['formData']> extends Record<string, FormDataEntryValue | undefined> ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['formData']> : never : {}, TRouteSchemas['request'] extends {
+  headers: JSONSchema;
+} ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['headers']> extends Record<string, string> ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['headers']> : never : {}, TMethod, TRouteSchemas['request'] extends {
+  query: JSONSchema;
+} ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['query']> : {}, TRouteSchemas['request'] extends {
+  params: JSONSchema;
+} ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['params']> extends Record<string, any> ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['params']> : never : Record<ExtractPathParamsWithPattern<TPath>, string>> : TypedRequest<any, Partial<Record<string, FormDataEntryValue>>, Partial<Record<string, string>>, TMethod, any, Record<ExtractPathParamsWithPattern<TPath>, string>>;
+type TypedResponseFromRouteSchemas<TComponents extends RouterComponentsBase, TRouteSchemas extends RouteSchemas> = TRouteSchemas extends {
+  responses: StatusCodeMap<JSONSchema>;
+} ? TypedResponseWithJSONStatusMap<{ [TStatusCode in keyof TRouteSchemas['responses']]: TRouteSchemas['responses'][TStatusCode] extends JSONSchema ? FromSchemaWithComponents<TComponents, TRouteSchemas['responses'][TStatusCode]> : never }> : TypedResponse;
+type RouteWithSchemasOpts<TServerContext, TComponents extends RouterComponentsBase, TRouteSchemas extends RouteSchemas, TMethod extends HTTPMethod, TPath extends string, TTypedRequest extends TypedRequestFromRouteSchemas<TComponents, TRouteSchemas, TMethod, TPath>, TTypedResponse extends TypedResponseFromRouteSchemas<TComponents, TRouteSchemas>> = {
+  schemas: TRouteSchemas;
+  security?: SecuritySchemeRefsFromComponents<TComponents>[];
+} & RouteWithTypesOpts<TServerContext, TMethod, TPath, TTypedRequest, TTypedResponse>;
+type SecuritySchemeRefsFromComponents<TComponents extends RouterComponentsBase> = TComponents extends {
+  securitySchemes: Record<string, SecurityScheme>;
+} ? Record<keyof TComponents['securitySchemes'], any> : never;
+type RouteWithTypesOpts<TServerContext, TMethod extends HTTPMethod, TPath extends string, TTypedRequest extends TypedRequest<any, Record<string, FormDataEntryValue | undefined>, Record<string, string | undefined>, TMethod, any, Record<ExtractPathParamsWithPattern<TPath>, string>>, TTypedResponse extends TypedResponse> = {
+  operationId?: string;
+  description?: string;
+  method?: TMethod;
+  tags?: string[];
+  internal?: boolean;
+  path: TPath;
+  handler: RouteHandler<TServerContext, TTypedRequest, TTypedResponse>;
+};
+type ExtractPathParamsWithPattern<TPath extends string> = Pipe<TPath, [Strings.Split<'/'>, Tuples.Filter<Strings.StartsWith<':'>>, Tuples.Map<Strings.Trim<':'>>, Tuples.ToUnion]>;
+//#endregion
+//#region lib/types/rumbleInput.d.ts
+type CustomRumblePothosConfig = Omit<ConstructorParameters<typeof SchemaBuilder>[0], "smartSubscriptions" | "drizzle">;
+type RumbleInput<UserContext extends Record<string, any>, DB extends DrizzleInstance, RequestEvent extends Record<string, any>, Action extends string, PothosConfig extends CustomRumblePothosConfig> = {
+  /**
+   * Your drizzle database instance
+   */
+  db: DB;
+  /**
+   * A function for providing context for each request based on the incoming HTTP Request.
+   * The type of the parameter equals the HTTPRequest type of your chosen server.
+   */
+  context?: ((event: RequestEvent) => Promise<UserContext> | UserContext) | undefined;
+  /**
+   * If you only want to disable query, mutation or subscription default objects, you can do so here
+   */
+  disableDefaultObjects?: {
+    mutation?: boolean;
+    subscription?: boolean;
+    query?: boolean;
+  };
+  /**
+   * The actions that are available
+   */
+  actions?: Action[];
+  /**
+   * Customization for subscriptions. See https://the-guild.dev/graphql/yoga-server/docs/features/subscriptions#distributed-pubsub-for-production
+   */
+  subscriptions?: Parameters<typeof createPubSub>;
+  /**
+   * Options passed along to the pothos schema builder.
+   */
+  pothosConfig?: PothosConfig;
+  /**
+   * Limits the returned amount when querying lists. Set to null to disable.
+   * @default 100
+   */
+  defaultLimit?: number | undefined | null;
+  /**
+   * rumble supports fuzzy search for the query helpers. This enables the users of your API to search for entities via fuzzy search inputs.
+   * This currently only is supported by postgres databases and will fail if enabled on other dialects.
+   *
+   * Please note that this will install the pg_trgm extension on startup if your database does not have it already installed.
+   * https://www.postgresql.org/docs/current/pgtrgm.html
+   */
+  search?: {
+    /**
+     * Whether search is enabled
+     */
+    enabled?: boolean;
+    /**
+     * The cuttoff factor to reduce the amount of returned results.
+     * Defaults to 0.3. Lower values will return more results.
+     */
+    threshold?: number;
+    /**
+     * Will perform a local
+     * SET cpu_operator_cost = x;
+     * for search queries. This can help to make the planner
+     * use a potential index scan instead of a sequential scan.
+     * This will not affect queries that are not using the search feature.
+     */
+    cpu_operator_cost?: number;
   } | undefined;
 };
 //#endregion
@@ -440,7 +4429,7 @@ declare const rumble: <UserContext extends Record<string, any>, DB extends Drizz
       ```
       * https://the-guild.dev/graphql/sofa-api/docs#usage
        */
-  createSofa: (args: Omit<Parameters<typeof useSofa>[0], "schema" | "context">) => fets0.Router<any, {}, {
+  createSofa: (args: Omit<Parameters<typeof useSofa>[0], "schema" | "context">) => Router<any, {}, {
     [TKey: string]: never;
   }>;
   /**