@m1212e/rumble 0.23.24 → 0.24.0

package/out/index.d.mts

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 import { GraphQLError, GraphQLSchema } from "graphql";
 import { EnvelopArmorPlugin } from "@escape.tech/graphql-armor";
 import { Tracer } from "@opentelemetry/api";
@@ -11,9 +12,10 @@ import SchemaBuilder from "@pothos/core";
 import { IncomingMessage, RequestListener, ServerResponse } from "node:http";
 import { Http2ServerRequest, Http2ServerResponse } from "node:http2";
 import { Socket } from "node:net";
+import "@whatwg-node/fetch";
 import { useSofa } from "@m1212e/sofa-api";
 import { ServerOptions } from "graphql-ws";
-
+//#endregion
 //#region lib/helpers/asserts.d.ts
 /**
  *
@@ -34,7 +36,7 @@ import { ServerOptions } from "graphql-ws";
            db.query.users
              .findFirst({
                ...query,
-               where: ctx.abilities.users.filter("read").single.where,
+               where: (await ctx.abilities.users.filter("read")).single.where,
              })
              // note that we need to manually raise an error if the value is not found
              .then(assertFindFirstExists)
@@ -45,7 +47,7 @@ import { ServerOptions } from "graphql-ws";
  });
  * ```
  */
-declare const assertFindFirstExists: <T>(value: T | undefined) => T;
+export declare const assertFindFirstExists: <T>(value: T | undefined) => T;
 /**
  *
  * Helper function to map a drizzle findFirst query result,
@@ -73,7 +75,7 @@ declare const assertFindFirstExists: <T>(value: T | undefined) => T;
             .where(
               and(
                 eq(schema.users.id, args.userId),
-                ctx.abilities.users.filter("update").single.where
+                (await ctx.abilities.users.filter("update")).single.where
               )
             )
             .returning({ id: schema.users.id, name: schema.users.name })
@@ -85,7 +87,7 @@ declare const assertFindFirstExists: <T>(value: T | undefined) => T;
   });
  * ```
  */
-declare const assertFirstEntryExists: <T>(value: T[]) => T;
+export declare const assertFirstEntryExists: <T>(value: T[]) => T;
 //#endregion
 //#region lib/helpers/mapNullFieldsToUndefined.d.ts
 /**
@@ -132,7 +134,7 @@ declare const assertFirstEntryExists: <T>(value: T[]) => T;
         return db.query.user
           .findFirst(
             query(
-              ctx.abilities.user.filter('read').merge(
+              (await ctx.abilities.user.filter('read')).merge(
                 {
                   where: { id: user.id },
                 }
@@ -146,7 +148,7 @@ declare const assertFirstEntryExists: <T>(value: T[]) => T;
  *
  * ```
  */
-declare function mapNullFieldsToUndefined<T extends object>(obj: T): { [K in keyof T]: T[K] extends null ? undefined : Exclude<T[K], null> };
+export 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 = PgAsyncDatabase<any, any> | SQLiteAsyncDatabase<any, any, any> | MySqlAsyncDatabase<any, any>;
@@ -159,7 +161,7 @@ type DrizzleQueryFunction<DB extends DrizzleInstance> = DB["query"];
  */
 type TableRelationNames<DB extends DrizzleInstance> = { [K in keyof DB["_"]["relations"]]: DB["_"]["relations"][K] extends {
   table: infer TTable;
-} ? TTable extends Table<any> ? K : never : never }[keyof DB["_"]["relations"]] & keyof DrizzleQueryFunction<DB>;
+} ? TTable extends Table<any> ? K : never : never; }[keyof DB["_"]["relations"]] & keyof DrizzleQueryFunction<DB>;
 /**
  * Type representing the input parameters for the `findMany` method of a specific table in the Drizzle query function.
  */
@@ -190,10 +192,15 @@ type FilterPrefetchCombo<Context, FilteredEntityType, PrefetchReturnType = never
  * `PostalAddress`.
  */
 type AddressShape = {
-  /** The street address, which may be multiple lines separated by newlines. */streetAddress?: string | null; /** City or town. */
-  locality?: string | null; /** State, province, prefecture or region. */
-  region?: string | null; /** Postal or zip code. */
-  postalCode?: string | null; /** ISO 3166-1 alpha-2 country code. */
+  /** The street address, which may be multiple lines separated by newlines. */
+  streetAddress?: string | null;
+  /** City or town. */
+  locality?: string | null;
+  /** State, province, prefecture or region. */
+  region?: string | null;
+  /** Postal or zip code. */
+  postalCode?: string | null;
+  /** ISO 3166-1 alpha-2 country code. */
   countryCode?: string | null;
 };
 /**
@@ -363,9 +370,10 @@ type DateTimeWhereInputArgument = {
   OR?: DateTimeWhereInputArgument[];
   NOT?: DateTimeWhereInputArgument;
 };
-//#endregion
-//#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;
+declare namespace helpers_d_exports {
+  export { AnyTuple, CamelCase, Equal$2 as Equal, Every, Expect, Extends, Head$1 as Head, IsArrayStrict, IsNever$1 as IsNever, IsTuple, Iterator$1 as Iterator, KebabCase, Not$2 as Not, Prettify$1 as Prettify, Primitive$1 as Primitive, RecursivePrettify, SnakeCase, Some, Split$2 as Split, Stringifiable, UnionToIntersection, UnionToTuple };
+}
+type Equal$2<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
@@ -373,6 +381,10 @@ type Equal$1<a, b> = (<T>() => T extends a ? 1 : 2) extends (<T>() => T extends
  * probably a TS bug).
  */
 type IsNever$1<T> = [T] extends [never] ? true : false;
