osu-taiko-stable/lib/index.d.ts

osu!stable version of osu!taiko ruleset based on osu!lazer source code.

import * as osu_classes from 'osu-classes';
import { ModCombination, IMod, HitObject, HitWindows, ISlidableObject, SliderPath, HitSample, ControlPointInfo, BeatmapDifficultySection, ISpinnableObject, EventGenerator, RulesetBeatmap, BeatmapConverter, IBeatmap, BeatmapProcessor, DifficultyAttributes, Autoplay, Cinema, DoubleTime, Easy, Flashlight, HalfTime, HardRock, Hidden, Nightcore, NoFail, NoMod, Perfect, Relax, SuddenDeath, PerformanceAttributes, DifficultyHitObject, IHitObject, StrainDecaySkill, Skill, DifficultyCalculator, PerformanceCalculator, IRuleset, IScoreInfo, ReplayFrame, IConvertibleReplayFrame, LegacyReplayFrame, ReplayConverter, IReplayFrame, HitResult, DifficultyRange, Ruleset } from 'osu-classes';

declare class TaikoModCombination extends ModCombination {
  get mode(): number;
  protected get _availableMods(): IMod[];
}

declare abstract class TaikoHitObject extends HitObject {
  /**
     * Default size of a drawable taiko hit object.
     */
  static DEFAULT_SIZE: number;
  hitWindows: HitWindows;
}

declare abstract class TaikoStrongHitObject extends TaikoHitObject {
  /**
     * Scale multiplier for a strong drawable taiko hit object.
     */
  static STRONG_SCALE: number;

  /**
     * Default size of a strong drawable taiko hit object.
     */
  static DEFAULT_STRONG_SIZE: number;

  /**
     * Whether this HitObject is a "strong" type.
     * Strong hit objects give more points for hitting the hit object with both keys.
     */
  get isStrong(): boolean;
  set isStrong(value: boolean);
}

declare class DrumRoll extends TaikoStrongHitObject implements ISlidableObject {
  /**
     * Drum roll distance that results in a duration of 1 speed-adjusted beat length.
     */
  static readonly BASE_DISTANCE = 100;

  /**
     * The length (in milliseconds) between ticks of this drumroll.
     * Half of this value is the hit window of the ticks.
     */
  tickInterval: number;

  /**
     * Numer of ticks per beat length.
     */
  tickRate: number;

  /**
     * Velocity of this {@link DrumRoll}
     */
  velocity: number;

  /**
     * Duration of this {@link DrumRoll}
     */
  duration: number;

  /**
     * Path of this {@link DrumRoll}
     * For compatibility with slidable hit object interface.
     */
  path: SliderPath;

  /**
     * Node samples of this {@link DrumRoll}
     * For compatibility with slidable hit object interface.
     */
  nodeSamples: HitSample[][];

  /**
     * Repeats of this {@link DrumRoll}.
     * For compatibility with slidable hit object interface.
     */
  repeats: number;
  hitWindows: osu_classes.HitWindows;
  get distance(): number;
  set distance(value: number);
  get spans(): number;
  get spanDuration(): number;
  get endTime(): number;
  set endTime(value: number);
  applyDefaultsToSelf(controlPoints: ControlPointInfo, difficulty: BeatmapDifficultySection): void;
  createNestedHitObjects(): void;
  clone(): this;
}

declare class DrumRollTick extends TaikoHitObject {
  /**
     * Whether this is the first (initial) tick of the slider.
     */
  firstTick: boolean;

  /**
     * The length (in milliseconds) between this tick and the next.
     * Half of this value is the hit window of the tick.
     */
  tickInterval: number;

  /**
     * The time allowed to hit this tick.
     */
  get hitWindow(): number;
  hitWindows: osu_classes.HitWindows;
  clone(): this;
}

declare class Hit extends TaikoStrongHitObject {
  get isRim(): boolean;
}

declare class Swell extends TaikoHitObject implements ISpinnableObject {
  /**
     * The number of hits required to complete the swell successfully.
     */
  requiredHits: number;

  /**
     * Ending time of this {@link Swell}
     */
  endTime: number;
  hitWindows: osu_classes.HitWindows;
  get duration(): number;
  set duration(value: number);
  createNestedHitObjects(): void;
  clone(): this;
}

