/// <reference types="node" />
/// <reference types="lodash" />

declare type KNumberType =
  | 's8'
  | 'u8'
  | 's16'
  | 'u16'
  | 's32'
  | 'u32'
  | 'time'
  | 'ip4'
  | 'float'
  | 'double'
  | 'bool';
declare type KBigIntType = 's64' | 'u64';
declare type KNumberGroupType =
  | '2s8'
  | '2u8'
  | '2s16'
  | '2u16'
  | '2s32'
  | '2u32'
  | '2f'
  | '2d'
  | '3s8'
  | '3u8'
  | '3s16'
  | '3u16'
  | '3s32'
  | '3u32'
  | '3f'
  | '3d'
  | '4s8'
  | '4u8'
  | '4s16'
  | '4u16'
  | '4s32'
  | '4u32'
  | '4f'
  | '4d'
  | '2b'
  | '3b'
  | '4b'
  | 'vb';
declare type KBigIntGroupType =
  | '2s64'
  | '2u64'
  | '3s64'
  | '3u64'
  | '4s64'
  | '4u64'
  | 'vs8'
  | 'vu8'
  | 'vs16'
  | 'vu16';

/**
 * Attribute object
 */
declare type KAttrMap = { [key: string]: string };

/**
 * Supported response encoding
 */
declare type KEncoding =
  | 'shift_jis'
  | 'utf8'
  | 'euc-jp'
  | 'ascii'
  | 'iso-8859-1';

/**
 * Information about requester
 */
declare interface EamuseInfo {
  module: string;
  method: string;
  model: string;
}

/**
 * Detail of a config
 */
declare interface ConfigOption {
  /** Provide a name to display in webui. If not provided, webui will use key as the name. */
  name?: string;
  /** Provide a description for the option */
  desc?: string;
  /** Type of the option */
  type: 'string' | 'integer' | 'float' | 'boolean';
  /** Only applies to 'integer' and 'float' */
  range?: [number, number];
  /** Validator for notify user about invalid values. return `true` to pass the validation. return a string to send a error message to WebUI. */
  validator?: (data: string) => true | string;
  /** Only applies to 'string', provide options in a dropdown menu. */
  options?: string[];
  /** Indicate whether user need to restart CORE to see changes. */
  needRestart?: boolean;
  /** Default value of the option */
  default: any;
}

/**
 * Response options
 */
declare interface EamuseSendOption {
  status?: number;

  /**
   * Encode response with specified encoding
   * Default: 'SHIFT_JIS'
   */
  encoding?: KEncoding;

  /**
   * Replace response root tag name.
   * Default to child tag name of request <call> tag,
   * which is usually the case and don't need to be replaced.
   */
  rootName?: string;

  compress?: boolean;
  kencode?: boolean;
  encrypt?: boolean;
}

declare interface EamuseSend {
  /**
   * Send empty response with status code 0
   */
  success: (options?: EamuseSendOption) => Promise<void>;

  /**
   * Send empty response with status code 1
   */
  deny: (options?: EamuseSendOption) => Promise<void>;

  /**
   * Send empty response with custom status code
   */
  status: (code: number, options?: EamuseSendOption) => Promise<void>;

  /**
   * Send plain javascript object.
   * When constructing objects, make sure to use helper [[K]]:
   * ```
   * {
   *   outter: K.ATTR({ status: "1" }, {
   *     inner: K.ITEM("s32", 1)
   *   })
   * }
   * ```
   *
   * Or follow xml-like format manually:
   * ```
   * {
   *   outter: {
   *     "@attr": { status: "1" },
   *     inner: {
   *       "@attr": { __type: "s32" },
   *       "@content": [1]
   *     }
   *   }
   * }
   * ```
   * @param res      xml-like formatted javascript object
   * @param options  Response options. See: [[EamuseSendOption]]
   */
  object: (res: any, options?: EamuseSendOption) => Promise<void>;

  /**
   * Send xml data using ejs template system.
   *
   * @param res      xml string as the template
   * @param data     Render template with specified data,
   *                 pass null or undefined to render static xml
   * @param options  Response options. See: [[EamuseSendOption]]
   */
  xml: (res: string, data?: any, options?: EamuseSendOption) => Promise<void>;

  /**
   * Send xml data using pug template system.
   *
   * @param res      pug string as the template
   * @param data     Render template with specified data,
   *                 pass null or undefined to render static xml
   * @param options  Response options. See: [[EamuseSendOption]]
   */
  pug: (res: string, data?: any, options?: EamuseSendOption) => Promise<void>;