+type Expect<a extends true> = a;
+type Some<bools extends boolean[]> = true extends bools[number] ? true : false;
+type Every<bools extends boolean[]> = bools[number] extends true ? true : false;
+type Extends<a, b> = [a] extends [b] ? true : false;
 type Not$2<a extends boolean> = a extends true ? false : true;
 /**
  * trick to combine multiple unions of objects into a single object
@@ -381,7 +393,9 @@ type Not$2<a extends boolean> = a extends true ? false : true;
  * @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;
+type Prettify$1<T> = { [K in keyof T]: T[K]; } | never;
+type RecursivePrettify<T> = IsArrayStrict<T> extends true ? RecursivePrettify<Extract<T, readonly any[]>[number]>[] : { [K in keyof T]: RecursivePrettify<T[K]>; };
+type AnyTuple = readonly [any, ...any];
 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]>;
@@ -431,7 +445,7 @@ type Primitive$1 = string | number | boolean | bigint | null | undefined | symbo
 type Head$1<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 ExcludePlaceholders<xs, output extends any[] = []> = xs extends [infer first, ...infer rest] ? Equal$2<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;
@@ -464,7 +478,7 @@ type rawArgs = typeof rawArgs;
  */
 interface Fn {
   [rawArgs]: unknown;
-  args: this[rawArgs] extends infer args extends unknown[] ? args : never;
+  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;
@@ -482,7 +496,7 @@ type unset = typeof unset;
  */
 type _ = typeof _;
 interface args$1<Constraint extends unknown[] = unknown[]> extends Fn {
-  return: this["args"] extends infer args extends Constraint ? args : never;
+  return: this["args"] extends (infer args extends Constraint) ? args : never;
 }
 /**
  * Call a HOTScript function with the given arguments.
@@ -573,7 +587,7 @@ type ComposeLeftImpl<fns extends Fn[], args extends any[]> = fns extends [infer
  * 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;
+  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
@@ -629,11 +643,11 @@ type CompareDigitNumbers<T extends DigitNumber, U extends DigitNumber> = Sign<T>
  * @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 Compare$1<T extends number | bigint, U extends number | bigint> = Equal$2<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 Equal$1<T extends number | bigint, U extends number | bigint> = Equal$2<T, U>;
+type NotEqual$1<T extends number | bigint, U extends number | bigint> = Equal$2<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;
@@ -733,6 +747,9 @@ type PowerDigits<T extends Digit[], U extends Digit[], Acc extends Digit[] = [1]
 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>>>>>>;
+declare namespace numbers_d_exports {
+  export { Abs, Add, Compare$1 as Compare, Div, Equal$1 as Equal, GreaterThan$1 as GreaterThan, GreaterThanOrEqual$1 as GreaterThanOrEqual, LessThan$1 as LessThan, LessThanOrEqual$1 as LessThanOrEqual, Max, Min, Mod, Mul, Negate, NotEqual$1 as NotEqual, Power, Sub };
+}
 //#endregion
 //#region node_modules/hotscript/dist/internals/numbers/Numbers.d.ts
 declare namespace Numbers {
@@ -920,7 +937,7 @@ declare namespace Numbers {
    */
   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;
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? Equal$1<a, b> : never;
   }
   /**
    * Check if two numbers are not equal
@@ -936,7 +953,7 @@ declare namespace Numbers {
    */
   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;
+    return: this["args"] extends [infer a extends number | bigint, infer b extends number | bigint, ...any] ? NotEqual$1<a, b> : never;
   }
   /**
    * Check if a number is less than another
@@ -1154,7 +1171,7 @@ declare namespace Tuples {
    */
   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;
