@rian8337/osu-difficulty-calculator 4.0.0-beta.14 → 4.0.0-beta.16

package/typings/index.d.ts

@@ -1,4 +1,4 @@
-import { Mod, MapStats, PlaceableHitObject, Beatmap, Modes, HitObject, Accuracy } from '@rian8337/osu-base';
+import { Mod, PlaceableHitObject, Modes, Beatmap, DifficultyStatisticsCalculatorResult, Accuracy } from '@rian8337/osu-base';
 
 /**
  * An evaluator for calculating aim skill.
@@ -98,24 +98,18 @@ type CacheableDifficultyAttributes<T extends DifficultyAttributes> = Omit<T, "mo
     mods: string;
 };
 
-/**
- * The base of calculation options.
- */
-interface CalculationOptions {
-    /**
-     * Custom map statistics to apply custom speed multiplier as well as old statistics.
-     */
-    stats?: MapStats;
-}
-
 /**
  * Represents options for difficulty calculation.
  */
-interface DifficultyCalculationOptions extends CalculationOptions {
+interface DifficultyCalculationOptions {
     /**
      * The modifications to apply.
      */
-    mods?: Mod[];
+    readonly mods?: Mod[];
+    /**
+     * The custom speed multiplier to apply. Defaults to 1.
+     */
+    readonly customSpeedMultiplier?: number;
 }
 
 /**
@@ -131,19 +125,7 @@ declare abstract class DifficultyHitObject {
      *
      * This is one less than the actual index of the hitobject in the beatmap.
      */
-    index: number;
-    /**
-     * The preempt time of the hitobject.
-     */
-    baseTimePreempt: number;
-    /**
-     * Adjusted preempt time of the hitobject, taking speed multiplier into account.
-     */
-    timePreempt: number;
-    /**
-     * The fade in time of the hitobject.
-     */
-    timeFadeIn: number;
+    readonly index: number;
     /**
      * The aim strain generated by the hitobject if sliders are considered.
      */
@@ -196,28 +178,51 @@ declare abstract class DifficultyHitObject {
     /**
      * The amount of milliseconds elapsed between this hitobject and the last hitobject.
      */
-    deltaTime: number;
+    readonly deltaTime: number;
     /**
      * The amount of milliseconds elapsed since the start time of the previous hitobject, with a minimum of 25ms.
      */
-    strainTime: number;
+    readonly strainTime: number;
     /**
      * Adjusted start time of the hitobject, taking speed multiplier into account.
      */
-    startTime: number;
+    readonly startTime: number;
     /**
      * Adjusted end time of the hitobject, taking speed multiplier into account.
      */
-    endTime: number;
+    readonly endTime: number;
     /**
      * Other hitobjects in the beatmap, including this hitobject.
      */
-    protected readonly hitObjects: DifficultyHitObject[];
+    protected readonly hitObjects: readonly DifficultyHitObject[];
+    protected abstract readonly mode: Modes;
+    protected readonly normalizedRadius = 50;
+    protected readonly maximumSliderRadius: number;
+    protected readonly assumedSliderRadius: number;
+    protected readonly minDeltaTime = 25;
+    private readonly lastObject;
+    private readonly lastLastObject;
     /**
+     * Note: You **must** call `computeProperties` at some point due to how TypeScript handles
+     * overridden properties (see [this](https://github.com/microsoft/TypeScript/issues/1617) GitHub issue.).
+     *
      * @param object The underlying hitobject.
-     * @param hitObjects All difficulty hitobjects in the processed beatmap.
+     * @param lastObject The hitobject before this hitobject.
+     * @param lastLastObject The hitobject before the last hitobject.
+     * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
+     * @param clockRate The clock rate of the beatmap.
+     * @param timePreempt The time preempt with clock rate.
+     * @param isForceAR Whether force AR is enabled.
+     * @param mode The gamemode to compute properties for.
+     */
+    protected constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number);
+    /**
+     * Computes the properties of this hitobject.
+     *
+     * @param clockRate The clock rate of the beatmap.
+     * @param hitObjects The hitobjects in the beatmap.
      */
-    protected constructor(object: PlaceableHitObject, hitObjects: DifficultyHitObject[]);
+    computeProperties(clockRate: number, hitObjects: readonly PlaceableHitObject[]): void;
     /**
      * Gets the difficulty hitobject at a specific index with respect to the current
      * difficulty hitobject's index.
@@ -248,16 +253,10 @@ declare abstract class DifficultyHitObject {
      * @returns The opacity of the hitobject at the given time.
      */
     opacityAt(time: number, isHidden: boolean): number;
-    /**
-     * Determines whether this hitobject is considered overlapping with the hitobject before it.
-     *
-     * Keep in mind that "overlapping" in this case is overlapping to the point where both hitobjects
-     * can be hit with just a single tap in osu!droid.
-     *
-     * @param considerDistance Whether to consider the distance between both hitobjects.
-     * @returns Whether the hitobject is considered overlapping.
-     */
-    isOverlapping(considerDistance: boolean): boolean;
+    protected abstract get scalingFactor(): number;
+    protected setDistances(clockRate: number): void;
+    private calculateSliderCursorPosition;
+    private getEndCursorPosition;
 }
 
 /**
@@ -324,11 +323,11 @@ declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObje
     /**
      * The total star rating of the beatmap.
      */