declare class SwellTick extends TaikoHitObject {
  hitWindows: osu_classes.HitWindows;
}

declare class TaikoEventGenerator extends EventGenerator {
  static generateDrumRollTicks(drumRoll: DrumRoll): Generator<TaikoHitObject>;
  static generateSwellTicks(swell: Swell): Generator<TaikoHitObject>;
}

declare class TaikoBeatmap extends RulesetBeatmap {
  mods: TaikoModCombination;
  hitObjects: TaikoHitObject[];
  get mode(): number;
  get maxCombo(): number;
  get hits(): Hit[];
  get drumRolls(): DrumRoll[];
  get swells(): Swell[];
}

declare class TaikoBeatmapConverter extends BeatmapConverter {
  /**
     * Osu!std is generally slower than taiko, so a factor is added to increase
     * speed. This must be used everywhere slider length or beat length is used.
     */
  static VELOCITY_MULTIPLIER: number;

  /**
     * Base osu! slider scoring distance.
     */
  static BASE_SCORING_DISTANCE: number;

  /**
     * Because swells are easier in taiko than spinners are in osu!,
     * taiko multiplies a factor when converting the number of required hits.
     */
  static SWELL_HIT_MULTIPLIER: number;
  isForCurrentRuleset: boolean;
  isForManiaRuleset: boolean;
  taikoDistance: number;
  taikoDuration: number;
  tickDistance: number;
  tickInterval: number;
  canConvert(_: IBeatmap): boolean;
  convertBeatmap(original: IBeatmap): TaikoBeatmap;
  convertHitObjects(beatmap: IBeatmap): Generator<TaikoHitObject>;
  private _convertHitObject;
  private _convertHittableObject;
  private _convertSlidableObject;
  private _convertSpinnableObject;
  private _shouldConvertToHits;
  createBeatmap(): TaikoBeatmap;
}

declare class TaikoBeatmapProcessor extends BeatmapProcessor {
}

declare class TaikoDifficultyAttributes extends DifficultyAttributes {
  /**
     * The difficulty corresponding to the stamina skill.
     */
  staminaDifficulty: number;

  /**
     * The difficulty corresponding to the rhythm skill.
     */
  rhythmDifficulty: number;

  /**
     * The difficulty corresponding to the colour skill.
     */
  colourDifficulty: number;

  /**
     * The difficulty corresponding to the hardest parts of the map.
     */
  peakDifficulty: number;

  /**
     * The perceived hit window for a GREAT hit inclusive of rate-adjusting mods (DT/HT/etc).
     * Rate-adjusting mods don't directly affect the hit window,
     * but have a perceived effect as a result of adjusting audio timing.
     */
  greatHitWindow: number;
}

declare class TaikoAutoplay extends Autoplay {
}

declare class TaikoCinema extends Cinema {
}

declare class TaikoDoubleTime extends DoubleTime {
}

declare class TaikoEasy extends Easy {
  applyToDifficulty(difficulty: BeatmapDifficultySection): void;
}

declare class TaikoFlashlight extends Flashlight {
}

declare class TaikoHalfTime extends HalfTime {
}

declare class TaikoHardRock extends HardRock {
  applyToDifficulty(difficulty: BeatmapDifficultySection): void;
}

declare class TaikoHidden extends Hidden {
}

declare class TaikoNightcore extends Nightcore {
}

declare class TaikoNoFail extends NoFail {
}

declare class TaikoNoMod extends NoMod {
}

declare class TaikoPerfect extends Perfect {
}

declare class TaikoRelax extends Relax {
}

declare class TaikoSuddenDeath extends SuddenDeath {
}

declare class TaikoPerformanceAttributes extends PerformanceAttributes {
  /**
     * The mods which were applied to the beatmap.
     */
  mods: TaikoModCombination;

  /**
     * The difficulty performance of a score.
     */
  difficultyPerformance: number;

  /**
     * The accuracy performance of a score.
     */
  accuracyPerformance: number;

  /**
     * Effective miss count of a score.
     */
  effectiveMissCount: number;