+    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;
@@ -1470,7 +1487,7 @@ declare namespace Tuples {
     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;
+    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.
@@ -1525,7 +1542,7 @@ declare namespace Tuples {
   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;
+  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
@@ -1543,7 +1560,7 @@ declare namespace Tuples {
    */
   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;
+    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"]>>]>;
   /**
@@ -1873,9 +1890,11 @@ type ascii = {
 };
 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 Compare<T extends string, U extends string> = Equal$2<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 Equal<T extends string, U extends string> = Equal$2<T, U>;
+type NotEqual<T extends string, U extends string> = Equal$2<T, U> extends true ? 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
@@ -1954,9 +1973,12 @@ declare namespace StringIterator {
 }
 //#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 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>;
+declare namespace strings_d_exports {
+  export { Compare, Equal, GreaterThan, GreaterThanOrEqual, Length, LessThan, LessThanOrEqual, NotEqual, Repeat, Replace, ReplaceReducer, Split$1 as Split, StringToTuple, Trim, TrimLeft, TrimRight };
+}
 //#endregion
 //#region node_modules/hotscript/dist/internals/strings/Strings.d.ts
 declare namespace Strings {
@@ -2357,22 +2379,23 @@ declare namespace Strings {
   }
   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;
+declare namespace objects_d_exports {
+  export { AllPaths, Assign, Create, Entries, FromEntries, GetFromPath, Keys, TransformObjectDeep, Update, Values };
+}
+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 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$2<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 RecursiveUpdate<obj, pathList, fnOrValue> = obj extends any ? pathList extends [infer first, ...infer rest] ? first extends keyof obj ? { [K in keyof obj]: Equal$2<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;
+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 {
@@ -2400,7 +2423,7 @@ declare namespace Objects {
   export interface Entries extends Fn {
     return: Entries<this["arg0"]>;
   }
-  type MapValuesImpl<T, fn extends Fn> = { [K in keyof T]: Call<fn, T[K], K> };
+  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
@@ -2417,7 +2440,7 @@ declare namespace Objects {
   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] };
+  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
@@ -2479,7 +2502,7 @@ declare namespace Objects {
   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;
+  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
@@ -2562,7 +2585,7 @@ declare namespace Objects {
   interface PickFn extends Fn {
     return: PickImpl<this["arg1"], this["arg0"]>;
   }
-  type PickImpl<obj, keys> = { [key in Extract<keyof obj, keys>]: obj[key] };
+  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.
@@ -2581,7 +2604,7 @@ declare namespace Objects {
   interface OmitFn extends Fn {
     return: OmitImpl<this["arg1"], this["arg0"]>;
   }
-  type OmitImpl<obj, keys> = { [key in Exclude<keyof obj, keys>]: obj[key] };
+  type OmitImpl<obj, keys> = { [key in Exclude<keyof obj, keys>]: obj[key]; };
   /**
    * Only keep keys of an object if the predicate function
    * returns true
@@ -2691,7 +2714,7 @@ declare namespace Objects {
    */
   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;
+    return: this["args"] extends [infer obj, ...any] ? { -readonly [key in keyof obj]: obj[key]; } : never;
   }
   /**
    * Makes all levels of an object optional
@@ -2902,7 +2925,7 @@ declare type IntersectUnion$1<UNION> = (UNION extends unknown ? (arg: UNION) =>
 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;
+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;
@@ -2911,7 +2934,7 @@ declare type Not$1<BOOL extends boolean> = BOOL extends false ? true : BOOL exte
 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;
+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$2<ARRAY extends unknown[]> = ARRAY extends readonly [] ? ARRAY : ARRAY extends readonly [unknown?, ...infer TAIL] ? TAIL : ARRAY;
@@ -2971,7 +2994,7 @@ declare type ResolveEnum<META_ENUM extends EnumType, OPTIONS extends ResolveOpti
 //#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 : {
+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;
@@ -3002,7 +3025,7 @@ declare type ResolveObject<META_OBJECT extends ObjectType, OPTIONS extends Resol
   [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> }>>>;
+}>, {}>, 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";
@@ -3061,11 +3084,11 @@ declare type UnionType = {
 };
 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;
+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 {
+declare type SerializableType = Type extends (infer META_TYPE) ? META_TYPE extends {
   isSerialized: boolean;
   deserialized: unknown;
 } ? META_TYPE : never : never;
@@ -3114,7 +3137,7 @@ declare type ResolveAny<META_ANY extends AnyType, OPTIONS extends ResolveOptions
 //#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>;
+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>>;
@@ -3132,14 +3155,14 @@ declare type IntersectConstToArray<META_CONST extends ConstType, META_ARRAY exte
 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];
+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 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>;
@@ -3164,8 +3187,8 @@ declare type IntersectArrays<META_ARRAY_A extends ArrayType, META_ARRAY_B extend
 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>> };
+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>>;
@@ -3179,7 +3202,7 @@ declare type Intersect<META_TYPE_A extends Type, META_TYPE_B extends Type> = $In
 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 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
@@ -3197,13 +3220,13 @@ declare type CheckNotExtendsResolved<META_CONST extends ConstType, META_TYPE ext
 }> ? 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];
+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 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
@@ -3242,18 +3265,18 @@ declare type ExcludeObjects<META_OBJECT_A extends ObjectType, META_OBJECT_B exte
   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 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>;
+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;
@@ -3282,6 +3305,9 @@ declare type ExtractConstValues<CONST_VALUES extends unknown[], RESULT extends u
 //#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;
+declare namespace index_d_exports {
+  export { _$Array as $Array, _$Exclude as $Exclude, $Intersect, _$Object as $Object, $Primitive, $Resolve, $Tuple, $Union, Any, AnyType, _Array as Array, ArrayType, Const, ConstType, Enum, EnumType, _Exclude as Exclude, Intersect, Never, NeverType, _Object as Object, ObjectType, Primitive, PrimitiveType, Resolve, Tuple, TupleType, Type, Union, UnionType };
+}
 //#endregion
 //#region node_modules/json-schema-to-ts/lib/types/definitions/deserializationPattern.d.ts
 type DeserializationPattern = Readonly<{
@@ -3365,7 +3391,7 @@ type FromSchemaDefaultOptions = {
 };
 //#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 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"];
@@ -3401,7 +3427,7 @@ type Split<STRING extends string, SEPARATOR extends string = "", RESULT extends
 type Tail$1<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;
+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<{
@@ -3460,11 +3486,11 @@ type IfThenElseSchema = 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 {
+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 {
+} ? $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>>;
+} ? $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<{
@@ -3498,10 +3524,10 @@ type ParseOneOfSchema<ONE_OF_SCHEMA extends OneOfSchema, OPTIONS extends ParseSc
 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$1<Split<PATH_IN_SOURCE, "/">>, false> : REFERENCE_SOURCE)> = $Intersect<ParseSchema<MATCHING_REFERENCE, OPTIONS>, ParseSchema<MergeSubSchema<MATCHING_REFERENCE, SCHEMA>, OPTIONS>>;
+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$1<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 {
+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, "/">>, "/">;
@@ -3572,14 +3598,14 @@ type ObjectSchema$1 = JSONSchema$1 & Readonly<{
 }>;
 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>>;
+}> ? _$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);
+}> ? 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<{
@@ -3590,8 +3616,8 @@ type GetOpenProps<OBJECT_SCHEMA extends ObjectSchema$1, OPTIONS extends ParseSch
 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]>;
+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<{
@@ -3618,7 +3644,7 @@ type ParseSchemaOptions = {
   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 {
+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
@@ -3762,7 +3788,7 @@ type ServerAdapterInitialContext = {
 };
 //#endregion
 //#region node_modules/fets/typings/types.d.ts
-type StatusCodeMap$1<T> = { [TKey in StatusCode$1]?: T };
+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;
@@ -4044,7 +4070,7 @@ type TypedResponse<TJSON = unknown, THeaders extends Record<string, string> = Re
    */
   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 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;
@@ -4070,7 +4096,7 @@ interface TypedFormData<TMap extends Record<string, FormDataEntryValue | undefin
 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 Simplify<T> = { [KeyType in keyof T]: Simplify<T[KeyType]>; } & {};
 type JSONSchema = Exclude<JSONSchema$1, boolean>;
 interface OpenAPIInfo {
   title?: string;
@@ -4156,7 +4182,7 @@ type ArrayItemValue<TJSONSchema extends JSONSchema> = TJSONSchema extends {
 } ? TItems : never;
 type HasCircularAnyOfRef<T extends JSONSchema> = T extends {
   properties: Record<string, JSONSchema>;
-} ? true extends { [K in keyof T['properties']]: PropIntroducesCycle<T['properties'][K], T> }[keyof T['properties']] ? true : false : false;
+} ? true extends { [K in keyof T['properties']]: PropIntroducesCycle<T['properties'][K], T>; }[keyof T['properties']] ? true : false : false;
 type PropIntroducesCycle<S, Root> = S extends {
   anyOf: infer Items extends readonly JSONSchema[];
 } ? TupleIntroducesCycle<Items, Root> : S extends {
@@ -4167,7 +4193,7 @@ type PropIntroducesCycle<S, Root> = S extends {
   $id: string;
 } ? false : S extends {
   properties: infer P extends Record<string, JSONSchema>;
-} ? true extends { [K in keyof P]: PropIntroducesCycle<P[K], Root> }[keyof P] ? true : AdditionalPropertiesCycle<S, Root> : AdditionalPropertiesCycle<S, Root>;
+} ? true extends { [K in keyof P]: PropIntroducesCycle<P[K], Root>; }[keyof P] ? true : AdditionalPropertiesCycle<S, Root> : AdditionalPropertiesCycle<S, Root>;
 type AdditionalPropertiesCycle<S, Root> = S extends {
   additionalProperties: infer AP extends JSONSchema;
 } ? PropIntroducesCycle<AP, Root> : false;
@@ -4177,7 +4203,7 @@ type MemberIntroducesCycle<Item, Root> = Item extends {
 } ? [Item] extends [Root] ? true : HasSelfCircularAnyOf<Item> : false;
 type HasSelfCircularAnyOf<T> = T extends {
   properties: Record<string, JSONSchema>;
-} ? true extends { [K in keyof T['properties']]: DirectSelfAnyOf<T['properties'][K], T> }[keyof T['properties']] ? true : false : false;
+} ? true extends { [K in keyof T['properties']]: DirectSelfAnyOf<T['properties'][K], T>; }[keyof T['properties']] ? true : false : false;
 type DirectSelfAnyOf<S, Root> = S extends {
   anyOf: infer Items extends readonly JSONSchema[];
 } ? TupleHasSelf<Items, Root> : S extends {
@@ -4188,7 +4214,7 @@ type DirectSelfAnyOf<S, Root> = S extends {
   $id: string;
 } ? false : S extends {
   properties: infer P extends Record<string, JSONSchema>;
-} ? true extends { [K in keyof P]: DirectSelfAnyOf<P[K], Root> }[keyof P] ? true : AdditionalPropertiesSelf<S, Root> : AdditionalPropertiesSelf<S, Root>;
+} ? true extends { [K in keyof P]: DirectSelfAnyOf<P[K], Root>; }[keyof P] ? true : AdditionalPropertiesSelf<S, Root> : AdditionalPropertiesSelf<S, Root>;
 type AdditionalPropertiesSelf<S, Root> = S extends {
   additionalProperties: infer AP extends JSONSchema;
 } ? DirectSelfAnyOf<AP, Root> : false;
@@ -4246,7 +4272,7 @@ type DirectTypeValue<T extends JSONSchema> = T extends {
 } ? AP extends false ? Record<string, never> : DirectIndexSignature<AP> : T extends {
   type: 'object';
 } ? Record<string, unknown> : unknown;
-type DirectNamedProps<Props extends Record<string, JSONSchema>, Req extends readonly string[] | undefined = undefined> = [Req] extends [readonly string[]] ? { [K in Extract<keyof Props, Req[number]>]: DirectType<Props[K]> } & { [K in Exclude<keyof Props, Req[number]>]?: DirectType<Props[K]> } : { [K in keyof Props]?: DirectType<Props[K]> };
+type DirectNamedProps<Props extends Record<string, JSONSchema>, Req extends readonly string[] | undefined = undefined> = [Req] extends [readonly string[]] ? { [K in Extract<keyof Props, Req[number]>]: DirectType<Props[K]>; } & { [K in Exclude<keyof Props, Req[number]>]?: DirectType<Props[K]>; } : { [K in keyof Props]?: DirectType<Props[K]>; };
 type DirectIndexSignature<AP> = AP extends false ? unknown : AP extends true ? Record<string, unknown> : AP extends JSONSchema ? Record<string, DirectType<AP>> : Record<string, unknown>;
 type DirectUnionType<Items extends readonly JSONSchema[]> = Items extends readonly [infer Head extends JSONSchema, ...infer Tail extends readonly JSONSchema[]] ? DirectType<Head> | DirectUnionType<Tail> : never;
 type DirectIntersectionType<Items extends readonly JSONSchema[]> = Items extends readonly [infer Head extends JSONSchema, ...infer Tail extends readonly JSONSchema[]] ? DirectType<Head> & DirectIntersectionType<Tail> : unknown;
@@ -4275,14 +4301,14 @@ type FromSchema<T> = T extends {
   }];
 }> : never;
 type PromiseOrValue<T> = T | Promise<T>;