  /**
   * Render and send ejs template from a file
   *
   * @param file     Filename of the template
   * @param data     Render template with specified data,
   *                 pass null or undefined to render static xml
   * @param options  Response options. See: [[EamuseSendOption]]
   */
  xmlFile: (
    file: string,
    data?: any,
    options?: EamuseSendOption
  ) => Promise<void>;

  /**
   * Render and send pug template from a file
   *
   * @param file     Filename of the template
   * @param data     Render template with specified data,
   *                 pass null or undefined to render static xml
   * @param options  Response options. See: [[EamuseSendOption]]
   */
  pugFile: (
    file: string,
    data?: any,
    options?: EamuseSendOption
  ) => Promise<void>;
}

/**
 * Helper type for typing your custom route.
 */
declare type EamusePluginRoute = (
  req: EamuseInfo,
  data: any,
  send: EamuseSend
) => Promise<any>;

/**
 * Helper type for typing your custom route.
 *
 * Alias for [[EamusePluginRoute]]
 */
declare type EPR = EamusePluginRoute;

/**
 * R stands for `Register`
 *
 * These functions can only be called in plugins' `register()` function.
 */
declare namespace R {
  /**
   * Register your custom route.
   *
   * You should only call this from your plugin's `register()` function.
   *
   * @param method    Method name of your target route,
   *                  usually looks like `"module.get"`
   * @param handler   Your custom route function/method following the type [[EamusePluginRoute]].
   *                  A boolean can be passed if you don't need any processing:
   *                    - `true`: Sending empty response with status code 0
   *                    - `false`: Sending empty response with status code 1
   */
  function Route(method: string, handler: EamusePluginRoute | boolean): void;

  /**
   * Register all unhandled routes for a game.
   *
   * You should only call this from your plugin's `register()` function.
   *
   * @param handler   Your custom route function/method following the type [[EamusePluginRoute]].
   *                  If undefined, the router will apply a default handler that prints method names.
   */
  function Unhandled(handler?: EamusePluginRoute): void;

  /**
   * Register a target game code to your plugin for checking savedata.
   *
   * You should only call this from your plugin's `register()` function.
   *
   * @param code  Model code of your target machine,
   *                  usually __three capital letters__
   *
   */
  function GameCode(code: string): void;

  /**
   * Register a contributor.
   *
   * Contributors will show up in WebUI.
   *
   * @param name Contributor's name
   * @param link Contributor's homepage
   */
  function Contributor(name: string, link?: string): void;

  /**
   * Register a configuration option.
   *
   * @param key config key
   * @param options See [[ConfigOption]]
   *
   * __NOTE__: `options.validator` will only notify user about invalid value. It wouldn't stop user from saving invalid value.
   */
  function Config(key: string, options: ConfigOption): void;

  /**
   * Register a WebUI event callback
   *
   * Which can be called in WebUI using `emit(event)` function or a post message to `/emit/<event>`
   *
   * Callback can be async function if you want to use await for your DB operations.
   */
  function WebUIEvent(
    event: string,
    callback: (data: any) => void | Promise<void>
  ): void;
}

/**
 * A warpper of javascript object for reading xml-like formatted data.
 */
declare class KDataReader {
  /**
   * Wrapped javascript object
   */
  public obj: any;
  constructor(obj: any);

  /**
   * Get attrubutes for a tag
   *
   * Example:
   * ```xml
   * <data>
   *   <tag status="1">
   *     <inner __type="s32">1</inner>
   *     <inner __type="s32">2</inner>
   *   </tag>
   * </data>
   * ```
   * ```javascript
   * const data = {
   *   tag: K.ATTR({ status: "1" }, {
   *     inner: [
   *       K.ITEM("s32", 1),
   *       K.ITEM("s32", 2)
   *     ]
   *   })
   * }
   * ```
   *
   * Evals:
   * ```javascript
   * $(data).attr("tag") // { status: "1" }
   * $(data).element("tag").attr().status // "1"
   * $(data).attr("tag.inner.0").__type // "s32"
   * ```
   */
  attr(path?: string): KAttrMap;