  /**
     * Creates new difficulty attributes.
     * @param mods The mods which were applied to the beatmap.
     * @param totalPerformance The total performance of a score.
     */
  constructor(mods: TaikoModCombination, totalPerformance: number);
}

/**
 * Represents a rhythm change in a taiko map.
 */
declare class TaikoDifficultyHitObjectRhythm {
  /**
     * The difficulty multiplier associated with this rhythm change.
     */
  readonly difficulty: number;

  /**
     * The ratio of current difficulty hit object's delta time.
     * to previous difficulty hit object's delta time for the rhythm change.
     * A {@link ratio} above 1 indicates a slow-down;
     * A {@link ratio} below 1 indicates a speed-up.
     */
  readonly ratio: number;

  /**
     * Creates an object representing a rhythm change.
     * @param numerator The numerator for {@link ratio}.
     * @param denominator The denominator for {@link ratio}.
     * @param difficulty The difficulty multiplier associated with this rhythm change.
     */
  constructor(numerator: number, denominator: number, difficulty: number);
}

/**
 * Encode colour information for a sequence of {@link TaikoDifficultyHitObject}s.
 * Consecutive {@link TaikoDifficultyHitObject}s of the same hit type
 * are encoded within the same {@link MonoStreak}.
 */
declare class MonoStreak {
  /**
     * List of {@link DifficultyHitObject}s that are encoded within this {@link MonoStreak}.
     */
  hitObjects: TaikoDifficultyHitObject[];

  /**
     * The parent {@link AlternatingMonoPattern} that contains this {@link MonoStreak}
     */
  parent: AlternatingMonoPattern;

  /**
     * Index of this {@link MonoStreak} within it's parent {@link AlternatingMonoPattern}
     */
  index: number;

  /**
     * The first {@link TaikoDifficultyHitObject} in this {@link MonoStreak}.
     */
  get firstHitObject(): TaikoDifficultyHitObject;

  /**
     * The hit type of all objects encoded within this {@link MonoStreak}
     */
  get isRim(): boolean;

  /**
     * How long the mono pattern encoded within is
     */
  get runLength(): number;
}

/**
 * Encodes a list of {@link AlternatingMonoPattern}s, grouped together
 * by back and forth repetition of the same * {@link AlternatingMonoPattern}.
 * Also stores the repetition interval between this and the previous {@link RepeatingHitPatterns}.
 */
declare class RepeatingHitPatterns {
  /**
     * Maximum amount of {@link RepeatingHitPatterns}s to look back to find a repetition.
     */
  private static MAX_REPETITION_INTERVAL;

  /**
     * The {@link AlternatingMonoPattern}s that are grouped together within this {@link RepeatingHitPatterns}.
     */
  readonly alternatingMonoPatterns: AlternatingMonoPattern[];

  /**
     * The parent {@link TaikoDifficultyHitObject} in this {@link RepeatingHitPatterns}
     */
  get firstHitObject(): TaikoDifficultyHitObject;

  /**
     * The previous {@link RepeatingHitPatterns}. This is used to determine the repetition interval.
     */
  readonly previous: RepeatingHitPatterns | null;
  private _repetitionInterval;

  /**
     * How many {@link RepeatingHitPatterns} between
     * the current and previous identical {@link RepeatingHitPatterns}.
     * If no repetition is found this will have a value of {@link MAX_REPETITION_INTERVAL} + 1.
     */
  get repetitionInterval(): number;
  private set repetitionInterval(value);
  constructor(previous: RepeatingHitPatterns | null);

  /**
     * Returns true if other is considered a repetition of this pattern.
     * This is true if other's first two payloads have identical mono lengths.
     */
  private _isRepetitionOf;

  /**
     * Finds the closest previous {@link RepeatingHitPatterns}
     * that has the identical {@link AlternatingMonoPatterns}.
     * Interval is defined as the amount of {@link RepeatingHitPatterns}
     * chunks between the current and repeated patterns.
     */
  findRepetitionInterval(): void;
}

/**
 * Stores colour compression information for a {@link TaikoDifficultyHitObject}.
 */
declare class TaikoDifficultyHitObjectColour {
  /**
     * The {@link MonoStreak} that encodes this note, only present
     * if this is the first note within a {@link MonoStreak}
     */
  monoStreak: MonoStreak | null;