-type StatusCodeMap<T> = { [TKey in StatusCode]?: 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>>;
   use<TSubServerContext, TSubComponents extends RouterComponentsBase, TSubRouterSDK extends RouterSDK<string, TypedRequest, TypedResponse>>(subRouter: Router<TSubServerContext, TSubComponents, TSubRouterSDK>): Router<TServerContext, TComponents, TRouterSDK & TSubRouterSDK>;
-  use<const TPrefix extends string, TSubServerContext, TSubComponents extends RouterComponentsBase, TSubRouterSDK extends RouterSDK<string, TypedRequest, TypedResponse>>(prefix: TPrefix, subRouter: Router<TSubServerContext, TSubComponents, TSubRouterSDK>): Router<TServerContext, TComponents, TRouterSDK & { [TKey in keyof TSubRouterSDK as TKey extends string ? `${TPrefix}${TKey}` : TKey]: TSubRouterSDK[TKey] }>;
+  use<const TPrefix extends string, TSubServerContext, TSubComponents extends RouterComponentsBase, TSubRouterSDK extends RouterSDK<string, TypedRequest, TypedResponse>>(prefix: TPrefix, subRouter: Router<TSubServerContext, TSubComponents, TSubRouterSDK>): Router<TServerContext, TComponents, TRouterSDK & { [TKey in keyof TSubRouterSDK as TKey extends string ? `${TPrefix}${TKey}` : TKey]: TSubRouterSDK[TKey]; }>;
   __client: TRouterSDK;
   __onRouterInitHooks: OnRouterInitHook<TServerContext>[];
   __routes: RouteWithSchemasOpts<any, RouterComponentsBase, RouteSchemas, HTTPMethod, string, TypedRequest, TypedResponse>[];
@@ -4294,7 +4320,6 @@ type RouteHandler<TServerContext = {}, TTypedRequest extends TypedRequest = Type
  * 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 & {
@@ -4337,7 +4362,7 @@ type RouterSDKOpts<TTypedRequest extends TypedRequest = TypedRequest, TMethod ex
 } : {
   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 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<{
@@ -4358,7 +4383,7 @@ type TypedRequestFromRouteSchemas<TComponents extends RouterComponentsBase, TRou
 } ? 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;
+} ? 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>[];
@@ -4540,27 +4565,28 @@ type RumbleInput<UserContext extends Record<string, any>, DB extends DrizzleInst
 };
 //#endregion
 //#region lib/rumble.d.ts
