@powerlines/deepkit 0.7.3 → 0.7.5

package/dist/type-8AL5U7vn.d.cts

@@ -0,0 +1,2969 @@
+import { c as AbstractClassType, d as CustomError, f as ExtractClassType, r as TypeAnnotation, s as CompilerContext, u as ClassType } from "./types-Bb6lL3KL.cjs";
+import { n as ReflectionOp, r as TypeNumberBrand } from "./type-DR66Hepn.cjs";
+import { Buffer } from "node:buffer";
+
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/changes.d.ts
+type NumberFields<T> = { [K in keyof T]: T[K] extends number | bigint ? K : never }[keyof T];
+type Expression<T> = { [P in keyof T & string]?: string };
+type Partial$1<T> = { [P in keyof T & string]?: T[P] };
+type DeepPartial<T> = { [P in keyof T]?: T[P] } & {
+  [deepPath: string]: any;
+};
+interface ChangesInterface<T> {
+  $set?: DeepPartial<T> | T;
+  $unset?: {
+    [path: string]: number;
+  };
+  $inc?: Partial$1<Pick<T, NumberFields<T>>>;
+}
+declare class Changes<T extends object> {
+  $set?: DeepPartial<T> | T;
+  $unset?: {
+    [path: string]: number;
+  };
+  $inc?: Partial$1<Pick<T, NumberFields<T>>>;
+  empty: boolean;
+  fieldNames: string[];
+  constructor(changes?: ChangesInterface<T>);
+  clear(): void;
+  getReturning(): string[];
+  protected detectEmpty(): void;
+  replaceSet($set: DeepPartial<T> | T): void;
+  mergeSet($set: Partial$1<T> | T): void;
+  increase(property: NumberFields<T>, increase?: number): void;
+  set(property: keyof T & string, value: any): void;
+  unset(property: keyof T & string, unset?: boolean): void;
+  has(name: keyof T & string): boolean;
+}
+declare class ItemChanges<T extends object> extends Changes<T> {
+  protected item: T;
+  constructor(changes: ChangesInterface<T> | undefined, item: T);
+  increase(property: NumberFields<T>, increase?: number): void;
+  set(property: keyof T & string, value: any): void;
+  unset(property: keyof T & string, unset?: boolean): void;
+}
+declare const changeSetSymbol: unique symbol;
+declare class AtomicChangeInstance<T extends object> {
+  protected object: any;
+  readonly changeSet: Changes<T>;
+  constructor(object: any);
+  increase(property: NumberFields<T>, increase?: number): void;
+}
+declare function atomicChange<T extends object>(object: T): AtomicChangeInstance<T>;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/reflection/type.d.ts
+declare enum ReflectionVisibility {
+  public = 0,
+  protected = 1,
+  private = 2
+}
+declare enum ReflectionKind {
+  never = 0,
+  any = 1,
+  unknown = 2,
+  void = 3,
+  object = 4,
+  string = 5,
+  number = 6,
+  boolean = 7,
+  symbol = 8,
+  bigint = 9,
+  null = 10,
+  undefined = 11,
+  regexp = 12,
+  literal = 13,
+  templateLiteral = 14,
+  property = 15,
+  method = 16,
+  function = 17,
+  parameter = 18,
+  promise = 19,
+  /**
+   * Uint8Array, Date, custom classes, Set, Map, etc
+   */
+  class = 20,
+  typeParameter = 21,
+  enum = 22,
+  union = 23,
+  intersection = 24,
+  array = 25,
+  tuple = 26,
+  tupleMember = 27,
+  enumMember = 28,
+  rest = 29,
+  objectLiteral = 30,
+  indexSignature = 31,
+  propertySignature = 32,
+  methodSignature = 33,
+  infer = 34,
+  callSignature = 35
+}
+type TypeDecorator = (annotations: Annotations, decorator: TypeObjectLiteral) => boolean;
+type Annotations = any;
+/**
+ * @reflection never
+ */
+interface TypeAnnotations {
+  id?: number;
+  origin?: Type;
+  /**
+   * True when this type comes from an inline type, e.g.
+   *
+   * `type A = T;`. Type of `T` is inlined.
+   * `type A = {}`. Type of `{}` is not inlined.
+   *
+   * If the type is not inlined and the result of a type function, then we assign parents of members accordingly. This is not the caee when a type was inlined.
+   */
+  inlined?: true;
+  /**
+   * If the type was created by a type function, this contains the alias name.
+   */
+  typeName?: string;
+  /**
+   * If the type was created by a type function, this contains the arguments passed the function.
+   */
+  typeArguments?: Type[];
+  /**
+   * Set for index access expressions, e.g. Config['property'].
+   */
+  indexAccessOrigin?: {
+    container: TypeClass | TypeObjectLiteral;
+    index: Type;
+  };
+  /**
+   * type User = {id: number, user: string};
+   * type UserCreate = Pick<User, 'user'>;
+   * typeOf<UserCreate>().originTypes[0].typeName = 'Pick'
+   * typeOf<UserCreate>().originTypes[0].typeArguments = [User, 'user']
+   */
+  originTypes?: {
+    typeName: string;
+    typeArguments?: Type[];
+  }[];
+  annotations?: Annotations;
+  decorators?: Type[];
+  scheduleDecorators?: TypeObjectLiteral[];
+  /**
+   * A place where arbitrary jit functions and its cache data is stored.
+   */
+  jit?: JitContainer;
+}
+declare function applyScheduledAnnotations(type: Type): void;
+declare function hasTypeInformation(object: ClassType | Function): boolean;
+/**
+ * Object to hold runtime jit data.
+ */
+type JitContainer = any;
+declare function getTypeJitContainer(type: Type): JitContainer;
+declare function clearTypeJitContainer(type: Type): void;
+interface TagsReflection {
+  hidden?: boolean;
+  ignore?: boolean;
+  internal?: boolean;
+  runtime?: boolean;
+  alias?: string[];
+  title?: string;
+  readonly?: boolean;
+  permission?: string[];
+  domain?: string;
+}
+interface TypeNever extends TypeAnnotations {
+  kind: ReflectionKind.never;
+  parent?: Type;
+}
+interface TypeAny extends TypeAnnotations {
+  kind: ReflectionKind.any;
+  parent?: Type;
+}
+interface TypeUnknown extends TypeAnnotations {
+  kind: ReflectionKind.unknown;
+  parent?: Type;
+}
+interface TypeVoid extends TypeAnnotations {
+  kind: ReflectionKind.void;
+  parent?: Type;
+}
+interface TypeObject extends TypeAnnotations {
+  kind: ReflectionKind.object;
+  parent?: Type;
+}
+interface TypeString extends TypeAnnotations {
+  kind: ReflectionKind.string;
+  parent?: Type;
+}
+declare function isIntegerType(type: Type): type is TypeNumber;
+interface TypeNumber extends TypeAnnotations {
+  kind: ReflectionKind.number;
+  brand?: TypeNumberBrand;
+  parent?: Type;
+}
+interface TypeBoolean extends TypeAnnotations {
+  kind: ReflectionKind.boolean;
+  parent?: Type;
+}
+interface TypeBigInt extends TypeAnnotations {
+  kind: ReflectionKind.bigint;
+  parent?: Type;
+}
+interface TypeSymbol extends TypeAnnotations {
+  kind: ReflectionKind.symbol;
+  parent?: Type;
+}
+interface TypeNull extends TypeAnnotations {
+  kind: ReflectionKind.null;
+  parent?: Type;
+}
+interface TypeUndefined extends TypeAnnotations {
+  kind: ReflectionKind.undefined;
+  parent?: Type;
+}
+interface TypeLiteral extends TypeAnnotations {
+  kind: ReflectionKind.literal;
+  literal: symbol | string | number | boolean | bigint | RegExp;
+  parent?: Type;
+}
+interface TypeTemplateLiteral extends TypeAnnotations {
+  kind: ReflectionKind.templateLiteral;
+  types: (TypeString | TypeAny | TypeNumber | TypeLiteral | TypeInfer)[];
+  parent?: Type;
+}
+interface TypeRegexp extends TypeAnnotations {
+  kind: ReflectionKind.regexp;
+  parent?: Type;
+}
+interface TypeBaseMember extends TypeAnnotations {
+  visibility: ReflectionVisibility;
+  abstract?: true;
+  static?: true;
+  optional?: true;
+  readonly?: true;
+  tags?: TagsReflection;
+}
+interface TypeParameter extends TypeAnnotations {
+  kind: ReflectionKind.parameter;
+  name: string;
+  type: Type;
+  parent: TypeFunction | TypeMethod | TypeMethodSignature | TypeCallSignature;
+  visibility?: ReflectionVisibility;
+  readonly?: true;
+  optional?: true;
+  description?: string;
+  /**
+   * Set when the parameter has a default value aka initializer.
+   */
+  default?: (() => any) | any;
+  tags?: TagsReflection;
+}
+interface TypeMethod extends TypeBaseMember {
+  kind: ReflectionKind.method;
+  parent: TypeClass;
+  name: number | string | symbol;
+  description?: string;
+  parameters: TypeParameter[];
+  return: Type;
+}
+interface TypeProperty extends TypeBaseMember {
+  kind: ReflectionKind.property;
+  parent: TypeClass;
+  visibility: ReflectionVisibility;
+  name: number | string | symbol;
+  description?: string;
+  type: Type;
+  /**
+   * Set when the property has a default value aka initializer.
+   */
+  default?: (() => any) | any;
+}
+interface TypeFunction extends TypeAnnotations {
+  kind: ReflectionKind.function;
+  parent?: Type;
+  name?: number | string | symbol;
+  description?: string;
+  function?: Function;
+  parameters: TypeParameter[];
+  return: Type;
+  tags?: TagsReflection;
+}
+interface TypeCallSignature extends TypeAnnotations {
+  kind: ReflectionKind.callSignature;
+  parent?: Type;
+  parameters: TypeParameter[];
+  return: Type;
+  tags?: TagsReflection;
+}
+interface TypePromise extends TypeAnnotations {
+  kind: ReflectionKind.promise;
+  parent?: Type;
+  type: Type;
+}
+interface TypeClass extends TypeAnnotations {
+  kind: ReflectionKind.class;
+  parent?: Type;
+  classType: ClassType;
+  description?: string;
+  /**
+   * When the class extends another class and uses on it generic type arguments, then those arguments
+   * are in this array.
+   * For example `class A extends B<string, boolean> {}` then extendsArguments = [string, boolean].
+   * The reference to `B` is not part of TypeClass since this information is available in JavaScript runtime
+   * by using `Object.getPrototypeOf(type.classType)`.
+   */
+  extendsArguments?: Type[];
+  /**
+   * When the class implements another interface/type, then those types are in this array.
+   *
+   * For example `class A implements B<string, boolean> {}` then implements = [B<string, boolean>].
+   */
+  implements?: Type[];
+  /**
+   * When class has generic type arguments, e.g. MyClass<string>, it contains
+   * all type arguments. If no type arguments are given, it's undefined.
+   */
+  arguments?: Type[];
+  /**
+   * properties/methods.
+   */
+  types: (TypeIndexSignature | TypeProperty | TypeMethod)[];
+  tags?: TagsReflection;
+}
+interface TypeEnum extends TypeAnnotations {
+  kind: ReflectionKind.enum;
+  parent?: Type;
+  enum: {
+    [name: string]: string | number | undefined | null;
+  };
+  values: (string | number | undefined | null)[];
+  indexType: Type;
+  description?: string;
+  tags?: TagsReflection;
+}
+interface TypeEnumMember extends TypeAnnotations {
+  kind: ReflectionKind.enumMember;
+  parent: TypeEnum;
+  name: string;
+  description?: string;
+  default?: (() => string | number) | string | number;
+  tags?: TagsReflection;
+}
+interface TypeTypeParameter extends TypeAnnotations {
+  kind: ReflectionKind.typeParameter;
+  parent?: Type;
+  name: string;
+  tags?: TagsReflection;
+}
+interface TypeUnion extends TypeAnnotations {
+  kind: ReflectionKind.union;
+  parent?: Type;
+  types: Type[];
+}
+interface TypeIntersection extends TypeAnnotations {
+  kind: ReflectionKind.intersection;
+  parent?: Type;
+  types: Type[];
+}
+interface TypeArray extends TypeAnnotations {
+  kind: ReflectionKind.array;
+  parent?: Type;
+  type: Type;
+  tags?: TagsReflection;
+}
+interface TypePropertySignature extends TypeAnnotations {
+  kind: ReflectionKind.propertySignature;
+  parent: TypeObjectLiteral;
+  name: number | string | symbol;
+  optional?: true;
+  readonly?: true;
+  description?: string;
+  type: Type;
+  /**
+   * Set when the property has a default value aka initializer.
+   */
+  default?: (() => any) | any;
+  tags?: TagsReflection;
+}
+interface TypeMethodSignature extends TypeAnnotations {
+  kind: ReflectionKind.methodSignature;
+  parent: TypeObjectLiteral;
+  name: number | string | symbol;
+  optional?: true;
+  description?: string;
+  parameters: TypeParameter[];
+  return: Type;
+  tags?: TagsReflection;
+}
+/**
+ * Object literals or interfaces.
+ */
+interface TypeObjectLiteral extends TypeAnnotations {
+  kind: ReflectionKind.objectLiteral;
+  parent?: Type;
+  description?: string;
+  types: (TypeIndexSignature | TypePropertySignature | TypeMethodSignature | TypeCallSignature)[];
+  /**
+   * When the interface extends another interface/type, then those types are in this array.
+   *
+   * For example `interface A extends B<string, boolean> {}` then implements = [B<string, boolean>].
+   */
+  implements?: Type[];
+  tags?: TagsReflection;
+}
+interface TypeIndexSignature extends TypeAnnotations {
+  kind: ReflectionKind.indexSignature;
+  parent: TypeClass | TypeObjectLiteral;
+  index: Type;
+  type: Type;
+  /**
+   * Set when the property has a default value aka initializer.
+   */
+  default?: (() => any) | any;
+  tags?: TagsReflection;
+}
+interface TypeInfer extends TypeAnnotations {
+  kind: ReflectionKind.infer;
+  parent?: Type;
+  set(type: Type): void;
+}
+interface TypeTupleMember extends TypeAnnotations {
+  kind: ReflectionKind.tupleMember;
+  parent: TypeTuple;
+  type: Type;
+  optional?: true;
+  name?: string;
+}
+interface TypeTuple extends TypeAnnotations {
+  kind: ReflectionKind.tuple;
+  parent?: Type;
+  types: TypeTupleMember[];
+}
+interface TypeRest extends TypeAnnotations {
+  kind: ReflectionKind.rest;
+  parent: TypeTypeParameter | TypeTupleMember;
+  type: Type;
+}
+/**
+ * @reflection never
+ */
+type Type = TypeNever | TypeAny | TypeUnknown | TypeVoid | TypeObject | TypeString | TypeNumber | TypeBoolean | TypeBigInt | TypeSymbol | TypeNull | TypeUndefined | TypeLiteral | TypeTemplateLiteral | TypeParameter | TypeFunction | TypeMethod | TypeProperty | TypePromise | TypeClass | TypeEnum | TypeEnumMember | TypeUnion | TypeIntersection | TypeArray | TypeObjectLiteral | TypeIndexSignature | TypePropertySignature | TypeMethodSignature | TypeTypeParameter | TypeInfer | TypeTuple | TypeTupleMember | TypeRest | TypeRegexp | TypeCallSignature;
+type Widen<T> = T extends string ? string : T extends number ? number : T extends bigint ? bigint : T extends boolean ? boolean : T extends symbol ? symbol : T;
+type FindType<T extends Type, LOOKUP extends ReflectionKind> = T extends {
+  kind: infer K;
+} ? K extends LOOKUP ? T : never : never;
+/**
+ * Merge dynamic runtime types with static types. In the type-system resolves as any, in runtime as the correct type.
+ *
+ * ```typescript
+ * const stringType = {kind: ReflectionKind.string};
+ * type t = {a: InlineRuntimeType<typeof stringType>}
+ *
+ * const value = 34;
+ * type t = {a: InlineRuntimeType<typeof value>}
+ * ```
+ */
+type InlineRuntimeType<T extends ReflectionClass<any> | Type | number | string | boolean | bigint> = T extends ReflectionClass<infer K> ? K : any;
+declare function isType(entry: any): entry is Type;
+declare function isBinary(type: Type): boolean;
+declare function isPrimitive<T extends Type>(type: T): boolean;
+declare function isPropertyType(type: Type): type is TypePropertySignature | TypeProperty;
+/**
+ * Returns true if the type is TypePropertySignature | TypeProperty and not a static member.
+ */
+declare function isPropertyMemberType(type: Type): type is TypePropertySignature | TypeProperty;
+/**
+ * Return all properties created in the constructor (via `constructor(public title: string)`)
+ *
+ * If a non-property parameter is in the constructor, the type is given instead, e.g. `constructor(public title: string, anotherOne:number)` => [TypeProperty, TypeNumber]
+ */
+declare function getConstructorProperties(type: TypeClass | TypeObjectLiteral): {
+  parameters: (TypeProperty | Type)[];
+  properties: TypeProperty[];
+};
+type WithAnnotations = TypeAny | TypeUnknown | TypeString | TypeNumber | TypeBigInt | TypeBoolean | TypeArray | TypeTuple | TypeLiteral | TypeNull | TypeUndefined | TypeClass | TypeObjectLiteral | TypeObject | TypeTemplateLiteral | TypeRegexp | TypeSymbol;
+declare function isWithAnnotations(type: ParentLessType): type is WithAnnotations;
+declare function getAnnotations(type: WithAnnotations): Annotations;
+type StackEntry$1 = {
+  left: Type;
+  right: Type;
+};
+/**
+ * Checks if the structure of a and b are identical.
+ */
+declare function isSameType(a: Type, b: Type, stack?: StackEntry$1[]): boolean;
+declare function addType<T extends Type>(container: T, type: Type): T;
+declare function isTypeIncluded(types: Type[], type: Type, stack?: StackEntry$1[]): boolean;
+/**
+ * `true | (string | number)` => `true | string | number`
+ */
+declare function flatten<T extends Type>(type: T): T;
+/**
+ * Flatten nested union types.
+ */
+declare function flattenUnionTypes(types: Type[]): Type[];
+/**
+ * empty union => never
+ * union with one member => member
+ * otherwise the union is returned
+ */
+declare function unboxUnion(union: TypeUnion): Type;
+declare function findMember(index: string | number | symbol | TypeTemplateLiteral, types: Type[]): TypePropertySignature | TypeMethodSignature | TypeMethod | TypeProperty | TypeIndexSignature | undefined;
+interface CStack {
+  iterator: Type[];
+  i: number;
+  round: number;
+}
+declare function emptyObject(type: Type): boolean;
+declare class CartesianProduct {
+  protected stack: CStack[];
+  private current;
+  private next;
+  toGroup(type: Type): Type[];
+  add(item: Type): void;
+  calculate(): Type[][];
+}
+/**
+ * Query a container type and return the result.
+ *
+ * container[index]
+ *
+ * e.g. {a: string}['a'] => string
+ * e.g. {a: string, b: number}[keyof T] => string | number
+ * e.g. [string, number][0] => string
+ * e.g. [string, number][number] => string | number
+ */
+declare function indexAccess(container: Type, index: Type): Type;
+declare function merge(types: (TypeObjectLiteral | TypeClass)[]): TypeObjectLiteral;
+declare function narrowOriginalLiteral(type: Type): Type;
+type GetArrayElement<T extends any[]> = [T] extends [Array<infer K>] ? K : never;
+type RemoveParent<T, K extends keyof T> = { [P in K]: T[P] extends Type[] ? RemoveParentHomomorphic<GetArrayElement<T[P]>>[] : T[P] extends Type ? RemoveParentHomomorphic<T[P]> : T[P] };
+type RemoveParentHomomorphic<T> = RemoveParent<T, Exclude<keyof T, "parent">>;
+type RemoveDeepParent<T extends Type> = T extends infer K ? RemoveParentHomomorphic<K> : never;
+type ParentLessType = RemoveDeepParent<Type>;
+/**
+ * This function does not do a deep copy, only shallow. A deep copy makes it way to inefficient, so much that router.spec.ts takes up to 20-30seconds
+ * to complete instead of barely 30ms.
+ */
+declare function copyAndSetParent<T extends ParentLessType>(inc: T, parent?: Type): FindType<Type, T["kind"]>;
+declare function widenLiteral(type: Type): Type;
+declare function assertType<K extends ReflectionKind, T>(t: Type | undefined, kind: K): asserts t is FindType<Type, K>;
+declare function getClassType(type: Type): ClassType;
+declare function isMember(type: Type): type is TypePropertySignature | TypeProperty | TypeMethodSignature | TypeMethod;
+declare function hasMember(type: TypeObjectLiteral | TypeClass, memberName: number | string | symbol, memberType?: Type): boolean;
+declare function getMember(type: TypeObjectLiteral | TypeClass, memberName: number | string | symbol): TypeMethodSignature | TypeMethod | TypePropertySignature | TypeProperty | void;
+declare function getTypeObjectLiteralFromTypeClass<T extends Type>(type: T): T extends TypeClass ? TypeObjectLiteral : T;
+/**
+ * Checks whether `undefined` is allowed as type.
+ */
+declare function isOptional(type: Type): boolean;
+/**
+ * Whether a property has an initializer/default value.
+ */
+declare function hasDefaultValue(type: Type): boolean;
+/**
+ * Checks whether `null` is allowed as type.
+ */
+declare function isNullable(type: Type): boolean;
+/**
+ * Get tags from type.
+ */
+declare function getTags(type: Type): TagsReflection;
+/**
+ * Checks whether the \`hidden\` tag was specified for the type.
+ */
+declare function isHidden(type: Type): boolean;
+/**
+ * Checks whether the \`ignore\` tag was specified for the type.
+ */
+declare function isIgnore(type: Type): boolean;
+/**
+ * Checks whether the \`internal\` tag was specified for the type.
+ */
+declare function isInternal(type: Type): boolean;
+/**
+ * Checks whether the \`runtime\` tag was specified for the type.
+ */
+declare function isRuntime(type: Type): boolean;
+/**
+ * Returns the values specified by the type's \`alias\` tag(s).
+ */
+declare function getAlias(type: Type): string[];
+/**
+ * Checks whether the \`readonly\` tag was specified for the type.
+ */
+declare function isReadonly(type: Type): boolean;
+/**
+ * Returns the values specified by the type's \`title\` tag.
+ */
+declare function getTitle(type: Type): string | undefined;
+/**
+ * Returns the values specified by the type's \`permission\` tag(s).
+ */
+declare function getPermission(type: Type): string[];
+/**
+ * Returns the values specified by the type's \`domain\` tag.
+ */
+declare function getDomain(type: Type): string | undefined;
+/**
+ * Integer
+ */
+type integer = number;
+/**
+ * Integer 8 bit.
+ * Min value -127, max value 128
+ */
+type int8 = number;
+/**
+ * Unsigned integer 8 bit.
+ * Min value 0, max value 255
+ */
+type uint8 = number;
+/**
+ * Integer 16 bit.
+ * Min value -32768, max value 32767
+ */
+type int16 = number;
+/**
+ * Unsigned integer 16 bit.
+ * Min value 0, max value 65535
+ */
+type uint16 = number;
+/**
+ * Integer 8 bit.
+ * Min value -2147483648, max value 2147483647
+ */
+type int32 = number;
+/**
+ * Unsigned integer 32 bit.
+ * Min value 0, max value 4294967295
+ */
+type uint32 = number;
+/**
+ * Float (same as number, but different semantic for databases).
+ */
+type float = number;
+/**
+ * Float 32 bit.
+ */
+type float32 = number;
+/**
+ * Float 64 bit.
+ */
+type float64 = number;
+declare class AnnotationDefinition<T = true> {
+  readonly id: string;
+  symbol: symbol;
+  constructor(id: string);
+  register(annotations: Annotations, data: T): void;
+  reset(annotations: Annotations): void;
+  registerType<TType extends Type>(type: TType, data: T): TType;
+  replace(annotations: Annotations, annotation: T[]): void;
+  replaceType(type: Type, annotation: T[]): void;
+  getAnnotations(type: Type): T[];
+  getFirst(type: Type): T | undefined;
+  hasAnnotations(type: Type): boolean;
+}
+type AnnotationType<T extends AnnotationDefinition<any>> = T extends AnnotationDefinition<infer K> ? K : never;
+type ReferenceActions = "RESTRICT" | "NO ACTION" | "CASCADE" | "SET NULL" | "SET DEFAULT";
+interface ReferenceOptions {
+  /**
+   * Default is CASCADE.
+   */
+  onDelete?: ReferenceActions;
+  /**
+   * Default is CASCADE.
+   */
+  onUpdate?: ReferenceActions;
+}
+/**
+ * note: if this is adjusted, make sure to adjust ReflectionClass, entityAnnotation, and type serializer accordingly.
+ */
+interface EntityOptions {
+  name?: string;
+  description?: string;
+  collection?: string;
+  database?: string;
+  singleTableInheritance?: boolean;
+  indexes?: {
+    names: string[];
+    options: IndexOptions;
+  }[];
+}
+/**
+ * Type to decorate an interface/object literal with entity information.
+ *
+ * ```typescript
+ * interface User extends Entity<{name: 'user'}> {
+ *     id: number & PrimaryKey & AutoIncrement;
+ *     username: string & Unique;
+ * }
+ * ```
+ */
+type Entity<T extends EntityOptions> = {} & TypeAnnotation<"entity", T>;
+/**
+ * Marks a property as primary key.
+ * ```typescript
+ * class Entity {
+ *     id: number & Primary = 0;
+ * }
+ * ```
+ */
+type PrimaryKey = TypeAnnotation<"primaryKey">;
+type TypeKeyOf<T> = T[keyof T];
+type PrimaryKeyFields<T> = any extends T ? any : { [P in keyof T]: Required<T[P]> extends Required<PrimaryKey> ? T[P] : never };
+type PrimaryKeyType<T> = any extends T ? any : TypeKeyOf<PrimaryKeyFields<T>>;
+type ReferenceFields<T> = { [P in keyof T]: Required<T[P]> extends Required<Reference> | Required<BackReference> ? T[P] : never };
+/**
+ * Marks a primary property key as auto-increment.
+ *
+ * ```typescript
+ * class Entity {
+ *     id: number & Primary & AutoIncrement = 0;
+ * }
+ * ```
+ */
+type AutoIncrement = TypeAnnotation<"autoIncrement">;
+/**
+ * UUID v4, as string, serialized as string in JSON, and binary in database.
+ * Use `uuid()` as handy initializer.
+ *
+ * ```typescript
+ * class Entity {
+ *     id: UUID = uuid();
+ * }
+ * ```
+ */
+type UUID = string & TypeAnnotation<"UUIDv4">;
+/**
+ * MongoDB's ObjectID type. serialized as string in JSON, ObjectID in database.
+ */
+type MongoId = string & TypeAnnotation<"mongoId">;
+/**
+ * Same as `bigint` but serializes to unsigned binary with unlimited size (instead of 8 bytes in most databases).
+ * Negative values will be converted to positive (abs(x)).
+ *
+ * ```typescript
+ * class Entity {
+ *     id: BinaryBigInt = 0n;
+ * }
+ * ```
+ */
+type BinaryBigInt = bigint & TypeAnnotation<"binaryBigInt">;
+/**
+ * Same as `bigint` but serializes to signed binary with unlimited size (instead of 8 bytes in most databases).
+ * The binary has an additional leading sign byte and is represented as an uint: 255 for negative, 0 for zero, or 1 for positive.
+ *
+ * ```typescript
+ * class Entity {
+ *     id: SignedBinaryBigInt = 0n;
+ * }
+ * ```
+ */
+type SignedBinaryBigInt = bigint & TypeAnnotation<"signedBinaryBigInt">;
+interface BackReferenceOptions {
+  /**
+   * Necessary for normalised many-to-many relations. This defines the class of the pivot table/collection.
+   */
+  via?: ClassType | {};
+  /**
+   * A reference/backReference can define which reference on the other side
+   * reference back. This is necessary when there are multiple outgoing references
+   * to the same entity.
+   */
+  mappedBy?: string;
+}
+type Reference<Options extends ReferenceOptions = {}> = TypeAnnotation<"reference", Options>;
+type BackReference<Options extends BackReferenceOptions = {}> = TypeAnnotation<"backReference", Options>;
+type EmbeddedMeta<Options> = TypeAnnotation<"embedded", Options>;
+type Embedded<T, Options extends {
+  prefix?: string;
+} = {}> = T & EmbeddedMeta<Options>;
+type MapName<Alias extends string, ForSerializer extends string = ""> = TypeAnnotation<"mapName", [Alias, ForSerializer]>;
+declare const referenceAnnotation: AnnotationDefinition<ReferenceOptions>;
+declare const entityAnnotation: {
+  set<K extends keyof EntityOptions>(type: Type, name: K, value: EntityOptions[K]): void;
+  get(type: Type): EntityOptions;
+  symbol: symbol;
+  readonly id: string;
+  register(annotations: Annotations, data: EntityOptions): void;
+  reset(annotations: Annotations): void;
+  registerType<TType extends Type>(type: TType, data: EntityOptions): TType;
+  replace(annotations: Annotations, annotation: EntityOptions[]): void;
+  replaceType(type: Type, annotation: EntityOptions[]): void;
+  getAnnotations(type: Type): EntityOptions[];
+  getFirst(type: Type): EntityOptions | undefined;
+  hasAnnotations(type: Type): boolean;
+};
+declare const mapNameAnnotation: AnnotationDefinition<{
+  name: string;
+  serializer?: string;
+}>;
+declare const autoIncrementAnnotation: AnnotationDefinition<true>;
+declare const primaryKeyAnnotation: {
+  isPrimaryKey(type: Type): boolean;
+  symbol: symbol;
+  readonly id: string;
+  register(annotations: Annotations, data: true): void;
+  reset(annotations: Annotations): void;
+  registerType<TType extends Type>(type: TType, data: true): TType;
+  replace(annotations: Annotations, annotation: true[]): void;
+  replaceType(type: Type, annotation: true[]): void;
+  getAnnotations(type: Type): true[];
+  getFirst(type: Type): true | undefined;
+  hasAnnotations(type: Type): boolean;
+};
+interface BackReferenceOptionsResolved {
+  /**
+   * Necessary for normalised many-to-many relations. This defines the class of the pivot table/collection.
+   */
+  via?: TypeClass | TypeObjectLiteral;
+  /**
+   * A reference/backReference can define which reference on the other side
+   * reference back. This is necessary when there are multiple outgoing references
+   * to the same entity.
+   */
+  mappedBy?: string;
+}
+declare const backReferenceAnnotation: AnnotationDefinition<BackReferenceOptionsResolved>;
+declare const validationAnnotation: AnnotationDefinition<{
+  name: string;
+  args: Type[];
+}>;
+declare const UUIDAnnotation: AnnotationDefinition<true>;
+declare const mongoIdAnnotation: AnnotationDefinition<true>;
+declare const uuidAnnotation: AnnotationDefinition<true>;
+declare const defaultAnnotation: AnnotationDefinition<Type>;
+declare function isUUIDType(type: Type): boolean;
+declare function isPrimaryKeyType(type: Type): boolean;
+declare function isAutoIncrementType(type: Type): boolean;
+declare function isMongoIdType(type: Type): boolean;
+declare function isBinaryBigIntType(type: Type): boolean;
+declare function isReferenceType(type: Type): boolean;
+declare function getReferenceType(type: Type): ReferenceOptions | undefined;
+declare function isBackReferenceType(type: Type): boolean;
+declare function resolveProperty(type: Type): Type;
+declare function getBackReferenceType(type: Type): BackReferenceOptionsResolved;
+declare function isDateType(type: Type): boolean;
+declare function isSetType(type: Type): boolean;
+declare function isMapType(type: Type): boolean;
+/**
+ * Get the key type of a Map or object literal with index signatures.
+ */
+declare function getKeyType(type: Type): Type;
+/**
+ * Get the value type of a Map or object literal with index signatures.
+ */
+declare function getValueType(type: Type): Type;
+interface EmbeddedOptions {
+  prefix?: string;
+}
+declare const embeddedAnnotation: AnnotationDefinition<EmbeddedOptions>;
+declare function hasEmbedded(type: Type): boolean;
+/**
+ * Assigns one or multiple groups to a type.
+ *
+ * @example
+ * ```typescript
+ * interface User {
+ *     username: string;
+ *     password: string & Group<'credentials'>;
+ * }
+ * ```
+ */
+type Group<Name extends string> = TypeAnnotation<"group", Name>;
+/**
+ * Excludes the type from serialization of all kind.
+ *
+ * @example
+ * ```typescript
+ * interface User {
+ *    username: string;
+ *    password: string & Excluded;
+ *  }
+ *  ```
+ */
+type Excluded<Name extends string = "*"> = TypeAnnotation<"excluded", Name>;
+/**
+ * Assigns arbitrary data to a type that can be read in runtime.
+ *
+ * @example
+ * ```typescript
+ * interface User {
+ *   username: string;
+ *   password: string & Data<'role', 'admin'>;
+ * }
+ * ```
+ */
+type Data<Name extends string, Value> = TypeAnnotation<"data", [Name, Value]>;
+/**
+ * Resets an already set decorator to undefined.
+ *
+ * The required Name is the name of the type decorator (its first tuple entry).
+ *
+ * ```typescript
+ * type Password = string & MinLength<6> & Excluded;
+ *
+ * interface UserCreationPayload {
+ *     password: Password & ResetAnnotation<'excluded'>
+ * }
+ * ```
+ */
+type ResetAnnotation<Name extends string> = TypeAnnotation<"reset", Name>;
+type IndexOptions = {
+  name?: string;
+  size?: number;
+  unique?: boolean;
+  spatial?: boolean;
+  sparse?: boolean;
+  fulltext?: boolean;
+  where?: string;
+  expireAfterSeconds?: number;
+};
+type Unique<Options extends IndexOptions = {}> = TypeAnnotation<"index", Options & {
+  unique: true;
+}>;
+type Index<Options extends IndexOptions = {}> = TypeAnnotation<"index", Options>;
+interface DatabaseFieldOptions {
+  /**
+   * The name of the column in the database.
+   * e.g. `userName: string & DatabaseField<{name: 'user_name'}>`
+   *
+   * Can alternatively also be configured by using a different NamingStrategy.
+   */
+  name?: string;
+  /**
+   *
+   * e.g. `field: string & MySQL<{type: 'VARCHAR(255)'}>`
+   */
+  type?: string;
+  /**
+   * If the property is on a class, its initializer/default value is per default used.
+   * This can be overridden using this option.
+   * e.g. `field: string & MySQL<{default: 'abc'}>`
+   */
+  default?: any;
+  /**
+   * e.g. `field: string & MySQL<{defaultExpr: 'NOW()'}>`
+   */
+  defaultExpr?: any;
+  /**
+   * If true no default column value is inferred from the property initializer/default value.
+   * e.g. `field: string & MySQL<{noDefault: true}> = ''`
+   */
+  noDefault?: true;
+  /**
+   * Skip this property in all queries and database migration files.
+   */
+  skip?: true;
+  /**
+   * Skip this property in database migration files. This excludes the property from the database, but
+   * keeps it in the queries.
+   */
+  skipMigration?: true;
+}
+interface MySQLOptions extends DatabaseFieldOptions {}
+interface PostgresOptions extends DatabaseFieldOptions {}
+interface SqliteOptions extends DatabaseFieldOptions {}
+type Database<Name extends string, Options extends {
+  [name: string]: any;
+}> = TypeAnnotation<"database", [Name, Options]>;
+type MySQL<Options extends MySQLOptions> = Database<"mysql", Options>;
+type Postgres<Options extends PostgresOptions> = Database<"postgres", Options>;
+type SQLite<Options extends SqliteOptions> = Database<"sqlite", Options>;
+type DatabaseField<Options extends DatabaseFieldOptions, Name extends string = "*"> = Database<Name, Options>;
+declare const enum BinaryBigIntType {
+  unsigned = 0,
+  signed = 1
+}
+declare const binaryBigIntAnnotation: AnnotationDefinition<BinaryBigIntType>;
+declare const groupAnnotation: AnnotationDefinition<string>;
+declare const excludedAnnotation: {
+  isExcluded(type: Type, name: string): boolean;
+  symbol: symbol;
+  readonly id: string;
+  register(annotations: Annotations, data: string): void;
+  reset(annotations: Annotations): void;
+  registerType<TType extends Type>(type: TType, data: string): TType;
+  replace(annotations: Annotations, annotation: string[]): void;
+  replaceType(type: Type, annotation: string[]): void;
+  getAnnotations(type: Type): string[];
+  getFirst(type: Type): string | undefined;
+  hasAnnotations(type: Type): boolean;
+};
+declare const dataAnnotation: {
+  set<T extends Type>(type: T, key: string, value: any): T;
+  get(type: Type, key: string): any;
+  symbol: symbol;
+  readonly id: string;
+  register(annotations: Annotations, data: {
+    [name: string]: any;
+  }): void;
+  reset(annotations: Annotations): void;
+  registerType<TType extends Type>(type: TType, data: {
+    [name: string]: any;
+  }): TType;
+  replace(annotations: Annotations, annotation: {
+    [name: string]: any;
+  }[]): void;
+  replaceType(type: Type, annotation: {
+    [name: string]: any;
+  }[]): void;
+  getAnnotations(type: Type): {
+    [name: string]: any;
+  }[];
+  getFirst(type: Type): {
+    [name: string]: any;
+  } | undefined;
+  hasAnnotations(type: Type): boolean;
+};
+/**
+ * All raw data from `TypeAnnotation<Name, Options>` types.
+ */
+declare const typeAnnotation: {
+  /**
+   * Returns the parsed Type to JS objects, e.g. `{name: string}` => `{name: 'xy'}`
+   */
+  getOption(type: Type, name: string): any;
+  /**
+   * Returns the Type object of the annotation which can be parsed with `typeToObject`.
+   */
+  getType(type: Type, name: string): Type | undefined;
+  symbol: symbol;
+  readonly id: string;
+  register(annotations: Annotations, data: {
+    name: string;
+    options: Type;
+  }): void;
+  reset(annotations: Annotations): void;
+  registerType<TType extends Type>(type: TType, data: {
+    name: string;
+    options: Type;
+  }): TType;
+  replace(annotations: Annotations, annotation: {
+    name: string;
+    options: Type;
+  }[]): void;
+  replaceType(type: Type, annotation: {
+    name: string;
+    options: Type;
+  }[]): void;
+  getAnnotations(type: Type): {
+    name: string;
+    options: Type;
+  }[];
+  getFirst(type: Type): {
+    name: string;
+    options: Type;
+  } | undefined;
+  hasAnnotations(type: Type): boolean;
+};
+declare const indexAnnotation: AnnotationDefinition<IndexOptions>;
+declare const databaseAnnotation: {
+  getDatabase<T extends DatabaseFieldOptions>(type: Type, name: string): T | undefined;
+  symbol: symbol;
+  readonly id: string;
+  register(annotations: Annotations, data: {
+    name: string;
+    options: {
+      [name: string]: any;
+    };
+  }): void;
+  reset(annotations: Annotations): void;
+  registerType<TType extends Type>(type: TType, data: {
+    name: string;
+    options: {
+      [name: string]: any;
+    };
+  }): TType;
+  replace(annotations: Annotations, annotation: {
+    name: string;
+    options: {
+      [name: string]: any;
+    };
+  }[]): void;
+  replaceType(type: Type, annotation: {
+    name: string;
+    options: {
+      [name: string]: any;
+    };
+  }[]): void;
+  getAnnotations(type: Type): {
+    name: string;
+    options: {
+      [name: string]: any;
+    };
+  }[];
+  getFirst(type: Type): {
+    name: string;
+    options: {
+      [name: string]: any;
+    };
+  } | undefined;
+  hasAnnotations(type: Type): boolean;
+};
+declare function registerTypeDecorator(decorator: TypeDecorator): void;
+/**
+ * Type annotations are object literals with a single optional __meta in it
+ * that has as type a tuple with the name of the annotation as first entry.
+ * The tuple is intersected with the `never` type to make sure it does not
+ * interfere with type checking.
+ *
+ * The processor has currently implemented to not resolve `never & x` to `never`,
+ * so we still have the intersection type in runtime to resolve __meta correctly.
+ *
+ * ```typescript
+ * type MyAnnotation1 = TypeAnnotation<'myAnnotation'>
+ * type MyAnnotation1<T> = TypeAnnotation<'myAnnotation', T>
+ *
+ * //under the hood it is:
+ * type lowLevel1 = { __meta?: never & ['myAnnotation'] }
+ * type lowLevel2<T> = { __meta?: never & ['myAnnotation', T] }
+ * ```
+ */
+declare function getAnnotationMeta(type: TypeObjectLiteral): {
+  id: string;
+  options: Type;
+} | undefined;
+declare const typeDecorators: TypeDecorator[];
+declare function typeToObject(type?: Type, state?: {
+  stack: Type[];
+}): any;
+declare function memberNameToString(name: number | string | symbol): string;
+declare const binaryTypes: ClassType[];
+/**
+ * Returns true if the given type is Date, ArrayBuffer, Uint8Array, etc.
+ */
+declare function isGlobalTypeClass(type: Type): type is TypeClass;
+/**
+ * Returns true if the given type is TypeClass and references a custom (non-global) class.
+ */
+declare function isCustomTypeClass(type: Type): type is TypeClass;
+/**
+ * Returns a type predicate that checks if the given type is a class and is of the given classType.
+ * If withInheritance is true, it also checks if the type is a subclass of the given classType.
+ */
+declare function isTypeClassOf(classType: ClassType, withInheritance?: boolean): (type: Type) => boolean;
+/**
+ * Returns the members of a class or object literal.
+ */
+declare function resolveTypeMembers(type: TypeClass | TypeObjectLiteral): (TypeProperty | TypePropertySignature | TypeMethodSignature | TypeMethod | TypeIndexSignature | TypeCallSignature)[];
+declare function stringifyResolvedType(type: Type): string;
+declare function stringifyShortResolvedType(type: Type, stateIn?: Partial<StringifyTypeOptions>): string;
+/**
+ * Returns all (including inherited) constructor properties of a class.
+ */
+declare function getDeepConstructorProperties(type: TypeClass): TypeParameter[];
+/**
+ * Returns the index to `type.values` if the given value is part of the enum, exactly or case-insensitive.
+ * Returns -1 if not found.
+ */
+declare function getEnumValueIndexMatcher(type: TypeEnum): (value: string | number | undefined | null) => number;
+interface StringifyTypeOptions {
+  showNames: boolean;
+  showFullDefinition: boolean;
+  showDescription: boolean;
+  defaultIsOptional: boolean;
+  showHeritage: boolean;
+  showDefaults: boolean;
+  showTags: boolean;
+  defaultValues: any;
+  stringify?: (type: Type) => string | undefined;
+}
+declare function stringifyType(type: Type, stateIn?: Partial<StringifyTypeOptions>): string;
+declare function annotateClass<T>(clazz: ClassType | AbstractClassType, type?: ReceiveType<T>): void;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/type-serialization.d.ts
+interface SerializedTypeAnnotations {
+  entityOptions?: EntityOptions;
+  typeName?: string;
+  typeArguments?: SerializedTypeReference[];
+  indexAccessOrigin?: {
+    container: SerializedTypeReference;
+    index: SerializedTypeReference;
+  };
+  decorators?: SerializedTypeReference[];
+}
+interface SerializedTypeObjectLiteral extends SerializedTypeAnnotations {
+  kind: ReflectionKind.objectLiteral;
+  types: SerializedTypeReference[];
+  tags?: TagsReflection;
+}
+interface SerializedTypeClassType extends SerializedTypeAnnotations {
+  kind: ReflectionKind.class;
+  name?: string;
+  globalObject?: true;
+  classType: string;
+  extendsArguments?: SerializedTypeReference[];
+  arguments?: SerializedTypeReference[];
+  superClass?: SerializedTypeReference;
+  types: SerializedTypeReference[];
+  tags?: TagsReflection;
+}
+interface SerializedTypeFunction extends SerializedTypeAnnotations {
+  kind: ReflectionKind.function;
+  name?: number | string | symbol;
+  parameters: SerializedTypeParameter[];
+  return: SerializedTypeReference;
+  tags?: TagsReflection;
+}
+type SerializedTypeReference = number;
+interface SimpleSerializedType extends SerializedTypeAnnotations {
+  kind: ReflectionKind.never | ReflectionKind.any | ReflectionKind.unknown | ReflectionKind.void | ReflectionKind.object | ReflectionKind.string | ReflectionKind.number | ReflectionKind.boolean | ReflectionKind.symbol | ReflectionKind.bigint | ReflectionKind.null | ReflectionKind.undefined | ReflectionKind.regexp;
+  origin?: SerializedTypeReference;
+}
+interface SerializedTypeLiteral extends SerializedTypeAnnotations {
+  kind: ReflectionKind.literal;
+  literal: {
+    type: "symbol";
+    name: string;
+  } | string | number | boolean | {
+    type: "bigint";
+    value: string;
+  } | {
+    type: "regex";
+    regex: string;
+  };
+}
+interface SerializedTypeTemplateLiteral extends SerializedTypeAnnotations {
+  kind: ReflectionKind.templateLiteral;
+  types: SerializedTypeReference[];
+}
+interface SerializedTypeParameter extends SerializedTypeAnnotations {
+  kind: ReflectionKind.parameter;
+  name: string;
+  type: SerializedTypeReference;
+  visibility?: ReflectionVisibility;
+  readonly?: true;
+  optional?: true;
+  /**
+   * Set when the parameter has a default value aka initializer.
+   */
+  default?: any;
+  tags?: TagsReflection;
+}
+interface SerializedTypeBaseMember extends SerializedTypeAnnotations {
+  visibility: ReflectionVisibility;
+  abstract?: true;
+  optional?: true;
+  readonly?: true;
+  tags?: TagsReflection;
+}
+interface SerializedTypeMethod extends SerializedTypeBaseMember {
+  kind: ReflectionKind.method;
+  visibility: ReflectionVisibility;
+  name: number | string | symbol;
+  parameters: SerializedTypeParameter[];
+  optional?: true;
+  abstract?: true;
+  return: SerializedTypeReference;
+}
+interface SerializedTypeProperty extends SerializedTypeBaseMember {
+  kind: ReflectionKind.property;
+  visibility: ReflectionVisibility;
+  name: number | string | symbol;
+  optional?: true;
+  readonly?: true;
+  abstract?: true;
+  description?: string;
+  type: SerializedTypeReference;
+  /**
+   * Set when the property has a default value aka initializer.
+   */
+  default?: any;
+}
+interface SerializedTypePromise extends SerializedTypeAnnotations {
+  kind: ReflectionKind.promise;
+  type: SerializedTypeReference;
+}
+interface SerializedTypeEnum extends SerializedTypeAnnotations {
+  kind: ReflectionKind.enum;
+  enum: {
+    [name: string]: string | number | undefined | null;
+  };
+  values: (string | number | undefined | null)[];
+  indexType: SerializedTypeReference;
+  tags?: TagsReflection;
+}
+interface SerializedTypeUnion extends SerializedTypeAnnotations {
+  kind: ReflectionKind.union;
+  types: SerializedTypeReference[];
+}
+interface SerializedTypeIntersection extends SerializedTypeAnnotations {
+  kind: ReflectionKind.intersection;
+  types: SerializedTypeReference[];
+}
+interface SerializedTypeArray extends SerializedTypeAnnotations {
+  kind: ReflectionKind.array;
+  type: SerializedTypeReference;
+  tags?: TagsReflection;
+}
+interface SerializedTypeIndexSignature extends SerializedTypeAnnotations {
+  kind: ReflectionKind.indexSignature;
+  index: SerializedTypeReference;
+  type: SerializedTypeReference;
+  /**
+   * Set when the parameter has a default value aka initializer.
+   */
+  default?: any;
+}
+interface SerializedTypePropertySignature extends SerializedTypeAnnotations {
+  kind: ReflectionKind.propertySignature;
+  name: number | string | symbol;
+  optional?: true;
+  readonly?: true;
+  description?: string;
+  type: SerializedTypeReference;
+  /**
+   * Set when the parameter has a default value aka initializer.
+   */
+  default?: any;
+  tags?: TagsReflection;
+}
+interface SerializedTypeMethodSignature extends SerializedTypeAnnotations {
+  kind: ReflectionKind.methodSignature;
+  name: number | string | symbol;
+  optional?: true;
+  parameters: SerializedTypeParameter[];
+  return: SerializedTypeReference;
+  tags?: TagsReflection;
+}
+interface SerializedTypeTypeParameter extends SerializedTypeAnnotations {
+  kind: ReflectionKind.typeParameter;
+  name: string;
+}
+interface SerializedTypeInfer extends SerializedTypeAnnotations {
+  kind: ReflectionKind.infer;
+}
+interface SerializedTypeTupleMember extends SerializedTypeAnnotations {
+  kind: ReflectionKind.tupleMember;
+  type: SerializedTypeReference;
+  optional?: true;
+  name?: string;
+}
+interface SerializedTypeTuple extends SerializedTypeAnnotations {
+  kind: ReflectionKind.tuple;
+  types: SerializedTypeTupleMember[];
+}
+interface SerializedTypeRest extends SerializedTypeAnnotations {
+  kind: ReflectionKind.rest;
+  type: SerializedTypeReference;
+}
+type SerializedType = SimpleSerializedType | SerializedTypeLiteral | SerializedTypeTemplateLiteral | SerializedTypeParameter | SerializedTypeFunction | SerializedTypeMethod | SerializedTypeProperty | SerializedTypePromise | SerializedTypeClassType | SerializedTypeEnum | SerializedTypeUnion | SerializedTypeIntersection | SerializedTypeArray | SerializedTypeObjectLiteral | SerializedTypeIndexSignature | SerializedTypePropertySignature | SerializedTypeMethodSignature | SerializedTypeTypeParameter | SerializedTypeInfer | SerializedTypeTuple | SerializedTypeTupleMember | SerializedTypeRest;
+type SerializedTypes = SerializedType[];
+interface SerializerState {
+  types: SerializedTypes;
+  disableMethods?: true;
+  refs: Map<Type, number>;
+}
+/**
+ * Converts a (possibly circular/nested) type into a JSON.stringify'able structure suited to be transmitted over the wire and deserialized back to the correct Type object.
+ */
+declare function serializeType(type: Type, state?: Partial<SerializerState>): SerializedTypes;
+interface DeserializeState {
+  types: SerializedTypes;
+  disableReuse?: boolean;
+  deserialized: {
+    [index: number]: {
+      type: Type;
+      refs: Type[];
+      active: boolean;
+    };
+  };
+}
+declare function deserializeType(types?: SerializedTypes, state?: Partial<DeserializeState>): Type;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/serializer.d.ts
+/**
+ * Make sure to change the id when a custom naming strategy is implemented, since caches are based on it.
+ */
+declare class NamingStrategy {
+  id: string;
+  constructor(id?: string);
+  getPropertyName(type: TypeProperty | TypePropertySignature, forSerializer: string): string | undefined;
+}
+declare const underscoreNamingStrategy: {
+  getPropertyName(type: TypeProperty | TypePropertySignature, forSerializer: string): string | undefined;
+  id: string;
+};
+/**
+ * Options that can be passed to the serialization/deserialization functions
+ * and change the behavior in runtime (not embedded in JIT).
+ */
+interface SerializationOptions {
+  /**
+   * Which groups to include. If a property is not assigned to
+   * a given group, it will be excluded.
+   * Use an empty array to include only non-grouped properties.
+   */
+  groups?: string[];
+  /**
+   * Which groups to exclude. If a property is assigned to at least
+   * one given group, it will be excluded. Basically the opposite of
+   * `groups`, but you can combine both.
+   * Use an empty array to exclude only non-grouped properties.
+   */
+  groupsExclude?: string[];
+  /**
+   * Allows more loosely data for certain types. e.g.
+   *
+   * - '1', '0', 'true', 'false' will be converted to true|false for boolean type.
+   * - '1' will be converted to number for number type.
+   * - 1 will be converted to string for string type.
+   *
+   * This will activate all registered type guards with negative specifically.
+   *
+   * This is enabled by default.
+   */
+  loosely?: boolean;
+}
+type SerializeFunction<T = any, R = any> = (data: T, state?: SerializationOptions) => R;
+declare function getPartialType(type: TypeClass | TypeObjectLiteral): any;
+/**
+ * Creates a (cached) Partial<T> of the given type and returns a (cached) serializer function for the given registry (serialize or deserialize).
+ */
+declare function getPartialSerializeFunction(type: TypeClass | TypeObjectLiteral, registry: TemplateRegistry, namingStrategy?: NamingStrategy): SerializeFunction<any, any>;
+/**
+ * Returns a (cached) serializer function for the given registry (serialize or deserialize).
+ */
+declare function getSerializeFunction(type: Type, registry: TemplateRegistry, namingStrategy?: NamingStrategy, path?: string, jitStack?: JitStack): SerializeFunction;
+declare function createSerializeFunction(type: Type, registry: TemplateRegistry, namingStrategy?: NamingStrategy, path?: string | RuntimeCode | (string | RuntimeCode)[], jitStack?: JitStack): SerializeFunction;
+type Guard<T> = (data: any, state?: {
+  errors?: ValidationErrorItem[];
+}) => data is T;
+declare function createTypeGuardFunction(type: Type, stateIn?: Partial<TemplateState>, serializerToUse?: Serializer, withLoose?: boolean): undefined | Guard<any>;
+declare class SerializationError extends CustomError {
+  originalMessage: string;
+  code: string;
+  path: string;
+  constructor(originalMessage: string, code?: string, path?: string);
+}
+declare class RuntimeCode {
+  code: string;
+  constructor(code: string);
+}
+declare function collapsePath(path: (string | RuntimeCode)[], prefix?: string): string;
+declare function getPropertyNameString(propertyName?: string | RuntimeCode): string;
+/**
+ * internal: The jit stack cache is used in both serializer and guards, so its cache key needs to be aware of it
+ */
+declare class JitStack {
+  protected stacks: {
+    registry?: TemplateRegistry;
+    map: Map<Type, {
+      fn: Function | undefined;
+      id: number;
+    }>;
+  }[];
+  protected id: number;
+  getStack(registry?: TemplateRegistry): Map<Type, {
+    fn: Function | undefined;
+    id: number;
+  }>;
+  has(registry: TemplateRegistry, type: Type): boolean;
+  get(registry: TemplateRegistry, type: Type): {
+    fn: Function | undefined;
+    id: number;
+  } | undefined;
+  prepare(registry: TemplateRegistry, type: Type): {
+    id: number;
+    prepare: (fn: Function) => {
+      fn: Function | undefined;
+    };
+  };
+  getOrCreate(registry: TemplateRegistry | undefined, type: Type, create: () => Function): {
+    fn: Function | undefined;
+    id: number;
+  };
+}
+declare class ContainerAccessor {
+  container: string | ContainerAccessor;
+  property: string;
+  constructor(container: string | ContainerAccessor, property: string);
+  toString(): string;
+}
+declare class TemplateState {
+  originalSetter: string | ContainerAccessor;
+  originalAccessor: string | ContainerAccessor;
+  compilerContext: CompilerContext;
+  registry: TemplateRegistry;
+  namingStrategy: NamingStrategy;
+  jitStack: JitStack;
+  path: (string | RuntimeCode)[];
+  /**
+   * Before and after template content is rendered before/after all other templates.
+   * When a template is put into its own function, before/after templates are run outside of this function.
+   */
+  template: string;
+  ended: boolean;
+  setter: string | ContainerAccessor;
+  accessor: string | ContainerAccessor;
+  /**
+   * Strict means only use type guards of specificality of 1 (used for is()/validation()).
+   * For deserialization loose is used.
+   */
+  validation?: "strict" | "loose";
+  /**
+   * When this is set all specificalities are used (used in union type guards to detect which member to pick).
+   */
+  allSpecificalities?: TypeGuardRegistry;
+  propertyName?: string | RuntimeCode;
+  setterDisabled: boolean;
+  parentTypes: Type[];
+  target: "serialize" | "deserialize";
+  protected handledAnnotations: AnnotationDefinition[];
+  constructor(originalSetter: string | ContainerAccessor, originalAccessor: string | ContainerAccessor, compilerContext: CompilerContext, registry: TemplateRegistry, namingStrategy?: NamingStrategy, jitStack?: JitStack, path?: (string | RuntimeCode)[]);
+  isValidation(): boolean;
+  withValidation(validation: this["validation"]): this;
+  includeAllSpecificalities(guardRegistry: TypeGuardRegistry): this;
+  replaceTemplate(template: string): void;
+  /**
+   * Forks as state, with an empty propertyName.
+   */
+  fork(setter?: string | ContainerAccessor, accessor?: string | ContainerAccessor, path?: (string | RuntimeCode)[]): TemplateState;
+  fullFork(): TemplateState;
+  forRegistry(registry: TemplateRegistry): this;
+  forPropertyName(name?: string | number | symbol | RuntimeCode): this;
+  disableSetter(): this;
+  enableSetter(): this;
+  /**
+   * Can be used to track which annotation was already handled. Necessary to use with `isAnnotationHandled` to avoid infinite recursive loops
+   * when a serializer template issues sub calls depending on annotation data.
+   */
+  annotationHandled(annotation: AnnotationDefinition<any>): void;
+  isAnnotationHandled(annotation: AnnotationDefinition<any>): boolean;
+  get isSerialization(): boolean;
+  get isDeserialization(): boolean;
+  extendPath(path: string | RuntimeCode | number | symbol): this;
+  assignValidationError(code: string, message: string): string;
+  throwCode(type: Type | string, error?: string, accessor?: string | ContainerAccessor): string;
+  /**
+   * Adds template code for setting the `this.setter` variable. The expression evaluated in `code` is assigned to `this.setter`.
+   * `this.accessor` will point now to `this.setter`.
+   */
+  addSetter(code: string | {
+    toString(): string;
+  }): void;
+  addSetterAndReportErrorIfInvalid(errorCode: string, message: string, code: string): void;
+  /**
+   * Adds a converter function that is executed on the current `this.accessor` value.
+   *
+   * @example
+   * ```typescript
+   * serializer.deserializeRegistry.registerClass(Date, (type, state) => {
+   *     // make sure to check `v` as it is any!
+   *     state.convert((v: any) => {
+   *         if ('number' !== typeof v) throw new SerializationError('Expected number');
+   *         return new Date(v);
+   *     });
+   * });
+   *
+   * serializer.serializeRegistry.registerClass(Date, (type, state) => {
+   *     // in serialization `v` is always the specific type
+   *     state.convert((v: Date) => v.getTime());
+   * });
+   * ```
+   */
+  convert(callback: (value: any) => any): void;
+  /**
+   * Allows to add a custom code that is executed on the current `this.accessor` value.
+   *
+   * @example
+   * ```typescript
+   * serializer.deserializeRegistry.addDecorator(
+   *     isCustomTypeClass,
+   *     (type, state) => {
+   *         state.touch((value) => {
+   *              if ('onLoad' in value) value.onLoad();
+   *         });
+   *     }
+   * );
+   * ```
+   */
+  touch(callback: (value: any) => void): void;
+  /**
+   * Stop executing next templates.
+   */
+  stop(): void;
+  setVariable(name: string, value?: any): string;
+  setContext(values: {
+    [name: string]: any;
+  }): void;
+  addCode(code: string): void;
+  /**
+   * Adds template code for setting the `this.setter` variable manually, so use `${state.setter} = value`.
+   * `this.accessor` will point now to `this.setter`.
+   */
+  addCodeForSetter(code: string): void;
+  hasSetterCode(): boolean;
+}
+type Template<T extends Type> = (type: T, state: TemplateState) => void;
+type TemplateHook = (type: Type, state: TemplateState) => void;
+/**
+ * Just sets the state.setter to state.accessor without any modification.
+ */
+declare function noopTemplate(type: Type, state: TemplateState): void;
+interface TemplateDecorator {
+  predicate: (type: Type) => boolean;
+  template: Template<any>;
+}
+declare class TemplateRegistry {
+  serializer: Serializer;
+  protected static ids: number;
+  id: number;
+  protected templates: { [kind in ReflectionKind]?: Template<any>[] };
+  protected decorator: TemplateDecorator[];
+  preHooks: TemplateHook[];
+  postHooks: TemplateHook[];
+  classTemplates: Map<ClassType<any>, Template<any>[]>;
+  constructor(serializer?: Serializer);
+  clear(): void;
+  get(type: Type): Template<Type>[];
+  getDecorator(type: Type): Template<Type>[];
+  /**
+   * Registers a template for all binary classes: ArrayBuffer, Uint8Array, Int8Array, etc.
+   */
+  registerBinary(template: Template<TypeClass>): void;
+  /**
+   * Registers a template for a given class type.
+   *
+   * As soon as a single template has registered for the given classType the template registry
+   * only returns templates for this particular classType and omits all general purpose ReflectionKind.class templates for this particular classType.
+   */
+  registerClass(classType: ClassType, template: Template<TypeClass>): void;
+  prependClass(classType: ClassType, template: Template<TypeClass>): void;
+  appendClass(classType: ClassType, template: Template<TypeClass>): void;
+  protected getClassTemplates(classType: ClassType): Template<TypeClass>[];
+  addPreHook(callback: TemplateHook): void;
+  addPostHook(callback: TemplateHook): void;
+  /**
+   * Removes all registered templates.
+   */
+  unregister(kind: ReflectionKind): void;
+  /**
+   * Registers a new template and replaces all existing (added via register,prepend,append).
+   */
+  register<T extends ReflectionKind>(kind: T, template: Template<FindType<Type, T>>): void;
+  /**
+   * Registers additional templates that handle type decorators/annotations. The templates can safely assume that the given type in `state.accessor`
+   * is already type-checked to be `T`.
+   *
+   * Decorator templates run last (after normal templates and postHook).
+   *
+   * This split between register and registerForDecorator is made to have a distinction between native type templates and additional user-made templates.
+   * This allows to fetch only decorator templates and decide upon the result whether additional code is necessary or not. (this would not be possible
+   * if everything is added to the `register` call that does always the basic checks).
+   */
+  addDecorator(predicate: (type: Type) => boolean, template: Template<Type>): void;
+  /**
+   * Removes all registered decorators for a certain type.
+   */
+  removeDecorator(type: Type): void;
+  prepend<T extends ReflectionKind>(kind: T, template: Template<FindType<Type, T>>): void;
+  append<T extends ReflectionKind>(kind: T, template: Template<FindType<Type, T>>): void;
+}
+/**
+ * To avoid circular builds, class/object literal code is extract to its own function.
+ * if this returns true, code is put into state to call an already existing function.
+ */
+declare function callExtractedFunctionIfAvailable(state: TemplateState, type: Type): boolean;
+declare function extractStateToFunctionAndCallIt(state: TemplateState, type: Type): {
+  setFunction: (fn: Function) => {
+    fn: Function | undefined;
+  };
+  id: number;
+  state: TemplateState;
+};
+declare function buildFunction(state: TemplateState, type: Type): Function;
+declare function executeTemplates(state: TemplateState, type: Type, withLoose?: boolean, withCache?: boolean): string;
+declare function createConverterJSForMember(property: ReflectionProperty | TypeProperty | TypePropertySignature | TypeIndexSignature, state: TemplateState, undefinedSetterCode?: string, nullSetterCode?: string): string;
+declare function inAccessor(accessor: ContainerAccessor | string): string;
+declare function deserializeEmbedded(type: TypeClass | TypeObjectLiteral, state: TemplateState, container?: string): string;
+declare function getIndexCheck(context: CompilerContext, i: string, type: Type): string;
+/**
+ * Sort, so the order is literal, number, string, symbol.  literal comes first as its the most specific type.
+ * We need to do that for numbers since all keys are string|symbol in runtime, and we need to check if a string is numeric first before falling back to string.
+ */
+declare function sortSignatures(signatures: TypeIndexSignature[]): void;
+declare function getStaticDefaultCodeForProperty(member: TypeProperty | TypePropertySignature, setter: string | ContainerAccessor, state: TemplateState): string;
+declare function getEmbeddedProperty(type: TypeClass | TypeObjectLiteral): TypeProperty | TypePropertySignature | undefined;
+declare function serializeObjectLiteral(type: TypeObjectLiteral | TypeClass, state: TemplateState): void;
+declare function typeGuardEmbedded(type: TypeClass | TypeObjectLiteral, state: TemplateState, embedded: EmbeddedOptions): void;
+declare function typeGuardObjectLiteral(type: TypeObjectLiteral | TypeClass, state: TemplateState): void;
+declare function serializeArray(type: TypeArray, state: TemplateState): void;
+declare function typeGuardArray(elementType: Type, state: TemplateState): void;
+declare function getSetTypeToArray(type: TypeClass): TypeArray;
+declare function getMapTypeToArray(type: TypeClass): TypeArray;
+declare function getNTypeToArray(type: TypeClass, n: number): TypeArray;
+declare function executeTypeArgumentAsArray(type: TypeClass, typeIndex: number, state: TemplateState): void;
+declare function forwardSetToArray(type: TypeClass, state: TemplateState): void;
+declare function forwardMapToArray(type: TypeClass, state: TemplateState): void;
+declare function serializePropertyOrParameter(type: TypePropertySignature | TypeProperty | TypeParameter, state: TemplateState): void;
+declare function validatePropertyOrParameter(type: TypePropertySignature | TypeProperty | TypeParameter, state: TemplateState): void;
+declare function handleUnion(type: TypeUnion, state: TemplateState): void;
+declare function getNameExpression(name: string | number | symbol | undefined, state: TemplateState): string;
+declare class TypeGuardRegistry {
+  serializer: Serializer;
+  registry: {
+    [specificality: number]: TemplateRegistry;
+  };
+  protected sorted?: [specificality: number, registry: TemplateRegistry][];
+  /**
+   * Lowest specificality first
+   */
+  getSortedTemplateRegistries(): [specificality: number, registry: TemplateRegistry][];
+  constructor(serializer: Serializer);
+  clear(): void;
+  /**
+   *
+   * @see register() for specificality explanation.
+   */
+  getRegistry(specificality: number): TemplateRegistry;
+  /**
+   * Registers a new template and replaces all existing (added via register,prepend,append).
+   *
+   * Specificality defines when the given template guard is executed.
+   *
+   * - 1 means its used for JS types - exact types. For example for type string `'string' ==== typeof v` is used. Same for number, bigint, and boolean.
+   *   Guards of this specificality are used for the `is()` function.
+   *
+   * - >1 means it acts as a fallback. For example in a union `number | Date`, when a string is given, the Date can allow `string` type as well, so it gets converted to a Date.
+   *
+   * - >0 && <1 means its acts as a priority guard. For example in a `string | Date`, a string of date-format is converted to a Date instead of a string. This is necessary
+   *   to support regular JSON.
+   *
+   * - <0, anything below 0 means it can optionally be used for loosely types. This is handy when data comes from a string-only encoding like URL query strings.
+   *   In this specificality a numeric string is converted to a number or bigint, a 1|0|true|false string converted to boolean .
+   */
+  register<T extends ReflectionKind>(specificality: number, kind: T, template: Template<FindType<Type, T>>): void;
+  /**
+   * @see register
+   */
+  registerClass(specificality: number, classType: ClassType, template: Template<TypeClass>): void;
+  /**
+   * @see register
+   */
+  registerBinary(specificality: number, template: Template<TypeClass>): void;
+}
+/**
+ * Default serializer that can convert JS data structures to the target type.
+ * It coerces types, converts object literals to class instances, and has type guards for JS types.
+ *
+ * JSONSerializer has the same but for JSON data structures.
+ */
+declare class Serializer {
+  name: string;
+  serializeRegistry: TemplateRegistry;
+  deserializeRegistry: TemplateRegistry;
+  typeGuards: TypeGuardRegistry;
+  validators: TemplateRegistry;
+  constructor(name?: string);
+  setExplicitUndefined(type: Type, state: TemplateState): boolean;
+  protected registerValidators(): void;
+  clear(): void;
+  protected registerSerializers(): void;
+  protected registerTypeGuards(): void;
+}
+declare const serializableKinds: ReflectionKind[];
+declare class EmptySerializer extends Serializer {
+  constructor(name?: string);
+  protected registerValidators(): void;
+  protected registerSerializers(): void;
+}
+declare const serializer: Serializer;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/validator.d.ts
+type ValidatorMeta<Name extends string, Args extends [...args: any[]] = []> = TypeAnnotation<'validator', [Name, Args]>;
+type ValidateFunction = (value: any, type: Type, options: any) => ValidatorError | void;
+type Validate<T extends ValidateFunction, Options extends Parameters<T>[2] = unknown> = ValidatorMeta<'function', [T, Options]>;
+type Pattern<T extends RegExp> = ValidatorMeta<'pattern', [T]>;
+type Alpha = ValidatorMeta<'alpha'>;
+type Alphanumeric = ValidatorMeta<'alphanumeric'>;
+type Ascii = ValidatorMeta<'ascii'>;
+type Decimal<MinDigits extends number = 1, MaxDigits extends number = 100> = ValidatorMeta<'decimal', [MinDigits, MaxDigits]>;
+type MultipleOf<Num extends number> = ValidatorMeta<'multipleOf', [Num]>;
+type MinLength<Length extends number> = ValidatorMeta<'minLength', [Length]>;
+type MaxLength<Length extends number> = ValidatorMeta<'maxLength', [Length]>;
+type Includes<T extends string | number | boolean> = ValidatorMeta<'includes', [T]>;
+type Excludes<T extends string | number | boolean> = ValidatorMeta<'excludes', [T]>;
+type Minimum<T extends number | bigint> = ValidatorMeta<'minimum', [T]>;
+type Maximum<T extends number | bigint> = ValidatorMeta<'maximum', [T]>;
+/**
+ Includes 0. Use PositiveNoZero to exclude 0.
+ */
+type Positive = ValidatorMeta<'positive', unknown & [true]>;
+/**
+ * Includes 0. Use NegativeNoZero to exclude 0.
+ */
+type Negative = ValidatorMeta<'negative', [true]>;
+type PositiveNoZero = ValidatorMeta<'positive', [false]>;
+type NegativeNoZero = ValidatorMeta<'negative', [false]>;
+type ExclusiveMinimum<T extends number | bigint> = ValidatorMeta<'exclusiveMinimum', [T]>;
+type ExclusiveMaximum<T extends number | bigint> = ValidatorMeta<'exclusiveMaximum', [T]>;
+type BeforeDate<T extends number> = ValidatorMeta<'beforeDate', [T]>;
+type AfterDate<T extends number> = ValidatorMeta<'afterDate', [T]>;
+type BeforeNow = ValidatorMeta<'beforeNow'>;
+type AfterNow = ValidatorMeta<'afterNow'>;
+declare const EMAIL_REGEX: RegExp;
+type Email = string & Pattern<typeof EMAIL_REGEX>;
+/**
+ * Used in validator functions.
+ */
+declare class ValidatorError {
+  readonly code: string;
+  readonly message: string;
+  readonly path?: string | undefined;
+  constructor(code: string, message: string, path?: string | undefined);
+}
+/**
+ * The structure of a validation error.
+ *
+ * Path defines the shallow or deep path (using dots).
+ * Message is an arbitrary message in english.
+ *
+ * In validators please use and return `new ValidatorError('code', 'message')` instead.
+ */
+declare class ValidationErrorItem {
+  /**
+   * The path to the property. Might be a deep path separated by dot.
+   */
+  readonly path: string;
+  /**
+   * A lower cased error code that can be used to identify this error and translate.
+   */
+  readonly code: string;
+  /**
+   * Free text of the error.
+   */
+  readonly message: string;
+  /**
+   * Optional value that caused the error.
+   */
+  readonly value?: any | undefined;
+  constructor(
+  /**
+   * The path to the property. Might be a deep path separated by dot.
+   */
+
+  path: string,
+  /**
+   * A lower cased error code that can be used to identify this error and translate.
+   */
+
+  code: string,
+  /**
+   * Free text of the error.
+   */
+
+  message: string,
+  /**
+   * Optional value that caused the error.
+   */
+
+  value?: any | undefined);
+  toString(prefix?: string): string;
+}
+declare class ValidationError extends CustomError {
+  readonly errors: ValidationErrorItem[];
+  constructor(errors: ValidationErrorItem[], type?: Type);
+  static from(errors: {
+    path: string;
+    message: string;
+    code?: string;
+    value?: any;
+  }[]): ValidationError;
+}
+/**
+ * Returns empty array when valid, or ValidationErrorItem[] with detailed error messages if not valid.
+ *
+ * Returns validation error items when failed. If successful returns an empty array.
+ */
+declare function validate<T>(data: any, type?: ReceiveType<T>): ValidationErrorItem[];
+declare function validateFunction<T>(serializerToUse?: Serializer, type?: ReceiveType<T>): (data: T) => ValidationErrorItem[];
+/**
+ * Returns true when valid, and false if not.
+ */
+declare function validates<T>(data: any, type?: ReceiveType<T>): boolean;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/reflection/processor.d.ts
+type RuntimeStackEntry = Type | Object | (() => ClassType | Object) | string | number | boolean | bigint;
+type Packed = (RuntimeStackEntry | string)[] & {
+  __is?: (data: any) => boolean;
+} & {
+  __type?: Type;
+} & {
+  __unpack?: PackStruct;
+};
+declare class PackStruct {
+  ops: ReflectionOp[];
+  stack: RuntimeStackEntry[];
+  constructor(ops?: ReflectionOp[], stack?: RuntimeStackEntry[]);
+}
+declare function encodeOps(ops: ReflectionOp[]): string;
+/**
+ * Pack a pack structure (op instructions + pre-defined stack) and create a encoded version of it.
+ */
+declare function pack(packOrOps: PackStruct | ReflectionOp[]): Packed;
+declare function unpack(pack: Packed): PackStruct;
+declare function resolvePacked(type: Packed, args?: any[], options?: ReflectOptions): Type;
+/**
+ * Computes a type of given object. This function caches the result on the object itself.
+ * This is the slow path, using the full type virtual machine to resolve the type.
+ * If you want to handle some fast paths (including cache), try using resolveReceiveType() instead.
+ */
+declare function resolveRuntimeType(o: ClassType | Function | Packed | any, args?: any[], options?: ReflectOptions): Type;
+interface Frame {
+  index: number;
+  startIndex: number;
+  variables: number;
+  inputs: RuntimeStackEntry[];
+  previous?: Frame;
+  mappedType?: Loop;
+  distributiveLoop?: Loop;
+}
+declare class Loop {
+  fromType: Type;
+  private types;
+  private i;
+  constructor(fromType: Type);
+  next(): Type | undefined;
+}
+interface Program {
+  frame: Frame;
+  active: boolean;
+  stack: (RuntimeStackEntry | Type)[];
+  stackPointer: number;
+  program: number;
+  depth: number;
+  initialStack: (RuntimeStackEntry | Type)[];
+  resultType: Type;
+  ops: ReflectionOp[];
+  end: number;
+  inputs: RuntimeStackEntry[];
+  resultTypes?: Type[];
+  started: number;
+  typeParameters?: Type[];
+  previous?: Program;
+  directReturn?: boolean;
+  object?: ClassType | Function | Packed | any;
+}
+interface ReflectOptions {
+  /**
+   *
+   */
+  reuseCached?: boolean;
+  inline?: boolean;
+  typeName?: string;
+}
+/**
+ * @reflection never
+ */
+declare class Processor {
+  static typeProcessor?: Processor;
+  static get(): Processor;
+  private cache;
+  /**
+   * Linked list of programs to execute. For each external call to external program will this be changed.
+   */
+  protected program: Program;
+  reflect(object: ClassType | Function | Packed | any, inputs?: RuntimeStackEntry[], options?: ReflectOptions): Type;
+  _reflect(object: ClassType | Function | Packed | any, inputs?: RuntimeStackEntry[], options?: ReflectOptions): Type;
+  run(ops: ReflectionOp[], initialStack: RuntimeStackEntry[], inputs?: RuntimeStackEntry[], object?: ClassType | Function | Packed | any): Type;
+  runProgram(program: Program): Type;
+  /**
+   * Semantic is important here: This triggers true only for the very last op of a program.
+   * If it is checked in OP inline then it could be true or false:
+   *
+   * type t<T> = T; => false since we have nominal past the inline op
+   * typeOf<T>() => true since we have no nominal past the inline op
+   */
+  protected isEnded(): boolean;
+  /**
+   * Runs all scheduled programs until termination.
+   */
+  protected loop(until?: Program): Type | RuntimeStackEntry;
+  private handleTuple;
+  private handleIntersection;
+  private handleDistribute;
+  private handleIndexAccess;
+  private handleKeyOf;
+  private handleMappedType;
+  private handleTemplateLiteral;
+  protected push(entry: RuntimeStackEntry, program?: Program): void;
+  protected pop(): RuntimeStackEntry;
+  protected pushFrame(): void;
+  protected popFrame(): RuntimeStackEntry[];
+  /**
+   * Create a new stack frame with the calling convention.
+   */
+  protected call(program: number, jumpBackTo?: number): void;
+  /**
+   * Removes the stack frame, and puts the latest entry on the stack.
+   */
+  protected returnFrame(): void;
+  protected pushType(type: Type): void;
+  protected eatParameter(): RuntimeStackEntry;
+}
+declare function typeInfer(value: any): Type;
+declare function getEnumType(values: any[]): Type;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/reflection/reflection.d.ts
+/**
+ * Receives the runtime type of template argument.
+ *
+ * Use
+ *
+ * ```typescript
+ *
+ * function f<T>(type?: ReceiveType<T>): Type {
+ *     return resolveReceiveType(type);
+ * }
+ *
+ * ```
+ */
+type ReceiveType<T> = Packed | Type | ClassType<T>;
+declare function resolveReceiveType(type?: Packed | Type | ClassType | AbstractClassType | ReflectionClass<any>): Type;
+declare function reflect(o: any, ...args: any[]): Type;
+declare function reflectOrUndefined(o: any, ...args: any[]): Type | undefined;
+declare function valuesOf<T>(args?: any[], p?: ReceiveType<T>): (string | number | symbol | Type)[];
+declare function propertiesOf<T>(args?: any[], p?: ReceiveType<T>): (string | number | symbol | Type)[];
+declare function getNominalId<T>(args?: any[], p?: ReceiveType<T>): number | undefined;
+declare function typeOf<T>(args?: any[], p?: ReceiveType<T>): Type;
+declare function removeTypeName<T extends Type>(type: T): T;
+declare function removeNominal<T extends Type | undefined | Type[]>(type: T): T;
+declare function getProperty(type: TypeObjectLiteral | TypeClass, memberName: number | string | symbol): TypeProperty | TypePropertySignature | undefined;
+declare function toSignature(type: TypeProperty | TypeMethod | TypePropertySignature | TypeMethodSignature): TypePropertySignature | TypeMethodSignature;
+declare function hasCircularReference(type: Type): any;
+declare function visit(type: Type, visitor: (type: Type, path: string) => false | void, onCircular?: () => void): void;
+/**
+ * @reflection never
+ */
+declare class ReflectionParameter {
+  readonly parameter: TypeParameter;
+  readonly reflectionFunction: ReflectionMethod | ReflectionFunction;
+  type: Type;
+  constructor(parameter: TypeParameter, reflectionFunction: ReflectionMethod | ReflectionFunction);
+  getType(): Type;
+  getName(): string;
+  get name(): string;
+  isOptional(): boolean;
+  hasDefault(): boolean;
+  isValueRequired(): boolean;
+  getDefaultValue(): any;
+  setDefaultValue(value: any): void;
+  hasDefaultFunctionExpression(): boolean;
+  applyDecorator(t: TData): void;
+  getVisibility(): ReflectionVisibility | undefined;
+  isPublic(): boolean;
+  isProtected(): boolean;
+  isPrivate(): boolean;
+  isReadonly(): boolean;
+  setTags(tags: TagsReflection): void;
+  getTags(): TagsReflection;
+  isHidden(): boolean;
+  isIgnored(): boolean;
+  isInternal(): boolean;
+  isRuntime(): boolean;
+  getAlias(): string[];
+  getTitle(): string | undefined;
+  getPermission(): string[];
+  getDomain(): string | undefined;
+  /**
+   * True if the parameter becomes a property in the class.
+   * This is the case for parameters in constructors with visibility or readonly.
+   *
+   * ```typescript
+   * class User {
+   *    constructor(public name: string) {}
+   * }
+   */
+  isProperty(): boolean;
+}
+/**
+ * @reflection never
+ */
+declare class ReflectionFunction {
+  readonly type: TypeMethod | TypeMethodSignature | TypeFunction;
+  parameters: ReflectionParameter[];
+  parameterAliases: Map<string, string>;
+  description: string;
+  constructor(type: TypeMethod | TypeMethodSignature | TypeFunction);
+  static from(fn: Function): ReflectionFunction;
+  getParameterNames(): string[];
+  hasParameter(name: string | number | symbol): boolean;
+  getParameterOrUndefined(name: string | number | symbol): ReflectionParameter | undefined;
+  getParameter(name: string | number | symbol): ReflectionParameter;
+  getParameterType(name: string | number | symbol): Type | undefined;
+  getParameters(): ReflectionParameter[];
+  getReturnType(): Type;
+  getName(): number | string | symbol;
+  getDescription(): string;
+  get name(): string;
+  setTags(tags: TagsReflection): void;
+  getTags(): TagsReflection;
+  isHidden(): boolean;
+  isReadonly(): boolean;
+  isIgnored(): boolean;
+  isInternal(): boolean;
+  isRuntime(): boolean;
+  getAlias(): string[];
+  getTitle(): string | undefined;
+  getPermission(): string[];
+  getDomain(): string | undefined;
+}
+/**
+ * @reflection never
+ */
+declare class ReflectionMethod extends ReflectionFunction {
+  type: TypeMethod | TypeMethodSignature;
+  reflectionClass: ReflectionClass<any>;
+  /**
+   * Whether this method acts as validator.
+   */
+  validator: boolean;
+  constructor(type: TypeMethod | TypeMethodSignature, reflectionClass: ReflectionClass<any>);
+  setType(method: TypeMethod | TypeMethodSignature): void;
+  applyDecorator(data: TData): void;
+  clone(reflectionClass?: ReflectionClass<any>, method?: TypeMethod | TypeMethodSignature): ReflectionMethod;
+  isOptional(): boolean;
+  setTags(tags: TagsReflection): void;
+  getTags(): TagsReflection;
+  isHidden(): boolean;
+  isIgnored(): boolean;
+  isReadonly(): boolean;
+  isInternal(): boolean;
+  isRuntime(): boolean;
+  getAlias(): string[];
+  getTitle(): string | undefined;
+  getPermission(): string[];
+  getDomain(): string | undefined;
+}
+declare function resolveForeignReflectionClass(property: ReflectionProperty): ReflectionClass<any>;
+/**
+ * Resolved the class/object ReflectionClass of the given TypeClass|TypeObjectLiteral
+ */
+declare function resolveClassType(type: Type): ReflectionClass<any>;
+/**
+ * @reflection never
+ */
+declare class ReflectionProperty {
+  property: TypeProperty | TypePropertySignature;
+  reflectionClass: ReflectionClass<any>;
+  jsonType?: Type;
+  serializer?: SerializerFn;
+  deserializer?: SerializerFn;
+  data: {
+    [name: string]: any;
+  };
+  /**
+   * The type of the property, not the property itself.
+   *
+   * Note: If the property is optional via `property?: T`, this information
+   * is not available here. It's on `property`.
+   * Use `isOptional()` instead, which handles this case plus the case
+   * where optionality is given via union of T and undefined.
+   */
+  type: Type;
+  symbol: symbol;
+  protected cachedResolvedReflectionClass?: ReflectionClass<any>;
+  constructor(property: TypeProperty | TypePropertySignature, reflectionClass: ReflectionClass<any>);
+  setType(type: Type): void;
+  isPrimaryKey(): boolean;
+  isEmbedded(): boolean;
+  /**
+   * Returns the sub type if available (for arrays for example).
+   *
+   * @throws Error if the property type does not support sub types.
+   */
+  getSubType(): Type;
+  /**
+   * If undefined, it's not an embedded class.
+   */
+  getEmbedded(): {
+    prefix?: string;
+  } | undefined;
+  isBackReference(): boolean;
+  isDatabaseSkipped(database: string): boolean;
+  isDatabaseMigrationSkipped(database: string): boolean;
+  getBackReference(): BackReferenceOptionsResolved;
+  isAutoIncrement(): boolean;
+  isReference(): boolean;
+  isArray(): boolean;
+  isDate(): boolean;
+  isNumber(): boolean;
+  getForeignKeyName(): string;
+  getReference(): ReferenceOptions | undefined;
+  getGroups(): string[];
+  isInGroup(...group: string[]): boolean;
+  getExcluded(): string[];
+  isSerializerExcluded(name: string): boolean;
+  getData(): {
+    [name: string]: any;
+  };
+  /**
+   * Returns the ReflectionClass of the reference class/object literal.
+   *
+   * @throws Error if the property is not from type TypeClass or TypeObjectLiteral
+   */
+  getResolvedReflectionClass(): ReflectionClass<any>;
+  /**
+   * If undefined the property is not an index.
+   * A unique property is defined as index with IndexOptions.unique=true.
+   */
+  getIndex(): IndexOptions | undefined;
+  /**
+   * Returns database specific options, if defined
+   *
+   * ```typescript
+   * interface User {
+   *     logins: number & DatabaseField<{type: 'integer(8)'}>;
+   *
+   *     //of for a specific db engine
+   *     logins: number & Sqlite<{type: 'integer(8)'}>;
+   * }
+   *
+   * ```
+   */
+  getDatabase<T extends DatabaseFieldOptions>(name: string): T | undefined;
+  clone(reflectionClass?: ReflectionClass<any>, property?: TypeProperty | TypePropertySignature): ReflectionProperty;
+  applyDecorator(data: TData): void;
+  getName(): number | string | symbol;
+  getNameAsString(): string;
+  get name(): string;
+  getKind(): ReflectionKind;
+  getType(): Type;
+  getDescription(): string;
+  /**
+   * Whether a value is required from serialization point of view.
+   * If this property has for example a default value (set via constructor or manually via t.default),
+   * then the value is not required to instantiate the property value.
+   */
+  isValueRequired(): boolean;
+  /**
+   * Returns true when `undefined` or a missing value is allowed at the class itself.
+   * This is now only true when `optional` is set, but also when type is `any`.
+   */
+  isActualOptional(): boolean;
+  /**
+   * If the property is actual optional or is an union with undefined in it.
+   */
+  isOptional(): boolean;
+  setOptional(v: boolean): void;
+  isNullable(): boolean;
+  isReadonly(): boolean;
+  isAbstract(): boolean;
+  hasDefault(): boolean;
+  getDefaultValue(): any;
+  setDefaultValue(value: any): void;
+  hasDefaultFunctionExpression(): boolean;
+  getDefaultValueFunction(): (() => any) | undefined;
+  getVisibility(): ReflectionVisibility | undefined;
+  isPublic(): boolean;
+  isProtected(): boolean;
+  isPrivate(): boolean;
+  setTags(tags: TagsReflection): void;
+  getTags(): TagsReflection;
+  isHidden(): boolean;
+  isIgnored(): boolean;
+  isInternal(): boolean;
+  isRuntime(): boolean;
+  getAlias(): string[];
+  getTitle(): string | undefined;
+  getPermission(): string[];
+  getDomain(): string | undefined;
+}
+declare const reflectionClassSymbol: unique symbol;
+interface SerializerFn {
+  (value: any, property: ReflectionProperty): any;
+}
+declare class TData {
+  validator: boolean;
+  validators: ValidateFunction[];
+  type?: Packed | Type | ClassType;
+  data: {
+    [name: string]: any;
+  };
+  serializer?: SerializerFn;
+  deserializer?: SerializerFn;
+}
+declare class EntityData {
+  name?: string;
+  collectionName?: string;
+  databaseSchemaName?: string;
+  disableConstructor: boolean;
+  data: {
+    [name: string]: any;
+  };
+  indexes: {
+    names: string[];
+    options: IndexOptions;
+  }[];
+  singleTableInheritance?: true;
+}
+/**
+ * @reflection never
+ */
+declare class ReflectionClass<T> {
+  readonly type: TypeClass | TypeObjectLiteral;
+  readonly parent?: ReflectionClass<any> | undefined;
+  /**
+   * The description, extracted from the class JSDoc @description.
+   */
+  description: string;
+  /**
+   * The tags, extracted from the class JSDoc @tag.
+   */
+  tags?: TagsReflection;
+  /**
+   * A place where arbitrary data is stored, usually set via decorator t.data.
+   */
+  data: {
+    [name: string]: any;
+  };
+  /**
+   * The unique entity name.
+   *
+   * ```typescript
+   * @entity.name('user')
+   * class User {
+   *
+   * }
+   * ```
+   */
+  name?: string;
+  databaseSchemaName?: string;
+  disableConstructor: boolean;
+  /**
+   * The collection name, used in database context (also known as table name).
+   *
+   * Usually, if this is not set, `name` will be used.
+   *
+   * ```typescript
+   * @entity.collection('users').name('user')
+   * class User {
+   *
+   * }
+   * ```
+   */
+  collectionName?: string;
+  /**
+   * True when @entity.singleTableInheritance was set.
+   */
+  singleTableInheritance: boolean;
+  /**
+   * Contains all indexed, multi-field using entity.index and all indexes from properties.
+   *
+   * ```typescript
+   * @entity
+   *    .collection('users')
+   *    .name('user')
+   *    .index(['username', 'email'])
+   *    .index(['email', 'region'], {unique: true})
+   * class User {
+   *     username: string;
+   *     email: string;
+   * }
+   * ```
+   */
+  indexes: {
+    names: string[];
+    options: IndexOptions;
+  }[];
+  protected propertyNames: string[];
+  protected methodNames: string[];
+  protected properties: ReflectionProperty[];
+  protected propertyAliases: Map<string, string>;
+  protected methods: ReflectionMethod[];
+  protected methodAliases: Map<string, string>;
+  /**
+   * References and back references.
+   */
+  protected references: ReflectionProperty[];
+  protected primaries: ReflectionProperty[];
+  protected autoIncrements: ReflectionProperty[];
+  /**
+   * If a custom validator method was set via @t.validator, then this is the method name.
+   */
+  validationMethod?: string | symbol | number | TypeTemplateLiteral;
+  /**
+   * A class using @t.singleTableInheritance registers itself in this array in its super class.
+   */
+  subClasses: ReflectionClass<any>[];
+  constructor(type: TypeClass | TypeObjectLiteral, parent?: ReflectionClass<any> | undefined);
+  clone(): ReflectionClass<any>;
+  toString(): string;
+  getPropertiesDeclaredInConstructor(): ReflectionProperty[];
+  clearJitContainer(): void;
+  getJitContainer(): any;
+  getClassType(): ClassType;
+  getClassName(): string;
+  createDefaultObject(): object;
+  getName(): string;
+  getDescription(): string;
+  getCollectionName(): string;
+  hasProperty(name: string | symbol | number): boolean;
+  hasMethod(name: string | symbol | number): boolean;
+  getPrimary(): ReflectionProperty;
+  getAutoIncrement(): ReflectionProperty | undefined;
+  isSchemaOf(classType: ClassType): boolean;
+  hasPrimary(): boolean;
+  getPrimaries(): ReflectionProperty[];
+  /**
+   * Returns the ReflectionClass object from parent/super class, if available.
+   */
+  getSuperReflectionClass(): ReflectionClass<any> | undefined;
+  removeProperty(name: string | number | symbol): void;
+  registerProperty(property: ReflectionProperty): void;
+  addProperty(prop: {
+    name: number | string | symbol;
+    optional?: true;
+    readonly?: true;
+    description?: string;
+    visibility?: ReflectionVisibility;
+    type: Type;
+    default?: any;
+    tags?: TagsReflection;
+  }): ReflectionProperty;
+  registerMethod(method: ReflectionMethod): void;
+  add(member: Type): void;
+  assignedSingleTableInheritanceSubClassesByIdentifier?: {
+    [id: string]: ReflectionClass<any>;
+  };
+  getAssignedSingleTableInheritanceSubClassesByIdentifier(): {
+    [id: string]: ReflectionClass<any>;
+  } | undefined;
+  hasSingleTableInheritanceSubClasses(): boolean;
+  getSingleTableInheritanceDiscriminantName(): string;
+  applyDecorator(data: EntityData): void;
+  static from<T>(classTypeIn?: ReceiveType<T> | AbstractClassType<T> | TypeClass | TypeObjectLiteral | ReflectionClass<any>, args?: any[]): ReflectionClass<T>;
+  getIndexSignatures(): void;
+  getPropertyNames(): (string | number | symbol)[];
+  getProperties(): ReflectionProperty[];
+  getPropertiesInGroup(...group: string[]): ReflectionProperty[];
+  getMethodNames(): (string | number | symbol)[];
+  getMethods(): ReflectionMethod[];
+  /**
+   * Returns references and back references.
+   */
+  getReferences(): ReflectionProperty[];
+  getConstructorOrUndefined(): ReflectionMethod | undefined;
+  getPropertyOrUndefined(name: string | number | symbol | TypeTemplateLiteral): ReflectionProperty | undefined;
+  getProperty(name: string | number | symbol): ReflectionProperty;
+  getMethodParameters(name: string | number | symbol): ReflectionParameter[];
+  getMethodOrUndefined(name: string | number | symbol | TypeTemplateLiteral): ReflectionMethod | undefined;
+  getMethod(name: string | number | symbol): ReflectionMethod;
+  hasCircularReference(): boolean;
+  serializeType(): SerializedTypes;
+  setTags(tags: TagsReflection): void;
+  getTags(): TagsReflection;
+  isHidden(): boolean;
+  isIgnored(): boolean;
+  isInternal(): boolean;
+  isRuntime(): boolean;
+  isReadonly(): boolean;
+  getAlias(): string[];
+  getTitle(): string | undefined;
+  getPermission(): string[];
+  getDomain(): string | undefined;
+  /**
+   * All references have a counter-part. This methods finds it and errors if not possible.
+   *
+   * If the given reference is a owning reference it finds the correct backReference,
+   *    which can be found by checking all reference options.mappedBy.
+   *
+   * If the given reference is a back reference it finds the owning reference,
+   *    which can be found by using its options.mappedBy.
+   *
+   * Alternatively we simply check for resolvedClassType to be given `classType`, and if only one
+   * found, we return it. When more than one found, we throw an error saying the user he
+   * should make its relation mapping not ambiguous.
+   */
+  findReverseReference(toClassType: ClassType, fromReference: ReflectionProperty): ReflectionProperty;
+  extractPrimaryKey(item: object): Partial<T>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/change-detector.d.ts
+/**
+ * This is a comparator function for the snapshots. They are either string, number, boolean, array, or objects.
+ * No date, moment, or custom classes involved here.
+ */
+declare function genericEqual(a: any, b: any): boolean;
+declare function getChangeDetector<T extends object>(classSchema: ReflectionClass<T>): (last: any, current: any, item: T) => ItemChanges<T> | undefined;
+declare function buildChanges<T extends object>(classSchema: ReflectionClass<T>, lastSnapshot: any, item: T): Changes<T>;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/core.d.ts
+declare enum UnpopulatedCheck {
+  None = 0,
+  //returns undefined
+  Throw = 1,
+  //throws regular error
+  ReturnSymbol = 2
+}
+declare const unpopulatedSymbol: unique symbol;
+interface TypeSettings {
+  registeredEntities: {
+    [name: string]: ClassType;
+  };
+  unpopulatedCheck: UnpopulatedCheck;
+}
+declare const typeSettings: TypeSettings;
+interface TypedArrayClassType<T> {
+  new (...args: any[]): T;
+  readonly BYTES_PER_ELEMENT: number;
+}
+interface TypedArray {
+  /**
+   * The size in bytes of each element in the array.
+   */
+  readonly BYTES_PER_ELEMENT: number;
+  /**
+   * The ArrayBuffer instance referenced by the array.
+   */
+  readonly buffer: ArrayBufferLike;
+  /**
+   * The length of the array.
+   */
+  readonly length: number;
+  /**
+   * The length in bytes of the array.
+   */
+  readonly byteLength: number;
+  /**
+   * The offset in bytes of the array.
+   */
+  readonly byteOffset: number;
+}
+declare function nodeBufferToTypedArray<K>(buf: Buffer, type: TypedArrayClassType<K>): K;
+/**
+ * When using Buffer.from() node is using a buffer from the buffer pool.
+ * This makes it necessary to create the given TypedArray using byteOffset and byteLength accordingly.
+ *
+ * Note: The created TypedArray.buffer is pointing probably to a larger Buffer. Make sure
+ * to use byteLength/byeOffset correctly or use typedArrayToArrayBuffer() if you want to use
+ * a raw ArrayBuffer that represents the actual data correctly.
+ */
+declare function base64ToTypedArray<K>(base64: string, type: TypedArrayClassType<K>): K;
+/**
+ * Creates a new fresh ArrayBuffer with given data.
+ * Note: Regular Buffer.from(base64, 'base64) creates in Node a shared buffer, this function makes
+ * sure a copy happens and the ArrayBuffer is not shared.
+ */
+declare function base64ToArrayBuffer(base64: string): ArrayBuffer;
+/**
+ * When using Buffer.from() node is using a buffer from the buffer pool.
+ * This makes it necessary to create the a new ArrayType using slice to make a copy.
+ *
+ * This makes a copy.
+ */
+declare function nodeBufferToArrayBuffer<K>(buf: Uint8Array | ArrayBuffer): ArrayBuffer;
+/**
+ * In node environment the TypedArray.buffer is probably a larger buffer from the buffer pool.
+ * This makes it necessary to create a Buffer with offset & length so that it accurately represents
+ * the given TypedArray.
+ */
+declare function typedArrayToBuffer<K>(typedArray: TypedArray): Buffer;
+declare function arrayBufferToBase64(arrayBuffer: ArrayBuffer): string;
+declare function typedArrayToBase64(typedArray: TypedArray): string;
+/**
+ * Same as Buffer.from() but creates a ArrayBuffer that is not shared.
+ */
+declare function arrayBufferFrom(data: string, encoding?: string): ArrayBuffer;
+/**
+ * Same as Buffer.from(arrayBuffer).toString(encoding), but more in line with the current API.
+ */
+declare function arrayBufferTo(arrayBuffer: ArrayBuffer, encoding?: string | "utf8" | "base64" | "ascii"): string;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/decorator-builder.d.ts
+type ClassDecoratorFn = (classType: AbstractClassType, property?: string, parameterIndexOrDescriptor?: any) => void;
+type PropertyDecoratorFn = (prototype: object, property?: number | string | symbol, parameterIndexOrDescriptor?: any) => void;
+type FluidDecorator<T, D extends Function> = { [name in keyof T]: T[name] extends ((...args: infer K) => any) ? (...args: K) => D & FluidDecorator<T, D> : D & FluidDecorator<T, D> & {
+  _data: ExtractApiDataType<T>;
+} };
+declare function createFluidDecorator<API extends APIClass<any> | APIProperty<any>, D extends Function>(api: API, modifier: {
+  name: string;
+  args?: any;
+  Ω?: any;
+}[], collapse: (modifier: {
+  name: string;
+  args?: any;
+}[], target: any, property?: string, parameterIndexOrDescriptor?: any) => void, returnCollapse?: boolean, fluidFunctionSymbol?: symbol): FluidDecorator<ExtractClass<API>, D>;
+type UnionToIntersection$1<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type Merge<U> = { [K in keyof U]: U[K] extends ((...a: infer A) => infer R) ? R extends DualDecorator ? (...a: A) => PropertyDecoratorFn & R & U : (...a: A) => R : never };
+/**
+ * A dual decorator is a decorator that can be used on a class and class property.
+ */
+type DualDecorator = void & {
+  __DualDecorator?: true;
+};
+declare function mergeDecorator<T extends any[]>(...args: T): Merge<Omit<UnionToIntersection$1<T[number]>, '_fetch' | 't'>>;
+interface ClassApiTypeInterface<T> {
+  t: T;
+  onDecorator?: (classType: ClassType, property?: string, parameterIndexOrDescriptor?: any) => void;
+}
+type APIClass<T> = ClassType<ClassApiTypeInterface<T>>;
+type ExtractClass<T> = T extends ClassType<infer K> ? K : never;
+type ExtractApiDataType<T> = T extends AbstractClassType<infer K> ? K extends {
+  t: infer P;
+} ? P : never : (T extends {
+  t: infer P;
+} ? P : never);
+type ClassDecoratorResult<API extends APIClass<any>> = FluidDecorator<ExtractClass<API>, ClassDecoratorFn> & DecoratorAndFetchSignature<API, ClassDecoratorFn>;
+declare function createClassDecoratorContext<API extends APIClass<any>, T = ExtractApiDataType<API>>(apiType: API): ClassDecoratorResult<API>;
+interface PropertyApiTypeInterface<T> {
+  t: T;
+  onDecorator?: (target: ClassType, property: string | undefined, parameterIndexOrDescriptor?: any) => void;
+}
+type APIProperty<T> = ClassType<PropertyApiTypeInterface<T>>;
+type DecoratorAndFetchSignature<API extends APIProperty<any>, FN extends (...args: any[]) => any> = FN & {
+  _fetch: (...args: Parameters<FN>) => ExtractApiDataType<API> | undefined;
+};
+type PropertyDecoratorResult<API extends APIProperty<any>> = FluidDecorator<ExtractClass<API>, PropertyDecoratorFn> & DecoratorAndFetchSignature<API, PropertyDecoratorFn>;
+declare function createPropertyDecoratorContext<API extends APIProperty<any>>(apiType: API): PropertyDecoratorResult<API>;
+type FreeDecoratorFn<API> = {
+  (target?: any, property?: number | string | symbol, parameterIndexOrDescriptor?: any): ExtractApiDataType<API>;
+} & {
+  _data: ExtractApiDataType<API>;
+};
+type FreeFluidDecorator<API> = { [name in keyof ExtractClass<API>]: ExtractClass<API>[name] extends ((...args: infer K) => any) ? (...args: K) => FreeFluidDecorator<API> : FreeFluidDecorator<API> } & FreeDecoratorFn<API>;
+type FreeDecoratorResult<API extends APIClass<any>> = FreeFluidDecorator<API> & {
+  _fluidFunctionSymbol: symbol;
+};
+declare function createFreeDecoratorContext<API extends APIClass<any>, T = ExtractApiDataType<API>>(apiType: API): FreeDecoratorResult<API>;
+declare function isDecoratorContext<API extends APIClass<any>>(context: FreeDecoratorResult<API>, fn: Function): fn is FreeFluidDecorator<API>;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/decorator.d.ts
+declare class TDecorator {
+  t: TData;
+  onDecorator(target: any, property?: string, parameterIndexOrDescriptor?: any): void;
+  type<T>(type: ReceiveType<T> | ClassType): void;
+  /**
+   * Marks the method as validator. Is executed for each is/validate call.
+   *
+   * ```typescript
+   *
+   * class MyClass {
+   *     field1: string;
+   *     field2: string;
+   *
+   *     @t.validator
+   *     validate(): ValidatorError | undefined {
+   *          return new ValidatorError('invalid', 'MyClass is invalid');
+   *     }
+   * }
+   *
+   * ```
+   */
+  get validator(): void;
+  validate(...validators: ValidateFunction[]): void;
+  serialize(serializer: SerializerFn): void;
+  deserialize(deserializer: SerializerFn): void;
+  data(name: string, value: any): void;
+}
+declare const t: PropertyDecoratorResult<typeof TDecorator>;
+declare class EntityDecorator {
+  t: EntityData;
+  onDecorator(target: any): void;
+  name(name: string): void;
+  collection(name: string): void;
+  /**
+   * Disables calling the constructor when deserializing.
+   */
+  disableConstructor(): void;
+  databaseSchema(name: string): void;
+  index(names: string[], options?: IndexOptions): void;
+  singleTableInheritance(): void;
+  data(name: string, value: any): void;
+  /**
+   * Exclude this entity from database migrations.
+   */
+  excludeMigration(): void;
+}
+declare const entity: ClassDecoratorResult<typeof EntityDecorator>;
+interface DeferredDecorator {
+  data: any;
+  target: any;
+  property?: string;
+  parameterIndexOrDescriptor?: any;
+}
+declare function isWithDeferredDecorators(obj: any): obj is {
+  __decorators: DeferredDecorator[];
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/default.d.ts
+/**
+ * Returns a sensible default value for a given type.
+ * Sensible means it satisfies the type checker, but not necessarily attached validators.
+ */
+declare function defaultValue(type: Type): any;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/mixin.d.ts
+type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends ((x: infer R) => any) ? R : never;
+/**
+ * Function to mixin multiple classes together and create a new class, which can be extended from.
+ *
+ * The first entry of the mixin() call will be used as base class.
+ *
+ * @example
+ * ```typescript
+ *
+ *   class Timestampable {
+ *       createdAt: Date = new Date;
+ *       updatedAt: Date = new Date;
+ *   }
+ *
+ *   class SoftDeleted {
+ *       deletedAt?: Date;
+ *       deletedBy?: string;
+ *   }
+ *
+ *   class User extends mixin(Timestampable, SoftDeleted) {
+ *       id: number = 0;
+ *       constructor(public username: string) {}
+ *   }
+ * ```
+ */
+declare function mixin<T extends AbstractClassType[]>(...classTypes: T): ClassType<UnionToIntersection<ExtractClassType<T[number]>>>;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/path.d.ts
+type Resolver = (path: string) => Type | undefined;
+declare function resolvePath<T>(path: string, type?: ReceiveType<T>): Type;
+declare function pathResolver<T>(type?: ReceiveType<T>, jitStack?: JitStack): Resolver;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/reference.d.ts
+declare function isReferenceInstance(obj: any): boolean;
+declare function getReferenceInfo<T>(obj: T): ReferenceInfo<T> | undefined;
+declare function getReferenceItemInfo<T>(obj: T): ReferenceItemInfo<T> | undefined;
+declare function getOrCreateReferenceItemInfo<T>(obj: T): ReferenceItemInfo<T>;
+declare function isReferenceHydrated(obj: any): boolean;
+declare function markAsHydrated(item: any): void;
+interface ReferenceInfo<T> {
+  hydrator?: (item: T) => Promise<void>;
+}
+interface ReferenceItemInfo<T> {
+  hydrated: boolean;
+}
+declare const referenceSymbol: unique symbol;
+declare const referenceItemSymbol: unique symbol;
+declare function createReference<T>(type: ClassType<T> | Type | ReflectionClass<any>, pk: {
+  [name: string]: any;
+}): T;
+declare function createReferenceClass<T>(reflection: ReflectionClass<any>): ClassType<T>;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/registry.d.ts
+interface RegistryDecorator<T> {
+  predicate: (type: Type) => boolean;
+  v: T;
+}
+declare class TypeRegistry<T> {
+  protected results: { [kind in ReflectionKind]?: T };
+  classes: Map<ClassType<any>, T>;
+  protected decorators: RegistryDecorator<T>[];
+  clear(): void;
+  get(type: Type): T | undefined;
+  decorator(predicate: (type: Type) => boolean, v: T): void;
+  /**
+   * Registers a template for all binary classes: ArrayBuffer, Uint8Array, Int8Array, etc.
+   */
+  setBinary(v: T): void;
+  setNumeric(v: T): void;
+  /**
+   * Registers a template for a given class type.
+   *
+   * As soon as a single template has registered for the given classType the template registry
+   * only returns templates for this particular classType and omits all general purpose ReflectionKind.class templates for this particular classType.
+   */
+  setClass(classType: ClassType, v: T): void;
+  /**
+   * Removes all registered templates.
+   */
+  remove(kind: ReflectionKind): void;
+  /**
+   * Registers a new template and replaces all existing (added via register,prepend,append).
+   */
+  set(kind: ReflectionKind | ReflectionKind[] | ((type: Type) => boolean), v: T): void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/utils.d.ts
+declare class NoTypeReceived extends Error {
+  constructor(message?: string);
+}
+/**
+ * Returns a new UUID v4 as string.
+ */
+declare function uuid(): string;
+/**
+ * Writes a new uuid v4 into an existing buffer, and returns the same buffer.
+ */
+declare function writeUuid(buffer: Uint8Array, offset?: number): Uint8Array;
+/**
+ * Stringify an exising Uint8Array buffer.
+ */
+declare function stringifyUuid(buffer: Uint8Array, offset?: number): string;
+type Binary = ArrayBuffer | Uint8Array | Int8Array | Uint8ClampedArray | Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array | Float64Array;
+type JSONPartial<T> = T extends Date ? string : T extends Array<infer K> ? Array<JSONPartial<K>> : T extends Binary ? string : T extends object ? JSONPartialObject<T> : T extends string ? number | T : T extends boolean ? number | string | T : T extends bigint ? number | string | T : T extends number ? bigint | string | T : T;
+type JSONPartialObject<T> = { [name in keyof T]?: T[name] | null };
+type JSONSingle<T> = T extends Date ? string | Date : T extends Array<infer K> ? Array<JSONSingle<K>> : T extends Binary ? string : T extends object ? JSONEntity<T> : T extends string ? string | number | boolean | undefined : T extends boolean ? T | number | string : T extends number ? T | string : T;
+type JSONEntity<T> = { [name in keyof T]: JSONSingle<T[name]> };
+declare function regExpFromString(v: string): RegExp;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/serializer-facade.d.ts
+/**
+ * Casts/coerces a given data structure to the target data type and validates all attached validators.
+ *
+ * Same as validatedDeserialize().
+ *
+ * @throws ValidationError if casting or validation fails
+ */
+declare function cast<T>(data: JSONPartial<T> | unknown, options?: SerializationOptions, serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): T;
+/**
+ * Same as cast but returns a ready to use function. Used to improve performance.
+ */
+declare function castFunction<T>(serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): (data: JSONPartial<T> | unknown, options?: SerializationOptions) => T;
+/**
+ * Deserialize given data structure from JSON data objects to JavaScript objects, without running any validators.
+ *
+ * Types that are already correct will be used as-is.
+ *
+ * ```typescript
+ * interface Data {
+ *     created: Date;
+ * }
+ *
+ * const data = deserialize<Data>({created: '2009-02-13T23:31:30.123Z'});
+ * //data is {created: Date(2009-02-13T23:31:30.123Z)}
+ *
+ * @throws ValidationError when deserialization fails.
+ * ```
+ */
+declare function deserialize<T>(data: JSONPartial<T> | unknown, options?: SerializationOptions, serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): T;
+/**
+ * Same as deserialize but returns a ready to use function. Used to improve performance.
+ */
+declare function deserializeFunction<T>(serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): SerializeFunction<any, T>;
+/**
+ * Patch serialization for deep dot paths, e.g. `{'user.shippingAddress.street': 'abc'}`
+ * If a naming strategy is used, it could be converted to `{'user.shipping_address.street': 'abc'}`.
+ */
+declare function patch<T>(data: DeepPartial<T>, options?: SerializationOptions, serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): (data: JSONPartial<T> | unknown) => T;
+/**
+ * Create a serializer/deserializer function including validator for the given type for a patch structure.
+ * This is handy for deep patch structures like e.g '{user.address.street: "new street"}'.
+ */
+declare function getPatchSerializeFunction(type: TypeClass | TypeObjectLiteral, registry: TemplateRegistry, namingStrategy?: NamingStrategy): (data: any, state?: SerializationOptions, patch?: {
+  normalizeArrayIndex: boolean;
+}) => any;
+/**
+ * Serialize given data structure to JSON data objects (not a JSON string).
+ *
+ * The resulting JSON object can be stringified using JSON.stringify().
+ *
+ * ```typescript
+ * interface Data {
+ *     created: Date;
+ * }
+ *
+ * const json = serialize<Data>({created: new Date(1234567890123)});
+ * //json is {created: '2009-02-13T23:31:30.123Z'}
+ *
+ * const jsonString = JSON.stringify(json);
+ * //jsonString is '{"created":"2009-02-13T23:31:30.123Z"}'
+ * ```
+ *
+ * @throws ValidationError when serialization or validation fails.
+ */
+declare function serialize<T>(data: T, options?: SerializationOptions, serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): JSONSingle<T>;
+/**
+ * Same as serialize but returns a ready to use function. Used to improve performance.
+ */
+declare function serializeFunction<T>(serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): SerializeFunction<T>;
+/**
+ * Clones a class instance deeply.
+ */
+declare function cloneClass<T>(target: T, options?: SerializationOptions): T;
+/**
+ * Tries to deserialize given data as T, and throws an error if it's not possible or validation after conversion fails.
+ *
+ * @deprecated use cast() instead
+ *
+ * @throws ValidationError when serialization or validation fails.
+ */
+declare function validatedDeserialize<T>(data: any, options?: SerializationOptions, serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): T;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/snapshot.d.ts
+declare class SnapshotSerializer extends Serializer {
+  name: string;
+  protected registerSerializers(): void;
+}
+declare const snapshotSerializer: SnapshotSerializer;
+/**
+ * Creates a new JIT compiled function to convert the class instance to a snapshot.
+ * A snapshot is essentially the class instance as `plain` serialization while references are
+ * stored only as their primary keys.
+ *
+ * Generated function is cached.
+ */
+declare function getConverterForSnapshot(reflectionClass: ReflectionClass<any>): (value: any) => any;
+/**
+ * Creates a snapshot using getConverterForSnapshot().
+ */
+declare function createSnapshot<T>(reflectionClass: ReflectionClass<T>, item: T): any;
+/**
+ * Extracts the primary key of a snapshot and converts to class type.
+ */
+declare function getPrimaryKeyExtractor<T>(reflectionClass: ReflectionClass<T>): (value: any) => Partial<T>;
+/**
+ * Creates a primary key hash generator that takes an item from any format
+ * converts it to class format, then to plain, then uses the primitive values to create a string hash.
+ *
+ * This function is designed to work on the plain values (db records or json values)
+ */
+declare function getPrimaryKeyHashGenerator(reflectionClass: ReflectionClass<any>, serializerToUse?: Serializer): (value: any) => string;
+declare function getSimplePrimaryKeyHashGenerator(reflectionClass: ReflectionClass<any>): (data: PrimaryKeyFields<any>) => string;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/typeguard.d.ts
+/**
+ * ```typescript
+ * const validator = getValidatorFunction<MyType>();
+ *
+ * const errors: ValidationErrorItem[] = [];
+ * const valid = validator(data, {errors})
+ *
+ * if (errors.length) console.log(errors); //validation failed if not empty
+ * ```
+ */
+declare function getValidatorFunction<T>(serializerToUse?: Serializer, receiveType?: ReceiveType<T>): Guard<T>;
+declare function is<T>(data: any, serializerToUse?: Serializer, errors?: ValidationErrorItem[], receiveType?: ReceiveType<T>): data is T;
+declare function guard<T>(serializerToUse?: Serializer, receiveType?: ReceiveType<T>): Guard<T>;
+/**
+ * @throws ValidationError when type is invalid.
+ */
+declare function assert<T>(data: any, serializerToUse?: Serializer, receiveType?: ReceiveType<T>): asserts data is T;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/types.d.ts
+type AutoId = number & PrimaryKey & AutoIncrement & Positive;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/validators.d.ts
+declare const validators: { [name in string]?: (...args: any[]) => (value: any) => ValidatorError | undefined };
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type@1.0.5_patch_hash=b103dd6f0287e0e911c8eda19b8f7147926ed1313aee24aa43566163_7860537665a0856c25274a46f4912f7a/node_modules/@deepkit/type/dist/cjs/src/reflection/extends.d.ts
+type AssignableType = Type | string | boolean | number | symbol | bigint | undefined | null;
+type StackEntry = {
+  left: Type;
+  right: Type;
+};
+/**
+ * The check of `extends` in Typescript. This function can be read as `left extends right`.
+ *
+ * See https://www.typescriptlang.org/docs/handbook/type-compatibility.html#any-unknown-object-void-undefined-null-and-never-assignability
+ * This algo follows strict mode.
+ *
+ * Warning: If you do not pass Type objects, typeInfer() is used which does not use cache (it is designed to be called withing type processor)
+ */
+declare function isExtendable(leftValue: AssignableType, rightValue: AssignableType, extendStack?: StackEntry[]): boolean;
+declare function _isExtendable(left: Type, right: Type, extendStack?: StackEntry[]): boolean;
+/**
+ * We don't want to embed in each and every file the type definition of Promise<t>,
+ * so we do it ondemand at runtime instead. This saves bundle size.
+ */
+declare function createPromiseObjectLiteral(type: TypePromise): TypeObjectLiteral;
+declare function parametersToTuple(parameters: TypeParameter[]): TypeTuple;
+declare function extendTemplateLiteral(left: TypeLiteral | TypeTemplateLiteral, right: TypeTemplateLiteral): boolean;
+//#endregion
+export { resolvePath as $, TypeParameter as $a, Entity as $i, PositiveNoZero as $n, getMember as $o, serializePropertyOrParameter as $r, primaryKeyAnnotation as $s, ReflectionProperty as $t, JSONPartial as A, TypeAnnotations as Aa, SerializedTypeTypeParameter as Ai, AfterDate as An, dataAnnotation as Ao, deserializeEmbedded as Ar, isMember as As, TypedArray as At, ReferenceItemInfo as B, TypeEnumMember as Ba, AutoIncrement as Bi, Excludes as Bn, float as Bo, getNameExpression as Br, isRuntime as Bs, typeSettings as Bt, getPatchSerializeFunction as C, ReflectionVisibility as Ca, NumberFields as Cc, SerializedTypeProperty as Ci, encodeOps as Cn, assertType as Co, TypeGuardRegistry as Cr, isDateType as Cs, createClassDecoratorContext as Ct, validatedDeserialize as D, SqliteOptions as Da, SerializedTypeTemplateLiteral as Di, resolveRuntimeType as Dn, binaryTypes as Do, createConverterJSForMember as Dr, isIntegerType as Ds, isDecoratorContext as Dt, serializeFunction as E, SignedBinaryBigInt as Ea, changeSetSymbol as Ec, SerializedTypeRest as Ei, resolvePacked as En, binaryBigIntAnnotation as Eo, collapsePath as Er, isIgnore as Es, createPropertyDecoratorContext as Et, stringifyUuid as F, TypeBoolean as Fa, deserializeType as Fi, BeforeDate as Fn, entityAnnotation as Fo, forwardSetToArray as Fr, isPrimitive as Fs, arrayBufferToBase64 as Ft, getReferenceItemInfo as G, TypeLiteral as Ga, BinaryBigIntType as Gi, Maximum as Gn, getAnnotations as Go, getSetTypeToArray as Gr, isTypeIncluded as Gs, genericEqual as Gt, createReferenceClass as H, TypeIndexSignature as Ha, BackReferenceOptions as Hi, ExclusiveMinimum as Hn, float64 as Ho, getPartialType as Hr, isSetType as Hs, typedArrayToBuffer as Ht, uuid as I, TypeCallSignature as Ia, serializeType as Ii, BeforeNow as In, excludedAnnotation as Io, getEmbeddedProperty as Ir, isPropertyMemberType as Is, base64ToArrayBuffer as It, markAsHydrated as J, TypeNever as Ja, DatabaseField as Ji, MultipleOf as Jn, getConstructorProperties as Jo, inAccessor as Jr, mapNameAnnotation as Js, ReceiveType as Jt, isReferenceHydrated as K, TypeMethod as Ka, CartesianProduct as Ki, MinLength as Kn, getBackReferenceType as Ko, getStaticDefaultCodeForProperty as Kr, isUUIDType as Ks, getChangeDetector as Kt, writeUuid as L, TypeClass as La, AnnotationDefinition as Li, Decimal as Ln, findMember as Lo, getIndexCheck as Lr, isPropertyType as Ls, base64ToTypedArray as Lt, JSONSingle as M, TypeArray as Ma, SerializedTypes as Mi, Alpha as Mn, defaultAnnotation as Mo, executeTypeArgumentAsArray as Mr, isNullable as Ms, UnpopulatedCheck as Mt, NoTypeReceived as N, TypeBaseMember as Na, SerializerState as Ni, Alphanumeric as Nn, embeddedAnnotation as No, extractStateToFunctionAndCallIt as Nr, isOptional as Ns, arrayBufferFrom as Nt, Binary as O, TagsReflection as Oa, SerializedTypeTuple as Oi, typeInfer as On, clearTypeJitContainer as Oo, createSerializeFunction as Or, isInternal as Os, mergeDecorator as Ot, regExpFromString as P, TypeBigInt as Pa, SimpleSerializedType as Pi, Ascii as Pn, emptyObject as Po, forwardMapToArray as Pr, isPrimaryKeyType as Ps, arrayBufferTo as Pt, pathResolver as Q, TypeObjectLiteral as Qa, EmbeddedOptions as Qi, Positive as Qn, getKeyType as Qo, serializeObjectLiteral as Qr, narrowOriginalLiteral as Qs, ReflectionParameter as Qt, TypeRegistry as R, TypeDecorator as Ra, AnnotationType as Ri, EMAIL_REGEX as Rn, flatten as Ro, getMapTypeToArray as Rr, isReadonly as Rs, nodeBufferToArrayBuffer as Rt, deserializeFunction as S, ReflectionKind as Sa, ItemChanges as Sc, SerializedTypePromise as Si, RuntimeStackEntry as Sn, applyScheduledAnnotations as So, TemplateState as Sr, isCustomTypeClass as Ss, UnionToIntersection$1 as St, serialize as T, SQLite as Ta, atomicChange as Tc, SerializedTypeReference as Ti, pack as Tn, backReferenceAnnotation as To, callExtractedFunctionIfAvailable as Tr, isHidden as Ts, createFreeDecoratorContext as Tt, getOrCreateReferenceItemInfo as U, TypeInfer as Ua, BackReferenceOptionsResolved as Ui, Includes as Un, getAlias as Uo, getPropertyNameString as Ur, isType as Us, unpopulatedSymbol as Ut, createReference as V, TypeFunction as Va, BackReference as Vi, ExclusiveMaximum as Vn, float32 as Vo, getPartialSerializeFunction as Vr, isSameType as Vs, typedArrayToBase64 as Vt, getReferenceInfo as W, TypeIntersection as Wa, BinaryBigInt as Wi, MaxLength as Wn, getAnnotationMeta as Wo, getSerializeFunction as Wr, isTypeClassOf as Ws, buildChanges as Wt, referenceSymbol as X, TypeNumber as Xa, Embedded as Xi, NegativeNoZero as Xn, getDomain as Xo, serializableKinds as Xr, merge as Xs, ReflectionFunction as Xt, referenceItemSymbol as Y, TypeNull as Ya, DatabaseFieldOptions as Yi, Negative as Yn, getDeepConstructorProperties as Yo, noopTemplate as Yr, memberNameToString as Ys, ReflectionClass as Yt, Resolver as Z, TypeObject as Za, EmbeddedMeta as Zi, Pattern as Zn, getEnumValueIndexMatcher as Zo, serializeArray as Zr, mongoIdAnnotation as Zs, ReflectionMethod as Zt, snapshotSerializer as _, PrimaryKeyType as _a, AtomicChangeInstance as _c, SerializedTypeLiteral as _i, visit as _n, Unique as _o, SerializeFunction as _r, integer as _s, FreeFluidDecorator as _t, parametersToTuple as a, IndexOptions as aa, stringifyShortResolvedType as ac, underscoreNamingStrategy as ai, propertiesOf as an, TypeString as ao, ValidatorMeta as ar, getTypeObjectLiteralFromTypeClass as as, APIClass as at, cloneClass as b, ReferenceFields as ba, DeepPartial as bc, SerializedTypeObjectLiteral as bi, Processor as bn, addType as bo, TemplateHook as br, isBinary as bs, PropertyDecoratorFn as bt, assert as c, MapName as ca, typeDecorators as cc, SerializedTypeAnnotations as ci, reflectionClassSymbol as cn, TypeTuple as co, validates as cr, hasDefaultValue as cs, ClassDecoratorFn as ct, is as d, MySQLOptions as da, uint32 as dc, SerializedTypeClassType as di, resolveClassType as dn, TypeUndefined as do, Guard as dr, hasTypeInformation as ds, DualDecorator as dt, EntityOptions as ea, referenceAnnotation as ec, serializer as ei, SerializerFn as en, TypePromise as eo, Validate as er, getPermission as es, mixin as et, createSnapshot as f, ParentLessType as fa, uint8 as fc, SerializedTypeEnum as fi, resolveForeignReflectionClass as fn, TypeUnion as fo, JitStack as fr, indexAccess as fs, ExtractApiDataType as ft, getSimplePrimaryKeyHashGenerator as g, PrimaryKeyFields as ga, widenLiteral as gc, SerializedTypeIntersection as gi, valuesOf as gn, UUIDAnnotation as go, SerializationOptions as gr, int8 as gs, FreeDecoratorResult as gt, getPrimaryKeyHashGenerator as h, PrimaryKey as ha, validationAnnotation as hc, SerializedTypeInfer as hi, typeOf as hn, UUID as ho, SerializationError as hr, int32 as hs, FreeDecoratorFn as ht, isExtendable as i, Index as ia, stringifyResolvedType as ic, typeGuardObjectLiteral as ii, hasCircularReference as in, TypeRest as io, ValidatorError as ir, getTypeJitContainer as is, t as it, JSONPartialObject as j, TypeAny as ja, SerializedTypeUnion as ji, AfterNow as jn, databaseAnnotation as jo, executeTemplates as jr, isMongoIdType as js, TypedArrayClassType as jt, JSONEntity as k, Type as ka, SerializedTypeTupleMember as ki, unpack as kn, copyAndSetParent as ko, createTypeGuardFunction as kr, isMapType as ks, TypeSettings as kt, getValidatorFunction as l, MongoId as la, typeToObject as lc, SerializedTypeArray as li, removeNominal as ln, TypeTupleMember as lo, ContainerAccessor as lr, hasEmbedded as ls, ClassDecoratorResult as lt, getPrimaryKeyExtractor as m, PostgresOptions as ma, uuidAnnotation as mc, SerializedTypeIndexSignature as mi, toSignature as mn, TypeVoid as mo, RuntimeCode as mr, int16 as ms, FluidDecorator as mt, createPromiseObjectLiteral as n, FindType as na, resolveProperty as nc, typeGuardArray as ni, getNominalId as nn, TypePropertySignature as no, ValidationError as nr, getTags as ns, entity as nt, validators as o, InlineRuntimeType as oa, stringifyType as oc, validatePropertyOrParameter as oi, reflect as on, TypeSymbol as oo, validate as or, getValueType as os, APIProperty as ot, getConverterForSnapshot as p, Postgres as pa, unboxUnion as pc, SerializedTypeFunction as pi, resolveReceiveType as pn, TypeUnknown as po, NamingStrategy as pr, indexAnnotation as ps, ExtractClass as pt, isReferenceInstance as q, TypeMethodSignature as qa, Data as qi, Minimum as qn, getClassType as qo, handleUnion as qr, isWithAnnotations as qs, EntityData as qt, extendTemplateLiteral as r, Group as ra, resolveTypeMembers as rc, typeGuardEmbedded as ri, getProperty as rn, TypeRegexp as ro, ValidationErrorItem as rr, getTitle as rs, isWithDeferredDecorators as rt, AutoId as s, JitContainer as sa, typeAnnotation as sc, SerializedType as si, reflectOrUndefined as sn, TypeTemplateLiteral as so, validateFunction as sr, groupAnnotation as ss, ClassApiTypeInterface as st, _isExtendable as t, Excluded as ta, registerTypeDecorator as tc, sortSignatures as ti, TData as tn, TypeProperty as to, ValidateFunction as tr, getReferenceType as ts, defaultValue as tt, guard as u, MySQL as ua, uint16 as uc, SerializedTypeBaseMember as ui, removeTypeName as un, TypeTypeParameter as uo, EmptySerializer as ur, hasMember as us, DecoratorAndFetchSignature as ut, cast as v, Reference as va, Changes as vc, SerializedTypeMethod as vi, PackStruct as vn, Widen as vo, Serializer as vr, isAutoIncrementType as vs, Merge as vt, patch as w, ResetAnnotation as wa, Partial$1 as wc, SerializedTypePropertySignature as wi, getEnumType as wn, autoIncrementAnnotation as wo, buildFunction as wr, isGlobalTypeClass as ws, createFluidDecorator as wt, deserialize as x, ReferenceOptions as xa, Expression as xc, SerializedTypeParameter as xi, ReflectOptions as xn, annotateClass as xo, TemplateRegistry as xr, isBinaryBigIntType as xs, PropertyDecoratorResult as xt, castFunction as y, ReferenceActions as ya, ChangesInterface as yc, SerializedTypeMethodSignature as yi, Packed as yn, WithAnnotations as yo, Template as yr, isBackReferenceType as ys, PropertyApiTypeInterface as yt, ReferenceInfo as z, TypeEnum as za, Annotations as zi, Email as zn, flattenUnionTypes as zo, getNTypeToArray as zr, isReferenceType as zs, nodeBufferToTypedArray as zt };
+//# sourceMappingURL=type-8AL5U7vn.d.cts.map