  /**
     * The {@link AlternatingMonoPattern} that encodes this note,
     * only present if this is the first note within a {@link AlternatingMonoPattern}
     */
  alternatingMonoPattern: AlternatingMonoPattern | null;

  /**
     * The {@link RepeatingHitPattern} that encodes this note,
     * only present if this is the first note within a {@link RepeatingHitPattern}
     */
  repeatingHitPattern: RepeatingHitPatterns | null;
}

/**
 * Represents a single hit object in taiko difficulty calculation.
 */
declare class TaikoDifficultyHitObject extends DifficultyHitObject {
  /**
     * The list of all {@link TaikoDifficultyHitObject}
     * of the same colour as this {@link TaikoDifficultyHitObject} in the beatmap.
     */
  private readonly _monoDifficultyHitObjects;

  /**
     * The index of this {@link TaikoDifficultyHitObject} in {@link monoDifficultyHitObjects}.
     */
  readonly monoIndex: number;

  /**
     * The list of all {@link TaikoDifficultyHitObject} that
     * is either a regular note or finisher in the beatmap
     */
  private readonly _noteDifficultyHitObjects;

  /**
     * The index of this {@link TaikoDifficultyHitObject} in {@link noteDifficultyHitObjects}.
     */
  readonly noteIndex: number;

  /**
     * The rhythm required to hit this hit object.
     */
  readonly rhythm: TaikoDifficultyHitObjectRhythm;

  /**
     * Colour data for this hit object. This is used by colour evaluator
     * to calculate colour difficulty, but can be used by other skills in the future.
     */
  readonly colour: TaikoDifficultyHitObjectColour;

  /**
     * Creates a new difficulty hit object.
     * @param hitObject The gameplay {@link IHitObject} associated with this difficulty object.
     * @param lastObject The gameplay {@link IHitObject} preceding hit object.
     * @param lastLastObject The gameplay {@link IHitObject} preceding last object.
     * @param clockRate The rate of the gameplay clock. Modified by speed-changing mods.
     * @param objects The list of all {@link DifficultyHitObject}s in the current beatmap.
     * @param centreHitObjects The list of centre (don) {@link DifficultyHitObject}s in the current beatmap.
     * @param rimHitObjects The list of rim (kat) {@link DifficultyHitObject}s in the current beatmap.
     * @param noteObjects The list of {@link DifficultyHitObject}s that is a hit
     * (i.e. not a drumroll or swell) in the current beatmap.
     * @param index The position of this {@link DifficultyHitObject} in the objects list.
     */
  constructor(hitObject: IHitObject, lastObject: IHitObject, lastLastObject: IHitObject, clockRate: number, objects: DifficultyHitObject[], centreHitObjects: TaikoDifficultyHitObject[], rimHitObjects: TaikoDifficultyHitObject[], noteObjects: TaikoDifficultyHitObject[], index: number);

  /**
     * List of most common rhythm changes in taiko maps.
     * The general guidelines for the values are:
     *  - rhythm changes with ratio closer to 1 (that are not 1) are harder to play,
     *  - speeding up is generally harder than slowing down
     *  (with exceptions of rhythm changes requiring a hand switch).
     */
  private static readonly COMMON_RHYTHMS;

  /**
     * Returns the closest rhythm change from {@link COMMON_RHYTHMS} required to hit this object.
     * @param lastObject The gameplay {@link IHitObject} preceding this one.
     * @param lastLastObject The gameplay {@link IHitObject} preceding last object
     * @param clockRate The rate of the gameplay clock.
     */
  private _getClosestRhythm;
  previousMono(backwardsIndex: number): TaikoDifficultyHitObject | null;
  nextMono(forwardsIndex: number): TaikoDifficultyHitObject | null;
  previousNote(backwardsIndex: number): TaikoDifficultyHitObject | null;
  nextNote(forwardsIndex: number): TaikoDifficultyHitObject | null;
}

/**
 * Encodes a list of {@link MonoStreak}s. {@link MonoStreak}s with the same
 * {@link MonoStreak.runLength} are grouped together.
 */
declare class AlternatingMonoPattern {
  /**
     * {@link MonoStreak}s that are grouped together within this {@link AlternatingMonoPattern}.
     */
  readonly monoStreaks: MonoStreak[];

