@rian8337/osu-difficulty-calculator 4.0.0-beta.9 → 4.0.0-beta.90

package/typings/index.d.ts

@@ -1,43 +1,13 @@
-import { MapStats, Mod, PlaceableHitObject, Modes, Beatmap, HitObject, Accuracy } from '@rian8337/osu-base';
-
-/**
- * An evaluator for calculating aim skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-declare abstract class AimEvaluator {
-    protected static readonly wideAngleMultiplier: number;
-    protected static readonly acuteAngleMultiplier: number;
-    protected static readonly sliderMultiplier: number;
-    protected static readonly velocityChangeMultiplier: number;
-    /**
-     * Calculates the bonus of wide angles.
-     */
-    protected static calculateWideAngleBonus(angle: number): number;
-    /**
-     * Calculates the bonus of acute angles.
-     */
-    protected static calculateAcuteAngleBonus(angle: number): number;
-}
-
-/**
- * The base of calculation options.
- */
-interface CalculationOptions {
-    /**
-     * Custom map statistics to apply custom speed multiplier as well as old statistics.
-     */
-    stats?: MapStats;
-}
+import { ModMap, SerializedMod, PlaceableHitObject, Vector2, Modes, PlayableBeatmap, Mod, 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.
      */
-    mods: Mod[];
+    mods: ModMap;
     /**
      * The combined star rating of all skills.
      */
@@ -73,13 +43,7 @@ interface DifficultyAttributes {
      */
     clockRate: number;
     /**
-     * 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 perceived overall difficulty inclusive of rate-adjusting mods (DT/HT/etc), based on osu!standard judgement.
+     * The perceived overall difficulty **exclusive** of rate-adjusting mods (DT/HT/etc).
      *
      * Rate-adjusting mods don't directly affect the overall difficulty value, but have a perceived effect as a result of adjusting audio timing.
      */
@@ -96,22 +60,61 @@ interface DifficultyAttributes {
      * The number of spinners in the beatmap.
      */
     spinnerCount: number;
+    /**
+     * The number of sliders weighted by difficulty.
+     */
+    aimDifficultSliderCount: number;
+    /**
+     * The amount of strains that are considered difficult with respect to the aim skill.
+     */
+    aimDifficultStrainCount: number;
 }
 
 /**
- * Represents options for difficulty calculation.
+ * Represents difficulty attributes that can be cached.
  */
-interface DifficultyCalculationOptions extends CalculationOptions {
+type CacheableDifficultyAttributes<T extends IDifficultyAttributes> = Omit<T, "mods" | "toCacheableAttributes"> & {
+    /**
+     * The mods which were applied to the beatmap.
+     */
+    mods: SerializedMod[];
+};
+
+/**
+ * Holds data that can be used to calculate performance points.
+ */
+declare abstract class DifficultyAttributes implements IDifficultyAttributes {
+    mods: ModMap;
+    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.
+     */
+    toCacheableAttributes(): CacheableDifficultyAttributes<this>;
+    /**
+     * Returns a string representation of the difficulty attributes.
      */
-    mods?: Mod[];
+    toString(): string;
 }
 
 /**
- * Represents an osu!standard hit object with difficulty calculation values.
+ * Represents a hit object with difficulty calculation values.
  */
-declare class DifficultyHitObject {
+declare abstract class DifficultyHitObject {
     /**
      * The underlying hitobject.
      */
@@ -121,19 +124,7 @@ declare 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.
      */
@@ -142,41 +133,10 @@ declare class DifficultyHitObject {
      * The aim strain generated by the hitobject if sliders are not considered.
      */
     aimStrainWithoutSliders: number;
-    /**
-     * The tap strain generated by the hitobject.
-     *
-     * This is also used for osu!standard as opposed to "speed strain".
-     */
-    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 multiplier generated by the hitobject. This is used to alter tap strain.
      */
     rhythmMultiplier: 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 normalized distance from the "lazy" end position of the previous hitobject to the start position of this hitobject.
      *
@@ -208,6 +168,21 @@ declare class DifficultyHitObject {
      * The time taken to travel through `travelDistance`, with a minimum value of 25ms for sliders.
      */
     travelTime: number;
+    /**
+     * The position of the cursor at the point of completion of this hitobject if it was hit
+     * with as few movements as possible.
+     */
+    lazyEndPosition?: Vector2;
+    /**
+     * The distance travelled by the cursor upon completion of this hitobject if it was hit
+     * with as few movements as possible.
+     */
+    lazyTravelDistance: number;
+    /**
+     * The time taken by the cursor upon completion of this hitobject if it was hit with
+     * as few movements as possible.
+     */
+    lazyTravelTime: number;
     /**
      * Angle the player has to take to hit this hitobject.
      *
@@ -217,42 +192,66 @@ declare 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;
     /**
-     * The note density of the hitobject.
+     * The full great window of the hitobject.
      */
-    noteDensity: number;
+    readonly fullGreatWindow: number;
     /**
-     * The overlapping factor of the hitobject.
-     *
-     * This is used to scale visual skill.
+     * Selective bonus for beatmaps with higher circle size.
      */
-    overlappingFactor: number;
+    abstract get smallCircleBonus(): number;
     /**
-     * Adjusted velocity of the hitobject, taking speed multiplier into account.
+     * Other hitobjects in the beatmap, including this hitobject.
      */
-    velocity: number;
+    protected readonly hitObjects: readonly DifficultyHitObject[];
     /**
-     * Other hitobjects in the beatmap, including this hitobject.
+     * The normalized radius of the hitobject.
      */
-    private readonly hitObjects;
+    static readonly normalizedRadius: number;
+    /**
+     * The normalized diameter of the hitobject.
+     */
+    static get normalizedDiameter(): number;
+    protected abstract readonly mode: Modes;
+    protected readonly maximumSliderRadius: number;
+    protected readonly assumedSliderRadius: number;
+    /**
+     * The lowest possible delta time value.
+     */
+    static readonly minDeltaTime = 25;
+    private readonly lastObject;
+    private readonly lastDifficultyObject;
+    private readonly lastLastDifficultyObject;
     /**
+     * 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 difficultyHitObjects All difficulty hitobjects in the processed beatmap.
+     * @param clockRate The clock rate of the beatmap.
+     * @param index The index of this hitobject in the list of all hitobjects.
+     */
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, index: number);
+    /**
+     * Computes the properties of this hitobject.
+     *
+     * @param clockRate The clock rate of the beatmap.
      */
-    constructor(object: PlaceableHitObject, hitObjects: DifficultyHitObject[]);
+    computeProperties(clockRate: number): void;
     /**
      * Gets the difficulty hitobject at a specific index with respect to the current
      * difficulty hitobject's index.
@@ -263,7 +262,7 @@ declare class DifficultyHitObject {
      * @returns The difficulty hitobject at the index with respect to the current
      * difficulty hitobject's index, `null` if the index is out of range.
      */
-    previous(backwardsIndex: number): DifficultyHitObject | null;
+    previous(backwardsIndex: number): this | null;
     /**
      * Gets the difficulty hitobject at a specific index with respect to the current
      * difficulty hitobject's index.
@@ -274,26 +273,25 @@ declare class DifficultyHitObject {
      * @returns The difficulty hitobject at the index with respect to the current
      * difficulty hitobject's index, `null` if the index is out of range.
      */
-    next(forwardsIndex: number): DifficultyHitObject | null;
+    next(forwardsIndex: number): this | null;
     /**
      * Calculates the opacity of the hitobject at a given time.
      *
      * @param time The time to calculate the hitobject's opacity at.
-     * @param isHidden Whether Hidden mod is used.
-     * @param mode The gamemode to calculate the opacity for.
+     * @param mods The mods used.
      * @returns The opacity of the hitobject at the given time.
      */
-    opacityAt(time: number, isHidden: boolean, mode: Modes): number;
+    opacityAt(time: number, mods: ModMap): 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.
+     * How possible is it to doubletap this object together with the next one and get perfect
+     * judgement in range from 0 to 1.
      *
-     * @param considerDistance Whether to consider the distance between both hitobjects.
-     * @returns Whether the hitobject is considered overlapping.
+     * A value closer to 1 indicates a higher possibility.
      */
-    isOverlapping(considerDistance: boolean): boolean;
+    getDoubletapness(nextObj: this | null): number;
+    protected setDistances(clockRate: number): void;
+    private calculateSliderCursorPosition;
+    private getEndCursorPosition;
 }
 
 /**
@@ -305,8 +303,8 @@ declare abstract class Skill {
     /**
      * The mods that this skill processes.
      */
-    protected readonly mods: Mod[];
-    constructor(mods: Mod[]);
+    protected readonly mods: ModMap;
+    constructor(mods: ModMap);
     /**
      * Processes a hitobject.
      *
@@ -320,18 +318,32 @@ declare abstract class Skill {
 }
 
 /**
- * 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.
+ * Represents the strain peaks of various calculated difficulties.
  */
-declare abstract class StrainSkill extends Skill {
+interface StrainPeaks {
+    /**
+     * The strain peaks of aim difficulty if sliders are considered.
+     */
+    aimWithSliders: readonly number[];
     /**
-     * The strain of currently calculated hitobject.
+     * The strain peaks of aim difficulty if sliders are not considered.
+     */
+    aimWithoutSliders: readonly number[];
+    /**
+     * The strain peaks of speed difficulty.
      */
-    protected currentStrain: number;
+    speed: readonly number[];
     /**
-     * The current section's strain peak.
+     * The strain peaks of flashlight difficulty.
      */
-    protected currentSectionPeak: number;
+    flashlight: readonly 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.
+ */
+declare abstract class StrainSkill extends Skill {
     /**
      * Strain peaks are stored here.
      */
@@ -345,247 +357,250 @@ declare abstract class StrainSkill extends Skill {
      * The baseline multiplier applied to the section with the biggest strain.
      */
     protected abstract readonly reducedSectionBaseline: number;
-    /**
-     * Strain values are multiplied by this number for the given skill. Used to balance the value of different skills between each other.
-     */
-    protected abstract readonly skillMultiplier: number;
     /**
      * Determines how quickly strain decays for the given skill.
      *
      * For example, a value of 0.15 indicates that strain decays to 15% of its original value in one second.
      */
     protected abstract readonly strainDecayBase: number;
+    protected readonly _objectStrains: number[];
+    protected difficulty: number;
+    /**
+     * The strains of hitobjects.
+     */
+    get objectStrains(): readonly number[];
     private readonly sectionLength;
+    private currentStrain;
+    private currentSectionPeak;
     private currentSectionEnd;
-    private isFirstObject;
     /**
-     * Calculates the strain value of a hitobject and stores the value in it. This value is affected by previously processed objects.
+     * Converts a difficulty value to a performance value.
      *
-     * @param current The hitobject to process.
+     * @param difficulty The difficulty value to convert.
+     * @returns The performance value.
      */
+    static difficultyToPerformance(difficulty: number): number;
     process(current: DifficultyHitObject): void;
     /**
      * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
      */
     saveCurrentPeak(): void;
+    /**
+     * Returns the number of strains weighed against the top strain.
+     *
+     * The result is scaled by clock rate as it affects the total number of strains.
+     */
+    countTopWeightedStrains(): number;
     /**
      * Calculates strain decay for a specified time frame.
      *
      * @param ms The time frame to calculate.
      */
     protected strainDecay(ms: number): number;
+    /**
+     * Calculates the starting time of a strain section at an object.
+     *
+     * @param current The object at which the strain section starts.
+     * @returns The start time of the strain section.
+     */
+    protected calculateCurrentSectionStart(current: DifficultyHitObject): number;
     /**
      * Calculates the strain value at a hitobject.
+     *
+     * @param current The hitobject to calculate.
      */
     protected abstract strainValueAt(current: DifficultyHitObject): number;
     /**
      * Saves the current strain to a hitobject.
      */
     protected abstract saveToHitObject(current: DifficultyHitObject): void;
+    /**
+     * Retrieves the peak strain at a point in time.
+     *
+     * @param time The time to retrieve the peak strain at.
+     * @param current The current hit object.
+     * @returns The peak strain.
+     */
+    protected abstract calculateInitialStrain(time: number, current: DifficultyHitObject): number;
     /**
      * Sets the initial strain level for a new section.
      *
-     * @param offset The beginning of the new section in milliseconds, adjusted by speed multiplier.
+     * @param time The beginning of the new section in milliseconds.
      * @param current The current hitobject.
      */
     private startNewSectionFrom;
 }
 
 /**
- * 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[];
-}
-
-/**
- * The base of difficulty calculators.
+ * The base of a difficulty calculator.
  */
-declare abstract class DifficultyCalculator {
+declare abstract class DifficultyCalculator<TBeatmap extends PlayableBeatmap, THitObject extends DifficultyHitObject, TAttributes extends DifficultyAttributes> {
     /**
-     * The calculated beatmap.
+     * `Mod`s that adjust the difficulty of a beatmap.
      */
-    readonly beatmap: Beatmap;
+    protected readonly difficultyAdjustmentMods: (typeof Mod)[];
     /**
-     * The difficulty objects of the beatmap.
-     */
-    readonly objects: DifficultyHitObject[];
-    /**
-     * The modifications applied.
-     */
-    mods: Mod[];
-    /**
-     * The total star rating of the beatmap.
-     */
-    total: number;
-    /**
-     * The map statistics of the beatmap after modifications are applied.
-     */
-    stats: MapStats;
-    /**
-     * The strain peaks of various calculated difficulties.
-     */
-    readonly strainPeaks: StrainPeaks;
-    /**
-     * Holds data that can be used to calculate performance points.
-     */
-    abstract readonly attributes: DifficultyAttributes;
-    protected abstract readonly difficultyMultiplier: number;
-    protected abstract readonly mode: Modes;
-    /**
-     * Constructs a new instance of the calculator.
+     * Retains `Mod`s that adjust a beatmap's difficulty from the specified mods.
      *
-     * @param beatmap The beatmap to calculate. This beatmap will be deep-cloned to prevent reference changes.
+     * @param mods The mods to retain the difficulty adjustment mods from.
+     * @returns The retained difficulty adjustment mods.
      */
-    constructor(beatmap: Beatmap);
+    abstract retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
     /**
-     * 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.
+     * Calculates the difficulty of a `Beatmap` with specific `Mod`s.
      *
-     * @param options Options for the difficulty calculation.
-     * @returns The current instance.
+     * @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(options?: DifficultyCalculationOptions): this;
+    calculate(beatmap: Beatmap, mods?: ModMap): TAttributes;
     /**
-     * Generates difficulty hitobjects for this calculator.
+     * 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`.
      */
-    generateDifficultyHitObjects(): void;
+    calculateStrainPeaks(beatmap: TBeatmap): StrainPeaks;
     /**
-     * Performs some pre-processing before proceeding with difficulty calculation.
+     * 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`.
      */
-    protected preProcess(): void;
+    calculateStrainPeaks(beatmap: Beatmap, mods?: ModMap): StrainPeaks;
     /**
-     * Calculates the skills provided.
+     * Creates the `Skill`s to calculate the difficulty of a `PlayableBeatmap`.
      *
-     * @param skills The skills to calculate.
+     * @param beatmap The `PlayableBeatmap` whose difficulty will be calculated.
+     * @return The `Skill`s.
      */
-    protected calculateSkills(...skills: StrainSkill[]): void;
+    protected abstract createSkills(beatmap: TBeatmap): Skill[];
     /**
-     * Calculates the total star rating of the beatmap and stores it in this instance.
+     * Creates the `Skill`s to obtain the strain peaks of a `PlayableBeatmap`.
+     *
+     * @param beatmap
      */
-    abstract calculateTotal(): void;
+    protected abstract createStrainPeakSkills(beatmap: TBeatmap): StrainSkill[];
     /**
-     * Calculates every star rating of the beatmap and stores it in this instance.
+     * Creates difficulty hitobjects for this calculator.
+     *
+     * @param beatmap The beatmap to generate difficulty hitobjects from.
+     * @returns The generated difficulty hitobjects.
      */
-    abstract calculateAll(): void;
+    protected abstract createDifficultyHitObjects(beatmap: TBeatmap): THitObject[];
     /**
-     * Returns a string representative of the class.
+     * 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.
      */
-    abstract toString(): string;
+    protected abstract createDifficultyAttributes(beatmap: TBeatmap, skills: Skill[], objects: THitObject[]): TAttributes;
     /**
-     * Creates skills to be calculated.
+     * 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 createSkills(): StrainSkill[];
+    protected abstract createPlayableBeatmap(beatmap: Beatmap, mods?: ModMap): TBeatmap;
+}
+
+/**
+ * Represents a slider that is considered difficult.
+ *
+ * This structure is a part of difficulty attributes and can be cached.
+ */
+interface DifficultSlider {
     /**
-     * Populates the stored difficulty attributes with necessary data.
+     * The index of the slider in the beatmap.
      */
-    protected populateDifficultyAttributes(): void;
+    readonly index: number;
     /**
-     * Calculates the star rating value of a difficulty.
+     * The difficulty rating of this slider compared to other sliders, based on the velocity of the slider.
      *
-     * @param difficulty The difficulty to calculate.
-     */
-    protected starValue(difficulty: number): number;
-    /**
-     * Calculates the base performance value of a difficulty rating.
+     * A value closer to 1 indicates that this slider is more difficult compared to most sliders.
      *
-     * @param rating The difficulty rating.
+     * A value closer to 0 indicates that this slider is easier compared to most sliders.
      */
-    protected basePerformanceValue(rating: number): number;
+    readonly difficultyRating: number;
 }
 
 /**
- * A converter used to convert normal hitobjects into difficulty hitobjects.
+ * Represents an osu!droid hit object with difficulty calculation values.
  */
-declare class DifficultyHitObjectCreator {
+declare class DroidDifficultyHitObject extends DifficultyHitObject {
+    /**
+     * The tap strain generated by the hitobject.
+     */
+    tapStrain: number;
     /**
-     * The threshold for small circle buff for osu!droid.
+     * The tap strain generated by the hitobject if `strainTime` isn't modified by
+     * OD. This is used in three-finger detection.
      */
-    private readonly DROID_CIRCLESIZE_BUFF_THRESHOLD;
+    originalTapStrain: number;
     /**
-     * The threshold for small circle buff for osu!standard.
+     * The rhythm strain generated by the hitobject.
      */
-    private readonly PC_CIRCLESIZE_BUFF_THRESHOLD;
+    rhythmStrain: number;
     /**
-     * The gamemode this creator is creating for.
+     * The flashlight strain generated by the hitobject if sliders are considered.
      */
-    private mode;
+    flashlightStrainWithSliders: number;
     /**
-     * The base normalized radius of hitobjects.
+     * The flashlight strain generated by the hitobject if sliders are not considered.
      */
-    private readonly normalizedRadius;
-    private maximumSliderRadius;
-    private readonly assumedSliderRadius;
-    private readonly minDeltaTime;
+    flashlightStrainWithoutSliders: number;
     /**
-     * Generates difficulty hitobjects for difficulty calculation.
+     * The reading difficulty generated by the hitobject.
      */
-    generateDifficultyObjects(params: {
-        objects: readonly HitObject[];
-        circleSize: number;
-        mods: Mod[];
-        speedMultiplier: number;
-        mode: Modes;
-        preempt?: number;
-    }): DifficultyHitObject[];
+    readingDifficulty: number;
     /**
-     * Calculates a slider's cursor position.
+     * The note density of the hitobject.
      */
-    private calculateSliderCursorPosition;
+    noteDensity: number;
     /**
-     * Gets the scaling factor of a radius.
+     * The overlapping factor of the hitobject.
      *
-     * @param radius The radius to get the scaling factor from.
+     * This is used to scale visual skill.
      */
-    private getScalingFactor;
+    overlappingFactor: number;
     /**
-     * Returns the end cursor position of a hitobject.
+     * Adjusted preempt time of the hitobject, taking speed multiplier into account.
      */
-    private getEndCursorPosition;
-    private applyToOverlappingFactor;
-}
-
-/**
- * Represents a slider that is considered difficult.
- *
- * This structure is a part of difficulty attributes and can be cached.
- */
-interface DifficultSlider {
+    readonly timePreempt: number;
+    private readonly radiusBuffThreshold;
+    protected readonly mode = Modes.droid;
+    protected readonly maximumSliderRadius: number;
+    get smallCircleBonus(): number;
     /**
-     * The index of the slider in the beatmap.
+     * 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 difficultyHitObjects All difficulty hitobjects in the processed beatmap.
+     * @param clockRate The clock rate of the beatmap.
      */
-    readonly index: number;
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, index: number);
+    opacityAt(time: number, mods: ModMap): number;
+    previous(backwardsIndex: number): this | null;
+    next(forwardsIndex: number): this | null;
     /**
-     * The difficulty rating of this slider compared to other sliders, based on the velocity of the slider.
+     * Determines whether this hitobject is considered overlapping with the hitobject before it.
      *
-     * A value closer to 1 indicates that this slider is more difficult compared to most sliders.
+     * 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.
      *
-     * A value closer to 0 indicates that this slider is easier compared to most sliders.
+     * In the case of sliders, it is considered overlapping if all nested hitobjects can be hit with
+     * one aim motion.
+     *
+     * @param considerDistance Whether to consider the distance between both hitobjects.
+     * @returns Whether the hitobject is considered overlapping.
      */
-    readonly difficultyRating: number;
+    isOverlapping(considerDistance: boolean): boolean;
 }
 
 /**
@@ -597,41 +612,56 @@ declare abstract class DroidSkill extends StrainSkill {
      * The bonus multiplier that is given for a sequence of notes of equal difficulty.
      */
     protected abstract readonly starsPerDouble: number;
+    process(current: DifficultyHitObject): void;
     difficultyValue(): number;
+    /**
+     * Gets the strain of a hitobject.
+     *
+     * @param current The hitobject to get the strain from.
+     * @returns The strain of the hitobject.
+     */
+    protected abstract getObjectStrain(current: DifficultyHitObject): number;
+    protected calculateCurrentSectionStart(current: DifficultyHitObject): number;
 }
 
 /**
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
 declare class DroidAim extends DroidSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly starsPerDouble: number;
-    private readonly withSliders;
-    constructor(mods: Mod[], withSliders: boolean);
-    /**
-     * @param current The hitobject to calculate.
-     */
-    protected strainValueAt(current: DifficultyHitObject): number;
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly starsPerDouble = 1.05;
+    private readonly skillMultiplier;
+    private currentAimStrain;
+    private readonly sliderStrains;
+    private maxSliderStrain;
+    readonly withSliders: boolean;
+    constructor(mods: ModMap, withSliders: boolean);
+    static difficultyToPerformance(difficulty: number): number;
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
+     */
+    countDifficultSliders(): number;
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected getObjectStrain(): number;
     /**
      * @param current The hitobject to save to.
      */
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
 /**
  * An evaluator for calculating osu!droid Aim skill.
  */
-declare abstract class DroidAimEvaluator extends AimEvaluator {
-    protected static readonly wideAngleMultiplier: number;
-    protected static readonly sliderMultiplier: number;
-    protected static readonly velocityChangeMultiplier: number;
-    /**
-     * Spacing threshold for a single hitobject spacing.
-     */
-    private static readonly SINGLE_SPACING_THRESHOLD;
+declare abstract class DroidAimEvaluator {
+    private static readonly wideAngleMultiplier;
+    private static readonly acuteAngleMultiplier;
+    private static readonly sliderMultiplier;
+    private static readonly velocityChangeMultiplier;
+    private static readonly wiggleMultiplier;
+    private static readonly singleSpacingThreshold;
     private static readonly minSpeedBonus;
     /**
      * Evaluates the difficulty of aiming the current object, based on:
@@ -644,21 +674,23 @@ declare abstract class DroidAimEvaluator extends AimEvaluator {
      * @param current The current object.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, withSliders: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, withSliders: boolean): number;
     /**
-     * Calculates the aim strain of a hitobject.
+     * Calculates the snap aim strain of a hitobject.
      */
-    private static aimStrainOf;
+    private static snapAimStrainOf;
     /**
-     * Calculates the movement strain of a hitobject.
+     * Calculates the flow aim strain of a hitobject.
      */
-    private static movementStrainOf;
+    private static flowAimStrainOf;
+    private static calculateWideAngleBonus;
+    private static calculateAcuteAngleBonus;
 }
 
 /**
  * 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.
      */
@@ -668,211 +700,171 @@ interface DroidDifficultyAttributes extends DifficultyAttributes {
      */
     rhythmDifficulty: number;
     /**
-     * The difficulty corresponding to the visual skill.
-     */
-    visualDifficulty: number;
-}
-
-/**
- * Represents a beatmap section at which the strains of objects are considerably high.
- */
-interface HighStrainSection {
-    /**
-     * The index of the first object in this section with respect to the full beatmap.
-     */
-    readonly firstObjectIndex: number;
-    /**
-     * The index of the last object in this section with respect to the full beatmap.
+     * The difficulty corresponding to the reading skill.
      */
-    readonly lastObjectIndex: number;
+    readingDifficulty: number;
     /**
-     * The summed strain of this section.
+     * The amount of strains that are considered difficult with respect to the tap skill.
      */
-    readonly sumStrain: 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.
- */
-interface ExtendedDroidDifficultyAttributes extends DroidDifficultyAttributes {
-    /**
-     * Possible sections at which the player can use three fingers on.
-     */
-    possibleThreeFingeredSections: HighStrainSection[];
+    tapDifficultStrainCount: number;
     /**
-     * Sliders that are considered difficult.
+     * The amount of strains that are considered difficult with respect to the flashlight skill.
      */
-    difficultSliders: DifficultSlider[];
+    flashlightDifficultStrainCount: number;
     /**
-     * The number of clickable objects weighted by difficulty.
-     *
-     * Related to aim difficulty.
+     * The amount of notes that are considered difficult with respect to the reading skill.
      */
-    aimNoteCount: number;
+    readingDifficultNoteCount: number;
     /**
-     * Describes how much of flashlight difficulty is contributed to by hitcircles or sliders.
-     *
-     * A value closer to 1 indicates most of flashlight difficulty is contributed by hitcircles.
-     *
-     * A value closer to 0 indicates most of flashlight difficulty is contributed by sliders.
+     * The average delta time of speed objects.
      */
-    flashlightSliderFactor: number;
+    averageSpeedDeltaTime: number;
     /**
-     * Describes how much of visual difficulty is contributed to by hitcircles or sliders.
+     * Describes how much of tap difficulty is contributed by notes that are "vibroable".
      *
-     * A value closer to 1 indicates most of visual difficulty is contributed by hitcircles.
+     * A value closer to 1 indicates most of tap difficulty is contributed by notes that are not "vibroable".
      *
-     * A value closer to 0 indicates most of visual difficulty is contributed by sliders.
+     * A value closer to 0 indicates most of tap difficulty is contributed by notes that are "vibroable".
      */
-    visualSliderFactor: number;
+    vibroFactor: number;
 }
 
 /**
- * A difficulty calculator for osu!droid gamemode.
+ * Holds data that can be used to calculate osu!droid performance points.
  */
-declare class DroidDifficultyCalculator extends DifficultyCalculator {
-    /**
-     * The aim star rating of the beatmap.
-     */
-    aim: number;
-    /**
-     * The tap star rating of the beatmap.
-     */
-    tap: number;
-    /**
-     * The rhythm star rating of the beatmap.
-     */
-    rhythm: number;
-    /**
-     * The flashlight star rating of the beatmap.
-     */
-    flashlight: number;
-    /**
-     * The visual star rating of the beatmap.
-     */
-    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;
-    readonly attributes: ExtendedDroidDifficultyAttributes;
-    protected readonly difficultyMultiplier: number;
-    protected readonly mode: Modes;
-    /**
-     * 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;
+declare class DroidDifficultyAttributes extends DifficultyAttributes implements IDroidDifficultyAttributes {
+    tapDifficulty: number;
+    rhythmDifficulty: number;
+    readingDifficulty: number;
+    tapDifficultStrainCount: number;
+    flashlightDifficultStrainCount: number;
+    readingDifficultNoteCount: number;
+    averageSpeedDeltaTime: number;
+    vibroFactor: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IDroidDifficultyAttributes>);
     toString(): string;
-    protected preProcess(): void;
-    protected createSkills(): DroidSkill[];
+}
+
+/**
+ * Represents a beatmap section at which the strains of objects are considerably high.
+ */
+interface HighStrainSection {
     /**
-     * Called after aim skill calculation.
-     *
-     * @param aimSkill The aim skill that considers sliders.
-     * @param aimSkillWithoutSliders The aim skill that doesn't consider sliders.
+     * The index of the first object in this section with respect to the full beatmap.
      */
-    private postCalculateAim;
+    readonly firstObjectIndex: number;
     /**
-     * Calculates aim-related attributes.
+     * The index of the last object in this section with respect to the full beatmap.
      */
-    private calculateAimAttributes;
+    readonly lastObjectIndex: number;
     /**
-     * Called after tap skill calculation.
-     *
-     * @param tapSkill The tap skill.
+     * The summed strain of this section.
      */
-    private postCalculateTap;
+    readonly sumStrain: 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.
+ */
+interface IExtendedDroidDifficultyAttributes extends IDroidDifficultyAttributes {
     /**
-     * Calculates speed-related attributes.
+     * The mode of the difficulty calculation.
      */
-    private calculateSpeedAttributes;
+    mode: "live";
     /**
-     * Calculates the sum of strains for possible three-fingered sections.
-     *
-     * @param firstObjectIndex The index of the first object in the section.
-     * @param lastObjectIndex The index of the last object in the section.
-     * @returns The summed strain of the section.
+     * Possible sections at which the player can use three fingers on.
      */
-    private calculateThreeFingerSummedStrain;
+    possibleThreeFingeredSections: HighStrainSection[];
     /**
-     * Called after rhythm skill calculation.
-     *
-     * @param rhythmSkill The rhythm skill.
+     * Sliders that are considered difficult.
      */
-    private postCalculateRhythm;
+    difficultSliders: DifficultSlider[];
     /**
-     * Called after flashlight skill calculation.
+     * Describes how much of flashlight difficulty is contributed to by hitcircles or sliders.
      *
-     * @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.
+     * A value closer to 1 indicates most of flashlight difficulty is contributed by hitcircles.
      *
-     * @param visualSkillWithSliders The visual skill that considers sliders.
-     * @param visualSkillWithoutSliders The visual skill that doesn't consider sliders.
+     * A value closer to 0 indicates most of flashlight difficulty is contributed by sliders.
      */
-    private postCalculateVisual;
+    flashlightSliderFactor: number;
 }
 
 /**
- * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
+ * 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 DroidFlashlight extends DroidSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly starsPerDouble: number;
-    private readonly isHidden;
-    private readonly withSliders;
-    constructor(mods: Mod[], withSliders: boolean);
+declare class ExtendedDroidDifficultyAttributes extends DroidDifficultyAttributes implements IExtendedDroidDifficultyAttributes {
+    mode: "live";
+    possibleThreeFingeredSections: HighStrainSection[];
+    difficultSliders: DifficultSlider[];
+    flashlightSliderFactor: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IExtendedDroidDifficultyAttributes>);
+}
+
+/**
+ * A difficulty calculator for osu!droid gamemode.
+ */
+declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidPlayableBeatmap, DroidDifficultyHitObject, ExtendedDroidDifficultyAttributes> {
     /**
-     * @param current The hitobject to calculate.
+     * The strain threshold to start detecting for possible three-fingered section.
+     *
+     * Increasing this number will result in less sections being flagged.
      */
-    protected strainValueAt(current: DifficultyHitObject): number;
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    static readonly threeFingerStrainThreshold = 175;
+    private readonly difficultyMultiplier;
+    constructor();
+    retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
+    protected createDifficultyAttributes(beatmap: DroidPlayableBeatmap, skills: Skill[], objects: DroidDifficultyHitObject[]): ExtendedDroidDifficultyAttributes;
+    protected createPlayableBeatmap(beatmap: Beatmap, mods?: ModMap): DroidPlayableBeatmap;
+    protected createDifficultyHitObjects(beatmap: DroidPlayableBeatmap): DroidDifficultyHitObject[];
+    protected createSkills(beatmap: DroidPlayableBeatmap): Skill[];
+    protected createStrainPeakSkills(beatmap: DroidPlayableBeatmap): StrainSkill[];
+    private populateAimAttributes;
+    private populateTapAttributes;
+    private populateRhythmAttributes;
+    private populateFlashlightAttributes;
+    private populateReadingAttributes;
+    /**
+     * Calculates the base rating of a `Skill`.
+     *
+     * @param skill The `Skill` to calculate the rating of.
+     * @returns The rating of the `Skill`.
+     */
+    private calculateRating;
 }
 
 /**
- * An evaluator for calculating flashlight skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
+ * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
-declare abstract class FlashlightEvaluator {
-    protected static readonly maxOpacityBonus: number;
-    protected static readonly hiddenBonus: number;
-    protected static readonly minVelocity: number;
-    protected static readonly sliderMultiplier: number;
-    protected static readonly minAngleMultiplier: number;
+declare class DroidFlashlight extends DroidSkill {
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 0;
+    protected readonly reducedSectionBaseline = 1;
+    protected readonly starsPerDouble = 1.06;
+    private readonly skillMultiplier;
+    private currentFlashlightStrain;
+    readonly withSliders: boolean;
+    constructor(mods: ModMap, withSliders: boolean);
+    static difficultyToPerformance(difficulty: number): number;
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
+    protected getObjectStrain(): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
+    difficultyValue(): number;
 }
 
 /**
  * An evaluator for calculating osu!droid Flashlight skill.
  */
-declare abstract class DroidFlashlightEvaluator extends FlashlightEvaluator {
+declare abstract class DroidFlashlightEvaluator {
+    private static readonly maxOpacityBonus;
+    private static readonly hiddenBonus;
+    private static readonly traceableCircleBonus;
+    private static readonly traceableObjectBonus;
+    private static readonly minVelocity;
+    private static readonly sliderMultiplier;
+    private static readonly minAngleMultiplier;
     /**
      * Evaluates the difficulty of memorizing and hitting the current object, based on:
      *
@@ -883,10 +875,10 @@ declare abstract class DroidFlashlightEvaluator extends FlashlightEvaluator {
      * - and whether Hidden mod is enabled.
      *
      * @param current The current object.
-     * @param isHiddenMod Whether the Hidden mod is enabled.
+     * @param mods The mods used.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, isHiddenMod: boolean, withSliders: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, mods: ModMap, withSliders: boolean): number;
 }
 
 /**
@@ -905,6 +897,14 @@ interface PerformanceCalculationOptions {
      * The amount of misses achieved in the score.
      */
     miss?: number;
+    /**
+     * The amount of slider ends dropped in the score.
+     */
+    sliderEndsDropped?: number;
+    /**
+     * The amount of slider ticks missed in the score.
+     */
+    sliderTicksMissed?: number;
     /**
      * The tap penalty to apply for penalized scores. Only used when using `DroidPerformanceCalculator`.
      */
@@ -926,7 +926,7 @@ interface PerformanceCalculationOptions {
 /**
  * The base class of performance calculators.
  */
-declare abstract class PerformanceCalculator {
+declare abstract class PerformanceCalculator<T extends IDifficultyAttributes> {
     /**
      * The overall performance value.
      */
@@ -935,32 +935,39 @@ declare abstract class PerformanceCalculator {
      * The calculated accuracy.
      */
     computedAccuracy: Accuracy;
+    /**
+     * The calculated maximum combo.
+     */
+    combo: number;
     /**
      * The difficulty attributes that is being calculated.
      */
-    abstract readonly difficultyAttributes: DifficultyAttributes;
+    readonly difficultyAttributes: T | CacheableDifficultyAttributes<T>;
     /**
-     * Penalty for combo breaks.
+     * The mods that were used.
      */
-    protected comboPenalty: number;
+    protected readonly mods: ModMap;
+    private _sliderEndsDropped;
     /**
-     * The global multiplier to be applied to the final performance value.
-     *
-     * This is being adjusted to keep the final value scaled around what it used to be when changing things.
+     * The amount of slider ends dropped in the score.
      */
-    protected abstract finalMultiplier: number;
+    protected get sliderEndsDropped(): number;
+    private _sliderTicksMissed;
     /**
-     * The gamemode to calculate for.
+     * The amount of slider ticks missed in the score.
+     *
+     * This is used to calculate the slider accuracy.
      */
-    protected abstract readonly mode: Modes;
+    protected get sliderTicksMissed(): number;
+    private _usingClassicSliderAccuracy;
     /**
-     * The amount of misses that are filtered out from sliderbreaks.
+     * Whether this score uses classic slider accuracy.
      */
-    protected effectiveMissCount: number;
+    protected get usingClassicSliderAccuracy(): boolean;
     /**
-     * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
+     * @param difficultyAttributes The difficulty attributes to calculate.
      */
-    protected sliderNerfFactor: number;
+    constructor(difficultyAttributes: T | CacheableDifficultyAttributes<T>);
     /**
      * Calculates the performance points of the beatmap.
      *
@@ -977,10 +984,6 @@ declare abstract class PerformanceCalculator {
      * performance value of the beatmap and stores them in this instance.
      */
     protected abstract calculateValues(): void;
-    /**
-     * Calculates the total performance value of the beatmap and stores it in this instance.
-     */
-    protected abstract calculateTotalValue(): void;
     /**
      * The total hits that can be done in the beatmap.
      */
@@ -990,9 +993,9 @@ declare abstract class PerformanceCalculator {
      */
     protected get totalSuccessfulHits(): number;
     /**
-     * Calculates the base performance value of a star rating.
+     * The total of imperfect hits (100s, 50s, misses).
      */
-    protected baseValue(stars: number): number;
+    protected get totalImperfectHits(): number;
     /**
      * Processes given options for usage in performance calculation.
      *
@@ -1000,15 +1003,18 @@ declare abstract class PerformanceCalculator {
      */
     protected handleOptions(options?: PerformanceCalculationOptions): void;
     /**
-     * Calculates the amount of misses + sliderbreaks from combo.
+     * Determines whether an attribute is a cacheable attribute.
+     *
+     * @param attributes The attributes to check.
+     * @returns Whether the attributes are cacheable.
      */
-    private calculateEffectiveMissCount;
+    private isCacheableAttribute;
 }
 
 /**
  * A performance points calculator that calculates performance points for osu!droid gamemode.
  */
-declare class DroidPerformanceCalculator extends PerformanceCalculator {
+declare class DroidPerformanceCalculator extends PerformanceCalculator<IDroidDifficultyAttributes> {
     /**
      * The aim performance value.
      */
@@ -1026,9 +1032,9 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      */
     flashlight: number;
     /**
-     * The visual performance value.
+     * The reading performance value.
      */
-    visual: number;
+    reading: number;
     /**
      * The penalty used to penalize the tap performance value.
      *
@@ -1056,58 +1062,17 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      */
     get flashlightSliderCheesePenalty(): number;
     /**
-     * The penalty used to penalize the visual performance value.
-     *
-     * Can be properly obtained by analyzing the replay associated with the score.
+     * The amount of misses, including slider breaks.
      */
-    get visualSliderCheesePenalty(): number;
-    readonly difficultyAttributes: DroidDifficultyAttributes;
-    protected finalMultiplier: number;
-    protected readonly mode: Modes;
+    get effectiveMissCount(): number;
+    static readonly finalMultiplier = 1.24;
     private _aimSliderCheesePenalty;
     private _flashlightSliderCheesePenalty;
-    private _visualSliderCheesePenalty;
     private _tapPenalty;
+    private _effectiveMissCount;
     private _deviation;
     private _tapDeviation;
-    /**
-     * @param difficultyAttributes The difficulty attributes to calculate.
-     */
-    constructor(difficultyAttributes: DroidDifficultyAttributes);
-    /**
-     * Applies a tap penalty value to this calculator.
-     *
-     * The tap and total performance value will be recalculated afterwards.
-     *
-     * @param value The tap penalty value. Must be greater than or equal to 1.
-     */
-    applyTapPenalty(value: number): void;
-    /**
-     * Applies an aim slider cheese penalty value to this calculator.
-     *
-     * The aim and total performance value will be recalculated afterwards.
-     *
-     * @param value The slider cheese penalty value. Must be between than 0 and 1.
-     */
-    applyAimSliderCheesePenalty(value: number): void;
-    /**
-     * Applies a flashlight slider cheese penalty value to this calculator.
-     *
-     * The flashlight and total performance value will be recalculated afterwards.
-     *
-     * @param value The slider cheese penalty value. Must be between 0 and 1.
-     */
-    applyFlashlightSliderCheesePenalty(value: number): void;
-    /**
-     * Applies a visual slider cheese penalty value to this calculator.
-     *
-     * The visual and total performance value will be recalculated afterwards.
-     *
-     * @param value The slider cheese penalty value. Must be between 0 and 1.
-     */
-    applyVisualSliderCheesePenalty(value: number): void;
     protected calculateValues(): void;
-    protected calculateTotalValue(): void;
     protected handleOptions(options?: PerformanceCalculationOptions): void;
     /**
      * Calculates the aim performance value of the beatmap.
@@ -1126,11 +1091,32 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      */
     private calculateFlashlightValue;
     /**
-     * Calculates the visual performance value of the beatmap.
+     * Calculates the reading performance value of the beatmap.
+     */
+    private calculateReadingValue;
+    /**
+     * Calculates a strain-based miss penalty.
+     *
+     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
+     * so we use the amount of relatively difficult sections to adjust miss penalty
+     * to make it more punishing on maps with lower amount of hard sections.
+     */
+    private calculateStrainBasedMissPenalty;
+    /**
+     * The object-based proportional miss penalty.
      */
-    private calculateVisualValue;
+    private get proportionalMissPenalty();
     /**
-     * Estimates the player's tap deviation based on the OD, number of circles and sliders,
+     * Calculates the object-based length scaling based on the deviation of a player for a full
+     * combo in this beatmap, taking retries into account.
+     *
+     * @param objectCount The amount of objects to be considered. Defaults to the amount of
+     * objects in this beatmap.
+     * @param punishForMemorization Whether to punish the deviation for memorization. Defaults to `false`.
+     */
+    private calculateDeviationBasedLengthScaling;
+    /**
+     * Estimates the player's deviation based on the OD, number of circles and sliders,
      * and number of 300s, 100s, 50s, and misses, assuming the player's mean hit error is 0.
      *
      * The estimation is consistent in that two SS scores on the same map
@@ -1151,281 +1137,286 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      * This is fine though, since this method is only used to scale tap pp.
      */
     private calculateTapDeviation;
+    /**
+     * Calculates a multiplier for tap to account for improper tapping based on the deviation and tap difficulty.
+     *
+     * [Graph](https://www.desmos.com/calculator/z5l9ebrwpi)
+     */
+    private calculateTapHighDeviationNerf;
+    private getHitWindow;
     toString(): string;
 }
 
 /**
- * Represents the skill required to properly follow a beatmap's rhythm.
+ * Represents the skill required to read every object in the map.
  */
-declare class DroidRhythm extends DroidSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly strainDecayBase: number;
-    protected readonly starsPerDouble: number;
-    private currentRhythm;
-    private readonly hitWindow;
-    constructor(mods: Mod[], overallDifficulty: number);
-    protected strainValueAt(current: DifficultyHitObject): number;
-    protected saveToHitObject(current: DifficultyHitObject): void;
+declare class DroidReading extends Skill {
+    private readonly clockRate;
+    private readonly hitObjects;
+    private readonly noteDifficulties;
+    private readonly strainDecayBase;
+    private readonly skillMultiplier;
+    private currentNoteDifficulty;
+    private difficulty;
+    private noteWeightSum;
+    constructor(mods: ModMap, clockRate: number, hitObjects: readonly PlaceableHitObject[]);
+    /**
+     * Converts a difficulty value to a performance value.
+     *
+     * @param difficulty The difficulty value to convert.
+     * @returns The performance value.
+     */
+    static difficultyToPerformance(difficulty: number): number;
+    process(current: DroidDifficultyHitObject): void;
+    difficultyValue(): number;
+    /**
+     * Returns the number of relevant objects weighted against the top note.
+     */
+    countTopWeightedNotes(): number;
+    private strainDecay;
 }
 
 /**
- * An evaluator for calculating rhythm skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
+ * An evaluator for calculating osu!droid reading skill.
+ */
+declare abstract class DroidReadingEvaluator {
+    private static readonly emptyModMap;
+    private static readonly readingWindowSize;
+    private static readonly distanceInfluenceThreshold;
+    private static readonly hiddenMultiplier;
+    private static readonly densityMultiplier;
+    private static readonly densityDifficultyBase;
+    private static readonly preemptBalancingFactor;
+    private static readonly preemptStartingPoint;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, clockRate: number, mods: ModMap): number;
+    /**
+     * Retrieves a list of objects that are visible at the point in time the current object needs to be hit.
+     *
+     * @param current The current object.
+     */
+    private static retrievePastVisibleObjects;
+    /**
+     * Calculates the density of objects visible at the point in time the current object needs to be hit.
+     *
+     * @param current The current object.
+     */
+    private static calculateCurrentVisibleObjectsDensity;
+    /**
+     * Returns the time an object spends invisible with the Hidden mod at the current approach rate.
+     *
+     * @param current The current object.
+     */
+    private static getDurationSpentInvisible;
+    /**
+     * Calculates a factor of how often the current object's angle has been repeated in a certain time frame.
+     * It does this by checking the difference in angle between current and past objects and sums them up
+     * based on a range of similarity.
+     *
+     * @param current The current object.
+     */
+    private static getConstantAngleNerfFactor;
+    private static getTimeNerfFactor;
+}
+
+/**
+ * Represents the skill required to properly follow a beatmap's rhythm.
  */
-declare abstract class RhythmEvaluator {
-    protected static readonly rhythmMultiplier: number;
-    protected static readonly historyTimeMax: number;
+declare class DroidRhythm extends DroidSkill {
+    protected readonly reducedSectionCount = 5;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly strainDecayBase = 0.3;
+    protected readonly starsPerDouble = 1.75;
+    private readonly useSliderAccuracy;
+    private currentRhythmStrain;
+    private currentRhythmMultiplier;
+    constructor(mods: ModMap);
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected getObjectStrain(): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
 /**
  * An evaluator for calculating osu!droid Rhythm skill.
  */
-declare abstract class DroidRhythmEvaluator extends RhythmEvaluator {
+declare abstract class DroidRhythmEvaluator {
+    private static readonly historyTimeMax;
+    private static readonly historyObjectsMax;
+    private static readonly rhythmOverallMultiplier;
+    private static readonly rhythmRatioMultiplier;
     /**
      * Calculates a rhythm multiplier for the difficulty of the tap associated
      * with historic data of the current object.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
+     * @param useSliderAccuracy Whether to use slider accuracy.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, greatWindow: number): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, useSliderAccuracy: boolean): number;
 }
 
 /**
  * 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 DroidTap extends DroidSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly strainDecayBase: number;
-    protected readonly starsPerDouble: number;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly strainDecayBase = 0.3;
+    protected readonly starsPerDouble = 1.1;
     private currentTapStrain;
-    private currentOriginalTapStrain;
-    private readonly greatWindow;
-    constructor(mods: Mod[], overallDifficulty: number);
+    private currentRhythmMultiplier;
+    private readonly skillMultiplier;
+    private readonly _objectDeltaTimes;
+    private maxStrain;
     /**
-     * @param current The hitobject to calculate.
+     * The delta time of hitobjects.
      */
-    protected strainValueAt(current: DifficultyHitObject): number;
+    get objectDeltaTimes(): readonly number[];
+    readonly considerCheesability: boolean;
+    readonly strainTimeCap?: number;
+    constructor(mods: ModMap, considerCheesability: boolean, strainTimeCap?: number);
+    /**
+     * The amount of notes that are relevant to the difficulty.
+     */
+    relevantNoteCount(): number;
+    /**
+     * The delta time relevant to the difficulty.
+     */
+    relevantDeltaTime(): number;
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected getObjectStrain(): number;
     /**
      * @param current The hitobject to save to.
      */
-    protected saveToHitObject(current: DifficultyHitObject): void;
-}
-
-/**
- * An evaluator for calculating speed or tap skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-declare abstract class SpeedEvaluator {
-    protected static readonly minSpeedBonus: number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
 /**
  * An evaluator for calculating osu!droid tap skill.
  */
-declare abstract class DroidTapEvaluator extends SpeedEvaluator {
+declare abstract class DroidTapEvaluator {
+    private static readonly minSpeedBonus;
     /**
      * Evaluates the difficulty of tapping the current object, based on:
      *
      * - time between pressing the previous and current object,
      * - distance between those objects,
-     * - and how easily they can be cheesed.
+     * - how easily they can be cheesed,
+     * - and the strain time cap.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
      * @param considerCheesability Whether to consider cheesability.
+     * @param strainTimeCap The strain time to cap the object's strain time to.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, greatWindow: number, considerCheesability: boolean): number;
-}
-
-/**
- * Represents the skill required to read every object in the map.
- */
-declare class DroidVisual extends DroidSkill {
-    protected readonly starsPerDouble: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    private readonly isHidden;
-    private readonly withSliders;
-    constructor(mods: Mod[], withSliders: boolean);
-    protected strainValueAt(current: DifficultyHitObject): number;
-    protected saveToHitObject(current: DifficultyHitObject): void;
-}
-
-/**
- * An evaluator for calculating osu!droid Visual skill.
- */
-declare abstract class DroidVisualEvaluator {
-    /**
-     * Evaluates the difficulty of reading the current object, based on:
-     *
-     * - note density of the current object,
-     * - overlapping factor of the current object,
-     * - the preempt time of the current object,
-     * - the visual opacity of the current object,
-     * - the velocity of the current object if it's a slider,
-     * - past objects' velocity if they are sliders,
-     * - and whether the Hidden mod is enabled.
-     *
-     * @param current The current object.
-     * @param isHiddenMod Whether the Hidden mod is enabled.
-     * @param withSliders Whether to take slider difficulty into account.
-     */
-    static evaluateDifficultyOf(current: DifficultyHitObject, isHiddenMod: boolean, withSliders: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, considerCheesability: boolean, strainTimeCap?: number): 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.
+ * Holds data that can be used to calculate osu!standard performance points.
  */
-declare abstract class OsuSkill extends StrainSkill {
+interface IOsuDifficultyAttributes extends IDifficultyAttributes {
     /**
-     * The default multiplier applied to the final difficulty value after all other calculations.
+     * The perceived approach rate **exclusive** of rate-adjusting mods (DT/HT/etc).
      *
-     * May be overridden via {@link difficultyMultiplier}.
-     */
-    static readonly defaultDifficultyMultiplier: number;
-    /**
-     * The final multiplier to be applied to the final difficulty value after all other calculations.
+     * Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
      */
-    protected readonly difficultyMultiplier: number;
+    approachRate: number;
     /**
-     * The weight by which each strain value decays.
+     * The health drain rate of the beatmap.
      */
-    protected abstract readonly decayWeight: number;
-    difficultyValue(): number;
-}
-
-/**
- * Holds data that can be used to calculate osu!standard performance points.
- */
-interface OsuDifficultyAttributes extends DifficultyAttributes {
+    drainRate: number;
     /**
      * The difficulty corresponding to the speed skill.
      */
     speedDifficulty: number;
-}
-
-/**
- * A difficulty calculator for osu!standard gamemode.
- */
-declare class OsuDifficultyCalculator extends DifficultyCalculator {
     /**
-     * The aim star rating of the beatmap.
+     * The amount of strains that are considered difficult with respect to the speed skill.
      */
-    aim: number;
-    /**
-     * The speed star rating of the beatmap.
-     */
-    speed: number;
-    /**
-     * The flashlight star rating of the beatmap.
-     */
-    flashlight: number;
-    readonly attributes: OsuDifficultyAttributes;
-    protected readonly difficultyMultiplier: number;
-    protected readonly mode: Modes;
-    /**
-     * 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 preProcess(): void;
-    protected createSkills(): OsuSkill[];
+    speedDifficultStrainCount: number;
     /**
-     * Called after aim skill calculation.
+     * Describes how much of {@link aimDifficultStrainCount} is contributed to by circles or sliders.
      *
-     * @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.
+     * A value closer to 0 indicates most of {@link aimDifficultStrainCount} is contributed by circles.
      *
-     * @param speedSkill The speed skill.
+     * A value closer to infinity indicates most of {@link aimDifficultStrainCount} is contributed by sliders.
      */
-    private postCalculateSpeed;
+    aimTopWeightedSliderFactor: number;
     /**
-     * Calculates speed-related attributes.
-     */
-    private calculateSpeedAttributes;
-    /**
-     * Called after flashlight skill calculation.
+     * Describes how much of {@link speedDifficultStrainCount} is contributed to by circles or sliders.
      *
-     * @param flashlightSkill The flashlight skill.
+     * A value closer to 0 indicates most of {@link speedDifficultStrainCount} is contributed by circles.
+     *
+     * A value closer to infinity indicates most of {@link speedDifficultStrainCount} is contributed by sliders.
      */
-    private postCalculateFlashlight;
+    speedTopWeightedSliderFactor: number;
 }
 
 /**
- * A difficulty calculator that calculates for both osu!droid and osu!standard gamemode.
+ * Represents an osu!standard hit object with difficulty calculation values.
  */
-declare class MapStars {
+declare class OsuDifficultyHitObject extends DifficultyHitObject {
     /**
-     * The osu!droid difficulty calculator of the beatmap.
+     * The speed strain generated by the hitobject.
      */
-    readonly droid: DroidDifficultyCalculator;
+    speedStrain: number;
     /**
-     * The osu!standard difficulty calculator of the beatmap.
+     * The flashlight strain generated by this hitobject.
      */
-    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);
+    flashlightStrain: number;
+    get smallCircleBonus(): number;
+    protected readonly mode = Modes.osu;
+}
+
+/**
+ * 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.
+ */
+declare abstract class OsuSkill extends StrainSkill {
     /**
-     * Returns a string representative of the class.
+     * The weight by which each strain value decays.
      */
-    toString(): string;
+    protected abstract readonly decayWeight: number;
+    difficultyValue(): 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 skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly difficultyMultiplier: number;
-    protected readonly decayWeight: number;
-    private readonly withSliders;
-    constructor(mods: Mod[], withSliders: boolean);
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly decayWeight = 0.9;
+    private currentAimStrain;
+    private readonly skillMultiplier;
+    private readonly sliderStrains;
+    readonly withSliders: boolean;
+    constructor(mods: ModMap, withSliders: boolean);
     /**
-     * @param current The hitobject to calculate.
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
      */
-    protected strainValueAt(current: DifficultyHitObject): number;
+    countDifficultSliders(): number;
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain, weighted by consistency.
+     */
+    countTopWeightedSliders(): number;
+    protected strainValueAt(current: OsuDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
     /**
      * @param current The hitobject to save to.
      */
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
 }
 
 /**
  * An evaluator for calculating osu!standard Aim skill.
  */
-declare abstract class OsuAimEvaluator extends AimEvaluator {
+declare abstract class OsuAimEvaluator {
+    private static readonly wideAngleMultiplier;
+    private static readonly acuteAngleMultiplier;
+    private static readonly sliderMultiplier;
+    private static readonly velocityChangeMultiplier;
+    private static readonly wiggleMultiplier;
     /**
      * Evaluates the difficulty of aiming the current object, based on:
      *
@@ -1437,31 +1428,69 @@ declare abstract class OsuAimEvaluator extends AimEvaluator {
      * @param current The current object.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, withSliders: boolean): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, withSliders: boolean): number;
+    private static calculateWideAngleBonus;
+    private static calculateAcuteAngleBonus;
+}
+
+/**
+ * Holds data that can be used to calculate osu!standard performance points.
+ */
+declare class OsuDifficultyAttributes extends DifficultyAttributes implements IOsuDifficultyAttributes {
+    approachRate: number;
+    drainRate: number;
+    speedDifficulty: number;
+    speedDifficultStrainCount: number;
+    aimTopWeightedSliderFactor: number;
+    speedTopWeightedSliderFactor: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IOsuDifficultyAttributes>);
+    toString(): string;
+}
+
+/**
+ * A difficulty calculator for osu!standard gamemode.
+ */
+declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuPlayableBeatmap, OsuDifficultyHitObject, OsuDifficultyAttributes> {
+    private readonly starRatingMultiplier;
+    constructor();
+    retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
+    protected createDifficultyAttributes(beatmap: OsuPlayableBeatmap, skills: Skill[]): OsuDifficultyAttributes;
+    protected createPlayableBeatmap(beatmap: Beatmap, mods?: ModMap): OsuPlayableBeatmap;
+    protected createDifficultyHitObjects(beatmap: OsuPlayableBeatmap): OsuDifficultyHitObject[];
+    protected createSkills(beatmap: OsuPlayableBeatmap): OsuSkill[];
+    protected createStrainPeakSkills(beatmap: OsuPlayableBeatmap): StrainSkill[];
+    private calculateMechanicalDifficultyRating;
+    private calculateStarRating;
+    static calculateRateAdjustedApproachRate(approachRate: number, clockRate: number): number;
+    static calculateRateAdjustedOverallDifficulty(overallDifficulty: number, clockRate: number): number;
 }
 
 /**
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 declare class OsuFlashlight extends OsuSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly decayWeight: number;
-    private readonly isHidden;
-    constructor(mods: Mod[]);
-    /**
-     * @param current The hitobject to calculate.
-     */
-    protected strainValueAt(current: DifficultyHitObject): number;
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 0;
+    protected readonly reducedSectionBaseline = 1;
+    protected readonly decayWeight = 1;
+    private currentFlashlightStrain;
+    private readonly skillMultiplier;
+    static difficultyToPerformance(difficulty: number): number;
+    difficultyValue(): number;
+    protected strainValueAt(current: OsuDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
 }
 
 /**
  * An evaluator for calculating osu!standard Flashlight skill.
  */
-declare abstract class OsuFlashlightEvaluator extends FlashlightEvaluator {
+declare abstract class OsuFlashlightEvaluator {
+    private static readonly maxOpacityBonus;
+    private static readonly hiddenBonus;
+    private static readonly minVelocity;
+    private static readonly sliderMultiplier;
+    private static readonly minAngleMultiplier;
     /**
      * Evaluates the difficulty of memorizing and hitting the current object, based on:
      *
@@ -1472,15 +1501,15 @@ declare abstract class OsuFlashlightEvaluator extends FlashlightEvaluator {
      * - and whether Hidden mod is enabled.
      *
      * @param current The current object.
-     * @param isHiddenMod Whether the Hidden mod is enabled.
+     * @param mods The mods used.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, isHiddenMod: boolean): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, mods: ModMap): number;
 }
 
 /**
  * A performance points calculator that calculates performance points for osu!standard gamemode.
  */
-declare class OsuPerformanceCalculator extends PerformanceCalculator {
+declare class OsuPerformanceCalculator extends PerformanceCalculator<IOsuDifficultyAttributes> {
     /**
      * The aim performance value.
      */
@@ -1497,15 +1526,19 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator {
      * The flashlight performance value.
      */
     flashlight: number;
-    readonly difficultyAttributes: OsuDifficultyAttributes;
-    protected finalMultiplier: number;
-    protected readonly mode: Modes;
     /**
-     * @param difficultyAttributes The difficulty attributes to calculate.
-     */
-    constructor(difficultyAttributes: OsuDifficultyAttributes);
+     * The amount of misses, including slider breaks.
+     */
+    get effectiveMissCount(): number;
+    static readonly finalMultiplier = 1.14;
+    private greatWindow;
+    private okWindow;
+    private mehWindow;
+    private approachRate;
+    private overallDifficulty;
+    private _effectiveMissCount;
+    private speedDeviation;
     protected calculateValues(): void;
-    protected calculateTotalValue(): void;
     /**
      * Calculates the aim performance value of the beatmap.
      */
@@ -1522,55 +1555,105 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator {
      * Calculates the flashlight performance value of the beatmap.
      */
     private calculateFlashlightValue;
+    /**
+     * Calculates a strain-based miss penalty.
+     *
+     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
+     * so we use the amount of relatively difficult sections to adjust miss penalty
+     * to make it more punishing on maps with lower amount of hard sections.
+     */
+    private calculateMissPenalty;
+    /**
+     * Estimates a player's deviation on speed notes using {@link calculateDeviation}, assuming worst-case.
+     *
+     * Treats all speed notes as hit circles.
+     */
+    private calculateSpeedDeviation;
+    /**
+     * Estimates the player's tap deviation based on the OD, given number of greats, oks, mehs and misses,
+     * assuming the player's mean hit error is 0. The estimation is consistent in that two SS scores on the
+     * same map with the same settings will always return the same deviation.
+     *
+     * Misses are ignored because they are usually due to misaiming.
+     *
+     * Greats and oks are assumed to follow a normal distribution, whereas mehs are assumed to follow a uniform distribution.
+     */
+    private calculateDeviation;
+    /**
+     * Calculates multiplier for speed to account for improper tapping based on the deviation and speed difficulty.
+     *
+     * [Graph](https://www.desmos.com/calculator/dmogdhzofn)
+     */
+    private calculateSpeedHighDeviationNerf;
+    private calculateEstimatedSliderBreaks;
+    /**
+     * Calculates the amount of misses + sliderbreaks from combo.
+     */
+    private calculateComboBasedEstimatedMissCount;
     toString(): string;
 }
 
 /**
  * An evaluator for calculating osu!standard Rhythm skill.
  */
-declare abstract class OsuRhythmEvaluator extends RhythmEvaluator {
+declare abstract class OsuRhythmEvaluator {
+    private static readonly historyTimeMax;
+    private static readonly historyObjectsMax;
+    private static readonly rhythmOverallMultiplier;
+    private static readonly rhythmRatioMultiplier;
     /**
      * Calculates a rhythm multiplier for the difficulty of the tap associated
      * with historic data of the current object.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, greatWindow: number): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
 }
 
 /**
  * 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 skillMultiplier: number;
-    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 decayWeight = 0.9;
     private currentSpeedStrain;
     private currentRhythm;
-    private readonly greatWindow;
-    constructor(mods: Mod[], greatWindow: number);
+    private readonly skillMultiplier;
+    private readonly sliderStrains;
+    private maxStrain;
+    /**
+     * The amount of notes that are relevant to the difficulty.
+     */
+    relevantNoteCount(): number;
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain, weighted by consistency.
+     */
+    countTopWeightedSliders(): number;
     /**
      * @param current The hitobject to calculate.
      */
-    protected strainValueAt(current: DifficultyHitObject): number;
+    protected strainValueAt(current: OsuDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
     /**
      * @param current The hitobject to save to.
      */
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
 }
 
 /**
  * An evaluator for calculating osu!standard speed skill.
  */
-declare abstract class OsuSpeedEvaluator extends SpeedEvaluator {
+declare abstract class OsuSpeedEvaluator {
     /**
      * Spacing threshold for a single hitobject spacing.
+     *
+     * About 1.25 circles distance between hitobject centers.
      */
     private static readonly SINGLE_SPACING_THRESHOLD;
+    private static readonly minSpeedBonus;
+    private static readonly DISTANCE_MULTIPLIER;
     /**
      * Evaluates the difficulty of tapping the current object, based on:
      *
@@ -1579,9 +1662,10 @@ declare abstract class OsuSpeedEvaluator extends SpeedEvaluator {
      * - and how easily they can be cheesed.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
+     * @param mods The mods applied.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, greatWindow: number): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, mods: ModMap): number;
 }
 
-export { AimEvaluator, CalculationOptions, DifficultSlider, DifficultyAttributes, DifficultyCalculationOptions, DifficultyCalculator, DifficultyHitObject, DifficultyHitObjectCreator, DroidAim, DroidAimEvaluator, DroidDifficultyAttributes, DroidDifficultyCalculator, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, DroidVisual, DroidVisualEvaluator, ExtendedDroidDifficultyAttributes, FlashlightEvaluator, HighStrainSection, MapStars, OsuAim, OsuAimEvaluator, OsuDifficultyAttributes, OsuDifficultyCalculator, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, PerformanceCalculationOptions, PerformanceCalculator, RhythmEvaluator, SpeedEvaluator, StrainPeaks };
+export { DifficultyAttributes, DifficultyCalculator, DifficultyHitObject, DroidAim, DroidAimEvaluator, DroidDifficultyAttributes, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidReading, DroidReadingEvaluator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, ExtendedDroidDifficultyAttributes, OsuAim, OsuAimEvaluator, OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, PerformanceCalculator };
+export type { CacheableDifficultyAttributes, DifficultSlider, HighStrainSection, IDifficultyAttributes, IDroidDifficultyAttributes, IExtendedDroidDifficultyAttributes, IOsuDifficultyAttributes, PerformanceCalculationOptions, StrainPeaks };