  /**
   * Get a bigint value from a tag, convert to bigint if applicable.
   *
   * Example:
   * ```xml
   * <data>
   *   <inner __type="s64">1</inner>
   *   <inner __type="s32">2</inner>
   *   <invalid __type="str">abc</invalid>
   * </data>
   * ```
   * ```javascript
   * const data = {
   *   inner: [
   *     K.ITEM("s64", 1n),
   *     K.ITEM("s32", 2)
   *   ],
   *   invalid: K.ITEM("str", "abc")
   * }
   * ```
   *
   * Evals:
   * ```javascript
   * $(data).element("inner").bigint() // 1n
   * $(data).bigint("inner.1") // 2n
   * $(data).bigint("invalid", 3n) // 3n
   * ```
   *
   * @param def Default return value when target path does
   *            not exists or is not valid.
   */
  bigint(path: string, def?: bigint): bigint;

  /**
   * Get a bigint array from a tag. Only returns valid arrays
   * when target tag has a type of [[KBigIntType]] or [[KBigIntGroupType]]
   *
   * Example:
   * ```xml
   * <data>
   *   <inner __type="s64" __count="2">1 2</inner>
   *   <invalid __type="s32" __count="2">3 4</invalid>
   * </data>
   * ```
   * ```javascript
   * const data = {
   *   inner: K.ARRAY("s64", [1n, 2n]),
   *   invalid: K.ARRAY("s32", [3, 4])
   * }
   * ```
   *
   * Evals:
   * ```javascript
   * $(data).bigints("inner") // [1n, 2n]
   * $(data).bigints("invalid") // undefined
   * ```
   */
  bigints(path: string, def?: bigint[]): bigint[];

  /**
   * Get a boolean value from a tag, return true only if value in the tag is number and **greater than zero**
   *
   * Example:
   * ```xml
   * <data>
   *   <inner __type="bool">0</inner>
   *   <inner __type="s32">2</inner>
   * </data>
   * ```
   * ```javascript
   * const data = {
   *   inner: [
   *     K.ITEM("bool", false),
   *     K.ITEM("s32", 2)
   *   ]
   * }
   * ```
   *
   * Evals:
   * ```javascript
   * $(data).bool("inner.0") // false
   * $(data).bool("inner.1") // true
   * $(data).bool("invalid") // false
   * ```
   */
  bool(path: string): boolean;

  /**
   * Get a Buffer object from a tag, Only returns valid Buffer
   * when target tag has a type of "bin"
   *
   * Example:
   * ```xml
   * <data>
   *   <inner __type="bin">00ff</inner>
   *   <invalid __type="u8" __count="3">1 2 3</invalid>
   * </data>
   * ```
   * ```javascript
   * const data = {
   *   inner: K.ITEM("bin", Buffer.from([0x00, 0xff])),
   *   invalid: K.ARRAY("u8", [1, 2, 3])
   * }
   * ```
   *
   * Evals:
   * ```javascript
   * $(data).buffer("inner") // <Buffer 00 ff>
   * $(data).buffer("invalid") // undefined
   * ```
   */
  buffer(path: string, def?: Buffer): Buffer;

  /**
   * Get raw content representation regardless of tag type
   *
   * Example:
   * ```xml
   * <data>
   *   <number __type="s32">1</number>
   *   <array __type="u8" __count="3">1 2 3</array>
   *   <string __type="str">abc</string>
   * </data>
   * ```
   * ```javascript
   * const data = {
   *   number: K.ITEM("s32", 1),
   *   array: K.ARRAY("u8", [1, 2, 3]),
   *   string: K.ITEM("str", "abc")
   * }
   * ```
   *
   * Evals:
   * ```javascript
   * $(data).content("number") // [1]
   * $(data).content("array") // [1, 2, 3]
   * $(data).content("string") // "abc"
   * ```
   */
  content(path: string, def?: any): any;

  /**
   * Get first element named **path** inside a tag
   *
   * Example:
   * ```xml
   * <data>
   *   <inner>
   *     <id __type="s32">1</id>
   *   </inner>
   *   <inner>
   *     <id __type="s32">1</id>
   *   </inner>
   * </data>
   * ```
   * ```javascript
   * const data = {
   *   inner: [
   *     { id: K.ITEM("s32", 1) },
   *     { id: K.ITEM("s32", 2) }
   *   ]
   * }
   * ```
   *
   * Evals:
   * ```javascript
   * $(data).element("inner") // <KDataReader>
   * $(data).element("inner").obj // { id: [object] }
   * $(data).element("inner").number("id") // 1
   * ```
   */
  element(path: string): KDataReader;