-    total: number;
+    get total(): number;
     /**
-     * The map statistics of the beatmap after modifications are applied.
+     * The difficulty statistics of the beatmap after modifications are applied.
      */
-    stats: MapStats;
+    difficultyStatistics: DifficultyStatisticsCalculatorResult<number, number, number, number>;
     /**
      * The strain peaks of various calculated difficulties.
      */
@@ -367,12 +366,17 @@ declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObje
     calculate(options?: DifficultyCalculationOptions): this;
     /**
      * Generates difficulty hitobjects for this calculator.
+     *
+     * @param beatmap The beatmap to generate difficulty hitobjects from.
      */
-    generateDifficultyHitObjects(): void;
+    protected abstract generateDifficultyHitObjects(beatmap: Beatmap): THitObject[];
     /**
-     * Performs some pre-processing before proceeding with difficulty calculation.
+     * Computes the difficulty statistics of the original beatmap with respect to the used options.
+     *
+     * @param options The options to use for the difficulty statistics calculation.
+     * @returns The computed difficulty statistics.
      */
-    protected preProcess(): void;
+    protected abstract computeDifficultyStatistics(options?: DifficultyCalculationOptions): DifficultyStatisticsCalculatorResult<number, number, number, number>;
     /**
      * Calculates the skills provided.
      *
@@ -413,148 +417,6 @@ declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObje
     protected basePerformanceValue(rating: number): number;
 }
 
-/**
- * Represents an osu!droid hit object with difficulty calculation values.
- */
-declare class DroidDifficultyHitObject extends DifficultyHitObject {
-    /**
-     * The tap strain generated by the hitobject.
-     */
-    tapStrain: number;
-    /**
-     * The tap strain generated by the hitobject if `strainTime` isn't modified by
-     * OD. This is used in three-finger detection.
-     */
-    originalTapStrain: number;
-    /**
-     * The rhythm strain generated by the hitobject.
-     */
-    rhythmStrain: number;
-    /**
-     * The flashlight strain generated by the hitobject if sliders are considered.
-     */
-    flashlightStrainWithSliders: number;
-    /**
-     * The flashlight strain generated by the hitobject if sliders are not considered.
-     */
-    flashlightStrainWithoutSliders: number;
-    /**
-     * The visual strain generated by the hitobject if sliders are considered.
-     */
-    visualStrainWithSliders: number;
-    /**
-     * The visual strain generated by the hitobject if sliders are not considered.
-     */
-    visualStrainWithoutSliders: number;
-    /**
-     * The note density of the hitobject.
-     */
-    noteDensity: number;
-    /**
-     * The overlapping factor of the hitobject.
-     *
-     * This is used to scale visual skill.
-     */
-    overlappingFactor: number;
-    /**
-     * @param object The underlying hitobject.
-     * @param hitObjects All difficulty hitobjects in the processed beatmap.
-     */
-    constructor(object: PlaceableHitObject, hitObjects: DroidDifficultyHitObject[]);
-}
-
-/**
- * Represents an osu!standard hit object with difficulty calculation values.
- */
-declare class OsuDifficultyHitObject extends DifficultyHitObject {
-    /**
-     * The speed strain generated by the hitobject.
-     */
-    speedStrain: number;
-    /**
-     * The flashlight strain generated by this hitobject.
-     */
-    flashlightStrain: number;
-    /**
-     * @param object The underlying hitobject.
-     * @param hitObjects All difficulty hitobjects in the processed beatmap.
-     */
-    constructor(object: PlaceableHitObject, hitObjects: OsuDifficultyHitObject[]);
-}
-
-/**
- * A converter used to convert normal hitobjects into difficulty hitobjects.
- */
-declare class DifficultyHitObjectCreator {
-    /**
-     * The threshold for small circle buff for osu!droid.
-     */
-    private readonly DROID_CIRCLESIZE_BUFF_THRESHOLD;
-    /**
-     * The threshold for small circle buff for osu!standard.
-     */
-    private readonly PC_CIRCLESIZE_BUFF_THRESHOLD;
-    /**
-     * The gamemode this creator is creating for.
-     */
-    private mode;
-    /**
-     * The base normalized radius of hitobjects.
-     */
-    private readonly normalizedRadius;
-    private maximumSliderRadius;
-    private readonly assumedSliderRadius;
-    private readonly minDeltaTime;
-    /**
-     * Generates difficulty hitobjects for difficulty calculation.
-     */
-    generateDifficultyObjects(params: {
-        objects: readonly HitObject[];
-        circleSize: number;
-        mods: Mod[];
-        speedMultiplier: number;
-        mode: Modes.droid;
-        preempt?: number;
-    }): DroidDifficultyHitObject[];
-    /**
-     * Generates difficulty hitobjects for difficulty calculation.
-     */
-    generateDifficultyObjects(params: {
-        objects: readonly HitObject[];
-        circleSize: number;
-        mods: Mod[];
-        speedMultiplier: number;
-        mode: Modes.osu;
-        preempt?: number;
-    }): OsuDifficultyHitObject[];
-    /**
-     * Generates difficulty hitobjects for difficulty calculation.
-     */
-    generateDifficultyObjects(params: {
-        objects: readonly HitObject[];
-        circleSize: number;
-        mods: Mod[];
-        speedMultiplier: number;
-        mode: Modes;
-        preempt?: number;
-    }): DifficultyHitObject[];
-    /**
-     * Calculates a slider's cursor position.
-     */
-    private calculateSliderCursorPosition;
-    /**
-     * Gets the scaling factor of a radius.
-     *
-     * @param radius The radius to get the scaling factor from.
-     */
-    private getScalingFactor;
-    /**
-     * Returns the end cursor position of a hitobject.
-     */
-    private getEndCursorPosition;
-    private applyToOverlappingFactor;
-}
-
 /**
  * Represents a slider that is considered difficult.
  *
@@ -653,6 +515,84 @@ declare abstract class DroidSkill extends StrainSkill {
     difficultyValue(): number;
 }
 
+/**
+ * Represents an osu!droid hit object with difficulty calculation values.
+ */
+declare class DroidDifficultyHitObject extends DifficultyHitObject {
+    /**
+     * The tap strain generated by the hitobject.
+     */
+    tapStrain: number;
+    /**
+     * The tap strain generated by the hitobject if `strainTime` isn't modified by
+     * OD. This is used in three-finger detection.
+     */
+    originalTapStrain: number;
+    /**
+     * The rhythm strain generated by the hitobject.
+     */
+    rhythmStrain: number;
+    /**
+     * The flashlight strain generated by the hitobject if sliders are considered.
+     */
+    flashlightStrainWithSliders: number;
+    /**
+     * The flashlight strain generated by the hitobject if sliders are not considered.
+     */
+    flashlightStrainWithoutSliders: number;
+    /**
+     * The visual strain generated by the hitobject if sliders are considered.
+     */
+    visualStrainWithSliders: number;
+    /**
+     * The visual strain generated by the hitobject if sliders are not considered.
+     */
+    visualStrainWithoutSliders: number;
+    /**
+     * The note density of the hitobject.
+     */
+    noteDensity: number;
+    /**
+     * The overlapping factor of the hitobject.
+     *
+     * This is used to scale visual skill.
+     */
+    overlappingFactor: number;
+    /**
+     * Adjusted preempt time of the hitobject, taking speed multiplier into account.
+     */
+    readonly timePreempt: number;
+    private readonly radiusBuffThreshold;
+    protected readonly mode = Modes.droid;
+    protected readonly maximumSliderRadius: number;
+    protected get scalingFactor(): number;
+    /**
+     * Note: You **must** call `computeProperties` at some point due to how TypeScript handles
+     * overridden properties (see [this](https://github.com/microsoft/TypeScript/issues/1617) GitHub issue.).
+     *
+     * @param object The underlying hitobject.
+     * @param lastObject The hitobject before this hitobject.
+     * @param lastLastObject The hitobject before the last hitobject.
+     * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
+     * @param clockRate The clock rate of the beatmap.
+     * @param isForceAR Whether force AR is enabled.
+     */
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, isForceAR: boolean);
+    computeProperties(clockRate: number, hitObjects: readonly PlaceableHitObject[]): void;
+    /**
+     * Determines whether this hitobject is considered overlapping with the hitobject before it.
+     *
+     * Keep in mind that "overlapping" in this case is overlapping to the point where both hitobjects
+     * can be hit with just a single tap in osu!droid.
+     *
+     * @param considerDistance Whether to consider the distance between both hitobjects.
+     * @returns Whether the hitobject is considered overlapping.
+     */
+    isOverlapping(considerDistance: boolean): boolean;
+    private setVisuals;
+    private applyToOverlappingFactor;
+}
+
 /**
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
@@ -742,6 +682,16 @@ interface DroidDifficultyAttributes extends DifficultyAttributes {
     averageSpeedDeltaTime: number;
 }
 
+/**
+ * Represents options for osu!droid difficulty calculation.
+ */
+interface DroidDifficultyCalculationOptions extends DifficultyCalculationOptions {
+    /**
+     * Whether to calculate for old statistics (1.6.7 and older). Defaults to `false`.
+     */
+    readonly oldStatistics?: boolean;
+}
+
 /**
  * Represents a beatmap section at which the strains of objects are considerably high.
  */
