@rian8337/osu-droid-replay-analyzer 2.0.0-alpha.3 → 2.0.0-alpha.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rian8337/osu-droid-replay-analyzer",
-  "version": "2.0.0-alpha.3",
+  "version": "2.0.0-alpha.4",
   "description": "A replay analyzer for analyzing osu!droid replay files.",
   "keywords": [
     "osu",
@@ -22,18 +22,17 @@
     "url": "git+https://github.com/Rian8337/osu-droid-module.git"
   },
   "scripts": {
-    "build": "rollup -c ../../rollup.config.js",
+    "build": "dts-gen -m java-deserialization -o -f ./node_modules/java-deserialization/src/index.d.ts && rollup -c ../../rollup.config.js",
     "lint": "eslint --ext ts",
-    "prepare": "dts-gen -m java-deserialization -o -f ./node_modules/java-deserialization/src/index.d.ts && npm run build",
     "test": "echo \"No tests for this module\""
   },
   "bugs": {
     "url": "https://github.com/Rian8337/osu-droid-module/issues"
   },
   "dependencies": {
-    "@rian8337/osu-base": "^2.0.0-alpha.0",
-    "@rian8337/osu-difficulty-calculator": "^2.0.0-alpha.2",
-    "@rian8337/osu-rebalance-difficulty-calculator": "^2.0.0-alpha.2",
+    "@rian8337/osu-base": "^2.0.0-alpha.4",
+    "@rian8337/osu-difficulty-calculator": "^2.0.0-alpha.4",
+    "@rian8337/osu-rebalance-difficulty-calculator": "^2.0.0-alpha.4",
     "java-deserialization": "^0.1.0",
     "unzipper": "^0.10.11"
   },
@@ -45,5 +44,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "2dcada0b1b3986ea9637472b2b34e6b51c0ea40d"
+  "gitHead": "d7ebd2e4178199a8ccede5e409bbeaaafae62b35"
 }

package/typings/index.d.ts

@@ -1,653 +1,668 @@
-import { Accuracy, Mod, Beatmap } from '@rian8337/osu-base';
-import { DroidStarRating } from '@rian8337/osu-difficulty-calculator';
-import { DroidStarRating as DroidStarRating$1 } from '@rian8337/osu-rebalance-difficulty-calculator';
+import { Accuracy, Mod, Beatmap } from "@rian8337/osu-base";
+import { DroidStarRating } from "@rian8337/osu-difficulty-calculator";
+import { DroidStarRating as DroidStarRating$1 } from "@rian8337/osu-rebalance-difficulty-calculator";
 