  /**
   * Get array of all elements named **path** inside a tag
   *
   * Example:
   * ```xml
   * <data>
   *   <inner>
   *     <id __type="s32">1</id>
   *   </inner>
   *   <inner>
   *     <id __type="s32">1</id>
   *   </inner>
   * </data>
   * ```
   * ```javascript
   * const data = {
   *   inner: [
   *     { id: K.ITEM("s32", 1) },
   *     { id: K.ITEM("s32", 2) }
   *   ]
   * }
   * ```
   *
   * Evals:
   * ```javascript
   * $(data).elements("inner") // [<KDataReader>, <KDataReader>]
   * $(data).elements("inner")[1].number("id") // 2
   * ```
   */
  elements(path: string): KDataReader[];

  /**
   * Get a number value from a tag, convert to number if applicable.
   *
   * Example:
   * ```xml
   * <data>
   *   <inner __type="s64">1</inner>
   *   <inner __type="s32">2</inner>
   *   <invalid __type="str">abc</invalid>
   * </data>
   * ```
   * ```javascript
   * const data = {
   *   inner: [
   *     K.ITEM("s64", 1n),
   *     K.ITEM("s32", 2)
   *   ],
   *   invalid: K.ITEM("str", "abc")
   * }
   * ```
   *
   * Evals:
   * ```javascript
   * $(data).element("inner").number() // 1
   * $(data).number("inner.1") // 2
   * $(data).number("invalid", 3) // 3
   * ```
   *
   * @param def Default return value when target path does
   *            not exists or is not valid.
   */
  number(path: string, def?: number): number;

  /**
   * Get a number array from a tag. Only returns valid arrays
   * when target tag has a type of [[KNumberType]] or [[KNumberGroupType]]
   *
   * Example:
   * ```xml
   * <data>
   *   <inner __type="s64" __count="2">1 2</inner>
   *   <invalid __type="s32" __count="2">3 4</invalid>
   * </data>
   * ```
   * ```javascript
   * const data = {
   *   invalid: K.ARRAY("s64", [1n, 2n]),
   *   inner: K.ARRAY("s32", [3, 4])
   * }
   * ```
   *
   * Evals:
   * ```javascript
   * $(data).bigints("invalid") // undefined
   * $(data).bigints("inner") // [3, 4]
   * ```
   */
  numbers(path: string, def?: number[]): number[];

  /**
   * Get a string from a tag, Only returns valid string
   * when target tag has a type of "str"
   *
   * Example:
   * ```xml
   * <data>
   *   <inner __type="str">abc</inner>
   *   <invalid __type="s32">1</invalid>
   * </data>
   * ```
   * ```javascript
   * const data = {
   *   inner: K.ITEM("str", "abc"),
   *   invalid: K.ITEM("s32", 1)
   * }
   * ```
   *
   * Evals:
   * ```javascript
   * $(data).str("inner") // "abc"
   * $(data).str("invalid") // undefined
   * ```
   */
  str(path: string, def?: string): string;
}

/**
 * Helper for reading xml-like formatted data.
 */
declare function $(data: any): KDataReader;
declare namespace $ {
  function ATTR(data: any, path?: string): KAttrMap;
  function BIGINT(data: any, path: string, def?: bigint): bigint;
  function BIGINTS(data: any, path: string, def?: bigint[]): bigint[];
  function BOOL(data: any, path: string): boolean;
  function BUFFER(data: any, path: string, def?: Buffer): Buffer;
  function CONTENT(data: any, path: string, def?: any): any;
  function ELEMENT(data: any, path: string, def?: any): any;
  function ELEMENTS(data: any, path: string, def?: any): any;
  function NUMBER(data: any, path: string, def?: number): number;
  function NUMBERS(data: any, path: string, def?: number[]): number[];
  function STR(data: any, path: string, def?: string): string;
}

/** @ignore */
declare interface KITEM<
  S extends
    | KNumberType
    | KBigIntType
    | KNumberGroupType
    | KBigIntGroupType
    | 'str'
    | 'bool'
    | 'bin'
    | 'ip4'
> {
  '@attr': {
    __type: S;
  };
  '@content': S extends 'str'
    ? string
    : S extends 'bin'
    ? Buffer
    : S extends KNumberType | 'ip4' | 'bool'
    ? [number]
    : S extends KBigIntType
    ? [bigint]
    : S extends KNumberGroupType
    ? number[]
    : S extends KBigIntGroupType
    ? bigint[]
    : unknown;
}

