import { GraphQLError } from "graphql";
import { MySqlDatabase } from "drizzle-orm/mysql-core";
import { PgAsyncDatabase } from "drizzle-orm/pg-core";
import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
import { IncomingMessage, RequestListener, ServerResponse } from "node:http";
import { Http2ServerRequest, Http2ServerResponse } from "node:http2";
import { Socket } from "node:net";
import { EnvelopArmorPlugin } from "@escape.tech/graphql-armor";
import { ServerOptions } from "graphql-ws";
import { YogaServerOptions, createPubSub } from "graphql-yoga";
import { useSofa } from "sofa-api";
import { Tracer } from "@opentelemetry/api";
import SchemaBuilder from "@pothos/core";
import { TracingWrapperOptions } from "@pothos/tracing-opentelemetry";

//#region lib/helpers/asserts.d.ts
/**
 *
 * Helper function to map a drizzle findFirst query result,
 * which may be optional, to a correct drizzle type.
 *
 * @throws RumbleError
 *
 * @example
 *
 * ```ts
 * schemaBuilder.queryFields((t) => {
   return {
     findFirstUser: t.drizzleField({
       type: UserRef,
       resolve: (query, root, args, ctx, info) => {
         return (
           db.query.users
             .findFirst({
               ...query,
               where: ctx.abilities.users.filter("read").single.where,
             })
             // note that we need to manually raise an error if the value is not found
             .then(assertFindFirstExists)
         );
       },
     }),
   };
 });
 * ```
 */
declare const assertFindFirstExists: <T>(value: T | undefined) => T;
/**
 *
 * Helper function to map a drizzle findFirst query result,
 * which may be optional, to a correct drizzle type.
 *
 * @throws RumbleError
 *
 * @example
 *
 * ```ts
  schemaBuilder.mutationFields((t) => {
    return {
      updateUsername: t.drizzleField({
        type: UserRef,
        args: {
          userId: t.arg.int({ required: true }),
          newName: t.arg.string({ required: true }),
        },
        resolve: (query, root, args, ctx, info) => {
          return db
            .update(schema.users)
            .set({
              name: args.newName,
            })
            .where(
              and(
                eq(schema.users.id, args.userId),
                ctx.abilities.users.filter("update").single.where
              )
            )
            .returning({ id: schema.users.id, name: schema.users.name })
        // note that we need to manually raise an error if the value is not found
            .then(assertFirstEntryExists);
        },
      }),
    };
  });
 * ```
 */