@@ -765,6 +715,10 @@ interface HighStrainSection {
  * as doing some analysis using the replay of a score.
  */
 interface ExtendedDroidDifficultyAttributes extends DroidDifficultyAttributes {
+    /**
+     * The mode of the difficulty calculation.
+     */
+    mode: "live";
     /**
      * Possible sections at which the player can use three fingers on.
      */
@@ -804,33 +758,34 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidDiffic
     /**
      * The aim star rating of the beatmap.
      */
-    aim: number;
+    get aim(): number;
     /**
      * The tap star rating of the beatmap.
      */
-    tap: number;
+    get tap(): number;
     /**
      * The rhythm star rating of the beatmap.
      */
-    rhythm: number;
+    get rhythm(): number;
     /**
      * The flashlight star rating of the beatmap.
      */
-    flashlight: number;
+    get flashlight(): number;
     /**
      * The visual star rating of the beatmap.
      */
-    visual: number;
+    get visual(): number;
     /**
      * The strain threshold to start detecting for possible three-fingered section.
      *
      * Increasing this number will result in less sections being flagged.
      */
-    static readonly threeFingerStrainThreshold: number;
+    static readonly threeFingerStrainThreshold = 175;
     readonly attributes: ExtendedDroidDifficultyAttributes;
     get cacheableAttributes(): CacheableDifficultyAttributes<DroidDifficultyAttributes>;
-    protected readonly difficultyMultiplier: number;
-    protected readonly mode: Modes;
+    protected readonly difficultyMultiplier = 0.18;
+    protected readonly mode = Modes.droid;
+    calculate(options?: DroidDifficultyCalculationOptions): this;
     /**
      * Calculates the aim star rating of the beatmap and stores it in this instance.
      */
@@ -854,7 +809,8 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidDiffic
     calculateTotal(): void;
     calculateAll(): void;
     toString(): string;
-    protected preProcess(): void;
+    protected generateDifficultyHitObjects(beatmap: Beatmap): DroidDifficultyHitObject[];
+    protected computeDifficultyStatistics(options?: DroidDifficultyCalculationOptions): DifficultyStatisticsCalculatorResult<number, number, number, number>;
     protected createSkills(): DroidSkill[];
     /**
      * Called after aim skill calculation.
@@ -1404,6 +1360,72 @@ declare abstract class OsuSkill extends StrainSkill {
     difficultyValue(): number;
 }
 
+/**
+ * Represents an osu!standard hit object with difficulty calculation values.
+ */
+declare class OsuDifficultyHitObject extends DifficultyHitObject {
+    /**
+     * The speed strain generated by the hitobject.
+     */
+    speedStrain: number;
+    /**
+     * The flashlight strain generated by this hitobject.
+     */
+    flashlightStrain: number;
+    private readonly radiusBuffThreshold;
+    protected readonly mode = Modes.osu;
+    protected get scalingFactor(): number;
+    /**
+     * Note: You **must** call `computeProperties` at some point due to how TypeScript handles
+     * overridden properties (see [this](https://github.com/microsoft/TypeScript/issues/1617) GitHub issue.).
+     *
+     * @param object The underlying hitobject.
+     * @param lastObject The hitobject before this hitobject.
+     * @param lastLastObject The hitobject before the last hitobject.
+     * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
+     * @param clockRate The clock rate of the beatmap.
+     */
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number);
+}
+
+/**
+ * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
+ */
+declare class OsuAim extends OsuSkill {
+    protected readonly strainDecayBase: number;
+    protected readonly reducedSectionCount: number;
+    protected readonly reducedSectionBaseline: number;
+    protected readonly decayWeight: number;
+    private currentAimStrain;
+    private readonly skillMultiplier;
+    private readonly withSliders;
+    constructor(mods: Mod[], withSliders: boolean);
+    protected strainValueAt(current: OsuDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
+    /**
+     * @param current The hitobject to save to.
+     */
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
+}
+
+/**
+ * An evaluator for calculating osu!standard Aim skill.
+ */
+declare abstract class OsuAimEvaluator extends AimEvaluator {
+    /**
+     * Evaluates the difficulty of aiming the current object, based on:
+     *
+     * - cursor velocity to the current object,
+     * - angle difficulty,
+     * - sharp velocity increases,
+     * - and slider difficulty.
+     *
+     * @param current The current object.
+     * @param withSliders Whether to take slider difficulty into account.
+     */
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, withSliders: boolean): number;
+}
+
 /**
  * Holds data that can be used to calculate osu!standard performance points.
  */
@@ -1421,19 +1443,19 @@ declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuDifficulty
     /**
      * The aim star rating of the beatmap.
      */
-    aim: number;
+    get aim(): number;
     /**
      * The speed star rating of the beatmap.
      */
-    speed: number;
+    get speed(): number;
     /**
      * The flashlight star rating of the beatmap.
      */
-    flashlight: number;
+    get flashlight(): number;
     readonly attributes: OsuDifficultyAttributes;
     get cacheableAttributes(): CacheableDifficultyAttributes<OsuDifficultyAttributes>;
-    protected readonly difficultyMultiplier: number;
-    protected readonly mode: Modes;
+    protected readonly difficultyMultiplier = 0.0675;
+    protected readonly mode = Modes.osu;
     /**
      * Calculates the aim star rating of the beatmap and stores it in this instance.
      */
@@ -1449,7 +1471,8 @@ declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuDifficulty
     calculateTotal(): void;
     calculateAll(): void;
     toString(): string;
-    protected preProcess(): void;
+    protected generateDifficultyHitObjects(): OsuDifficultyHitObject[];
+    protected computeDifficultyStatistics(options?: DifficultyCalculationOptions): DifficultyStatisticsCalculatorResult<number, number, number, number>;
     protected createSkills(): OsuSkill[];
     /**
      * Called after aim skill calculation.
@@ -1476,69 +1499,6 @@ declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuDifficulty
     private postCalculateFlashlight;
 }
 
-/**
- * A difficulty calculator that calculates for both osu!droid and osu!standard gamemode.
- */
-declare class MapStars {
-    /**
-     * The osu!droid difficulty calculator of the beatmap.
-     */
-    readonly droid: DroidDifficultyCalculator;
-    /**
-     * The osu!standard difficulty calculator of the beatmap.
-     */
-    readonly osu: OsuDifficultyCalculator;
-    /**
-     * Constructs this instance and calculates the given beatmap's osu!droid and osu!standard difficulty.
-     *
-     * @param beatmap The beatmap to calculate.
-     * @param options Options for the difficulty calculation.
-     */
-    constructor(beatmap: Beatmap, options?: DifficultyCalculationOptions);
-    /**
-     * Returns a string representative of the class.
-     */
-    toString(): string;
-}
-
-/**
- * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
- */
-declare class OsuAim extends OsuSkill {
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly decayWeight: number;
-    private currentAimStrain;
-    private readonly skillMultiplier;
-    private readonly withSliders;
-    constructor(mods: Mod[], withSliders: boolean);
-    protected strainValueAt(current: OsuDifficultyHitObject): number;
-    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
-    /**
-     * @param current The hitobject to save to.
-     */
-    protected saveToHitObject(current: OsuDifficultyHitObject): void;
-}
-
-/**
- * An evaluator for calculating osu!standard Aim skill.
- */
-declare abstract class OsuAimEvaluator extends AimEvaluator {
-    /**
-     * Evaluates the difficulty of aiming the current object, based on:
-     *
-     * - cursor velocity to the current object,
-     * - angle difficulty,
-     * - sharp velocity increases,
-     * - and slider difficulty.
-     *
-     * @param current The current object.
-     * @param withSliders Whether to take slider difficulty into account.
-     */
-    static evaluateDifficultyOf(current: OsuDifficultyHitObject, withSliders: boolean): number;
-}
-
 /**
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
@@ -1636,16 +1596,16 @@ declare abstract class OsuRhythmEvaluator extends RhythmEvaluator {
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
  */
 declare class OsuSpeed extends OsuSkill {
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly difficultyMultiplier: number;
-    protected readonly decayWeight: number;
+    protected readonly strainDecayBase = 0.3;
+    protected readonly reducedSectionCount = 5;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly difficultyMultiplier = 1.04;
+    protected readonly decayWeight = 0.9;
     private currentSpeedStrain;
     private currentRhythm;
     private readonly skillMultiplier;
     private readonly greatWindow;
-    constructor(mods: Mod[], greatWindow: number);
+    constructor(mods: Mod[], overallDifficulty: number);
     /**
      * @param current The hitobject to calculate.
      */
@@ -1678,4 +1638,4 @@ declare abstract class OsuSpeedEvaluator extends SpeedEvaluator {
     static evaluateDifficultyOf(current: OsuDifficultyHitObject, greatWindow: number): number;
 }
 
-export { AimEvaluator, type CacheableDifficultyAttributes, type CalculationOptions, type DifficultSlider, type DifficultyAttributes, type DifficultyCalculationOptions, DifficultyCalculator, DifficultyHitObject, DifficultyHitObjectCreator, DroidAim, DroidAimEvaluator, type DroidDifficultyAttributes, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, DroidVisual, DroidVisualEvaluator, type ExtendedDroidDifficultyAttributes, FlashlightEvaluator, type HighStrainSection, MapStars, OsuAim, OsuAimEvaluator, type OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, type PerformanceCalculationOptions, PerformanceCalculator, RhythmEvaluator, SpeedEvaluator, type StrainPeaks };
+export { AimEvaluator, type CacheableDifficultyAttributes, type DifficultSlider, type DifficultyAttributes, type DifficultyCalculationOptions, DifficultyCalculator, DifficultyHitObject, DroidAim, DroidAimEvaluator, type DroidDifficultyAttributes, type DroidDifficultyCalculationOptions, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, DroidVisual, DroidVisualEvaluator, type ExtendedDroidDifficultyAttributes, FlashlightEvaluator, type HighStrainSection, OsuAim, OsuAimEvaluator, type OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, type PerformanceCalculationOptions, PerformanceCalculator, RhythmEvaluator, SpeedEvaluator, type StrainPeaks };