  /**
     * The parent {@link RepeatingHitPatterns} that contains this {@link AlternatingMonoPattern}
     */
  parent: RepeatingHitPatterns;

  /**
     * Index of this {@link AlternatingMonoPattern} within it's parent {@link RepeatingHitPatterns}
     */
  index: number;

  /**
     * The first {@link TaikoDifficultyHitObject} in this {@link AlternatingMonoPattern}.
     */
  get firstHitObject(): TaikoDifficultyHitObject;

  /**
     * Determine if this {@link AlternatingMonoPattern} is a repetition
     * of another {@link AlternatingMonoPattern}. This is a strict comparison
     * and is true if and only if the colour sequence is exactly the same.
     */
  isRepetitionOf(other: AlternatingMonoPattern): boolean;

  /**
     * Determine if this {@link AlternatingMonoPattern} has the same
     * mono length of another {@link AlternatingMonoPattern}.
     */
  hasIdenticalMonoLength(other: AlternatingMonoPattern): boolean;
}

/**
 * Utility class to perform various encodings.
 */
declare class TaikoColourDifficultyPreprocessor {
  /**
     * Processes and encodes a list of {@link TaikoDifficultyHitObject}s
     * into a list of {@link TaikoDifficultyHitObjectColour}s,
     * assigning the appropriate {@link TaikoDifficultyHitObjectColour}s
     * to each {@link TaikoDifficultyHitObject},
     * and pre-evaluating colour difficulty of each {@link TaikoDifficultyHitObject}.
     */
  static processAndAssign(hitObjects: DifficultyHitObject[]): void;

  /**
     * Encodes a list of {@link TaikoDifficultyHitObject}s into a list of {@link RepeatingHitPatterns}s.
     */
  private static _encode;

  /**
     * Encodes a list of {@link TaikoDifficultyHitObject}s into a list of {@link MonoStreak}s.
     */
  private static _encodeMonoStreak;

  /**
     * Encodes a list of {@link MonoStreak}s into a list of {@link AlternatingMonoPattern}s.
     */
  private static _encodeAlternatingMonoPattern;

  /**
     * Encodes a list of {@link AlternatingMonoPattern}s into a list of {@link RepeatingHitPatterns}s.
     */
  private static _encodeRepeatingHitPattern;
}

/**
 * Calculates the colour coefficient of taiko difficulty.
 */
declare class Colour extends StrainDecaySkill {
  protected _skillMultiplier: number;

  /**
     * This is set to decay slower than other skills, due to the fact
     * that only the first note of each encoding class having any difficulty values,
     * and we want to allow colour difficulty to be able to build up even on slower maps.
     */
  protected _strainDecayBase: number;
  protected _strainValueOf(current: DifficultyHitObject): number;
}

/**
 * Calculates the rhythm coefficient of taiko difficulty.
 */
declare class Rhythm extends StrainDecaySkill {
  protected _skillMultiplier: number;
  protected _strainDecayBase: number;

  /**
     * The note-based decay for rhythm strain.
     * {@link strainDecayBase} is not used here, as it's time- and not note-based.
     */
  private static STRAIN_DECAY;

  /**
     * Maximum number of entries in {@link rhythmHistory}.
     */
  private static RHYTHM_HISTORY_MAX_LENGTH;

  /**
     * Contains the last {@link RHYTHM_HISTORY_MAX_LENGTH} changes in note sequence rhythms.
     */
  private readonly _rhythmHistory;

  /**
     * Contains the rolling rhythm strain. Used to apply per-note decay.
     */
  private _currentRhythmStrain;

  /**
     * Number of notes since the last rhythm change has taken place.
     */
  private _notesSinceRhythmChange;
  protected _strainValueOf(current: DifficultyHitObject): number;

  /**
     * Returns a penalty to apply to the current hit object caused by repeating rhythm changes.
     * Repetitions of more recent patterns are associated with a higher penalty.
     * @param hitObject The current hit object being considered.
     */
  private _repetitionPenalties;

  /**
     * Determines whether the rhythm change pattern starting at
     * {@link start} is a repeat of any of the {@link mostRecentPatternsToCompare}.
     */
  private _samePattern;