-declare const rumble: <UserContext extends Record<string, any>, DB extends DrizzleInstance, RequestEvent extends Record<string, any>, PothosConfig extends CustomRumblePothosConfig, Schema extends Record<string, any>, Action extends string = "read" | "update" | "delete">(rumbleInput: RumbleInput<UserContext, DB, RequestEvent, Action, PothosConfig> & {
+export declare const rumble: <UserContext extends Record<string, any>, DB extends DrizzleInstance, RequestEvent extends Record<string, any>, PothosConfig extends CustomRumblePothosConfig, Schema extends Record<string, any>, Action extends string = "delete" | "read" | "update">(rumbleInput: RumbleInput<UserContext, DB, RequestEvent, Action, PothosConfig> & {
   schema: Schema;
 }) => {
   /**
-     * The ability builder. Use it to declare whats allowed for each entity in your DB.
-     *
-     * @example
-     *
-     * ```ts
-     * // users can edit themselves
-     abilityBuilder.users
-       .allow(["read", "update", "delete"])
-       .when(({ userId }) => ({ where: eq(schema.users.id, userId) }));
-      // everyone can read posts
-     abilityBuilder.posts.allow("read");
-     *
-     * ```
-     */
+       * The ability builder. Use it to declare whats allowed for each entity in your DB.
+       *
+       * @example
+       *
+       * ```ts
+       * // users can edit themselves
+       abilityBuilder.users
+         .allow(["read", "update", "delete"])
+         .when(({ userId }) => ({ where: eq(schema.users.id, userId) }));
+
+       // everyone can read posts
+       abilityBuilder.posts.allow("read");
+       *
+       * ```
+       */
   abilityBuilder: { [key in TableRelationNames<DB>]: {
     allow: (action: Action | Action[]) => {
-      when: (queryFilter: DrizzleQueryFunctionInput<DB, key> | ((context: UserContext) => DrizzleQueryFunctionInput<DB, key> | "allow" | undefined)) => void;
+      when: (queryFilter: ((context: UserContext) => "allow" | Promise<"allow" | DrizzleQueryFunctionInput<DB, key> | undefined> | DrizzleQueryFunctionInput<DB, key> | undefined) | DrizzleQueryFunctionInput<DB, key>) => void;
     };
     filter: (action: Action | Action[]) => {
       prefetch: <PrefetchReturnType>(prefetch: Prefetch<UserContext, PrefetchReturnType>) => {
@@ -4570,38 +4596,35 @@ declare const rumble: <UserContext extends Record<string, any>, DB extends Drizz
     };
     _: {
       runtimeFilters: Map<Action, FilterPrefetchCombo<UserContext, any, any>[]>;
-      queryFilters: Map<Action, "unrestricted" | (DrizzleQueryFunctionInput<DB, key> | ((context: UserContext) => DrizzleQueryFunctionInput<DB, key> | "allow" | undefined))[]>;
+      queryFilters: Map<Action, "unrestricted" | (((context: UserContext) => "allow" | Promise<"allow" | DrizzleQueryFunctionInput<DB, key> | undefined> | DrizzleQueryFunctionInput<DB, key> | undefined) | DrizzleQueryFunctionInput<DB, key>)[]>;
     };
-  } } & {
+  }; } & {
     _: {
-      registeredFilters({
-        action,
-        table
-      }: {
+      registeredFilters({ action, table }: {
         table: TableRelationNames<DB>;
         action: Action;
       }): Filter<UserContext, DrizzleTableValueType<DB, TableRelationNames<DB>>>[];
-      build(): (ctx: UserContext) => { [key_1 in TableRelationNames<DB>]: {
-        filter: (action: Action) => {
+      build(): (ctx: UserContext) => { [key in TableRelationNames<DB>]: {
+        filter: (action: Action) => Promise<{
           query: {
-            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
-            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findFirst"]>[0]>>, "where">;
+            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findMany"]>[0]>>, "limit" | "where">;
           };
           sql: {
             readonly where: import("drizzle-orm").SQL<unknown> | undefined;
           };
         } & {
-          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
+          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key>>) => {
             query: {
-              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
-              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findFirst"]>[0]>>, "where">;
+              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findMany"]>[0]>>, "limit" | "where">;
             };
             sql: {
               readonly where: import("drizzle-orm").SQL<unknown> | undefined;
             };
           };
-        };
-      } };
+        }>;
+      }; };
     };
   };
   /**
@@ -4609,29 +4632,30 @@ declare const rumble: <UserContext extends Record<string, any>, DB extends Drizz
    */
   schemaBuilder: PothosSchemaTypes.SchemaBuilder<PothosSchemaTypes.ExtendDefaultTypes<{
     Context: Awaited<UserContext & {
-      abilities: { [key_1 in TableRelationNames<DB>]: {
-        filter: (action: Action) => {
+      abilities: { [key in TableRelationNames<DB>]: {
+        filter: (action: Action) => Promise<{
           query: {
-            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
-            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findFirst"]>[0]>>, "where">;
+            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findMany"]>[0]>>, "limit" | "where">;
           };
           sql: {
             readonly where: import("drizzle-orm").SQL<unknown> | undefined;
           };
         } & {
-          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
+          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key>>) => {
             query: {
-              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
-              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findFirst"]>[0]>>, "where">;
+              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findMany"]>[0]>>, "limit" | "where">;
             };
             sql: {
               readonly where: import("drizzle-orm").SQL<unknown> | undefined;
             };
           };
-        };
-      } };
+        }>;
+      }; };
     }>;
     DrizzleRelations: DB["_"]["relations"];
+    AsyncSelections: true;
     Objects: {
       Address: AddressShape;
     };
@@ -4760,40 +4784,36 @@ declare const rumble: <UserContext extends Record<string, any>, DB extends Drizz
   /**
    * A function for creating default objects for your schema
    */
-  object: <TableName extends TableRelationNames<DB>, RefName extends string>({
-    table,
-    refName,
-    readAction,
-    adjust
-  }: {
+  object: <TableName extends TableRelationNames<DB>, RefName extends string>({ table, refName, readAction, adjust }: {
     table: TableName;
     refName?: RefName | undefined;
     readAction?: Action | undefined;
     adjust?: ((t: import("@pothos/plugin-drizzle").DrizzleObjectFieldBuilder<PothosSchemaTypes.ExtendDefaultTypes<{
       Context: Awaited<UserContext & {
-        abilities: { [key_1 in TableRelationNames<DB>]: {
-          filter: (action: Action) => {
+        abilities: { [key in TableRelationNames<DB>]: {
+          filter: (action: Action) => Promise<{
             query: {
-              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
-              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findFirst"]>[0]>>, "where">;
+              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findMany"]>[0]>>, "limit" | "where">;
             };
             sql: {
               readonly where: import("drizzle-orm").SQL<unknown> | undefined;
             };
           } & {
-            merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
+            merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key>>) => {
               query: {
-                single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
-                many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+                single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findFirst"]>[0]>>, "where">;
+                many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findMany"]>[0]>>, "limit" | "where">;
               };
               sql: {
                 readonly where: import("drizzle-orm").SQL<unknown> | undefined;
               };
             };
-          };
-        } };
+          }>;
+        }; };
       }>;
       DrizzleRelations: DB["_"]["relations"];
+      AsyncSelections: true;
       Objects: {
         Address: AddressShape;
       };
@@ -4850,46 +4870,47 @@ declare const rumble: <UserContext extends Record<string, any>, DB extends Drizz
       DefaultFieldNullability: false;
     }>, (DB["_"]["relations"] & {})[TableName], DrizzleTableValueType<DB, TableName>, { [Key in keyof Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
       _: {
-        brand: "Table";
+        brand: 'Table';
       };
     }>["_"]["columns"] & string]: Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
       _: {
-        brand: "Table";
+        brand: 'Table';
       };
     }>["_"]["columns"][Key]["_"]["notNull"] extends true ? Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
       _: {
-        brand: "Table";
+        brand: 'Table';
       };
     }>["_"]["columns"][Key]["_"]["data"] : Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
       _: {
-        brand: "Table";
+        brand: 'Table';
       };
-    }>["_"]["columns"][Key]["_"]["data"] | null } extends infer T ? { [K in keyof T]: T[K] } : never>) => import("@pothos/core").FieldMap) | undefined;
+    }>["_"]["columns"][Key]["_"]["data"] | null; } extends (infer T) ? { [K in keyof T]: T[K]; } : never>) => import("@pothos/core").FieldMap) | undefined;
   }) => import("@pothos/plugin-drizzle").DrizzleObjectRef<PothosSchemaTypes.ExtendDefaultTypes<{
     Context: Awaited<UserContext & {
-      abilities: { [key_1 in TableRelationNames<DB>]: {
-        filter: (action: Action) => {
+      abilities: { [key in TableRelationNames<DB>]: {
+        filter: (action: Action) => Promise<{
           query: {
-            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
-            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findFirst"]>[0]>>, "where">;
+            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findMany"]>[0]>>, "limit" | "where">;
           };
           sql: {
             readonly where: import("drizzle-orm").SQL<unknown> | undefined;
           };
         } & {
-          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
+          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key>>) => {
             query: {
-              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
-              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findFirst"]>[0]>>, "where">;
+              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findMany"]>[0]>>, "limit" | "where">;
             };
             sql: {
               readonly where: import("drizzle-orm").SQL<unknown> | undefined;
             };
           };
-        };
-      } };
+        }>;
+      }; };
     }>;
     DrizzleRelations: DB["_"]["relations"];