/** @ignore */
declare interface KARRAY<S extends KNumberType | KBigIntType> {
  '@attr': {
    __count: number;
    __type: S;
  };
  '@content': S extends KNumberType
    ? number[]
    : S extends KBigIntType
    ? bigint[]
    : unknown;
}

/** @ignore */
declare interface KATTR<M> {
  '@attr': M;
}

/**
 * K stands for `Konstruct`
 *
 * Helper for constructing xml-like javascript object.
 */
declare namespace K {
  /**
   * Example:
   * ```
   * {
   *   tag: K.ATTR({attr: "1"}, {
   *     inner: [{}, {}]
   *   })
   * }
   * ```
   * Represents:
   * ```
   * <tag attr="1">
   *   <inner/>
   *   <inner/>
   * </tag>
   * ```
   * @param attr  Attribute map
   * @param inner Inner tag/data
   */
  function ATTR<M extends KAttrMap, T>(attr: M, inner?: T): KATTR<M> & T;

  /**
   * Example:
   * ```
   * {
   *   tag: K.ITEM('s32', 1, {attr: "2"})
   * }
   * ```
   * Represents:
   * ```
   * <tag __type="s32" attr="2">1</tag>
   * ```
   * @param type    ____type__ attribute, which is used during encoding and compression
   * @param content data of specified type
   * @param attr    attribute map in addition to **__type**
   */
  function ITEM(type: 'str', content: string, attr?: KAttrMap): KITEM<'str'>;
  function ITEM(type: 'bin', content: Buffer, attr?: KAttrMap): KITEM<'bin'>;
  function ITEM(type: 'ip4', content: string, attr?: KAttrMap): KITEM<'ip4'>;
  function ITEM(type: 'bool', content: boolean, attr?: KAttrMap): KITEM<'bool'>;
  function ITEM<S extends KNumberType>(
    type: S,
    content: number,
    attr?: KAttrMap
  ): KITEM<S>;
  function ITEM<S extends KBigIntType>(
    type: S,
    content: bigint,
    attr?: KAttrMap
  ): KITEM<S>;
  function ITEM<S extends KNumberGroupType>(
    type: S,
    content: number[],
    attr?: KAttrMap
  ): KITEM<S>;
  function ITEM<S extends KBigIntGroupType>(
    type: S,
    content: bigint[],
    attr?: KAttrMap
  ): KITEM<S>;

  /**
   * Example:
   * ```
   * {
   *   tag: K.ARRAY('s32', [1, 2, 3], {attr: "4"})
   * }
   * ```
   * Represents:
   * ```
   * <tag __type="s32" __count="3" attr="2">1 2 3</tag>
   * ```
   * @param type    ____type__ attribute, which is used during encoding and compression
   * @param content array of data, ____count__ attribute will be automatically set to `content.length`
   * @param attr    attribute map in addition to **__type** and **__count**
   */
  function ARRAY<S extends 'u8' | 's8'>(
    type: S,
    content: Buffer,
    attr?: KAttrMap
  ): KARRAY<S>;
  function ARRAY<S extends KNumberType>(
    type: S,
    content: number[],
    attr?: KAttrMap
  ): KARRAY<S>;
  function ARRAY<S extends KBigIntType>(
    type: S,
    content: bigint[],
    attr?: KAttrMap
  ): KARRAY<S>;
}

/**
 * Filesystem IO
 *
 * These are designed to match nodejs `fs` module. Along with custom filesystem implementation for reading compressed data.
 *
 * __DO NOT__ use IO for savedata. Please use [[DB]] namespace so your data can be managed by WebUI.
 *
 * Also, due to difference between operating systems, you should always prepare your files using ascii path.
 * Both UTF-8 and local encodings will have cross-platform compatibility issues.
 */
declare namespace IO {
  /**
   * Resolve a relative path starting from your plugin directory to an absolute path.
   */
  function Resolve(path: string): string;

  /**
   * Asynchronously read a directory.
   * @param path A path to a directory.
   */
  function ReadDir(
    path: string
  ): Promise<{ name: string; type: 'file' | 'dir' | 'unsupported' }[]>;