  /**
     * Calculates a single rhythm repetition penalty.
     * @param notesSince Number of notes since the last repetition of a rhythm change.
     */
  private static _repetitionPenalty;

  /**
     * Calculates a penalty based on the number of notes since the last rhythm change.
     * Both rare and frequent rhythm changes are penalised.
     * @param patternLength Number of notes since the last rhythm change.
     */
  private static _patternLengthPenalty;

  /**
     * Calculates a penalty for objects that do not require alternating hands.
     * @param deltaTime Time (in milliseconds) since the last hit object.
     */
  private _speedPenalty;

  /**
     * Resets the rolling strain value and {@link notesSinceRhythmChange} counter.
     */
  private _resetRhythmAndStrain;
}

/**
 * Calculates the stamina coefficient of taiko difficulty.
 * The reference play style chosen uses two hands, with full alternating (the hand changes after every hit).
 */
declare class Stamina extends StrainDecaySkill {
  protected _skillMultiplier: number;
  protected _strainDecayBase: number;
  protected _strainValueOf(current: DifficultyHitObject): number;
}

declare class Peaks extends Skill {
  private static FINAL_MULTIPLIER;
  private static RHYTHM_SKILL_MULTIPLIER;
  private static COLOUR_SKILL_MULTIPLIER;
  private static STAMINA_SKILL_MULTIPLIER;
  readonly rhythm: Rhythm;
  readonly colour: Colour;
  readonly stamina: Stamina;
  constructor(mods: TaikoModCombination);
  get colourDifficultyValue(): number;
  get rhythmDifficultyValue(): number;
  get staminaDifficultyValue(): number;

  /**
     * Returns the p-norm of an n-dimensional vector.
     * @param p The value of p to calculate the norm for.
     * @param values The coefficients of the vector.
     */
  private _norm;
  process(current: DifficultyHitObject): void;

  /**
     * For each section, the peak strains of all separate skills
     * are combined into a single peak strain for the section.
     * The resulting partial rating of the beatmap is a weighted sum
     * of the combined peaks (higher peaks are weighted more).
     * @returns The combined star rating of the beatmap,
     * calculated using peak strains from all sections of the map.
     */
  get difficultyValue(): number;
}

/**
 * A taiko difficulty calculator.
 */
declare class TaikoDifficultyCalculator extends DifficultyCalculator<TaikoDifficultyAttributes> {
  private static readonly DIFFICULTY_MULTIPLIER;
  protected _createSkills(_: IBeatmap, mods: TaikoModCombination): Skill[];
  get difficultyMods(): IMod[];
  protected _createDifficultyHitObjects(beatmap: IBeatmap, clockRate: number): DifficultyHitObject[];
  protected _createDifficultyAttributes(beatmap: IBeatmap, mods: TaikoModCombination, skills: Skill[], clockRate: number): TaikoDifficultyAttributes;

  /**
     * Calculates the penalty for the stamina skill for maps with low colour difficulty.
     * Some maps (especially converts) can be easy to read despite a high note density.
     * This penalty aims to reduce the star rating of such maps
     * by factoring in colour difficulty to the stamina skill.
     */
  private static _simpleColourPenalty;

  /**
     * Applies a final re-scaling of the star rating.
     * @param sr The raw star rating value before re-scaling.
     */
  private _rescale;
}

declare class TaikoPerformanceCalculator extends PerformanceCalculator {
  attributes: TaikoDifficultyAttributes;
  private _mods;
  private _countGreat;
  private _countOk;
  private _countMeh;
  private _countMiss;
  private _accuracy;
  private _effectiveMissCount;
  constructor(ruleset: IRuleset, attributes?: DifficultyAttributes, score?: IScoreInfo);
  calculateAttributes(attributes?: DifficultyAttributes, score?: IScoreInfo): TaikoPerformanceAttributes;
  private _computeDifficultyValue;
  private _computeAccuracyValue;
  private _addParams;
  private get _totalHits();
  private get _totalSuccessfulHits();
}

declare enum TaikoAction {
  /**
     * Left (rim)
     */
  LeftRim = 0,

  /**
     * Left (centre)
     */
  LeftCentre = 1,

  /**
     * Right (centre)
     */
  RightCentre = 2,