declare const assertFirstEntryExists: <T>(value: T[]) => T;
//#endregion
//#region lib/helpers/mapNullFieldsToUndefined.d.ts
/**
 * Helper to map null fields to undefined
 * @param obj The object to map
 * @returns The mapped object with all fields of 'null' transformed to 'undefined'
 *
 * This becomes useful for update mutations where you do not want to pass null (unset value in db)
 * but undefined (do not touch value in db) in case of a value not beeing set in the args of said mutation
 * @example
 * ```ts
 *  updateUser: t.drizzleField({
      type: User,
      args: {
        id: t.arg.string({ required: true }),
        email: t.arg.string(),
        lastName: t.arg.string(),
        firstName: t.arg.string(),
      },
      resolve: async (query, root, args, ctx, info) => {
        const mappedArgs = mapNullFieldsToUndefined(args);
        const user = await db.transaction(async (tx) => {
          const user = await tx
            .update(schema.user)
            .set({

              // email: args.email ?? undefined,
              // lastName: args.lastName ?? undefined,
              // firstName: args.firstName ?? undefined,

              // becomes this

              email: mappedArgs.email,
              lastName: mappedArgs.lastName,
              firstName: mappedArgs.firstName,
            })
            .returning()
            .then(assertFirstEntryExists);
          return user;
        });

        pubsub.updated(user.id);

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

request: TTypedRequest, context: TServerContext) => PromiseOrValue<TTypedResponse>;
type OnRouterInitHook<TServerContext> = (router: Router<TServerContext, any, any>) => void;
type ObjectSchemaWithPrimitiveProperties = JSONSchema & {
  type: 'object';
  properties: Record<string, {
    type: 'string' | 'number' | 'integer' | 'boolean' | 'null';
  }>;
};
type ObjectSchema = JSONSchema & {
  type: 'object';
};
type RouteSchemas = {
  request?: {
    headers?: ObjectSchemaWithPrimitiveProperties;
    params?: ObjectSchemaWithPrimitiveProperties;
    query?: ObjectSchema;
    json?: JSONSchema;
    formData?: ObjectSchema;
  };
  responses?: StatusCodeMap<JSONSchema>;
};
type RouterSDKOpts<TTypedRequest extends TypedRequest = TypedRequest, TMethod extends HTTPMethod = HTTPMethod> = TTypedRequest extends TypedRequest<infer TJSONBody, infer TFormData, infer THeaders, TMethod, infer TQueryParams, infer TPathParam> ? Simplify<(Partial<TJSONBody> extends TJSONBody ? {
  json?: TJSONBody;
} : {
  json: TJSONBody;
}) & (Partial<THeaders> extends THeaders ? {
  headers?: THeaders;
} : {
  headers: THeaders;
}) & (Partial<TQueryParams> extends TQueryParams ? {
  query?: TQueryParams;
} : {
  query: TQueryParams;
}) & (Partial<TPathParam> extends TPathParam ? {
  params?: TPathParam;
} : {
  params: TPathParam;
})> & (Partial<TFormData> extends TFormData ? {
  formData?: TFormData;
} : {
  formData: TFormData;
}) : never;
type RouterSDK<TPath extends string = string, TTypedRequest extends TypedRequest = TypedRequest, TTypedResponse extends TypedResponse = TypedResponse> = { [TPathKey in TPath]: { [TMethod in Lowercase<TTypedRequest['method']>]: Partial<RouterSDKOpts<TTypedRequest, TTypedRequest['method']>> extends RouterSDKOpts<TTypedRequest, TTypedRequest['method']> ? (opts?: RouterSDKOpts<TTypedRequest, TTypedRequest['method']> & ClientRequestInit) => ClientTypedResponsePromise<Exclude<TTypedResponse, undefined>> : (opts: RouterSDKOpts<TTypedRequest, TTypedRequest['method']> & ClientRequestInit) => ClientTypedResponsePromise<Exclude<TTypedResponse, undefined>> } };
type FromSchemaWithComponents<TComponents, TSchema extends JSONSchema> = TComponents extends {
  schemas: Record<string, JSONSchema>;
} ? FromSchema<{
  components: TComponents;
} & TSchema> : FromSchema<TSchema>;
type TypedRequestFromRouteSchemas<TComponents extends RouterComponentsBase, TRouteSchemas extends RouteSchemas, TMethod extends HTTPMethod, TPath extends string> = TRouteSchemas extends {
  request: Required<RouteSchemas>['request'];
} ? TypedRequest<TRouteSchemas['request'] extends {
  json: JSONSchema;
} ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['json']> : {}, TRouteSchemas['request'] extends {
  formData: JSONSchema;
} ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['formData']> extends Record<string, FormDataEntryValue | undefined> ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['formData']> : never : {}, TRouteSchemas['request'] extends {
  headers: JSONSchema;
} ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['headers']> extends Record<string, string> ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['headers']> : never : {}, TMethod, TRouteSchemas['request'] extends {
  query: JSONSchema;
} ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['query']> : {}, TRouteSchemas['request'] extends {
  params: JSONSchema;
} ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['params']> extends Record<string, any> ? FromSchemaWithComponents<TComponents, TRouteSchemas['request']['params']> : never : Record<ExtractPathParamsWithPattern<TPath>, string>> : TypedRequest<any, Partial<Record<string, FormDataEntryValue>>, Partial<Record<string, string>>, TMethod, any, Record<ExtractPathParamsWithPattern<TPath>, string>>;
type TypedResponseFromRouteSchemas<TComponents extends RouterComponentsBase, TRouteSchemas extends RouteSchemas> = TRouteSchemas extends {
  responses: StatusCodeMap<JSONSchema>;
} ? TypedResponseWithJSONStatusMap<{ [TStatusCode in keyof TRouteSchemas['responses']]: TRouteSchemas['responses'][TStatusCode] extends JSONSchema ? FromSchemaWithComponents<TComponents, TRouteSchemas['responses'][TStatusCode]> : never }> : TypedResponse;
type RouteWithSchemasOpts<TServerContext, TComponents extends RouterComponentsBase, TRouteSchemas extends RouteSchemas, TMethod extends HTTPMethod, TPath extends string, TTypedRequest extends TypedRequestFromRouteSchemas<TComponents, TRouteSchemas, TMethod, TPath>, TTypedResponse extends TypedResponseFromRouteSchemas<TComponents, TRouteSchemas>> = {
  schemas: TRouteSchemas;
  security?: SecuritySchemeRefsFromComponents<TComponents>[];
} & RouteWithTypesOpts<TServerContext, TMethod, TPath, TTypedRequest, TTypedResponse>;
type SecuritySchemeRefsFromComponents<TComponents extends RouterComponentsBase> = TComponents extends {
  securitySchemes: Record<string, SecurityScheme>;
} ? Record<keyof TComponents['securitySchemes'], any> : never;
type RouteWithTypesOpts<TServerContext, TMethod extends HTTPMethod, TPath extends string, TTypedRequest extends TypedRequest<any, Record<string, FormDataEntryValue | undefined>, Record<string, string | undefined>, TMethod, any, Record<ExtractPathParamsWithPattern<TPath>, string>>, TTypedResponse extends TypedResponse> = {
  operationId?: string;
  description?: string;
  method?: TMethod;
  tags?: string[];
  internal?: boolean;
  path: TPath;
  handler: RouteHandler<TServerContext, TTypedRequest, TTypedResponse>;
};
type ExtractPathParamsWithPattern<TPath extends string> = Pipe<TPath, [Strings.Split<'/'>, Tuples.Filter<Strings.StartsWith<':'>>, Tuples.Map<Strings.Trim<':'>>, Tuples.ToUnion]>;
//#endregion
//#region lib/types/rumbleInput.d.ts
type CustomRumblePothosConfig = Omit<ConstructorParameters<typeof SchemaBuilder>[0], "smartSubscriptions" | "drizzle">;
type RumbleInput<UserContext extends Record<string, any>, DB extends DrizzleInstance, RequestEvent extends Record<string, any>, Action extends string, PothosConfig extends CustomRumblePothosConfig, Schema extends Record<string, any> = Record<string, any>> = {
  /**
   * Your drizzle database instance
   */
  db: DB;
  /**
   * The drizzle schema object (the same one passed to `defineRelations`).
   */
  schema: Schema;
  /**
   * A function for providing context for each request based on the incoming HTTP Request.
   * The type of the parameter equals the HTTPRequest type of your chosen server.
   */
  context?: ((event: RequestEvent) => Promise<UserContext> | UserContext) | undefined;
  /**
   * If you only want to disable query, mutation or subscription default objects, you can do so here
   */
  disableDefaultObjects?: {
    mutation?: boolean;
    subscription?: boolean;
    query?: boolean;
  };
  /**
   * The actions that are available
   */
  actions?: Action[];
  /**
   * Customization for subscriptions. See https://the-guild.dev/graphql/yoga-server/docs/features/subscriptions#distributed-pubsub-for-production
   */
  subscriptions?: Parameters<typeof createPubSub>;
  /**
   * Options passed along to the pothos schema builder.
   */
  pothosConfig?: PothosConfig;
  /**
   * Limits the returned amount when querying lists. Set to null to disable.
   * @default 100
   */
  defaultLimit?: number | undefined | null;
  /**
   * rumble supports fuzzy search for the query helpers. This enables the users of your API to search for entities via fuzzy search inputs.
   * This currently only is supported by postgres databases and will fail if enabled on other dialects.
   *
   * Please note that this will install the pg_trgm extension on startup if your database does not have it already installed.
   * https://www.postgresql.org/docs/current/pgtrgm.html
   */
  search?: {
    /**
     * Whether search is enabled
     */
    enabled?: boolean;
    /**
     * The cuttoff factor to reduce the amount of returned results.
     * Defaults to 0.3. Lower values will return more results.
     */
    threshold?: number;
    /**
     * Will perform a local
     * SET cpu_operator_cost = x;
     * for search queries. This can help to make the planner
     * use a potential index scan instead of a sequential scan.
     * This will not affect queries that are not using the search feature.
     */
    cpu_operator_cost?: number;
  } | undefined;
  /**
   * rumble can set up otel tracing if you want to. This will provide details of execution time and outcome to the provided tracer. See https://pothos-graphql.dev/docs/plugins/tracing#install for more information.
   */
  otel?: {
    /**
     * Whether otel tracing should be enabled. This will create a tracer if none is provided.
     */
    enabled?: boolean;
    /**
     * The tracer to use. If enabled is true and no tracer is provided, a tracer will be created.
     */
    tracer?: Tracer;
    /**
     * You can pass options to the tracing wrapper
     */
    options?: TracingWrapperOptions<unknown>;
  };
};
//#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> & {
  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");
     *
     * ```
     */
  abilityBuilder: (keyof DrizzleQueryFunction<DB> extends infer T extends keyof DrizzleQueryFunction<DB> ? { [key in T]: {
    allow: (action: Action | Action[]) => {
      when: (queryFilter: DrizzleQueryFunctionInput<DB, key> | ((context: UserContext) => DrizzleQueryFunctionInput<DB, key> | "allow" | undefined)) => void;
    };
    filter: (action: Action | Action[]) => {
      prefetch: <PrefetchReturnType>(prefetch: Prefetch<UserContext, PrefetchReturnType>) => {
        by: (explicitFilter: Filter<UserContext, DrizzleTableValueType<DB, key>, PrefetchReturnType>) => void;
      };
      by: (explicitFilter: Filter<UserContext, DrizzleTableValueType<DB, key>>) => void;
    };
    _: {
      runtimeFilters: Map<Action, FilterPrefetchCombo<UserContext, any, any>[]>;
      queryFilters: Map<Action, "unrestricted" | (DrizzleQueryFunctionInput<DB, key> | ((context: UserContext) => DrizzleQueryFunctionInput<DB, key> | "allow" | undefined))[]>;
    };
  } } : never) & {
    _: {
      registeredFilters({
        action,
        table
      }: {
        table: keyof DrizzleQueryFunction<DB>;
        action: Action;
      }): Filter<UserContext, DrizzleTableValueType<DB, keyof DrizzleQueryFunction<DB>>>[];
      build(): (ctx: UserContext) => keyof DrizzleQueryFunction<DB> extends infer T_1 extends keyof DrizzleQueryFunction<DB> ? { [key_1 in T_1]: {
        filter: (action: Action) => {
          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">;
          };
          sql: {
            readonly where: import("drizzle-orm").SQL<unknown> | undefined;
          };
        } & {
          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
            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">;
            };
            sql: {
              readonly where: import("drizzle-orm").SQL<unknown> | undefined;
            };
          };
        };
      } } : never;
    };
  };
  /**
   * The pothos schema builder. See https://pothos-graphql.dev/docs/plugins/drizzle
   */
  schemaBuilder: PothosSchemaTypes.SchemaBuilder<PothosSchemaTypes.ExtendDefaultTypes<{
    Context: Awaited<UserContext & {
      abilities: keyof DrizzleQueryFunction<DB> extends infer T_1 extends keyof DrizzleQueryFunction<DB> ? { [key_1 in T_1]: {
        filter: (action: Action) => {
          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">;
          };
          sql: {
            readonly where: import("drizzle-orm").SQL<unknown> | undefined;
          };
        } & {
          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
            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">;
            };
            sql: {
              readonly where: import("drizzle-orm").SQL<unknown> | undefined;
            };
          };
        };
      } } : never;
    }>;
    DrizzleRelations: DB["_"]["relations"];
    Scalars: {
      JSON: {
        Input: unknown;
        Output: unknown;
      };
      Date: {
        Input: Date;
        Output: Date;
      };
      DateTime: {
        Input: Date;
        Output: Date;
      };
    };
    Inputs: {
      IntWhereInputArgument: NumberWhereInputArgument;
      FloatWhereInputArgument: NumberWhereInputArgument;
      StringWhereInputArgument: StringWhereInputArgument;
      DateWhereInputArgument: DateWhereInputArgument;
    };
    DefaultFieldNullability: false;
  }>>;
  /**
   * Creates the native yoga instance. Can be used to run an actual HTTP server.
   *
   * @example
   *
   * ```ts
   * import { createServer } from "node:http";
   * const server = createServer(createYoga());
   * server.listen(3000, () => {
   *   console.info("Visit http://localhost:3000/graphql");
   * });
   * ```
   * https://the-guild.dev/graphql/yoga-server/docs#server
   */
  createYoga: (args?: (Omit<YogaServerOptions<RequestEvent, any>, "schema" | "context"> & {
    /**
     * Determines if the API should disclose various things about its structure.
     * Defaults to `process.env.NODE_ENV === "development"`.
     * If enabled, the api will allow introspection requests, provide the graphiql
     * explorer and will not apply the additional envelop armor plugin.
     */
    enableApiDocs?: boolean;
    /**
     * Optional configuration passed to the auto-installed graphql-armor
     * EnvelopArmorPlugin. Only applied when `enableApiDocs` is false
     * (i.e. in production). Useful for relaxing the default depth/alias/
     * directive/token limits when the generated schema legitimately exceeds
     * them. See https://github.com/Escape-Technologies/graphql-armor for available options.
     *
     * @example
     * createYoga({ armorConfig: { maxDepth: { n: 20 } } })
     */
    armorConfig?: Parameters<typeof EnvelopArmorPlugin>[0];
  }) | undefined) => import("graphql-yoga").YogaServerInstance<RequestEvent, {}>;
  /**
   * Creates a sofa instance to offer a REST API.
   *
   * ```ts
   * import express from "express";
   *
   * const app = express();
   * const sofa = createSofa(...);
   *
   * app.use("/api", useSofa({ schema }));
   * ```
   * https://the-guild.dev/graphql/sofa-api/docs#usage
   */
  createSofa: (args: Omit<Parameters<typeof useSofa>[0], "schema" | "context">) => Promise<Router<any, {}, {
    [TKey: string]: never;
  }>>;
  /**
   * Creates a WebSocket server handler for GraphQL subscriptions.
   * Pass the ws implementation function as the first argument and rumble will
   * inject the schema and context automatically.
   *
   * @example
   *
   * ```ts
   * // ws
   * import { useServer } from "graphql-ws/use/ws";
   * import { WebSocketServer } from "ws";
   * const wss = new WebSocketServer({ port: 4000 });
   * const disposable = createWs(useServer, { ... }, wss);
   *
   * // bun
   * import { makeHandler } from "graphql-ws/use/bun";
   * Bun.serve({ websocket: createWs(makeHandler, { ... }), ... });
   * ```
   */
  createWs: <Options extends ServerOptions<any, any>, Rest extends unknown[], Return>(implementation: (options: Options, ...rest: Rest) => Return, args: Omit<Options, "schema" | "context">, ...rest: Rest) => Return;
  /**
   * A function for creating default objects for your schema
   */
  object: <TableName extends keyof DrizzleQueryFunction<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: keyof DrizzleQueryFunction<DB> extends infer T_2 extends keyof DrizzleQueryFunction<DB> ? { [key_1 in T_2]: {
          filter: (action: Action) => {
            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">;
            };
            sql: {
              readonly where: import("drizzle-orm").SQL<unknown> | undefined;
            };
          } & {
            merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
              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">;
              };
              sql: {
                readonly where: import("drizzle-orm").SQL<unknown> | undefined;
              };
            };
          };
        } } : never;
      }>;
      DrizzleRelations: DB["_"]["relations"];
      Scalars: {
        JSON: {
          Input: unknown;
          Output: unknown;
        };
        Date: {
          Input: Date;
          Output: Date;
        };
        DateTime: {
          Input: Date;
          Output: Date;
        };
      };
      Inputs: {
        IntWhereInputArgument: NumberWhereInputArgument;
        FloatWhereInputArgument: NumberWhereInputArgument;
        StringWhereInputArgument: StringWhereInputArgument;
        DateWhereInputArgument: DateWhereInputArgument;
      };
      DefaultFieldNullability: false;
    }>, (DB["_"]["relations"] & {})[TableName], DrizzleTableValueType<DB, TableName>, { [Key in keyof Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
      _: {
        brand: "Table";
      };
    }>["_"]["columns"] & string]: Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
      _: {
        brand: "Table";
      };
    }>["_"]["columns"][Key]["_"]["notNull"] extends true ? Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
      _: {
        brand: "Table";
      };
    }>["_"]["columns"][Key]["_"]["data"] : Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
      _: {
        brand: "Table";
      };
    }>["_"]["columns"][Key]["_"]["data"] | null } extends infer T_3 ? { [K in keyof T_3]: T_3[K] } : never>) => import("@pothos/core").FieldMap) | undefined;
  }) => import("@pothos/plugin-drizzle").DrizzleObjectRef<PothosSchemaTypes.ExtendDefaultTypes<{
    Context: Awaited<UserContext & {
      abilities: keyof DrizzleQueryFunction<DB> extends infer T_2 extends keyof DrizzleQueryFunction<DB> ? { [key_1 in T_2]: {
        filter: (action: Action) => {
          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">;
          };
          sql: {
            readonly where: import("drizzle-orm").SQL<unknown> | undefined;
          };
        } & {
          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
            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">;
            };
            sql: {
              readonly where: import("drizzle-orm").SQL<unknown> | undefined;
            };
          };
        };
      } } : never;
    }>;
    DrizzleRelations: DB["_"]["relations"];
    Scalars: {
      JSON: {
        Input: unknown;
        Output: unknown;
      };
      Date: {
        Input: Date;
        Output: Date;
      };
      DateTime: {
        Input: Date;
        Output: Date;
      };
    };
    Inputs: {
      IntWhereInputArgument: NumberWhereInputArgument;
      FloatWhereInputArgument: NumberWhereInputArgument;
      StringWhereInputArgument: StringWhereInputArgument;
      DateWhereInputArgument: DateWhereInputArgument;
    };
    DefaultFieldNullability: false;
  }>, TableName, import("drizzle-orm").BuildQueryResult<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})[TableName], true extends true | import("drizzle-orm").DBQueryConfig<"one", DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})[TableName]> ? true : (true | import("drizzle-orm").DBQueryConfig<"one", DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})[TableName]>) & {
    columns: {};
  }, import("drizzle-orm").Assume<(DB["_"]["relations"] & {})[TableName]["table"], {
    $inferSelect: Record<string, unknown>;
  }>["$inferSelect"]>>;
  /**
   * A function for creating where args to filter entities
   */
  whereArg: <TableName extends keyof DrizzleQueryFunction<DB>, RefName_1 extends string>({
    table,
    refName,
    dbName
  }: Partial<{
    table: TableName;
    refName: RefName_1 | undefined;
    dbName: string;
  }> & ({
    dbName: string;
  } | {
    table: TableName;
  })) => PothosSchemaTypes.InputObjectRef<PothosSchemaTypes.ExtendDefaultTypes<{
    Context: Awaited<UserContext & {
      abilities: keyof DrizzleQueryFunction<DB> extends infer T_2 extends keyof DrizzleQueryFunction<DB> ? { [key_1 in T_2]: {
        filter: (action: Action) => {
          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">;
          };
          sql: {
            readonly where: import("drizzle-orm").SQL<unknown> | undefined;
          };
        } & {
          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
            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">;
            };
            sql: {
              readonly where: import("drizzle-orm").SQL<unknown> | undefined;
            };
          };
        };
      } } : never;
    }>;
    DrizzleRelations: DB["_"]["relations"];
    Scalars: {
      JSON: {
        Input: unknown;
        Output: unknown;
      };
      Date: {
        Input: Date;
        Output: Date;
      };
      DateTime: {
        Input: Date;
        Output: Date;
      };
    };
    Inputs: {
      IntWhereInputArgument: NumberWhereInputArgument;
      FloatWhereInputArgument: NumberWhereInputArgument;
      StringWhereInputArgument: StringWhereInputArgument;
      DateWhereInputArgument: DateWhereInputArgument;
    };
    DefaultFieldNullability: false;
  }>, {
    [x: string]: unknown;
  }>;
  /**
   * A function for creating order args to sort entities
   */
  orderArg: <RefName_2 extends string, TableName extends keyof DrizzleQueryFunction<DB>>({
    table,
    refName,
    dbName
  }: Partial<{
    table: TableName;
    refName: RefName_2 | undefined;
    dbName: string;
  }> & ({
    dbName: string;
  } | {
    table: TableName;
  })) => PothosSchemaTypes.InputObjectRef<PothosSchemaTypes.ExtendDefaultTypes<{
    Context: Awaited<UserContext & {
      abilities: keyof DrizzleQueryFunction<DB> extends infer T_2 extends keyof DrizzleQueryFunction<DB> ? { [key_1 in T_2]: {
        filter: (action: Action) => {
          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">;
          };
          sql: {
            readonly where: import("drizzle-orm").SQL<unknown> | undefined;
          };
        } & {
          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
            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">;
            };
            sql: {
              readonly where: import("drizzle-orm").SQL<unknown> | undefined;
            };
          };
        };
      } } : never;
    }>;
    DrizzleRelations: DB["_"]["relations"];
    Scalars: {
      JSON: {
        Input: unknown;
        Output: unknown;
      };
      Date: {
        Input: Date;
        Output: Date;
      };
      DateTime: {
        Input: Date;
        Output: Date;
      };
    };
    Inputs: {
      IntWhereInputArgument: NumberWhereInputArgument;
      FloatWhereInputArgument: NumberWhereInputArgument;
      StringWhereInputArgument: StringWhereInputArgument;
      DateWhereInputArgument: DateWhereInputArgument;
    };
    DefaultFieldNullability: false;
  }>, {
    [x: string]: unknown;
  }>;
  /**
   * 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 keyof DrizzleQueryFunction<DB>>({
    table,
    readAction,
    listAction
  }: {
    table: TableName_1;
    readAction?: Action | undefined;
    listAction?: Action | 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;
  }) => {
    registerOnInstance({
      instance,
      action,
      primaryKeyValue
    }: {
      instance: {
        register: (id: string) => void;
      };
      action: "created" | "removed" | "updated";
      primaryKeyValue?: string;
    }): void;
    created(): void;
    removed(): void;
    updated(primaryKeyValue?: any | any[]): void;
  };
  /**
   * A function to implement enums for graphql usage.
   * 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;
  } & ({
    tsName: TsName;
    enum?: never;
    enumColumn?: never;
  } | {
    enum: EnumArg;
    tsName?: never;
    enumColumn?: never;
  } | {
    enumColumn: EnumColumn;
    tsName?: never;
    enum?: never;
  })) => PothosSchemaTypes.EnumRef<PothosSchemaTypes.ExtendDefaultTypes<{
    Context: Awaited<UserContext & {
      abilities: keyof DrizzleQueryFunction<DB> extends infer T_2 extends keyof DrizzleQueryFunction<DB> ? { [key_1 in T_2]: {
        filter: (action: Action) => {
          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">;
          };
          sql: {
            readonly where: import("drizzle-orm").SQL<unknown> | undefined;
          };
        } & {
          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
            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">;
            };
            sql: {
              readonly where: import("drizzle-orm").SQL<unknown> | undefined;
            };
          };
        };
      } } : never;
    }>;
    DrizzleRelations: DB["_"]["relations"];
    Scalars: {
      JSON: {
        Input: unknown;
        Output: unknown;
      };
      Date: {
        Input: Date;
        Output: Date;
      };
      DateTime: {
        Input: Date;
        Output: Date;
      };
    };
    Inputs: {
      IntWhereInputArgument: NumberWhereInputArgument;
      FloatWhereInputArgument: NumberWhereInputArgument;
      StringWhereInputArgument: StringWhereInputArgument;
      DateWhereInputArgument: DateWhereInputArgument;
    };
    DefaultFieldNullability: false;
  }>, [EnumColumn] extends [never] ? [EnumArg] extends [never] ? [TsName] extends [never] ? string : TsName extends keyof Schema ? (Schema[TsName] extends infer T_3 ? T_3 extends Schema[TsName] ? T_3 extends import("drizzle-orm/pg-core").PgEnum<infer V extends [string, ...string[]]> ? V : T_3 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_4 ? T_4 extends Schema[TsName] ? T_4 extends import("drizzle-orm/pg-core").PgEnum<infer V extends [string, ...string[]]> ? V : T_4 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
  }: {
    outputPath: string;
    apiUrl?: string;
    rumbleImportPath?: string;
    useExternalUrqlClient?: string;
    removeExisting?: boolean;
    forceReactivity?: boolean;
    autoIncludeIdField?: boolean | string;
  }) => Promise<void>;
  /**
   * A function for creating count queries for your tables
   */
  countQuery: <TableName_1 extends keyof DrizzleQueryFunction<DB>>({
    table,
    listAction,
    isAllowed
  }: {
    table: TableName_1;
    listAction?: Action | undefined;
    isAllowed?: ((context: UserContext) => boolean | Promise<boolean>) | undefined;
  }) => void;
  /**
   * The generated GraphQL schema. You can use this for example to create a GraphQL server with a different library than Yoga or to generate types with codegen.
   * When calling this function, the schema will be built for the first time and cached for later usage. So you can call this function multiple times without performance issues.
   * After calling, you cannot adjust the schema via the schema builder
   */
  buildSchema: () => import("graphql").GraphQLSchema;
};
//#endregion
//#region lib/types/rumbleError.d.ts
/**
 * 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 {
  constructor(message: string);
}
/**
 * An error that gets raised by rumble whenever an error occurs in a resolver, containing
 * information safely exposeable to the user.
 * E.g. the assert helpers issue these.
 */
declare class RumbleErrorSafe extends GraphQLError {}
//#endregion
export { RumbleError, RumbleErrorSafe, assertFindFirstExists, assertFirstEntryExists, mapNullFieldsToUndefined, rumble };
//# sourceMappingURL=index.d.cts.map