  /**
   * Asynchronously writes data to a file, replacing the file if it already exists.
   * @param path A path to a file.
   * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
   * @param data The data to write. If something other than a Buffer or Uint8Array is provided, the value is coerced to a string.
   * @param options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
   * If `encoding` is not supplied, the default of `'utf8'` is used.
   * If `mode` is not supplied, the default of `0o666` is used.
   * If `mode` is a string, it is parsed as an octal integer.
   * If `flag` is not supplied, the default of `'w'` is used.
   */
  function WriteFile(
    path: string,
    data: any,
    options:
      | { encoding?: string | null; mode?: number | string; flag?: string }
      | string
      | null
  ): Promise<void>;

  /**
   * Asynchronously writes data to a file, replacing the file if it already exists.
   * @param path A path to a file.
   * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
   * @param data The data to write. If something other than a Buffer or Uint8Array is provided, the value is coerced to a string.
   */
  function WriteFile(path: string, data: any): Promise<void>;

  /**
   * Asynchronously reads the entire contents of a file.
   * @param path A path to a file.
   * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
   * @param options An object that may contain an optional flag.
   * If a flag is not provided, it defaults to `'r'`.
   */
  function ReadFile(
    path: string,
    options: { encoding?: null; flag?: string } | undefined | null
  ): Promise<Buffer>;

  /**
   * Asynchronously reads the entire contents of a file.
   * @param path A path to a file.
   * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
   * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag.
   * If a flag is not provided, it defaults to `'r'`.
   */
  function ReadFile(
    path: string,
    options: { encoding: string; flag?: string } | string
  ): Promise<string>;

  /**
   * Asynchronously reads the entire contents of a file.
   * @param path A path to a file.
   * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
   * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag.
   * If a flag is not provided, it defaults to `'r'`.
   */
  function ReadFile(
    path: string,
    options:
      | { encoding?: string | null; flag?: string }
      | string
      | undefined
      | null
  ): Promise<string | Buffer>;

  /**
   * Asynchronously reads the entire contents of a file.
   * @param path A path to a file.
   * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
   */
  function ReadFile(path: string): Promise<Buffer>;
}

/**
 * U stands for `Utilities`
 *
 * You can find miscellaneous helpers here
 */
declare namespace U {
  /**
   * Convert json data to xml string.
   *
   * @param data xml-like javascript object
   */
  function toXML(data: any): string;

  /**
   * Convert xml string to javascript object. Output will always be plain javascript string.
   *
   * @param xml xml string
   * @param simplify if true, the parser will ignore attributes and only generate string values. (default: true)
   */
  function parseXML(xml: string, simplify?: boolean): any;

  /**
   * Get config from user configuration file.
   * @param key
   */
  function GetConfig(key: string): any;
}

/** @ignore */
type Doc<T> = { _id?: string } & T;
/** @ignore */
type ProfileDoc<T> = { _id?: string; __refid?: string } & T;
/** @ignore */
type Query<T> = {
  [P in keyof T]?:
    | T[P]
    | (T[P] extends Array<infer E>
        ? { $elemMatch: Query<E[]> } | { $size: number }
        : T[P] extends number | string
        ?
            | { $lt: T[P] }
            | { $lte: T[P] }
            | { $gt: T[P] }
            | { $gte: T[P] }
            | { $in: T[P][] }
            | { $ne: any }
            | { $nin: any[] }
            | { $exists: boolean }
            | { $regex: RegExp }
        : T[P] extends object
        ? Query<T[P]>
        : T[P]);
} & {
  $or?: Query<T>[];
  $and?: Query<T>[];
  $not?: Query<T>;
  $where?: (this: T) => boolean;
  _id?: string;
  [path: string]: any;
};
/** @ignore */
type Operators =
  | '$exists'
  | '$lt'
  | '$lte'
  | '$gt'
  | '$gte'
  | '$in'
  | '$ne'
  | '$nin'
  | '$regex';
/** @ignore */
type PickyOperator<T, C, F> = Pick<
  {
    [P in keyof T]?: T[P] extends C ? F : Omit<T[P], Operators>;
  },
  {
    [P in keyof T]: T[P] extends C ? P : never;
  }[keyof T]
>;
/** @ignore */
type ArrayPushOperator<T> = Pick<
  {
    [P in keyof T]?: T[P] extends Array<infer E>
      ? E | { $each?: E[]; $slice?: number }
      : never;
  },
  { [P in keyof T]: T[P] extends Array<any> ? P : never }[keyof T]