+    AsyncSelections: true;
     Objects: {
       Address: AddressShape;
     };
@@ -4952,59 +4973,52 @@ declare const rumble: <UserContext extends Record<string, any>, DB extends Drizz
   /**
    * A function for creating where args to filter entities
    */
-  whereArg: <TableName extends keyof DrizzleQueryFunction<DB>, RefName_1 extends string>({
-    table,
-    refName,
-    dbName
-  }: Partial<{
+  whereArg: <TableName extends keyof DrizzleQueryFunction<DB>, RefName extends string>({ table, refName, dbName }: Partial<{
     table: TableName;
-    refName: RefName_1 | undefined;
+    refName: RefName | undefined;
     dbName: string;
   }> & ({
-    dbName: string;
-  } | {
     table: TableName;
+  } | {
+    dbName: string;
   })) => any;
   /**
    * A function for creating order args to sort entities
    */
-  orderArg: <RefName_2 extends string, TableName extends keyof DrizzleQueryFunction<DB>>({
-    table,
-    refName,
-    dbName
-  }: Partial<{
+  orderArg: <RefName extends string, TableName extends keyof DrizzleQueryFunction<DB>>({ table, refName, dbName }: Partial<{
     table: TableName;
-    refName: RefName_2 | undefined;
+    refName: RefName | undefined;
     dbName: string;
   }> & ({
-    dbName: string;
-  } | {
     table: TableName;
+  } | {
+    dbName: string;
   })) => PothosSchemaTypes.InputObjectRef<PothosSchemaTypes.ExtendDefaultTypes<{
     Context: Awaited<UserContext & {
-      abilities: { [key_1 in TableRelationNames<DB>]: {
-        filter: (action: Action) => {
+      abilities: { [key in TableRelationNames<DB>]: {
+        filter: (action: Action) => Promise<{
           query: {
-            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
-            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findFirst"]>[0]>>, "where">;
+            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findMany"]>[0]>>, "limit" | "where">;
           };
           sql: {
             readonly where: import("drizzle-orm").SQL<unknown> | undefined;
           };
         } & {
-          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
+          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key>>) => {
             query: {
-              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
-              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findFirst"]>[0]>>, "where">;
+              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findMany"]>[0]>>, "limit" | "where">;
             };
             sql: {
               readonly where: import("drizzle-orm").SQL<unknown> | undefined;
             };
           };
-        };
-      } };
+        }>;
+      }; };
     }>;
     DrizzleRelations: DB["_"]["relations"];
+    AsyncSelections: true;
     Objects: {
       Address: AddressShape;
     };
@@ -5066,40 +5080,28 @@ declare const rumble: <UserContext extends Record<string, any>, DB extends Drizz
    * A function for creating default READ queries.
    * Make sure the objects for the table you are creating the queries for are implemented
    */
-  query: <TableName_1 extends TableRelationNames<DB>>({
-    table,
-    readAction,
-    listAction,
-    findFirst,
-    findMany
-  }: {
-    table: TableName_1;
+  query: <TableName extends TableRelationNames<DB>>({ table, readAction, listAction, findFirst, findMany }: {
+    table: TableName;
     readAction?: Action | undefined;
     listAction?: Action | undefined;
     findMany?: ((p: {
       tx: DB | Parameters<Parameters<DB["transaction"]>[0]>[0];
-      filter: Parameters<DrizzleQueryFunction<DB>[TableName_1]["findMany"]>[0];
-      queryArgs: Parameters<DrizzleQueryFunction<DB>[TableName_1]["findMany"]>[0];
-    }) => ReturnType<DrizzleQueryFunction<DB>[TableName_1]["findMany"]>) | undefined;
+      filter: Parameters<DrizzleQueryFunction<DB>[TableName]["findMany"]>[0];
+      queryArgs: Parameters<DrizzleQueryFunction<DB>[TableName]["findMany"]>[0];
+    }) => ReturnType<DrizzleQueryFunction<DB>[TableName]["findMany"]>) | undefined;
     findFirst?: ((p: {
       tx: DB;
-      filter: Parameters<DrizzleQueryFunction<DB>[TableName_1]["findFirst"]>[0];
-      queryArgs: Parameters<DrizzleQueryFunction<DB>[TableName_1]["findFirst"]>[0];
-    }) => ReturnType<DrizzleQueryFunction<DB>[TableName_1]["findFirst"]>) | undefined;
+      filter: Parameters<DrizzleQueryFunction<DB>[TableName]["findFirst"]>[0];
+      queryArgs: Parameters<DrizzleQueryFunction<DB>[TableName]["findFirst"]>[0];
+    }) => ReturnType<DrizzleQueryFunction<DB>[TableName]["findFirst"]>) | undefined;
   }) => void;
   /**
    * A function for creating a pubsub instance for a table. Use this to publish or subscribe events
    */
