@rian8337/osu-difficulty-calculator 4.0.0-beta.52 → 4.0.0-beta.55

package/typings/index.d.ts

@@ -1,9 +1,9 @@
-import { Mod, PlaceableHitObject, Modes, Beatmap, Accuracy } from '@rian8337/osu-base';
+import { Mod, SerializedMod, PlaceableHitObject, Modes, PlayableBeatmap, Beatmap, DroidPlayableBeatmap, Accuracy, OsuPlayableBeatmap } from '@rian8337/osu-base';
 
 /**
  * Holds data that can be used to calculate performance points.
  */
-interface DifficultyAttributes {
+interface IDifficultyAttributes {
     /**
      * The mods which were applied to the beatmap.
      */
@@ -73,25 +73,42 @@ interface DifficultyAttributes {
 /**
  * Represents difficulty attributes that can be cached.
  */
-type CacheableDifficultyAttributes<T extends DifficultyAttributes> = Omit<T, "mods"> & {
+type CacheableDifficultyAttributes<T extends IDifficultyAttributes> = Omit<T, "mods"> & {
     /**
      * The mods which were applied to the beatmap.
      */
-    mods: string;
+    mods: SerializedMod[];
 };
 
 /**
- * Represents options for difficulty calculation.
+ * Holds data that can be used to calculate performance points.
  */
-interface DifficultyCalculationOptions {
+declare abstract class DifficultyAttributes implements IDifficultyAttributes {
+    mods: Mod[];
+    starRating: number;
+    maxCombo: number;
+    aimDifficulty: number;
+    flashlightDifficulty: number;
+    speedNoteCount: number;
+    sliderFactor: number;
+    clockRate: number;
+    overallDifficulty: number;
+    hitCircleCount: number;
+    sliderCount: number;
+    spinnerCount: number;
+    aimDifficultSliderCount: number;
+    aimDifficultStrainCount: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IDifficultyAttributes>);
     /**
-     * The modifications to apply.
+     * Converts this `DifficultyAttributes` instance to an attribute structure that can be cached.
+     *
+     * @returns The cacheable attributes.
      */
-    readonly mods?: Mod[];
+    toCacheableAttributes(): CacheableDifficultyAttributes<IDifficultyAttributes>;
     /**
-     * The custom speed multiplier to apply. Defaults to 1.
+     * Returns a string representation of the difficulty attributes.
      */
-    readonly customSpeedMultiplier?: number;
+    toString(): string;
 }
 
 /**
@@ -208,7 +225,7 @@ declare abstract class DifficultyHitObject {
      * @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);
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, index: number);
     /**
      * Computes the properties of this hitobject.
      *
@@ -245,7 +262,7 @@ declare abstract class DifficultyHitObject {
      * @param mods The mods used.
      * @returns The opacity of the hitobject at the given time.
      */
-    opacityAt(time: number, mods: Mod[]): number;
+    opacityAt(time: number, mods: readonly Mod[]): number;
     /**
      * How possible is it to doubletap this object together with the next one and get perfect
      * judgement in range from 0 to 1.
@@ -259,28 +276,6 @@ declare abstract class DifficultyHitObject {
     private getEndCursorPosition;
 }
 
-/**
- * Represents the strain peaks of various calculated difficulties.
- */
-interface StrainPeaks {
-    /**
-     * The strain peaks of aim difficulty if sliders are considered.
-     */
-    aimWithSliders: number[];
-    /**
-     * The strain peaks of aim difficulty if sliders are not considered.
-     */
-    aimWithoutSliders: number[];
-    /**
-     * The strain peaks of speed difficulty.
-     */
-    speed: number[];
-    /**
-     * The strain peaks of flashlight difficulty.
-     */
-    flashlight: number[];
-}
-
 /**
  * A bare minimal abstract skill for fully custom skill implementations.
  *
@@ -290,8 +285,8 @@ declare abstract class Skill {
     /**
      * The mods that this skill processes.
      */
-    protected readonly mods: Mod[];
-    constructor(mods: Mod[]);
+    protected readonly mods: readonly Mod[];
+    constructor(mods: readonly Mod[]);
     /**
      * Processes a hitobject.
      *
@@ -305,140 +300,25 @@ declare abstract class Skill {
 }
 
 /**
- * The base of a difficulty calculator.
+ * Represents the strain peaks of various calculated difficulties.
  */
-declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObject, TAttributes extends DifficultyAttributes> {
-    /**
-     * The calculated beatmap.
-     */
-    readonly beatmap: Beatmap;
-    /**
-     * The difficulty objects of the beatmap.
-     */
-    private _objects;
-    /**
-     * The difficulty objects of the beatmap.
-     */
-    get objects(): readonly THitObject[];
-    /**
-     * The modifications applied.
-     */
-    mods: Mod[];
-    /**
-     * The total star rating of the beatmap.
-     */
-    get total(): number;
-    /**
-     * The strain peaks of various calculated difficulties.
-     */
-    readonly strainPeaks: StrainPeaks;
-    /**
-     * The difficulty attributes that can be used to calculate performance points.
-     */
-    abstract readonly attributes: TAttributes;
-    /**
-     * The difficulty attributes that can be cached. It can also be used to calculate performance points.
-     */
-    abstract get cacheableAttributes(): CacheableDifficultyAttributes<TAttributes>;
-    protected abstract readonly difficultyMultiplier: number;
-    protected abstract readonly mode: Modes;
-    /**
-     * Constructs a new instance of the calculator.
-     *
-     * @param beatmap The beatmap to calculate.
-     */
-    constructor(beatmap: Beatmap);
-    /**
-     * Calculates the star rating of the specified beatmap.
-     *
-     * The beatmap is analyzed in chunks of `sectionLength` duration.
-     * For each chunk the highest hitobject strains are added to
-     * a list which is then collapsed into a weighted sum, much
-     * like scores are weighted on a user's profile.
-     *
-     * For subsequent chunks, the initial max strain is calculated
-     * by decaying the previous hitobject's strain until the
-     * beginning of the new chunk.
-     *
-     * @param options Options for the difficulty calculation.
-     * @returns The current instance.
-     */
-    calculate(options?: DifficultyCalculationOptions): this;
-    /**
-     * Generates difficulty hitobjects for this calculator.
-     *
-     * @param beatmap The beatmap to generate difficulty hitobjects from.
-     * @param clockRate The clock rate of the beatmap.
-     */
-    protected abstract generateDifficultyHitObjects(beatmap: Beatmap, clockRate: number): THitObject[];
-    /**
-     * Calculates the skills provided.
-     *
-     * @param skills The skills to calculate.
-     */
-    protected calculateSkills(...skills: Skill[]): void;
-    /**
-     * Calculates the total star rating of the beatmap and stores it in this instance.
-     */
-    abstract calculateTotal(): void;
-    /**
-     * Calculates every star rating of the beatmap and stores it in this instance.
-     */
-    abstract calculateAll(): void;
-    /**
-     * Returns a string representative of the class.
-     */
-    abstract toString(): string;
-    /**
-     * Creates skills to be calculated.
-     */
-    protected abstract createSkills(): Skill[];
-    /**
-     * Obtains the clock rate of the beatmap.
-     *
-     * @param options The options to obtain the clock rate with.
-     * @returns The clock rate of the beatmap.
-     */
-    protected calculateClockRate(options?: DifficultyCalculationOptions): number;
-    /**
-     * Populates the stored difficulty attributes with necessary data.
-     *
-     * @param beatmap The beatmap to populate the attributes with.
-     * @param clockRate The clock rate of the beatmap.
-     */
-    protected populateDifficultyAttributes(beatmap: Beatmap, clockRate: number): void;
+interface StrainPeaks {
     /**
-     * Calculates the star rating value of a difficulty.
-     *
-     * @param difficulty The difficulty to calculate.
+     * The strain peaks of aim difficulty if sliders are considered.
      */
-    protected starValue(difficulty: number): number;
+    aimWithSliders: number[];
     /**
-     * Calculates the base performance value of a difficulty rating.
-     *
-     * @param rating The difficulty rating.
+     * The strain peaks of aim difficulty if sliders are not considered.
      */
-    protected basePerformanceValue(rating: number): number;
-}
-
-/**
- * Represents a slider that is considered difficult.
- *
- * This structure is a part of difficulty attributes and can be cached.
- */
-interface DifficultSlider {
+    aimWithoutSliders: number[];
     /**
-     * The index of the slider in the beatmap.
+     * The strain peaks of speed difficulty.
      */
-    readonly index: number;
+    speed: number[];
     /**
-     * The difficulty rating of this slider compared to other sliders, based on the velocity of the slider.
-     *
-     * A value closer to 1 indicates that this slider is more difficult compared to most sliders.
-     *
-     * A value closer to 0 indicates that this slider is easier compared to most sliders.
+     * The strain peaks of flashlight difficulty.
      */
-    readonly difficultyRating: number;
+    flashlight: number[];
 }
 
 /**
@@ -526,6 +406,124 @@ declare abstract class StrainSkill extends Skill {
     private startNewSectionFrom;
 }
 
+/**
+ * The base of a difficulty calculator.
+ */
+declare abstract class DifficultyCalculator<TBeatmap extends PlayableBeatmap, THitObject extends DifficultyHitObject, TAttributes extends DifficultyAttributes> {
+    protected abstract readonly difficultyMultiplier: number;
+    /**
+     * `Mod`s that adjust the difficulty of a beatmap.
+     */
+    protected readonly difficultyAdjustmentMods: Set<typeof Mod>;
+    /**
+     * Retains `Mod`s that adjust a beatmap's difficulty from the specified mods.
+     *
+     * @param mods The mods to retain the difficulty adjustment mods from.
+     * @returns The retained difficulty adjustment mods.
+     */
+    abstract retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
+    /**
+     * Calculates the difficulty of a `PlayableBeatmap`.
+     *
+     * @param beatmap The `PlayableBeatmap` whose difficulty is to be calculated.
+     * @returns A `DifficultyAttributes` object describing the difficulty of the `Beatmap`.
+     */
+    calculate(beatmap: TBeatmap): TAttributes;
+    /**
+     * Calculates the difficulty of a `Beatmap` with specific `Mod`s.
+     *
+     * @param beatmap The `Beatmap` whose difficulty is to be calculated.
+     * @param mods The `Mod`s to apply to the beatmap. Defaults to No Mod.
+     * @returns A `DifficultyAttributes` object describing the difficulty of the `Beatmap`.
+     */
+    calculate(beatmap: Beatmap, mods?: Mod[]): TAttributes;
+    /**
+     * Obtains the strain peaks of a `PlayableBeatmap`.
+     *
+     * @param beatmap The `PlayableBeatmap` whose strain peaks are to be calculated.
+     * @returns The strain peaks of the `PlayableBeatmap`.
+     */
+    calculateStrainPeaks(beatmap: TBeatmap): StrainPeaks;
+    /**
+     * Obtains the strain peaks of a `Beatmap` with specific `Mod`s.
+     *
+     * @param beatmap The `Beatmap` whose strain peaks are to be calculated.
+     * @param mods The `Mod`s to apply to the beatmap. Defaults to No Mod.
+     * @returns The strain peaks of the `Beatmap`.
+     */
+    calculateStrainPeaks(beatmap: Beatmap, mods: Mod[]): StrainPeaks;
+    /**
+     * Creates the `Skill`s to calculate the difficulty of a `PlayableBeatmap`.
+     *
+     * @param beatmap The `PlayableBeatmap` whose difficulty will be calculated.
+     * @return The `Skill`s.
+     */
+    protected abstract createSkills(beatmap: TBeatmap): Skill[];
+    /**
+     * Creates the `Skill`s to obtain the strain peaks of a `PlayableBeatmap`.
+     *
+     * @param beatmap
+     */
+    protected abstract createStrainPeakSkills(beatmap: TBeatmap): StrainSkill[];
+    /**
+     * Creates difficulty hitobjects for this calculator.
+     *
+     * @param beatmap The beatmap to generate difficulty hitobjects from.
+     * @returns The generated difficulty hitobjects.
+     */
+    protected abstract createDifficultyHitObjects(beatmap: TBeatmap): THitObject[];
+    /**
+     * Creates a `DifficultyAttributes` object to describe a `PlayableBeatmap`'s difficulty.
+     *
+     * @param beatmap The `PlayableBeatmap` whose difficulty was calculated.
+     * @param skills The `Skill`s which processed the `PlayableBeatmap`.
+     * @param objects The `DifficultyHitObject`s which were processed.
+     * @returns The `DifficultyAttributes` object.
+     */
+    protected abstract createDifficultyAttributes(beatmap: TBeatmap, skills: Skill[], objects: THitObject[]): TAttributes;
+    /**
+     * Constructs a `PlayableBeatmap` from a `Beatmap` with specific `Mod`s.
+     *
+     * @param beatmap The `Beatmap` to create a `PlayableBeatmap` from.
+     * @param mods The `Mod`s to apply to the `Beatmap`.
+     * @returns The `PlayableBeatmap`.
+     */
+    protected abstract createPlayableBeatmap(beatmap: Beatmap, mods: Mod[]): TBeatmap;
+    /**
+     * Calculates the base rating of a `Skill`.
+     *
+     * @param skill The `Skill` to calculate the rating of.
+     * @returns The rating of the `Skill`.
+     */
+    protected calculateRating(skill: Skill): number;
+    /**
+     * Calculates the base performance value of a difficulty rating.
+     *
+     * @param rating The difficulty rating.
+     */
+    protected basePerformanceValue(rating: number): number;
+}
+
+/**
+ * Represents a slider that is considered difficult.
+ *
+ * This structure is a part of difficulty attributes and can be cached.
+ */
+interface DifficultSlider {
+    /**
+     * The index of the slider in the beatmap.
+     */
+    readonly index: number;
+    /**
+     * The difficulty rating of this slider compared to other sliders, based on the velocity of the slider.
+     *
+     * A value closer to 1 indicates that this slider is more difficult compared to most sliders.
+     *
+     * A value closer to 0 indicates that this slider is easier compared to most sliders.
+     */
+    readonly difficultyRating: number;
+}
+
 /**
  * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
  * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
@@ -608,9 +606,11 @@ declare class DroidDifficultyHitObject extends DifficultyHitObject {
      * @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);
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, index: number);
     computeProperties(clockRate: number, hitObjects: readonly PlaceableHitObject[]): void;
-    opacityAt(time: number, mods: Mod[]): number;
+    opacityAt(time: number, mods: readonly Mod[]): number;
+    previous(backwardsIndex: number): this | null;
+    next(forwardsIndex: number): this | null;
     /**
      * Determines whether this hitobject is considered overlapping with the hitobject before it.
      *
@@ -640,7 +640,7 @@ declare class DroidAim extends DroidSkill {
     private currentAimStrain;
     private readonly sliderStrains;
     readonly withSliders: boolean;
-    constructor(mods: Mod[], withSliders: boolean);
+    constructor(mods: readonly Mod[], withSliders: boolean);
     /**
      * Obtains the amount of sliders that are considered difficult in terms of relative strain.
      */
@@ -692,7 +692,7 @@ declare abstract class DroidAimEvaluator {
 /**
  * Holds data that can be used to calculate osu!droid performance points.
  */
-interface DroidDifficultyAttributes extends DifficultyAttributes {
+interface IDroidDifficultyAttributes extends IDifficultyAttributes {
     /**
      * The difficulty corresponding to the tap skill.
      */
@@ -732,13 +732,19 @@ interface DroidDifficultyAttributes extends DifficultyAttributes {
 }
 
 /**
- * Represents options for osu!droid difficulty calculation.
+ * Holds data that can be used to calculate osu!droid performance points.
  */
-interface DroidDifficultyCalculationOptions extends DifficultyCalculationOptions {
-    /**
-     * Whether to calculate for old statistics (1.6.7 and older). Defaults to `false`.
-     */
-    readonly oldStatistics?: boolean;
+declare class DroidDifficultyAttributes extends DifficultyAttributes implements IDroidDifficultyAttributes {
+    tapDifficulty: number;
+    rhythmDifficulty: number;
+    visualDifficulty: number;
+    tapDifficultStrainCount: number;
+    flashlightDifficultStrainCount: number;
+    visualDifficultStrainCount: number;
+    averageSpeedDeltaTime: number;
+    vibroFactor: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IDroidDifficultyAttributes>);
+    toString(): string;
 }
 
 /**
@@ -763,7 +769,7 @@ interface HighStrainSection {
  * Holds data that can be used to calculate osu!droid performance points as well
  * as doing some analysis using the replay of a score.
  */
-interface ExtendedDroidDifficultyAttributes extends DroidDifficultyAttributes {
+interface IExtendedDroidDifficultyAttributes extends IDroidDifficultyAttributes {
     /**
      * The mode of the difficulty calculation.
      */
@@ -800,109 +806,43 @@ interface ExtendedDroidDifficultyAttributes extends DroidDifficultyAttributes {
     visualSliderFactor: number;
 }
 
+/**
+ * Holds data that can be used to calculate osu!droid performance points as well
+ * as doing some analysis using the replay of a score.
+ */
+declare class ExtendedDroidDifficultyAttributes extends DroidDifficultyAttributes implements IExtendedDroidDifficultyAttributes {
+    mode: "live";
+    possibleThreeFingeredSections: HighStrainSection[];
+    difficultSliders: DifficultSlider[];
+    aimNoteCount: number;
+    flashlightSliderFactor: number;
+    visualSliderFactor: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IExtendedDroidDifficultyAttributes>);
+}
+
 /**
  * A difficulty calculator for osu!droid gamemode.
  */
-declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidDifficultyHitObject, DroidDifficultyAttributes> {
-    /**
-     * The aim star rating of the beatmap.
-     */
-    get aim(): number;
-    /**
-     * The tap star rating of the beatmap.
-     */
-    get tap(): number;
-    /**
-     * The rhythm star rating of the beatmap.
-     */
-    get rhythm(): number;
-    /**
-     * The flashlight star rating of the beatmap.
-     */
-    get flashlight(): number;
-    /**
-     * The visual star rating of the beatmap.
-     */
-    get visual(): number;
+declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidPlayableBeatmap, DroidDifficultyHitObject, ExtendedDroidDifficultyAttributes> {
     /**
      * The strain threshold to start detecting for possible three-fingered section.
      *
      * Increasing this number will result in less sections being flagged.
      */
     static readonly threeFingerStrainThreshold = 175;
-    readonly attributes: ExtendedDroidDifficultyAttributes;
-    get cacheableAttributes(): CacheableDifficultyAttributes<DroidDifficultyAttributes>;
     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.
-     */
-    calculateAim(): void;
-    /**
-     * Calculates the tap star rating of the beatmap and stores it in this instance.
-     */
-    calculateTap(): void;
-    /**
-     * Calculates the rhythm star rating of the beatmap and stores it in this instance.
-     */
-    calculateRhythm(): void;
-    /**
-     * Calculates the flashlight star rating of the beatmap and stores it in this instance.
-     */
-    calculateFlashlight(): void;
-    /**
-     * Calculates the visual star rating of the beatmap and stores it in this instance.
-     */
-    calculateVisual(): void;
-    calculateTotal(): void;
-    calculateAll(): void;
-    toString(): string;
-    protected generateDifficultyHitObjects(beatmap: Beatmap, clockRate: number): DroidDifficultyHitObject[];
-    protected createSkills(): DroidSkill[];
-    protected calculateClockRate(options?: DroidDifficultyCalculationOptions): number;
-    /**
-     * Called after aim skill calculation.
-     *
-     * @param aimSkill The aim skill that considers sliders.
-     * @param aimSkillWithoutSliders The aim skill that doesn't consider sliders.
-     */
-    private postCalculateAim;
-    /**
-     * Calculates aim-related attributes.
-     */
-    private calculateAimAttributes;
-    /**
-     * Called after tap skill calculation.
-     *
-     * @param tapSkillCheese The tap skill that considers cheesing.
-     * @param tapSkillVibro The tap skill that considers vibro.
-     */
-    private postCalculateTap;
-    /**
-     * Calculates tap-related attributes.
-     */
-    private calculateTapAttributes;
-    /**
-     * Called after rhythm skill calculation.
-     *
-     * @param rhythmSkill The rhythm skill.
-     */
-    private postCalculateRhythm;
-    /**
-     * Called after flashlight skill calculation.
-     *
-     * @param flashlightSkill The flashlight skill that considers sliders.
-     * @param flashlightSkillWithoutSliders The flashlight skill that doesn't consider sliders.
-     */
-    private postCalculateFlashlight;
-    /**
-     * Called after visual skill calculation.
-     *
-     * @param visualSkillWithSliders The visual skill that considers sliders.
-     * @param visualSkillWithoutSliders The visual skill that doesn't consider sliders.
-     */
-    private postCalculateVisual;
+    constructor();
+    retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
+    protected createDifficultyAttributes(beatmap: DroidPlayableBeatmap, skills: Skill[], objects: DroidDifficultyHitObject[]): ExtendedDroidDifficultyAttributes;
+    protected createPlayableBeatmap(beatmap: Beatmap, mods: Mod[]): DroidPlayableBeatmap;
+    protected createDifficultyHitObjects(beatmap: DroidPlayableBeatmap): DroidDifficultyHitObject[];
+    protected createSkills(beatmap: DroidPlayableBeatmap): DroidSkill[];
+    protected createStrainPeakSkills(beatmap: DroidPlayableBeatmap): StrainSkill[];
+    private populateAimAttributes;
+    private populateTapAttributes;
+    private populateRhythmAttributes;
+    private populateFlashlightAttributes;
+    private populateVisualAttributes;
 }
 
 /**
@@ -916,7 +856,7 @@ declare class DroidFlashlight extends DroidSkill {
     private readonly skillMultiplier;
     private currentFlashlightStrain;
     readonly withSliders: boolean;
-    constructor(mods: Mod[], withSliders: boolean);
+    constructor(mods: readonly Mod[], withSliders: boolean);
     protected strainValueAt(current: DroidDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
     protected getObjectStrain(): number;
@@ -948,7 +888,7 @@ declare abstract class DroidFlashlightEvaluator {
      * @param mods The mods used.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current: DroidDifficultyHitObject, mods: Mod[], withSliders: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, mods: readonly Mod[], withSliders: boolean): number;
 }
 
 /**
@@ -988,7 +928,7 @@ interface PerformanceCalculationOptions {
 /**
  * The base class of performance calculators.
  */
-declare abstract class PerformanceCalculator<T extends DifficultyAttributes> {
+declare abstract class PerformanceCalculator<T extends IDifficultyAttributes> {
     /**
      * The overall performance value.
      */
@@ -1093,7 +1033,7 @@ declare abstract class PerformanceCalculator<T extends DifficultyAttributes> {
 /**
  * A performance points calculator that calculates performance points for osu!droid gamemode.
  */
-declare class DroidPerformanceCalculator extends PerformanceCalculator<DroidDifficultyAttributes> {
+declare class DroidPerformanceCalculator extends PerformanceCalculator<IDroidDifficultyAttributes> {
     /**
      * The aim performance value.
      */
@@ -1259,7 +1199,7 @@ declare class DroidRhythm extends DroidSkill {
     private readonly useSliderAccuracy;
     private currentRhythmStrain;
     private currentRhythmMultiplier;
-    constructor(mods: Mod[]);
+    constructor(mods: readonly Mod[]);
     protected strainValueAt(current: DroidDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
     protected getObjectStrain(): number;
@@ -1302,7 +1242,7 @@ declare class DroidTap extends DroidSkill {
     get objectDeltaTimes(): readonly number[];
     readonly considerCheesability: boolean;
     private readonly strainTimeCap?;
-    constructor(mods: Mod[], considerCheesability: boolean, strainTimeCap?: number);
+    constructor(mods: readonly Mod[], considerCheesability: boolean, strainTimeCap?: number);
     /**
      * The amount of notes that are relevant to the difficulty.
      */
@@ -1353,7 +1293,7 @@ declare class DroidVisual extends DroidSkill {
     private currentRhythmMultiplier;
     private readonly skillMultiplier;
     readonly withSliders: boolean;
-    constructor(mods: Mod[], withSliders: boolean);
+    constructor(mods: readonly Mod[], withSliders: boolean);
     protected strainValueAt(current: DroidDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
     protected getObjectStrain(): number;
@@ -1379,7 +1319,27 @@ declare abstract class DroidVisualEvaluator {
      * @param mods The mods used.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current: DroidDifficultyHitObject, mods: Mod[], withSliders: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, mods: readonly Mod[], withSliders: boolean): number;
+}
+
+/**
+ * Holds data that can be used to calculate osu!standard performance points.
+ */
+interface IOsuDifficultyAttributes extends IDifficultyAttributes {
+    /**
+     * The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
+     *
+     * Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
+     */
+    approachRate: number;
+    /**
+     * The difficulty corresponding to the speed skill.
+     */
+    speedDifficulty: number;
+    /**
+     * The amount of strains that are considered difficult with respect to the speed skill.
+     */
+    speedDifficultStrainCount: number;
 }
 
 /**
@@ -1423,7 +1383,7 @@ declare class OsuAim extends OsuSkill {
     private readonly skillMultiplier;
     private readonly sliderStrains;
     readonly withSliders: boolean;
-    constructor(mods: Mod[], withSliders: boolean);
+    constructor(mods: readonly Mod[], withSliders: boolean);
     /**
      * Obtains the amount of sliders that are considered difficult in terms of relative strain.
      */
@@ -1464,80 +1424,29 @@ declare abstract class OsuAimEvaluator {
 /**
  * Holds data that can be used to calculate osu!standard performance points.
  */
-interface OsuDifficultyAttributes extends DifficultyAttributes {
-    /**
-     * The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
-     *
-     * Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
-     */
+declare class OsuDifficultyAttributes extends DifficultyAttributes implements IOsuDifficultyAttributes {
     approachRate: number;
-    /**
-     * The difficulty corresponding to the speed skill.
-     */
     speedDifficulty: number;
-    /**
-     * The amount of strains that are considered difficult with respect to the speed skill.
-     */
     speedDifficultStrainCount: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IOsuDifficultyAttributes>);
+    toString(): string;
 }
 
 /**
  * A difficulty calculator for osu!standard gamemode.
  */
-declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuDifficultyHitObject, OsuDifficultyAttributes> {
-    /**
-     * The aim star rating of the beatmap.
-     */
-    get aim(): number;
-    /**
-     * The speed star rating of the beatmap.
-     */
-    get speed(): number;
-    /**
-     * The flashlight star rating of the beatmap.
-     */
-    get flashlight(): number;
-    readonly attributes: OsuDifficultyAttributes;
-    get cacheableAttributes(): CacheableDifficultyAttributes<OsuDifficultyAttributes>;
+declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuPlayableBeatmap, OsuDifficultyHitObject, OsuDifficultyAttributes> {
     protected readonly difficultyMultiplier = 0.0675;
-    protected readonly mode = Modes.osu;
-    /**
-     * Calculates the aim star rating of the beatmap and stores it in this instance.
-     */
-    calculateAim(): void;
-    /**
-     * Calculates the speed star rating of the beatmap and stores it in this instance.
-     */
-    calculateSpeed(): void;
-    /**
-     * Calculates the flashlight star rating of the beatmap and stores it in this instance.
-     */
-    calculateFlashlight(): void;
-    calculateTotal(): void;
-    calculateAll(): void;
-    toString(): string;
-    protected generateDifficultyHitObjects(beatmap: Beatmap, clockRate: number): OsuDifficultyHitObject[];
-    protected createSkills(): OsuSkill[];
-    protected populateDifficultyAttributes(beatmap: Beatmap, clockRate: number): void;
-    /**
-     * Called after aim skill calculation.
-     *
-     * @param aimSkill The aim skill that considers sliders.
-     * @param aimSkillWithoutSliders The aim skill that doesn't consider sliders.
-     */
-    private postCalculateAim;
-    /**
-     * Called after speed skill calculation.
-     *
-     * @param speedSkill The speed skill.
-     */
-    private postCalculateSpeed;
-    /**
-     * Called after flashlight skill calculation.
-     *
-     * @param flashlightSkill The flashlight skill.
-     */
-    private postCalculateFlashlight;
+    constructor();
+    retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
+    protected createDifficultyAttributes(beatmap: OsuPlayableBeatmap, skills: Skill[]): OsuDifficultyAttributes;
+    protected createPlayableBeatmap(beatmap: Beatmap, mods: Mod[]): OsuPlayableBeatmap;
+    protected createDifficultyHitObjects(beatmap: OsuPlayableBeatmap): OsuDifficultyHitObject[];
+    protected createSkills(beatmap: OsuPlayableBeatmap): OsuSkill[];
+    protected createStrainPeakSkills(beatmap: OsuPlayableBeatmap): StrainSkill[];
+    private populateAimAttributes;
+    private populateSpeedAttributes;
+    private populateFlashlightAttributes;
 }
 
 /**
@@ -1577,13 +1486,13 @@ declare abstract class OsuFlashlightEvaluator {
      * @param current The current object.
      * @param mods The mods used.
      */
-    static evaluateDifficultyOf(current: OsuDifficultyHitObject, mods: Mod[]): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, mods: readonly Mod[]): number;
 }
 
 /**
  * A performance points calculator that calculates performance points for osu!standard gamemode.
  */
-declare class OsuPerformanceCalculator extends PerformanceCalculator<OsuDifficultyAttributes> {
+declare class OsuPerformanceCalculator extends PerformanceCalculator<IOsuDifficultyAttributes> {
     /**
      * The aim performance value.
      */
@@ -1676,6 +1585,10 @@ declare class OsuSpeed extends OsuSkill {
     private currentSpeedStrain;
     private currentRhythm;
     private readonly skillMultiplier;
+    /**
+     * The amount of notes that are relevant to the difficulty.
+     */
+    relevantNoteCount(): number;
     /**
      * @param current The hitobject to calculate.
      */
@@ -1709,7 +1622,7 @@ declare abstract class OsuSpeedEvaluator {
      * @param current The current object.
      * @param mods The mods applied.
      */
-    static evaluateDifficultyOf(current: OsuDifficultyHitObject, mods: Mod[]): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, mods: readonly Mod[]): number;
 }
 
-export { 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, type HighStrainSection, OsuAim, OsuAimEvaluator, type OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, type PerformanceCalculationOptions, PerformanceCalculator, type StrainPeaks };
+export { type CacheableDifficultyAttributes, type DifficultSlider, DifficultyAttributes, DifficultyCalculator, DifficultyHitObject, DroidAim, DroidAimEvaluator, DroidDifficultyAttributes, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, DroidVisual, DroidVisualEvaluator, ExtendedDroidDifficultyAttributes, type HighStrainSection, type IDifficultyAttributes, type IDroidDifficultyAttributes, type IExtendedDroidDifficultyAttributes, type IOsuDifficultyAttributes, OsuAim, OsuAimEvaluator, OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, type PerformanceCalculationOptions, PerformanceCalculator, type StrainPeaks };