-/**
- * Movement type of a cursor in an osu!droid replay.
- */
-declare enum movementType {
-    DOWN = 0,
-    MOVE = 1,
-    UP = 2
+/**
+ * Movement type of a cursor in an osu!droid replay.
+ */
+declare enum movementType {
+    DOWN = 0,
+    MOVE = 1,
+    UP = 2,
 }
 
-/**
- * Contains information about a cursor instance.
- */
-interface CursorInformation {
-    /**
-     * The movement size of the cursor instance.
-     */
-    size: number;
-    /**
-     * The time during which this cursor instance is active in milliseconds.
-     */
-    time: number[];
-    /**
-     * The x coordinates of this cursor instance in osu!pixels.
-     */
-    x: number[];
-    /**
-     * The y coordinates of this cursor instance in osu!pixels.
-     */
-    y: number[];
-    /**
-     * The hit results of this cursor instance.
-     */
-    id: number[];
-}
-/**
- * Represents a cursor instance in an osu!droid replay.
- *
- * Stores cursor movement data such as x and y coordinates, movement size, etc.
- *
- * This is used when analyzing replays using replay analyzer.
- */
-declare class CursorData implements CursorInformation {
-    size: number;
-    readonly time: number[];
-    readonly x: number[];
-    readonly y: number[];
-    readonly id: movementType[];
-    constructor(values: CursorInformation);
+/**
+ * Contains information about a cursor instance.
+ */
+interface CursorInformation {
+    /**
+     * The movement size of the cursor instance.
+     */
+    size: number;
+    /**
+     * The time during which this cursor instance is active in milliseconds.
+     */
+    time: number[];
+    /**
+     * The x coordinates of this cursor instance in osu!pixels.
+     */
+    x: number[];
+    /**
+     * The y coordinates of this cursor instance in osu!pixels.
+     */
+    y: number[];
+    /**
+     * The hit results of this cursor instance.
+     */
+    id: number[];
+}
+/**
+ * Represents a cursor instance in an osu!droid replay.
+ *
+ * Stores cursor movement data such as x and y coordinates, movement size, etc.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+declare class CursorData implements CursorInformation {
+    size: number;
+    readonly time: number[];
+    readonly x: number[];
+    readonly y: number[];
+    readonly id: movementType[];
+    constructor(values: CursorInformation);
 }
 
-/**
- * Represents an exported replay's JSON structure.
- */
-interface ExportedReplayJSON {
-    /**
-     * The version of the exported replay.
-     */
-    version: number;
-    /**
-     * Data of the exported replay.
-     */
-    replaydata: {
-        /**
-         * The path towards the beatmap's `.osu` file from the song directory of the game.
-         */
-        filename: string;
-        /**
-         * The name of the player.
-         */
-        playername: string;
-        /**
-         * The name of the replay file.
-         */
-        replayfile: string;
-        /**
-         * Droid modifications that are used in the replay.
-         */
-        mod: string;
-        /**
-         * The amount of total score achieved.
-         */
-        score: number;
-        /**
-         * The maximum combo achieved.
-         */
-        combo: number;
-        /**
-         * The rank achieved in the replay.
-         */
-        mark: string;
-        /**
-         * The amount of geki hits in the replay.
-         */
-        h300k: number;
-        /**
-         * The amount of great hits in the replay.
-         */
-        h300: number;
-        /**
-         * The amount of katu hits in the replay.
-         */
-        h100k: number;
-        /**
-         * The amount of good hits in the replay.
-         */
-        h100: number;
-        /**
-         * The amount of meh hits in the replay.
-         */
-        h50: number;
-        /**
-         * The amount of misses in the replay.
-         */
-        misses: number;
-        /**
-         * Accuracy gained in the replay.
-         */
-        accuracy: number;
-        /**
-         * The epoch date at which the score was set, in milliseconds.
-         */
-        time: number;
-        /**
-         * Whether the score is a full combo (1 is `true`, 0 is `false`).
-         */
-        perfect: number;
-    };
+/**
+ * Represents an exported replay's JSON structure.
+ */
+interface ExportedReplayJSON {
+    /**
+     * The version of the exported replay.
+     */
+    version: number;
+    /**
+     * Data of the exported replay.
+     */
+    replaydata: {
+        /**
+         * The path towards the beatmap's `.osu` file from the song directory of the game.
+         */
+        filename: string;
+        /**
+         * The name of the player.
+         */
+        playername: string;
+        /**
+         * The name of the replay file.
+         */
+        replayfile: string;
+        /**
+         * Droid modifications that are used in the replay.
+         */
+        mod: string;
+        /**
+         * The amount of total score achieved.
+         */
+        score: number;
+        /**
+         * The maximum combo achieved.
+         */
+        combo: number;
+        /**
+         * The rank achieved in the replay.
+         */
+        mark: string;
+        /**
+         * The amount of geki hits in the replay.
+         */
+        h300k: number;
+        /**
+         * The amount of great hits in the replay.
+         */
+        h300: number;
+        /**
+         * The amount of katu hits in the replay.
+         */
+        h100k: number;
+        /**
+         * The amount of good hits in the replay.
+         */
+        h100: number;
+        /**
+         * The amount of meh hits in the replay.
+         */
+        h50: number;
+        /**
+         * The amount of misses in the replay.
+         */
+        misses: number;
+        /**
+         * Accuracy gained in the replay.
+         */
+        accuracy: number;
+        /**
+         * The epoch date at which the score was set, in milliseconds.
+         */
+        time: number;
+        /**
+         * Whether the score is a full combo (1 is `true`, 0 is `false`).
+         */
+        perfect: number;
+    };
 }
 
-/**
- * The result of a hit in an osu!droid replay.
- */
-declare enum hitResult {
-    /**
-     * Miss (0).
-     */
-    RESULT_0 = 1,
-    /**
-     * Meh (50).
-     */
-    RESULT_50 = 2,
-    /**
-     * Great (100).
-     */
-    RESULT_100 = 3,
-    /**
-     * Good (300).
-     */
-    RESULT_300 = 4
+/**
+ * The result of a hit in an osu!droid replay.
+ */
+declare enum hitResult {
+    /**
+     * Miss (0).
+     */
+    RESULT_0 = 1,
+    /**
+     * Meh (50).
+     */
+    RESULT_50 = 2,
+    /**
+     * Great (100).
+     */
+    RESULT_100 = 3,
+    /**
+     * Good (300).
+     */
+    RESULT_300 = 4,
 }
 
-/**
- * Represents a hitobject in an osu!droid replay.
- *
- * Stores information about hitobjects in an osu!droid replay such as hit offset, tickset, and hit result.
- *
- * This is used when analyzing replays using replay analyzer.
- */
-declare class ReplayObjectData {
-    /**
-     * The offset of which the hitobject was hit in milliseconds.
-     */
-    accuracy: number;
-    /**
-     * The tickset of the hitobject.
-     *
-     * This is used to determine whether or not a slider event (tick/repeat/end) is hit based on the order they appear.
-     */
-    tickset: boolean[];
-    /**
-     * The bitwise hit result of the hitobject.
-     */
-    result: hitResult;
-    constructor(values: {
-        /**
-         * The offset of which the hitobject was hit in milliseconds.
-         */
-        accuracy: number;
-        /**
-         * The tickset of the hitobject.
-         *
-         * This is used to determine whether or not a slider event (tick/repeat/end) is hit based on the order they appear.
-         */
-        tickset: boolean[];
-        /**
-         * The bitwise hit result of the hitobject.
-         */
-        result: hitResult;
-    });
+/**
+ * Represents a hitobject in an osu!droid replay.
+ *
+ * Stores information about hitobjects in an osu!droid replay such as hit offset, tickset, and hit result.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+declare class ReplayObjectData {
+    /**
+     * The offset of which the hitobject was hit in milliseconds.
+     */
+    accuracy: number;
+    /**
+     * The tickset of the hitobject.
+     *
+     * This is used to determine whether or not a slider event (tick/repeat/end) is hit based on the order they appear.
+     */
+    tickset: boolean[];
+    /**
+     * The bitwise hit result of the hitobject.
+     */
+    result: hitResult;
+    constructor(values: {
+        /**
+         * The offset of which the hitobject was hit in milliseconds.
+         */
+        accuracy: number;
+        /**
+         * The tickset of the hitobject.
+         *
+         * This is used to determine whether or not a slider event (tick/repeat/end) is hit based on the order they appear.
+         */
+        tickset: boolean[];
+        /**
+         * The bitwise hit result of the hitobject.
+         */
+        result: hitResult;
+    });
 }
 
-/**
- * Contains information about a replay.
- */
-interface ReplayInformation {
-    /**
-     * The version of the replay.
-     */
-    replayVersion: number;
-    /**
-     * The folder name containing the beatmap played.
-     */
-    folderName: string;
-    /**
-     * The file name of the beatmap played.
-     */
-    fileName: string;
-    /**
-     * The MD5 hash of the beatmap played.
-     */
-    hash: string;
-    /**
-     * The date of which the play was set.
-     *
-     * Only available in replay v3 or later.
-     */
-    time?: Date;
-    /**
-     * The amount of geki and 300 katu achieved in the play. See {@link https://osu.ppy.sh/help/wiki/Score this} osu! wiki page for more information.
-     *
-     * Only available in replay v3 or later.
-     *
-     * If `map` is defined in analyzer (either in `Beatmap` or `StarRating` instance), this will be analyzed using beatmap hitobject information and replay hitobject data for replay v1 and v2.
-     */
-    hit300k?: number;
-    /**
-     * The amount of 100 katu achieved in the play. See {@link https://osu.ppy.sh/help/wiki/Score this} osu! wiki page for more information.
-     *
-     * Only available in replay v3 or later.
-     *
-     * If `map` is defined in analyzer (either in `Beatmap` or `StarRating` instance), this will be analyzed using beatmap hitobject information and replay hitobject data for replay v1 and v2.
-     */
-    hit100k?: number;
-    /**
-     * The total score achieved in the play.
-     *
-     * Only available in replay v3 or later.
-     */
-    score?: number;
-    /**
-     * The maximum combo achieved in the play.
-     *
-     * Only available in replay v3 or later.
-     */
-    maxCombo?: number;
-    /**
-     * The accuracy achieved in the play.
-     *
-     * Only available in replay v3 or later.
-     *
-     * If `map` is defined in analyzer (either in `Beatmap` or `StarRating` instance), this will be analyzed using beatmap hitobject information and replay hitobject data for replay v1 and v2.
-     */
-    accuracy?: Accuracy;
-    /**
-     * Whether or not the play achieved the beatmap's maximum combo.
-     *
-     * Only available in replay v3 or later.
-     */
-    isFullCombo?: boolean;
-    /**
-     * The name of the player in the replay.
-     *
-     * Only available in replay v3 or later.
-     */
-    playerName?: string;
-    /**
-     * Enabled modifications during the play in raw Java object format.
-     *
-     * Only available in replay v3 or later.
-     */
-    rawMods?: string;
-    /**
-     * The achieved rank in the play.
-     *
-     * Only available in replay v3 or later.
-     *
-     * If `map` is defined in analyzer (either in `Beatmap` or `StarRating` instance), this will be analyzed using beatmap hitobject information and replay hitobject data for replay v1 and v2.
-     */
-    rank?: string;
-    /**
-     * Enabled modifications during the play in osu!standard format.
-     *
-     * Only available in replay v3 or later.
-     */
-    convertedMods?: Mod[];
-    /**
-     * The speed modification of the replay.
-     *
-     * Only available in replay v4 or later. By default this is 1.
-     */
-    speedModification?: number;
-    /**
-     * The forced AR of the replay.
-     *
-     * Only available in replay v4 or later.
-     */
-    forcedAR?: number;
-    /**
-     * The cursor movement data of the replay.
-     */
-    cursorMovement: CursorData[];
-    /**
-     * The hit object data of the replay.
-     */
-    hitObjectData: ReplayObjectData[];
-}
-/**
- * Represents a replay data in an osu!droid replay.
- *
- * Stores generic information about an osu!droid replay such as player name, MD5 hash, time set, etc.
- *
- * This is used when analyzing replays using replay analyzer.
- */
-declare class ReplayData implements ReplayInformation {
-    readonly replayVersion: number;
-    readonly folderName: string;
-    readonly fileName: string;
-    readonly hash: string;
-    readonly time: Date;
-    readonly hit300k: number;
-    readonly hit100k: number;
-    readonly score: number;
-    readonly maxCombo: number;
-    readonly accuracy: Accuracy;
-    readonly isFullCombo: boolean;
-    readonly playerName: string;
-    readonly rawMods: string;
-    readonly rank: string;
-    readonly convertedMods: Mod[];
-    readonly cursorMovement: CursorData[];
-    readonly hitObjectData: ReplayObjectData[];
-    readonly speedModification: number;
-    readonly forcedAR?: number;
-    constructor(values: ReplayInformation);
+/**
+ * Contains information about a replay.
+ */
+interface ReplayInformation {
+    /**
+     * The version of the replay.
+     */
+    replayVersion: number;
+    /**
+     * The folder name containing the beatmap played.
+     */
+    folderName: string;
+    /**
+     * The file name of the beatmap played.
+     */
+    fileName: string;
+    /**
+     * The MD5 hash of the beatmap played.
+     */
+    hash: string;
+    /**
+     * The date of which the play was set.
+     *
+     * Only available in replay v3 or later.
+     */
+    time?: Date;
+    /**
+     * The amount of geki and 300 katu achieved in the play. See {@link https://osu.ppy.sh/help/wiki/Score this} osu! wiki page for more information.
+     *
+     * Only available in replay v3 or later.
+     *
+     * If `map` is defined in analyzer (either in `Beatmap` or `StarRating` instance), this will be analyzed using beatmap hitobject information and replay hitobject data for replay v1 and v2.
+     */
+    hit300k?: number;
+    /**
+     * The amount of 100 katu achieved in the play. See {@link https://osu.ppy.sh/help/wiki/Score this} osu! wiki page for more information.
+     *
+     * Only available in replay v3 or later.
+     *
+     * If `map` is defined in analyzer (either in `Beatmap` or `StarRating` instance), this will be analyzed using beatmap hitobject information and replay hitobject data for replay v1 and v2.
+     */
+    hit100k?: number;
+    /**
+     * The total score achieved in the play.
+     *
+     * Only available in replay v3 or later.
+     */
+    score?: number;
+    /**
+     * The maximum combo achieved in the play.
+     *
+     * Only available in replay v3 or later.
+     */
+    maxCombo?: number;
+    /**
+     * The accuracy achieved in the play.
+     *
+     * Only available in replay v3 or later.
+     *
+     * If `map` is defined in analyzer (either in `Beatmap` or `StarRating` instance), this will be analyzed using beatmap hitobject information and replay hitobject data for replay v1 and v2.
+     */
+    accuracy?: Accuracy;
+    /**
+     * Whether or not the play achieved the beatmap's maximum combo.
+     *
+     * Only available in replay v3 or later.
+     */
+    isFullCombo?: boolean;
+    /**
+     * The name of the player in the replay.
+     *
+     * Only available in replay v3 or later.
+     */
+    playerName?: string;
+    /**
+     * Enabled modifications during the play in raw Java object format.
+     *
+     * Only available in replay v3 or later.
+     */
+    rawMods?: string;
+    /**
+     * The achieved rank in the play.
+     *
+     * Only available in replay v3 or later.
+     *
+     * If `map` is defined in analyzer (either in `Beatmap` or `StarRating` instance), this will be analyzed using beatmap hitobject information and replay hitobject data for replay v1 and v2.
+     */
+    rank?: string;
+    /**
+     * Enabled modifications during the play in osu!standard format.
+     *
+     * Only available in replay v3 or later.
+     */
+    convertedMods?: Mod[];
+    /**
+     * The speed modification of the replay.
+     *
+     * Only available in replay v4 or later. By default this is 1.
+     */
+    speedModification?: number;
+    /**
+     * The forced AR of the replay.
+     *
+     * Only available in replay v4 or later.
+     */
+    forcedAR?: number;
+    /**
+     * The cursor movement data of the replay.
+     */
+    cursorMovement: CursorData[];
+    /**
+     * The hit object data of the replay.
+     */
+    hitObjectData: ReplayObjectData[];
+}
+/**
+ * Represents a replay data in an osu!droid replay.
+ *
+ * Stores generic information about an osu!droid replay such as player name, MD5 hash, time set, etc.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+declare class ReplayData implements ReplayInformation {
+    readonly replayVersion: number;
+    readonly folderName: string;
+    readonly fileName: string;
+    readonly hash: string;
+    readonly time: Date;
+    readonly hit300k: number;
+    readonly hit100k: number;
+    readonly score: number;
+    readonly maxCombo: number;
+    readonly accuracy: Accuracy;
+    readonly isFullCombo: boolean;
+    readonly playerName: string;
+    readonly rawMods: string;
+    readonly rank: string;
+    readonly convertedMods: Mod[];
+    readonly cursorMovement: CursorData[];
+    readonly hitObjectData: ReplayObjectData[];
+    readonly speedModification: number;
+    readonly forcedAR?: number;
+    constructor(values: ReplayInformation);
 }
 
-interface HitErrorInformation {
-    negativeAvg: number;
-    positiveAvg: number;
-    unstableRate: number;
-}
-/**
- * A replay analyzer that analyzes a replay from osu!droid.
- *
- * Created by reverse engineering the replay parser from the game itself, which can be found {@link https://github.com/osudroid/osu-droid/blob/master/src/ru/nsu/ccfit/zuev/osu/scoring/Replay.java here}.
- *
- * Once analyzed, the result can be accessed via the `data` property.
- */
-declare class ReplayAnalyzer {
-    /**
-     * The score ID of the replay.
-     */
-    scoreID: number;
-    /**
-     * The original odr file of the replay.
-     */
-    originalODR: Buffer | null;
-    /**
-     * The fixed odr file of the replay.
-     */
-    fixedODR: Buffer | null;
-    /**
-     * Whether or not the play is considered using >=3 finger abuse.
-     */
-    is3Finger?: boolean;
-    /**
-     * Whether or not the play is considered 2-handed.
-     */
-    is2Hand?: boolean;
-    /**
-     * The beatmap that is being analyzed. `DroidStarRating` or `RebalanceDroidStarRating` is required for three finger or two hand analyzing.
-     */
-    map?: Beatmap | DroidStarRating | DroidStarRating$1;
-    /**
-     * The results of the analyzer. `null` when initialized.
-     */
-    data: ReplayData | null;
-    /**
-     * Penalty value used to penalize dpp for 2-hand.
-     */
-    aimPenalty: number;
-    /**
-     * Penalty value used to penalize dpp for 3 finger abuse.
-     */
-    tapPenalty: number;
-    /**
-     * Whether this replay has been checked against 3 finger usage.
-     */
-    hasBeenCheckedFor3Finger: boolean;
-    /**
-     * Whether this replay has been checked against 2 hand usage.
-     */
-    hasBeenCheckedFor2Hand: boolean;
-    private readonly BYTE_LENGTH;
-    private readonly SHORT_LENGTH;
-    private readonly INT_LENGTH;
-    private readonly FLOAT_LENGTH;
-    private readonly LONG_LENGTH;
-    constructor(values: {
-        /**
-         * The ID of the score.
-         */
-        scoreID: number;
-        /**
-         * The beatmap to analyze.
-         *
-         * `DroidStarRating` or `RebalanceDroidStarRating` is required for three finger or two hand analyzing.
-         */
-        map?: Beatmap | DroidStarRating | DroidStarRating$1;
-    });
-    /**
-     * Analyzes a replay.
-     */
-    analyze(): Promise<ReplayAnalyzer>;
-    /**
-     * Downloads the given score ID's replay.
-     */
-    private downloadReplay;
-    /**
-     * Decompresses a replay.
-     *
-     * The decompressed replay is in a form of Java object. This will be converted to a buffer and deserialized to read data from the replay.
-     */
-    private decompress;
-    /**
-     * Parses a replay after being downloaded and converted to a buffer.
-     */
-    private parseReplay;
-    /**
-     * Gets hit error information of the replay.
-     *
-     * `analyze()` must be called before calling this.
-     */
-    calculateHitError(): HitErrorInformation | null;
-    /**
-     * Converts replay mods to droid mod string.
-     */
-    private convertDroidMods;
-    /**
-     * Converts replay mods to regular mod string.
-     */
-    private convertMods;
-    /**
-     * Checks if a play is using 3 fingers.
-     *
-     * Requires `analyze()` to be called first and `map` to be defined as `DroidStarRating` or `RebalanceDroidStarRating`.
-     */
-    checkFor3Finger(): void;
-    /**
-     * Checks if a play is using 2 hands.
-     *
-     * Requires `analyze()` to be called first and `map` to be defined as `DroidStarRating` or `RebalanceDroidStarRating`.
-     */
-    checkFor2Hand(): void;
+interface HitErrorInformation {
+    negativeAvg: number;
+    positiveAvg: number;
+    unstableRate: number;
+}
+/**
+ * A replay analyzer that analyzes a replay from osu!droid.
+ *
+ * Created by reverse engineering the replay parser from the game itself, which can be found {@link https://github.com/osudroid/osu-droid/blob/master/src/ru/nsu/ccfit/zuev/osu/scoring/Replay.java here}.
+ *
+ * Once analyzed, the result can be accessed via the `data` property.
+ */
+declare class ReplayAnalyzer {
+    /**
+     * The score ID of the replay.
+     */
+    scoreID: number;
+    /**
+     * The original odr file of the replay.
+     */
+    originalODR: Buffer | null;
+    /**
+     * The fixed odr file of the replay.
+     */
+    fixedODR: Buffer | null;
+    /**
+     * Whether or not the play is considered using >=3 finger abuse.
+     */
+    is3Finger?: boolean;
+    /**
+     * Whether or not the play is considered 2-handed.
+     */
+    is2Hand?: boolean;
+    /**
+     * The beatmap that is being analyzed. `DroidStarRating` or `RebalanceDroidStarRating` is required for three finger or two hand analyzing.
+     */
+    map?: Beatmap | DroidStarRating | DroidStarRating$1;
+    /**
+     * The results of the analyzer. `null` when initialized.
+     */
+    data: ReplayData | null;
+    /**
+     * Penalty value used to penalize dpp for 2-hand.
+     */
+    aimPenalty: number;
+    /**
+     * Penalty value used to penalize dpp for 3 finger abuse.
+     */
+    tapPenalty: number;
+    /**
+     * Whether this replay has been checked against 3 finger usage.
+     */
+    hasBeenCheckedFor3Finger: boolean;
+    /**
+     * Whether this replay has been checked against 2 hand usage.
+     */
+    hasBeenCheckedFor2Hand: boolean;
+    private readonly BYTE_LENGTH;
+    private readonly SHORT_LENGTH;
+    private readonly INT_LENGTH;
+    private readonly FLOAT_LENGTH;
+    private readonly LONG_LENGTH;
+    constructor(values: {
+        /**
+         * The ID of the score.
+         */
+        scoreID: number;
+        /**
+         * The beatmap to analyze.
+         *
+         * `DroidStarRating` or `RebalanceDroidStarRating` is required for three finger or two hand analyzing.
+         */
+        map?: Beatmap | DroidStarRating | DroidStarRating$1;
+    });
+    /**
+     * Analyzes a replay.
+     */
+    analyze(): Promise<ReplayAnalyzer>;
+    /**
+     * Downloads the given score ID's replay.
+     */
+    private downloadReplay;
+    /**
+     * Decompresses a replay.
+     *
+     * The decompressed replay is in a form of Java object. This will be converted to a buffer and deserialized to read data from the replay.
+     */
+    private decompress;
+    /**
+     * Parses a replay after being downloaded and converted to a buffer.
+     */
+    private parseReplay;
+    /**
+     * Gets hit error information of the replay.
+     *
+     * `analyze()` must be called before calling this.
+     */
+    calculateHitError(): HitErrorInformation | null;
+    /**
+     * Converts replay mods to droid mod string.
+     */
+    private convertDroidMods;
+    /**
+     * Converts replay mods to regular mod string.
+     */
+    private convertMods;
+    /**
+     * Checks if a play is using 3 fingers.
+     *
+     * Requires `analyze()` to be called first and `map` to be defined as `DroidStarRating` or `RebalanceDroidStarRating`.
+     */
+    checkFor3Finger(): void;
+    /**
+     * Checks if a play is using 2 hands.
+     *
+     * Requires `analyze()` to be called first and `map` to be defined as `DroidStarRating` or `RebalanceDroidStarRating`.
+     */
+    checkFor2Hand(): void;
 }
 
-/**
- * Information about the result of a check.
- */
-interface ThreeFingerInformation {
-    /**
-     * Whether or not the beatmap is 3-fingered.
-     */
-    readonly is3Finger: boolean;
-    /**
-     * The final penalty. By default this is 1.
-     */
-    readonly penalty: number;
-}
-/**
- * Utility to check whether or not a beatmap is three-fingered.
- */
-declare class ThreeFingerChecker {
-    /**
-     * The beatmap to analyze.
-     */
-    readonly map: DroidStarRating | DroidStarRating$1;
-    /**
-     * The data of the replay.
-     */
-    readonly data: ReplayData;
-    /**
-     * The strain threshold to start detecting for 3-fingered section.
-     *
-     * Increasing this number will result in less sections being flagged.
-     */
-    private static readonly strainThreshold;
-    /**
-     * The distance threshold between cursors to assume that two cursors are
-     * actually pressed with 1 finger in osu!pixels.
-     *
-     * This is used to prevent cases where a player would lift their finger
-     * too fast to the point where the 4th cursor instance or beyond is recorded
-     * as 1st, 2nd, or 3rd cursor instance.
-     */
-    private readonly cursorDistancingDistanceThreshold;
-    /**
-     * The threshold for the amount of cursors that are assumed to be pressed
-     * by a single finger.
-     */
-    private readonly cursorDistancingCountThreshold;
-    /**
-     * The threshold for the time difference of cursors that are assumed to be pressed
-     * by a single finger, in milliseconds.
-     */
-    private readonly cursorDistancingTimeThreshold;
-    /**
-     * The amount of notes that has a tap strain exceeding `strainThreshold`.
-     */
-    private readonly strainNoteCount;
-    /**
-     * The ratio threshold between non-3 finger cursors and 3-finger cursors.
-     *
-     * Increasing this number will increase detection accuracy, however
-     * it also increases the chance of falsely flagged plays.
-     */
-    private readonly threeFingerRatioThreshold;
-    /**
-     * The maximum delta time allowed between two beatmap sections.
-     *
-     * Increasing this number decreases the amount of beatmap sections in general.
-     *
-     * Note that this value does not account for the speed multiplier of
-     * the play, similar to the way replay object data is stored.
-     */
-    private readonly maxSectionDeltaTime;
-    /**
-     * The minimum object count required to make a beatmap section.
-     *
-     * Increasing this number decreases the amount of beatmap sections.
-     */
-    private readonly minSectionObjectCount;
-    /**
-     * The sections of the beatmap that was cut based on `maxSectionDeltaTime` and `minSectionObjectCount`.
-     */
-    private readonly beatmapSections;
-    /**
-     * This threshold is used to filter out accidental taps.
-     *
-     * Increasing this number makes the filtration more sensitive, however it
-     * will also increase the chance of 3-fingered plays getting out from
-     * being flagged.
-     */
-    private readonly accidentalTapThreshold;
-    /**
-     * The hit window of this beatmap. Keep in mind that speed-changing mods do not change hit window length in game logic.
-     */
-    private readonly hitWindow;
-    /**
-     * A reprocessed break points to match right on object time.
-     *
-     * This is used to increase detection accuracy since break points do not start right at the
-     * start of the hitobject before it and do not end right at the first hitobject after it.
-     */
-    private readonly breakPointAccurateTimes;
-    /**
-     * A cursor data array that only contains `movementType.DOWN` movement ID occurrences.
-     */
-    private readonly downCursorInstances;
-    /**
-     * Nerf factors from all sections that were three-fingered.
-     */
-    private readonly nerfFactors;
-    /**
-     * @param map The beatmap to analyze.
-     * @param data The data of the replay.
-     */
-    constructor(map: DroidStarRating | DroidStarRating$1, data: ReplayData);
-    /**
-     * Checks whether a beatmap is eligible to be detected for 3-finger.
-     */
-    static isEligibleToDetect(map: DroidStarRating | DroidStarRating$1): boolean;
-    /**
-     * Checks if the given beatmap is 3-fingered and also returns the final penalty.
-     *
-     * The beatmap will be separated into sections and each section will be determined
-     * whether or not it is dragged.
-     *
-     * After that, each section will be assigned a nerf factor based on whether or not
-     * the section is 3-fingered. These nerf factors will be summed up into a final
-     * nerf factor, taking beatmap difficulty into account.
-     */
-    check(): ThreeFingerInformation;
-    /**
-     * Generates a new set of "accurate break points".
-     *
-     * This is done to increase detection accuracy since break points do not start right at the
-     * start of the hitobject before it and do not end right at the first hitobject after it.
-     */
-    private getAccurateBreakPoints;
-    /**
-     * Filters the original cursor instances, returning only those with `movementType.DOWN` movement ID.
-     *
-     * This also filters cursors that are in break period or happen before start/after end of the beatmap.
-     */
-    private filterCursorInstances;
-    /**
-     * Divides the beatmap into sections, which will be used to
-     * detect dragged sections and improve detection speed.
-     */
-    private getBeatmapSections;
-    /**
-     * Checks whether or not each beatmap sections is dragged.
-     */
-    private detectDragPlay;
-    /**
-     * Checks if a section is dragged and returns the index of the drag finger.
-     *
-     * If the section is not dragged, -1 will be returned.
-     *
-     * @param section The section to check.
-     */
-    private checkDrag;
-    /**
-     * Finds the drag index of the section.
-     *
-     * @param sectionObjects The objects in the section.
-     * @param sectionReplayObjectData The hitobject data of all objects in the section.
-     * @param cursorIndexes The indexes of the cursor instance that has at least an occurrence in the section.
-     */
-    private findDragIndex;
-    /**
-     * Redivides the beatmap into sections.
-     *
-     * The result will be used to detect for three-fingered
-     * sections.
-     */
-    private getDetailedBeatmapSections;
-    /**
-     * Attempts to prevent accidental taps from being flagged.
-     *
-     * This detection will filter cursors that don't hit
-     * any object in beatmap sections, thus eliminating any
-     * unnecessary taps.
-     */
-    private preventAccidentalTaps;
-    /**
-     * Creates nerf factors by scanning through objects.
-     *
-     * This check will ignore all objects with speed strain below `strainThreshold`.
-     */
-    private calculateNerfFactors;
-    /**
-     * Calculates the final penalty.
-     */
-    private calculateFinalPenalty;
+/**
+ * Information about the result of a check.
+ */
+interface ThreeFingerInformation {
+    /**
+     * Whether or not the beatmap is 3-fingered.
+     */
+    readonly is3Finger: boolean;
+    /**
+     * The final penalty. By default this is 1.
+     */
+    readonly penalty: number;
+}
+/**
+ * Utility to check whether or not a beatmap is three-fingered.
+ */
+declare class ThreeFingerChecker {
+    /**
+     * The beatmap to analyze.
+     */
+    readonly map: DroidStarRating | DroidStarRating$1;
+    /**
+     * The data of the replay.
+     */
+    readonly data: ReplayData;
+    /**
+     * The strain threshold to start detecting for 3-fingered section.
+     *
+     * Increasing this number will result in less sections being flagged.
+     */
+    private static readonly strainThreshold;
+    /**
+     * The distance threshold between cursors to assume that two cursors are
+     * actually pressed with 1 finger in osu!pixels.
+     *
+     * This is used to prevent cases where a player would lift their finger
+     * too fast to the point where the 4th cursor instance or beyond is recorded
+     * as 1st, 2nd, or 3rd cursor instance.
+     */
+    private readonly cursorDistancingDistanceThreshold;
+    /**
+     * The threshold for the amount of cursors that are assumed to be pressed
+     * by a single finger.
+     */
+    private readonly cursorDistancingCountThreshold;
+    /**
+     * The threshold for the time difference of cursors that are assumed to be pressed
+     * by a single finger, in milliseconds.
+     */
+    private readonly cursorDistancingTimeThreshold;
+    /**
+     * The amount of notes that has a tap strain exceeding `strainThreshold`.
+     */
+    private readonly strainNoteCount;
+    /**
+     * The ratio threshold between non-3 finger cursors and 3-finger cursors.
+     *
+     * Increasing this number will increase detection accuracy, however
+     * it also increases the chance of falsely flagged plays.
+     */
+    private readonly threeFingerRatioThreshold;
+    /**
+     * The maximum delta time allowed between two beatmap sections.
+     *
+     * Increasing this number decreases the amount of beatmap sections in general.
+     *
+     * Note that this value does not account for the speed multiplier of
+     * the play, similar to the way replay object data is stored.
+     */
+    private readonly maxSectionDeltaTime;
+    /**
+     * The minimum object count required to make a beatmap section.
+     *
+     * Increasing this number decreases the amount of beatmap sections.
+     */
+    private readonly minSectionObjectCount;
+    /**
+     * The sections of the beatmap that was cut based on `maxSectionDeltaTime` and `minSectionObjectCount`.
+     */
+    private readonly beatmapSections;
+    /**
+     * This threshold is used to filter out accidental taps.
+     *
+     * Increasing this number makes the filtration more sensitive, however it
+     * will also increase the chance of 3-fingered plays getting out from
+     * being flagged.
+     */
+    private readonly accidentalTapThreshold;
+    /**
+     * The hit window of this beatmap. Keep in mind that speed-changing mods do not change hit window length in game logic.
+     */
+    private readonly hitWindow;
+    /**
+     * A reprocessed break points to match right on object time.
+     *
+     * This is used to increase detection accuracy since break points do not start right at the
+     * start of the hitobject before it and do not end right at the first hitobject after it.
+     */
+    private readonly breakPointAccurateTimes;
+    /**
+     * A cursor data array that only contains `movementType.DOWN` movement ID occurrences.
+     */
+    private readonly downCursorInstances;
+    /**
+     * Nerf factors from all sections that were three-fingered.
+     */
+    private readonly nerfFactors;
+    /**
+     * @param map The beatmap to analyze.
+     * @param data The data of the replay.
+     */
+    constructor(map: DroidStarRating | DroidStarRating$1, data: ReplayData);
+    /**
+     * Checks whether a beatmap is eligible to be detected for 3-finger.
+     */
+    static isEligibleToDetect(
+        map: DroidStarRating | DroidStarRating$1
+    ): boolean;
+    /**
+     * Checks if the given beatmap is 3-fingered and also returns the final penalty.
+     *
+     * The beatmap will be separated into sections and each section will be determined
+     * whether or not it is dragged.
+     *
+     * After that, each section will be assigned a nerf factor based on whether or not
+     * the section is 3-fingered. These nerf factors will be summed up into a final
+     * nerf factor, taking beatmap difficulty into account.
+     */
+    check(): ThreeFingerInformation;
+    /**
+     * Generates a new set of "accurate break points".
+     *
+     * This is done to increase detection accuracy since break points do not start right at the
+     * start of the hitobject before it and do not end right at the first hitobject after it.
+     */
+    private getAccurateBreakPoints;
+    /**
+     * Filters the original cursor instances, returning only those with `movementType.DOWN` movement ID.
+     *
+     * This also filters cursors that are in break period or happen before start/after end of the beatmap.
+     */
+    private filterCursorInstances;
+    /**
+     * Divides the beatmap into sections, which will be used to
+     * detect dragged sections and improve detection speed.
+     */
+    private getBeatmapSections;
+    /**
+     * Checks whether or not each beatmap sections is dragged.
+     */
+    private detectDragPlay;
+    /**
+     * Checks if a section is dragged and returns the index of the drag finger.
+     *
+     * If the section is not dragged, -1 will be returned.
+     *
+     * @param section The section to check.
+     */
+    private checkDrag;
+    /**
+     * Finds the drag index of the section.
+     *
+     * @param sectionObjects The objects in the section.
+     * @param sectionReplayObjectData The hitobject data of all objects in the section.
+     * @param cursorIndexes The indexes of the cursor instance that has at least an occurrence in the section.
+     */
+    private findDragIndex;
+    /**
+     * Redivides the beatmap into sections.
+     *
+     * The result will be used to detect for three-fingered
+     * sections.
+     */
+    private getDetailedBeatmapSections;
+    /**
+     * Attempts to prevent accidental taps from being flagged.
+     *
+     * This detection will filter cursors that don't hit
+     * any object in beatmap sections, thus eliminating any
+     * unnecessary taps.
+     */
+    private preventAccidentalTaps;
+    /**
+     * Creates nerf factors by scanning through objects.
+     *
+     * This check will ignore all objects with speed strain below `strainThreshold`.
+     */
+    private calculateNerfFactors;
+    /**
+     * Calculates the final penalty.
+     */
+    private calculateFinalPenalty;
 }
 
-export { CursorData, CursorInformation, ExportedReplayJSON, HitErrorInformation, ReplayAnalyzer, ReplayData, ReplayInformation, ReplayObjectData, ThreeFingerChecker, ThreeFingerInformation, hitResult, movementType };
+export {
+    CursorData,
+    CursorInformation,
+    ExportedReplayJSON,
+    HitErrorInformation,
+    ReplayAnalyzer,
+    ReplayData,
+    ReplayInformation,
+    ReplayObjectData,
+    ThreeFingerChecker,
+    ThreeFingerInformation,
+    hitResult,
+    movementType,
+};