-  pubsub: <TableName_1 extends keyof DrizzleQueryFunction<DB>>({
-    table
-  }: {
-    table: TableName_1;
+  pubsub: <TableName extends keyof DrizzleQueryFunction<DB>>({ table }: {
+    table: TableName;
   }) => {
-    registerOnInstance({
-      instance,
-      action,
-      primaryKeyValue
-    }: {
+    registerOnInstance({ instance, action, primaryKeyValue }: {
       instance: {
         register: (id: string) => void;
       };
@@ -5115,8 +5117,8 @@ declare const rumble: <UserContext extends Record<string, any>, DB extends Drizz
    * The other helpers use this helper internally so in most cases you do not have to
    * call this helper directly, unless you need the reference to an enum type
    */
-  enum_: <TsName extends keyof { [K in keyof Schema as Schema[K] extends import("drizzle-orm/pg-core").PgEnum<any> | import("drizzle-orm/pg-core").PgEnumObject<any> ? K : never]: Schema[K] } = never, EnumArg extends import("drizzle-orm/pg-core").PgEnum<any> | import("drizzle-orm/pg-core").PgEnumObject<any> = never, EnumColumn extends import("drizzle-orm").Column = never, RefName_2 extends string = string>(args: {
-    refName?: RefName_2 | undefined;
+  enum_: <TsName extends keyof { [K in keyof Schema as Schema[K] extends import("drizzle-orm/pg-core").PgEnum<any> | import("drizzle-orm/pg-core").PgEnumObject<any> ? K : never]: Schema[K]; } = never, EnumArg extends import("drizzle-orm/pg-core").PgEnum<any> | import("drizzle-orm/pg-core").PgEnumObject<any> = never, EnumColumn extends import("drizzle-orm").Column = never, RefName extends string = string>(args: {
+    refName?: RefName | undefined;
   } & ({
     tsName: TsName;
     enum?: never;
@@ -5131,29 +5133,30 @@ declare const rumble: <UserContext extends Record<string, any>, DB extends Drizz
     enum?: never;
   })) => PothosSchemaTypes.EnumRef<PothosSchemaTypes.ExtendDefaultTypes<{
     Context: Awaited<UserContext & {
-      abilities: { [key_1 in TableRelationNames<DB>]: {
-        filter: (action: Action) => {
+      abilities: { [key in TableRelationNames<DB>]: {
+        filter: (action: Action) => Promise<{
           query: {
-            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
-            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findFirst"]>[0]>>, "where">;
+            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findMany"]>[0]>>, "limit" | "where">;
           };
           sql: {
             readonly where: import("drizzle-orm").SQL<unknown> | undefined;
           };
         } & {
-          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
+          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key>>) => {
             query: {
-              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
-              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findFirst"]>[0]>>, "where">;
+              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key]["findMany"]>[0]>>, "limit" | "where">;
             };
             sql: {
               readonly where: import("drizzle-orm").SQL<unknown> | undefined;
             };
           };
-        };
-      } };
+        }>;
+      }; };
     }>;
     DrizzleRelations: DB["_"]["relations"];
+    AsyncSelections: true;
     Objects: {
       Address: AddressShape;
     };
@@ -5208,24 +5211,16 @@ declare const rumble: <UserContext extends Record<string, any>, DB extends Drizz
       AddressInput: AddressInputShape;
     };
     DefaultFieldNullability: false;
-  }>, [EnumColumn] extends [never] ? [EnumArg] extends [never] ? [TsName] extends [never] ? string : TsName extends keyof Schema ? (Schema[TsName] extends infer T ? T extends Schema[TsName] ? T extends import("drizzle-orm/pg-core").PgEnum<infer V extends [string, ...string[]]> ? V : T extends import("drizzle-orm/pg-core").PgEnumObject<infer O extends object> ? readonly (O[keyof O] & string)[] : readonly [string, ...string[]] : never : never)[number] : string : (EnumArg extends import("drizzle-orm/pg-core").PgEnum<infer V extends [string, ...string[]]> ? V : EnumArg extends import("drizzle-orm/pg-core").PgEnumObject<infer O extends object> ? readonly (O[keyof O] & string)[] : readonly [string, ...string[]])[number] : EnumColumn extends {
+  }>, [EnumColumn] extends [never] ? [EnumArg] extends [never] ? [TsName] extends [never] ? string : TsName extends keyof Schema ? (Schema[TsName] extends (infer T) ? T extends Schema[TsName] ? T extends import("drizzle-orm/pg-core").PgEnum<infer V extends [string, ...string[]]> ? V : T extends import("drizzle-orm/pg-core").PgEnumObject<infer O extends object> ? readonly (O[keyof O] & string)[] : readonly [string, ...string[]] : never : never)[number] : string : (EnumArg extends import("drizzle-orm/pg-core").PgEnum<infer V extends [string, ...string[]]> ? V : EnumArg extends import("drizzle-orm/pg-core").PgEnumObject<infer O extends object> ? readonly (O[keyof O] & string)[] : readonly [string, ...string[]])[number] : EnumColumn extends {
     enumValues: infer CV extends readonly [string, ...string[]];
-  } ? CV[number] : string, [EnumColumn] extends [never] ? [EnumArg] extends [never] ? [TsName] extends [never] ? string : TsName extends keyof Schema ? (Schema[TsName] extends infer T_1 ? T_1 extends Schema[TsName] ? T_1 extends import("drizzle-orm/pg-core").PgEnum<infer V extends [string, ...string[]]> ? V : T_1 extends import("drizzle-orm/pg-core").PgEnumObject<infer O extends object> ? readonly (O[keyof O] & string)[] : readonly [string, ...string[]] : never : never)[number] : string : (EnumArg extends import("drizzle-orm/pg-core").PgEnum<infer V extends [string, ...string[]]> ? V : EnumArg extends import("drizzle-orm/pg-core").PgEnumObject<infer O extends object> ? readonly (O[keyof O] & string)[] : readonly [string, ...string[]])[number] : EnumColumn extends {
+  } ? CV[number] : string, [EnumColumn] extends [never] ? [EnumArg] extends [never] ? [TsName] extends [never] ? string : TsName extends keyof Schema ? (Schema[TsName] extends (infer T) ? T extends Schema[TsName] ? T extends import("drizzle-orm/pg-core").PgEnum<infer V extends [string, ...string[]]> ? V : T extends import("drizzle-orm/pg-core").PgEnumObject<infer O extends object> ? readonly (O[keyof O] & string)[] : readonly [string, ...string[]] : never : never)[number] : string : (EnumArg extends import("drizzle-orm/pg-core").PgEnum<infer V extends [string, ...string[]]> ? V : EnumArg extends import("drizzle-orm/pg-core").PgEnumObject<infer O extends object> ? readonly (O[keyof O] & string)[] : readonly [string, ...string[]])[number] : EnumColumn extends {
     enumValues: infer CV extends readonly [string, ...string[]];
   } ? CV[number] : string>;
   /**
    * Create a client to consume a rumble graphql api at the specified location.
    * Requires GraphQL, does not work with the SOFA REST API.
    */
-  clientCreator: ({
-    apiUrl,
-    outputPath,
-    rumbleImportPath,
-    useExternalUrqlClient,
-    removeExisting,
-    forceReactivity,
-    autoIncludeIdField
-  }: {
+  clientCreator: ({ apiUrl, outputPath, rumbleImportPath, useExternalUrqlClient, removeExisting, forceReactivity, autoIncludeIdField }: {
     outputPath: string;
     apiUrl?: string;
     rumbleImportPath?: string;
@@ -5237,12 +5232,8 @@ declare const rumble: <UserContext extends Record<string, any>, DB extends Drizz
   /**
    * A function for creating count queries for your tables
    */
-  countQuery: <TableName_1 extends TableRelationNames<DB>>({
-    table,
-    listAction,
-    isAllowed
-  }: {
-    table: TableName_1;
+  countQuery: <TableName extends TableRelationNames<DB>>({ table, listAction, isAllowed }: {
+    table: TableName;
     listAction?: Action | undefined;
     isAllowed?: ((context: UserContext) => boolean | Promise<boolean>) | undefined;
   }) => void;
@@ -5259,7 +5250,7 @@ declare const rumble: <UserContext extends Record<string, any>, DB extends Drizz
  * An error that gets raised by rumble whenever something does not go according to plan.
  * Mostly internals, configuration errors or other unexpected things.
  */
-declare class RumbleError extends Error {
+export declare class RumbleError extends Error {
   constructor(message: string);
 }
 /**
@@ -5267,7 +5258,6 @@ declare class RumbleError extends Error {
  * information safely exposeable to the user.
  * E.g. the assert helpers issue these.
  */
-declare class RumbleErrorSafe extends GraphQLError {}
+export declare class RumbleErrorSafe extends GraphQLError {}
 //#endregion
-export { RumbleError, RumbleErrorSafe, assertFindFirstExists, assertFirstEntryExists, mapNullFieldsToUndefined, rumble };
 //# sourceMappingURL=index.d.mts.map