  /**
     * Right (rim)
     */
  RightRim = 3,
}

declare class TaikoReplayFrame extends ReplayFrame implements IConvertibleReplayFrame {
  /**
     * Button actions of this replay frame.
     */
  actions: Set<TaikoAction>;
  fromLegacy(currentFrame: LegacyReplayFrame): this;
  toLegacy(): LegacyReplayFrame;
}

/**
 * osu!taiko replay converter.
 */
declare class TaikoReplayConverter extends ReplayConverter {
  protected _createConvertibleReplayFrame(): TaikoReplayFrame;
  protected _isConvertedReplayFrame(frame: IReplayFrame): boolean;
}

declare class TaikoHitWindows extends HitWindows {
  private static readonly TAIKO_RANGES;
  isHitResultAllowed(result: HitResult): boolean;
  protected _getRanges(): DifficultyRange[];
}

/**
 * osu!taiko ruleset.
 */
declare class TaikoRuleset extends Ruleset {
  /**
     * osu!taiko ruleset ID.
     */
  get id(): number;

  /**
     * Applies osu!taiko ruleset to a beatmap.
     * @param beatmap The beatmap.
     * @returns A new osu!taiko beatmap with applied ruleset.
     */
  applyToBeatmap(beatmap: IBeatmap): TaikoBeatmap;

  /**
     * Applies osu!taiko ruleset and mods to a beatmap.
     * @param beatmap The beatmap.
     * @param mods osu!taiko mod combination.
     * @returns A new osu!taiko beatmap with applied mods.
     */
  applyToBeatmapWithMods(beatmap: IBeatmap, mods?: TaikoModCombination): TaikoBeatmap;

  /**
     * Resets a mod combination from a beatmap.
     * @param beatmap The beatmap.
     * @returns A new beatmap with no mods.
     */
  resetMods(beatmap: IBeatmap): TaikoBeatmap;

  /**
     * Creates a new mod combination by converting legacy mod bitwise.
     * @param input Mod bitwise or acronyms.
     * @returns A new mod combination.
     */
  createModCombination(input?: number | string): TaikoModCombination;

  /**
     * @returns A new osu!taiko beatmap processor.
     */
  protected _createBeatmapProcessor(): TaikoBeatmapProcessor;

  /**
     * @returns A new osu!taiko beatmap converter.
     */
  protected _createBeatmapConverter(): TaikoBeatmapConverter;

  /**
     * @returns A new osu!taiko replay converter.
     */
  protected _createReplayConverter(): TaikoReplayConverter;

  /**
     * @param beatmap The beatmap for which the calculation will be done.
     * @returns A new osu!taiko difficulty calculator.
     */
  createDifficultyCalculator(beatmap: IBeatmap): TaikoDifficultyCalculator;

  /**
     * @param attributes The difficulty attributes.
     * @param score Score information.
     * @returns A new osu!taiko performance calculator.
     */
  createPerformanceCalculator(attributes?: TaikoDifficultyAttributes, score?: IScoreInfo): TaikoPerformanceCalculator;
}

export { AlternatingMonoPattern, Colour, DrumRoll, DrumRollTick, Hit, MonoStreak, Peaks, RepeatingHitPatterns, Rhythm, Stamina, Swell, SwellTick, TaikoAction, TaikoAutoplay, TaikoBeatmap, TaikoBeatmapConverter, TaikoBeatmapProcessor, TaikoCinema, TaikoColourDifficultyPreprocessor, TaikoDifficultyAttributes, TaikoDifficultyCalculator, TaikoDifficultyHitObject, TaikoDifficultyHitObjectColour, TaikoDifficultyHitObjectRhythm, TaikoDoubleTime, TaikoEasy, TaikoEventGenerator, TaikoFlashlight, TaikoHalfTime, TaikoHardRock, TaikoHidden, TaikoHitObject, TaikoHitWindows, TaikoModCombination, TaikoNightcore, TaikoNoFail, TaikoNoMod, TaikoPerfect, TaikoPerformanceAttributes, TaikoPerformanceCalculator, TaikoRelax, TaikoReplayConverter, TaikoReplayFrame, TaikoRuleset, TaikoStrongHitObject, TaikoSuddenDeath };