> & { [path: string]: any | { $each?: any[]; $slice?: number } };
/** @ignore */
type ArraySetOperator<T> = Pick<
  {
    [P in keyof T]?: T[P] extends Array<infer E> ? E | { $each: E[] } : never;
  },
  { [P in keyof T]: T[P] extends Array<any> ? P : never }[keyof T]
> & { [path: string]: any | { $each: any[] } };
/** @ignore */
type ArrayInOperator<T> = Pick<
  {
    [P in keyof T]?: T[P] extends Array<infer E> ? E | { $in: E[] } : never;
  },
  { [P in keyof T]: T[P] extends Array<any> ? P : never }[keyof T]
> & { [path: string]: any | { $in: any[] } };
/** @ignore */
type ArrayPopOperator<T> = Pick<
  {
    [P in keyof T]?: T[P] extends Array<any> ? -1 | 1 : never;
  },
  { [P in keyof T]: T[P] extends Array<any> ? P : never }[keyof T]
> & { [path: string]: -1 | 1 };
/** @ignore */
type Update<T> = Partial<T> & {
  $unset?: PickyOperator<T, number, true> & { [path: string]: true };
  $set?: { [P in keyof T]?: Omit<T[P], Operators> } & { [path: string]: any };
  $min?: PickyOperator<T, number, number> & { [path: string]: number };
  $max?: PickyOperator<T, number, number> & { [path: string]: number };
  $inc?: PickyOperator<T, number, number> & { [path: string]: number };
  $push?: ArrayPushOperator<T>;
  $addToSet?: ArraySetOperator<T>;
  $pop?: ArrayPopOperator<T>;
  $pull?: ArrayInOperator<T>;
} & {
  [path: string]: any;
};

/**
 * Database operation.
 *
 * There are two pools of data for each plugin: ___PluginSpace___ and __ProfileSpace__
 *
 * If `refid` is a string, query will match a specific profile data in __ProfileSpace__.
 *
 * If `refid` is null, query will match all profile data in __ProfileSpace__.
 *   (doesn't apply to [[DB.Insert]])
 *
 * If `refid` is not provided, query will match data in ___PluginSpace___.
 *
 * ---
 *
 * **NOTE**: since WebUI can delete data in __ProfileSpace__,
 * you should refrain from referencing refid in your document to prevent getting unclearable garbage data.
 *
 * If you need to make rival/friend feature, we recommend you to get all profile data by passing null to `refid`.
 * There will be 16 profiles maximum which is small enough to manage.
 *
 * All query and doc should not have any fields start with "__" with "__refid" being the only exception.
 * However, "__refid" field will still be ignored while other "__" starting fields will cause an error to be thrown.
 */
declare namespace DB {
  function FindOne<T>(
    refid: string | null,
    query: Query<T>
  ): Promise<ProfileDoc<T>>;
  function FindOne<T>(query: Query<T>): Promise<Doc<T>>;

  function Find<T>(
    refid: string | null,
    query: Query<T>
  ): Promise<ProfileDoc<T>[]>;
  function Find<T>(query: Query<T>): Promise<Doc<T>[]>;

  function Insert<T>(refid: string, doc: T): Promise<ProfileDoc<T>>;
  function Insert<T>(doc: T): Promise<Doc<T>>;

  function Remove<T>(refid: string | null, query: Query<T>): Promise<number>;
  function Remove<T>(query: Query<T>): Promise<number>;

  function Update<T>(
    refid: string | null,
    query: Query<T>,
    update: Update<T>
  ): Promise<{
    updated: number;
    docs: ProfileDoc<T>[];
  }>;
  function Update<T>(
    query: Query<T>,
    update: Update<T>
  ): Promise<{
    updated: number;
    docs: Doc<T>[];
  }>;

  function Upsert<T>(
    refid: string | null,
    query: Query<T>,
    update: Update<T>
  ): Promise<{
    updated: number;
    docs: ProfileDoc<T>[];
    upsert: boolean;
  }>;
  function Upsert<T>(
    query: Query<T>,
    update: Update<T>
  ): Promise<{
    updated: number;
    docs: Doc<T>[];
    upsert: boolean;
  }>;

  function Count<T>(refid: string | null, query: Query<T>): Promise<number>;
  function Count<T>(query: Query<T>): Promise<number>;
}

/** @ignore */
// @ts-ignore
declare const _: any;