kipphi 2.0.0 → 2.1.0

package/index.d.ts

@@ -0,0 +1,3055 @@
+declare module "chartTypes" {
+    /** 尽管JSON中有布尔值字面量，RPEJSON中没有使用它 */
+    export type Bool = 1 | 0;
+    /** 三元组，用带分数表示的时间 */
+    export type TimeT = [number, number, number];
+    export type RGB = [number, number, number];
+    export interface ChartDataRPE {
+        /** BPM列表 */
+        BPMList: BPMSegmentData[];
+        /** 元数据 */
+        META: MetaData;
+        /** 判定线组 */
+        judgeLineGroup: string[];
+        /** 判定线列表 */
+        judgeLineList: JudgeLineDataRPE[];
+        chartTime?: number;
+        kpaChartTime?: number;
+        multiLineString: string;
+        multiScale: number;
+    }
+    export interface BPMSegmentData {
+        bpm: number;
+        startTime: TimeT;
+    }
+    export interface MetaData {
+        /** RPE版本（int） */
+        RPEVersion: number;
+        /** 背景图片路径 */
+        background: string;
+        /** 画师名称 */
+        illustration: string;
+        /** 谱师名称 */
+        charter: string;
+        /** 曲师名称 */
+        composer: string;
+        /** 谱面ID，即Resources文件夹下的文件夹名称 */
+        id: string;
+        /** 谱面难度 */
+        level: string;
+        /** 谱面名称 */
+        name: string;
+        /** 谱面偏移（以毫秒计量） */
+        offset: number;
+        /** 音乐文件路径 */
+        song: string;
+        /** 音乐时长（1.6(存疑)新增） */
+        duration?: number;
+    }
+    export interface NoteDataRPE {
+        /** 音符是否在判定线上方 （2为下方） */
+        above: Bool | 2;
+        /** 音符不透明度 */
+        alpha: number;
+        /** 音符结束时间，无论是否为Hold都有该属性 */
+        endTime: TimeT;
+        /** 音符是否为假 */
+        isFake: Bool;
+        /** 音符在判定线上落点位置 */
+        positionX: number;
+        /** 音符大小（默认1.0） */
+        size: number;
+        /** 音符速度 */
+        speed: number;
+        /** 音符开始时间 */
+        startTime: TimeT;
+        /** 音符类型（1 为 Tap，2 为 Hold，3 为 Flick，4 为 Drag）*/
+        type: NoteType;
+        /** 音符可视时间（打击前多少秒开始显现，默认99999.0） */
+        visibleTime: number;
+        /** y值偏移，使音符被打击时的位置偏离判定线 */
+        yOffset: number;
+        /** Sets the Z index for the object. */
+        zIndex?: number;
+        /**
+         * Sets the Z index for the hit effects of the note. Defaults to 7.
+         */
+        zIndexHitEffects?: number;
+        /** Sets the tint for the hit effects of the note. Defaults to null. */
+        tint?: RGB;
+        tintHitEffects?: RGB;
+        /** Determines the width of the judgment area of the note. Defaults to size. */
+        judgeSize?: number;
+    }
+    export interface NoteDataKPA {
+        /** 音符是否在判定线上方 （2为下方） */
+        above: Bool | 2;
+        /** 音符不透明度 */
+        alpha: number;
+        /** 音符结束时间，无论是否为Hold都有该属性 */
+        endTime: TimeT;
+        /** 音符是否为假 */
+        isFake: Bool;
+        /** 音符在判定线上落点位置 */
+        positionX: number;
+        /** 音符大小（默认1.0） */
+        size: number;
+        /** 音符速度 */
+        speed: number;
+        /** 音符开始时间 */
+        startTime: TimeT;
+        /** 音符类型（1 为 Tap，2 为 Hold，3 为 Flick，4 为 Drag）*/
+        type: NoteType;
+        /** 音符可视时间（打击前多少秒开始显现，默认99999.0） */
+        visibleTime?: number;
+        /** y值偏移，使音符被打击时的位置偏离判定线 */
+        yOffset: number;
+        /** Sets the Z index for the object. */
+        zIndex?: number;
+        /**
+         * Sets the Z index for the hit effects of the note. Defaults to 7.
+         */
+        zIndexHitEffects?: number;
+        /** Sets the tint for the hit effects of the note. Defaults to null. */
+        tint?: RGB;
+        tintHitEffects?: RGB;
+        /** Determines the width of the judgment area of the note. Defaults to size. */
+        judgeSize?: number;
+        visibleBeats?: number;
+        absoluteYOffset: number;
+    }
+    /** 事件 */
+    export interface EventDataRPELike<T = number> {
+        /** 是否使用贝塞尔曲线 */
+        bezier: Bool;
+        /** 贝塞尔控制点 */
+        bezierPoints: [number, number, number, number];
+        /** 截取缓动左边界 */
+        easingLeft: number;
+        /** 截取缓动右边界 */
+        easingRight: number;
+        /** 缓动类型 */
+        easingType: number | string;
+        /** 结束值 */
+        end: T;
+        /** 结束时间 */
+        endTime: TimeT;
+        /** 链接组 */
+        linkgroup: number;
+        /** 开始值 */
+        start: T;
+        /** 开始时间 */
+        startTime: TimeT;
+    }
+    export enum InterpreteAs {
+        str = 0,
+        int = 1,
+        float = 2
+    }
+    export interface EventDataKPA<T = number> extends EventDataRPELike<T> {
+        /** 若设为真，则easingType当做JS表达式解读 */
+        isParametric?: boolean;
+        interpreteAs?: InterpreteAs;
+    }
+    export enum EasingType {
+        normal = 0,
+        template = 1,
+        bezier = 2,
+        segmented = 3,
+        wrapper = 4
+    }
+    export interface NormalEasingData {
+        type: EasingType.normal;
+        identifier: number;
+    }
+    export interface TemplateEasingData {
+        identifier: string;
+        type: EasingType.template;
+    }
+    export interface WrapperEasingData {
+        type: EasingType.wrapper;
+        identifier: string;
+    }
+    export interface BezierEasingData {
+        type: EasingType.bezier;
+        bezier: [number, number, number, number];
+    }
+    export interface SegmentedEasingData {
+        type: EasingType.segmented;
+        left: number;
+        right: number;
+        inner: EasingDataKPA2;
+    }
+    export type EasingDataKPA2 = NormalEasingData | TemplateEasingData | BezierEasingData | SegmentedEasingData | WrapperEasingData;
+    export enum EvaluatorType {
+        eased = 0,
+        expressionbased = 1,
+        macro = 2
+    }
+    interface EasedEvaluatorDataKPA2<T> {
+        type: EvaluatorType.eased;
+        easing: EasingDataKPA2;
+    }
+    export type NumericEasedEvaluatorKPA2 = EasedEvaluatorDataKPA2<number>;
+    export type ColorEasedEvaluatorKPA2 = EasedEvaluatorDataKPA2<RGB>;
+    export interface TextEasedEvaluatorKPA2 extends EasedEvaluatorDataKPA2<string> {
+        interpretedAs: InterpreteAs;
+    }
+    export type EasedEvaluatorDataOfType<T> = T extends number ? NumericEasedEvaluatorKPA2 : T extends RGB ? ColorEasedEvaluatorKPA2 : TextEasedEvaluatorKPA2;
+    export interface ExpressionEvaluatorDataKPA2 {
+        type: EvaluatorType.expressionbased;
+        jsExpr: string;
+    }
+    export interface MacroEvaluatorDataKPA2 {
+        type: EvaluatorType.macro;
+        name: string;
+        compiled: string;
+    }
+    export type EvaluatorDataKPA2<T> = EasedEvaluatorDataOfType<T> | ExpressionEvaluatorDataKPA2 | MacroEvaluatorDataKPA2;
+    export type MacroData = [id: string, proto: number] | string;
+    export type MacroLink = [macroTypeAndId: `${'value' | 'time'}:${string}`, nodeId: number];
+    export interface EventDataKPA2<T = number> {
+        /** 开始时间 */
+        startTime: TimeT;
+        /** 结束时间 */
+        endTime: TimeT;
+        /** 起始值 */
+        start: T;
+        /** 终值 */
+        end: T;
+        /** 求值器 */
+        evaluator: EvaluatorDataKPA2<T>;
+        /** 终值绑定的宏的ID */
+        macroEnd?: MacroData;
+        /** 起始值绑定的宏的ID */
+        macroStart?: MacroData;
+        /** 起始时间绑定的宏的ID */
+        macroStartTime?: MacroData;
+        /** 将该事件的起始节点关联到一个宏的某个参数 */
+        startLinkedMacro?: MacroLink[];
+        endLinkedMacro?: MacroLink[];
+    }
+    export interface FinalEventStartNodeDataKPA2<T = number> {
+        /** 开始时间 */
+        startTime: TimeT;
+        /** 起始值 */
+        start: T;
+        /** 求值器 */
+        evaluator: EvaluatorDataKPA2<T>;
+        /** 起始值绑定的宏的ID */
+        macro?: MacroData;
+        /** 起始时间绑定的宏的ID */
+        macroTime?: MacroData;
+        /** 将该事件的起始节点关联到一个宏的某个参数 */
+        linkedMacro?: MacroLink[];
+    }
+    export enum EventValueType {
+        numeric = 0,
+        color = 1,
+        text = 2
+    }
+    export type EventValueTypeOfType<T extends EventValueESType> = T extends number ? EventValueType.numeric : T extends RGB ? EventValueType.color : EventValueType.text;
+    export type EventValueESType = string | number | RGB;
+    /**
+     * 五个种类的事件的start/end含义：
+     * X/Y方向移动：像素
+     * 旋转：角度（以度计）
+     * 不透明度改变：不透明度（0-255的整数）
+     * 速度改变：RPE速度单位（每个单位代表每秒下降120px）
+     */
+    /** 每条判定线的前四个事件层级。第五个是特殊事件，这里没有列入 */
+    export interface EventLayerDataRPE {
+        moveXEvents?: EventDataRPELike[];
+        moveYEvents?: EventDataRPELike[];
+        rotateEvents?: EventDataRPELike[];
+        alphaEvents?: EventDataRPELike[];
+        speedEvents?: EventDataRPELike[];
+    }
+    export interface Control {
+        easing: number;
+        x: number;
+    }
+    export interface AlphaControl extends Control {
+        alpha: number;
+    }
+    export interface PosControl extends Control {
+        pos: number;
+    }
+    export interface SizeControl extends Control {
+        size: number;
+    }
+    export interface SkewControl extends Control {
+        skew: number;
+    }
+    export interface YControl extends Control {
+        y: number;
+    }
+    /** 判定线 */
+    export interface JudgeLineDataRPE {
+        /** 音符数据
+         * 对音符的顺序没有要求，但RPE生成的标准RPEJSON中应当按照时间升序排列，
+         * 且非Hold类型与Hold分开排列，非Hold在前
+         */
+        notes: NoteDataRPE[];
+        /** 所在的判定线组，对应judgeLineGroup数组中的字符串的下标 */
+        Group: number;
+        /** 线名 */
+        Name: string;
+        /** 纹理图片的路径 */
+        Texture: string;
+        /** BPM因数 */
+        bpmfactor: 1.0;
+        /** 事件层级，这里没有介绍第五个 */
+        eventLayers: (EventLayerDataRPE | null)[];
+        /** 扩展事件 */
+        extended?: {
+            colorEvents?: EventDataRPELike<RGB>[];
+            inclineEvents?: EventDataRPELike[];
+            scaleXEvents?: EventDataRPELike[];
+            scaleYEvents?: EventDataRPELike[];
+            textEvents?: EventDataRPELike<string>[];
+            gifEvents?: EventDataRPELike<number>[];
+        };
+        /** 父线线号，没有父线则为-1 */
+        father: number;
+        /** 有无遮罩 */
+        isCover: Bool;
+        /** 音符数量 */
+        numOfNotes: number;
+        alphaControl?: AlphaControl[];
+        posControl?: PosControl[];
+        sizeControl?: SizeControl[];
+        skewControl?: SkewControl[];
+        yControl?: YControl[];
+        /** z轴顺序，决定重叠的顺序 */
+        zOrder?: number;
+        anchor: [number, number];
+        /** 背景是否为GIF */
+        isGif: Bool;
+        rotateWithFather?: boolean;
+        attachUI?: "pause" | "combonumber" | "combo" | "score" | "bar" | "name" | "level";
+        /** Decides how scaleX events affect notes. Defaults to 0.
+         * 0: none; 1: scale; 2: clip
+        */
+        scaleOnNotes?: 0 | 1 | 2;
+        /** Decides how the line will be displayed when a UI component or any video is attached to it.
+         * Color events will override the color defined by these options. Defaults to 0.
+         * 0: hidden; 1: white colored; 2: FC/AP colored
+         */
+        appearanceOnAttach?: 0 | 1 | 2;
+        /** Sets the Z index for the object.
+         * For a judgeline, this property, if set, overrides the zOrder property,
+         * allowing for more control over on which layer the line should be displayed. */
+        zIndex?: number;
+    }
+    export interface TemplateEasingBodyData {
+        content: string;
+        name: string;
+    }
+    export interface EventLayerDataKPA {
+        moveX: string;
+        moveY: string;
+        rotate: string;
+        alpha: string;
+        speed: string;
+    }
+    export interface EventLayerDataKPA2 {
+        moveX: string;
+        moveY: string;
+        rotate: string;
+        alpha: string;
+    }
+    export interface NoteNodeDataKPA {
+        notes: NoteDataKPA[];
+        startTime: TimeT;
+    }
+    export interface NNListDataKPA {
+        speed: number;
+        medianYOffset: number;
+        noteNodes: NoteNodeDataKPA[];
+    }
+    export interface JudgeLineDataKPA {
+        cover: boolean;
+        id: number;
+        group: number;
+        nnLists: {
+            [k: string]: NNListDataKPA;
+        };
+        hnLists: {
+            [k: string]: NNListDataKPA;
+        };
+        Name: string;
+        Texture: string;
+        eventLayers: EventLayerDataKPA[];
+        children: JudgeLineDataKPA[];
+        rotatesWithFather: boolean;
+        anchor: [number, number];
+        extended?: {
+            scaleXEvents: string;
+            scaleYEvents: string;
+            textEvents?: string;
+            colorEvents?: string;
+        };
+        zOrder: number;
+    }
+    export interface JudgeLineDataKPA2 {
+        cover: boolean;
+        id: number;
+        group: number;
+        nnLists: {
+            [k: string]: NNListDataKPA;
+        };
+        hnLists: {
+            [k: string]: NNListDataKPA;
+        };
+        name: string;
+        texture: string;
+        eventLayers: EventLayerDataKPA2[];
+        speedEventNodeSeq: string;
+        children: JudgeLineDataKPA2[];
+        rotatesWithFather: boolean;
+        anchor: [number, number];
+        extended?: {
+            scaleXEvents: string;
+            scaleYEvents: string;
+            textEvents?: string;
+            colorEvents?: string;
+        };
+        zOrder: number;
+    }
+    export interface EventNodeSequenceDataKPA<VT> {
+        events: EventDataKPA<VT>[];
+        id: string;
+        type: EventType;
+        endValue: VT;
+    }
+    export interface EventNodeSequenceDataKPA2<VT> {
+        events: EventDataKPA2<VT>[];
+        id: string;
+        type: EventType;
+        final: FinalEventStartNodeDataKPA2<VT>;
+    }
+    export interface WrapperEasingBodyData {
+        jsExpr: string;
+        start: number;
+        end: number;
+        id: string;
+    }
+    export interface MacroEvaluatorBodyData {
+        macro: string;
+        id: string;
+    }
+    export interface MacroTimeBodyData {
+        id: string;
+        macro: string;
+        parametric?: boolean;
+    }
+    export interface MacroValueBodyData {
+        id: string;
+        macro: string;
+        parametric?: boolean;
+    }
+    export interface ChartDataKPA {
+        version: number;
+        offset: number;
+        duration: number;
+        info: {
+            level: string;
+            name: string;
+            charter: string;
+            illustrator: string;
+            composer: string;
+        };
+        ui: {
+            pause: number;
+            combonumber: number;
+            combo: number;
+            score: number;
+            bar: number;
+            name: number;
+            level: number;
+        };
+        envEasings: TemplateEasingBodyData[];
+        eventNodeSequences: EventNodeSequenceDataKPA<any>[];
+        orphanLines: JudgeLineDataKPA[];
+        bpmList: BPMSegmentData[];
+        judgeLineGroups: string[];
+        chartTime?: number;
+        rpeChartTime?: number;
+    }
+    export interface ChartDataKPA2 {
+        version: number;
+        $schema: string;
+        offset: number;
+        duration: number;
+        info: {
+            level: string;
+            name: string;
+            charter: string;
+            illustrator: string;
+            composer: string;
+        };
+        ui: {
+            pause?: number;
+            combonumber?: number;
+            combo?: number;
+            score?: number;
+            bar?: number;
+            name?: number;
+            level?: number;
+        };
+        templateEasings: TemplateEasingBodyData[];
+        wrapperEasings: WrapperEasingBodyData[];
+        macroEvaluators: MacroEvaluatorBodyData[];
+        timeMacros: MacroTimeBodyData[];
+        valueMacros: MacroValueBodyData[];
+        eventNodeSequences: EventNodeSequenceDataKPA2<unknown>[];
+        orphanLines: JudgeLineDataKPA2[];
+        bpmList: BPMSegmentData[];
+        judgeLineGroups: string[];
+        chartTime?: number;
+        rpeChartTime?: number;
+    }
+    export enum EventType {
+        moveX = 0,
+        moveY = 1,
+        rotate = 2,
+        alpha = 3,
+        speed = 4,
+        easing = 5,
+        bpm = 6,
+        scaleX = 7,
+        scaleY = 8,
+        text = 9,
+        color = 10
+    }
+    export enum NoteType {
+        tap = 1,
+        drag = 4,
+        flick = 3,
+        hold = 2
+    }
+    export type ValueTypeOfEventType<T extends EventType> = [number, number, number, number, number, number, number, number, number, string, RGB][T];
+    export type ExtendedEventTypeName = "scaleX" | "scaleY" | "text" | "color";
+}
+declare module "version" {
+    export const VERSION = 210;
+    export const SCHEMA = "https://cdn.jsdelivr.net/npm/kipphi@2.1.0/chartType2.schema.json";
+}
+declare module "util" {
+    import type { RGB, TimeT } from "chartTypes";
+    export enum NodeType {
+        HEAD = 0,
+        TAIL = 1,
+        MIDDLE = 2
+    }
+    export type TupleCoord = [x: number, y: number];
+    /**
+     * 检查值的类型
+     * @param value
+     * @param type 为字符串时，用typeof检测，为构造函数时，用instanceof检测，为数组时，识别为元组类型。
+     */
+    export const checkType: (value: unknown, type: string | (string | typeof Function)[] | typeof Function) => any;
+    export const rgb2hex: (rgb: RGB) => number;
+    export const hex2rgb: (hex: number) => RGB;
+    export const numberToRatio: (num: number) => [number, number];
+    export const toTimeString: (beaT: TimeT) => string;
+}
+declare module "jumparray" {
+    import { NodeType } from "util";
+    type EndNextFn<T extends TwoDirectionNodeLike> = (node: T) => [endBeats: number, next: T];
+    interface TwoDirectionNodeLike {
+        next: this | null;
+        previous: this | null;
+        type: NodeType;
+    }
+    export class JumpArray<T extends TwoDirectionNodeLike> {
+        endNextFn: EndNextFn<T>;
+        nextFn: (node: T, beats: number) => T | false;
+        resolveLastNode: (node: T) => T;
+        header: T;
+        tailer: T;
+        array: (T[] | T)[];
+        averageBeats: number;
+        effectiveBeats: number;
+        goPrev: (node: T) => T;
+        readonly MINOR_SCALE_COUNT: number;
+        /**
+         *
+         * @param head 链表头
+         * @param tail 链表尾
+         * @param originalListLength
+         * @param effectiveBeats 有效拍数（等同于音乐拍数）
+         * @param endNextFn 接收一个节点，返回该节点分管区段拍数，并给出下个节点。若抵达尾部，返回[null, null]（停止遍历的条件是抵达尾部而不是得到null）
+         * @param nextFn 接收一个节点，返回下个节点。如果应当停止，返回false。
+         */
+        constructor(head: T, tail: T, originalListLength: number, effectiveBeats: number, endNextFn: EndNextFn<T>, nextFn: (node: T, beats: number) => T | false, resolveLastNode?: (node: T) => T);
+        updateEffectiveBeats(val: number): void;
+        updateAverageBeats(): void;
+        /**
+         *
+         * @param firstNode 不含
+         * @param lastNode 含
+         */
+        updateRange(firstNode: T, lastNode: T): void;
+        getPreviousOf(node: T, beats: number): T;
+        /**
+         *
+         * @param beats 拍数
+         * @ param usePrev 可选，若设为true，则在取到事件头部时会返回前一个事件（即视为左开右闭）
+         * @returns 时间索引链表的节点，一般不是head
+         */
+        getNodeAt(beats: number): T;
+    }
+}
+declare module "bpm" {
+    import { type BPMSegmentData, type TimeT } from "chartTypes";
+    import { EventEndNode, EventNodeLike, EventNodeSequence, EventStartNode, type ENOrHead, type ENOrTail } from "event";
+    import { JumpArray } from "jumparray";
+    import { NodeType } from "util";
+    /**
+     * BPM起始节点类，表示BPM变化的开始点
+     * 每个BPMStartNode代表一个BPM值的开始，直到下一个BPM节点
+     */
+    export class BPMStartNode extends EventStartNode {
+        /** 每拍的秒数(Seconds Per Beat) */
+        spb: number;
+        /** 缓存的起始积分值，用于时间计算 */
+        cachedStartIntegral?: number;
+        /** 缓存的积分值，用于时间计算 */
+        cachedIntegral?: number;
+        /** 下一个BPM结束节点或尾部节点 */
+        next: BPMEndNode | BPMNodeLike<NodeType.TAIL>;
+        /** 上一个BPM结束节点或头部节点 */
+        previous: BPMEndNode | BPMNodeLike<NodeType.HEAD>;
+        /**
+         * 创建一个新的BPM起始节点
+         * @param startTime 节点开始时间
+         * @param bpm BPM值
+         */
+        constructor(startTime: TimeT, bpm: number);
+        /**
+         * 计算指定拍数对应的秒数
+         * @param beats 拍数
+         * @returns 对应的秒数
+         */
+        getSeconds(beats: number): number;
+        /**
+         * 获取当前BPM段的完整持续时间（秒）
+         * @this NonLastBPMStartNode 非最后一个BPM节点
+         * @returns 当前BPM段的持续时间（秒）
+         */
+        getFullSeconds(this: NonLastBPMStartNode): number;
+    }
+    /**
+     * BPM结束节点类，表示BPM段的结束点
+     * 用于标记BPM段的结束位置
+     */
+    export class BPMEndNode extends EventEndNode {
+        /** 每拍的秒数(Seconds Per Beat) */
+        spb: number;
+        /** 前一个BPM起始节点 */
+        previous: BPMStartNode;
+        /** 下一个BPM起始节点 */
+        next: BPMStartNode;
+        /**
+         * 创建一个新的BPM结束节点
+         * @param endTime 节点结束时间
+         */
+        constructor(endTime: TimeT);
+    }
+    /** 非最后一个BPM起始节点类型 */
+    type NonLastBPMStartNode = BPMStartNode & {
+        next: BPMEndNode;
+    };
+    /**
+     * BPM节点接口，定义了BPM节点的基本结构
+     */
+    interface BPMNodeLike<T extends NodeType> extends EventNodeLike<T> {
+        /** 下一个节点 */
+        next: [BPMStartNode, null, BNOrTail][T] | null;
+        /** 上一个节点 */
+        previous: [null, BPMStartNode, BNOrHead][T] | null;
+    }
+    /** BPM节点类型 */
+    type BPMNode = BPMStartNode | BPMEndNode;
+    /** 任意BPM节点类型 */
+    type AnyBN = (BPMNode | BPMNodeLike<NodeType.TAIL> | BPMNodeLike<NodeType.HEAD>);
+    /** BPM节点或尾部节点类型 */
+    type BNOrTail = BPMNode | BPMNodeLike<NodeType.TAIL>;
+    /** BPM节点或头部节点类型 */
+    type BNOrHead = BPMNode | BPMNodeLike<NodeType.HEAD>;
+    /**
+     * BPM序列类，管理BPM变化序列
+     * 拥有与事件类似的逻辑，每对节点之间代表一个BPM相同的片段
+     * 片段之间BPM可以发生改变
+     */
+    export class BPMSequence extends EventNodeSequence {
+        duration: number;
+        /** 头部节点 */
+        head: BPMNodeLike<NodeType.HEAD>;
+        /** 尾部节点 */
+        tail: BPMNodeLike<NodeType.TAIL>;
+        /** 从拍数访问节点的跳转数组 */
+        jump: JumpArray<AnyBN>;
+        /** 以秒计时的跳转数组，处理从秒访问节点 */
+        secondJump: JumpArray<AnyBN>;
+        /**
+         * 创建BPM序列
+         * @param bpmList BPM片段数据列表
+         * @param duration 总持续时间
+         */
+        constructor(bpmList: BPMSegmentData[], duration: number);
+        /**
+         * 初始化跳转数组
+         */
+        initJump(): void;
+        /**
+         * 更新秒跳转数组
+         */
+        updateSecondJump(): void;
+        /**
+         * 更新跳转数组
+         * @param from 起始节点
+         * @param to 结束节点
+         */
+        updateJump(from: ENOrHead, to: ENOrTail): void;
+        /**
+         * 根据秒数获取BPM起始节点
+         * @param seconds 秒数
+         * @returns 对应的BPM起始节点
+         */
+        getNodeBySeconds(seconds: number): BPMStartNode;
+        /**
+         * 导出BPM数据
+         * @returns BPM片段数据数组
+         */
+        dumpBPM(): BPMSegmentData[];
+        /**
+         * 根据拍数获取节点
+         * @param beats 拍数
+         * @param usePrev 是否使用前一个节点
+         * @returns 对应的BPM起始节点
+         */
+        getNodeAt(beats: number, usePrev?: boolean): BPMStartNode;
+    }
+    /**
+     * 时间计算器类，用于处理拍数与秒数之间的转换
+     */
+    export class TimeCalculator {
+        /** BPM片段数据列表 */
+        bpmList: BPMSegmentData[];
+        /** BPM序列 */
+        readonly bpmSequence: BPMSequence;
+        /** 总持续时间 */
+        duration: number;
+        /**
+         * 创建时间计算器
+         */
+        constructor();
+        /**
+         * 初始化BPM序列
+         */
+        initSequence(): void;
+        /**
+         * 将拍数转换为秒数
+         * @param beats 拍数
+         * @returns 对应的秒数
+         */
+        toSeconds(beats: number): number;
+        /**
+         * 获取从beats1到beats2的秒数
+         * @param beats1 起始拍数
+         * @param beats2 结束拍数
+         * @returns 两拍数之间的秒数差
+         */
+        segmentToSeconds(beats1: number, beats2: number): number;
+        /**
+         * 将秒数转换为拍数
+         * @param seconds 秒数
+         * @returns 对应的拍数
+         */
+        secondsToBeats(seconds: number): number;
+        /**
+         * 导出BPM数据
+         * @returns BPM片段数据数组
+         */
+        dump(): BPMSegmentData[];
+    }
+}
+declare module "note" {
+    /**
+     * @author Zes M Young
+     */
+    import type { Chart } from "chart";
+    import { NoteType, type NNListDataKPA, type NoteDataKPA, type NoteDataRPE, type NoteNodeDataKPA, type TimeT } from "chartTypes";
+    import type { JudgeLine } from "judgeline";
+    import { JumpArray } from "jumparray";
+    import { type TimeCalculator } from "bpm";
+    import { NodeType } from "util";
+    export type HEX = number;
+    export const notePropTypes: {
+        above: string;
+        alpha: string;
+        endTime: string[];
+        isFake: string;
+        positionX: string;
+        size: string;
+        speed: string;
+        startTime: string[];
+        type: string;
+        visibleTime: string;
+        visibleBeats: string;
+        yOffset: string;
+        tint: string[];
+        tintHitEffects: string[];
+        judgeSize: string;
+    };
+    /**
+     * 音符
+     * Basic element in music game.
+     * Has 4 types: tap, drag, flick and hold.
+     * Only hold has endTime; others' endTime is equal to startTime.
+     * For this reason, holds are store in a special list (HNList),
+     * which is sorted by both startTime and endTime,
+     * so that they are accessed correctly and rapidly in the renderer.
+     * Note that Hold and HoldNode are not individually-declared classes.
+     * Hold is a note with type being NoteType.hold,
+     * while HoldNode is a node that contains holds.
+     */
+    export class Note {
+        above: boolean;
+        alpha: number;
+        endTime: [number, number, number];
+        isFake: boolean;
+        /** x coordinate in the judge line */
+        positionX: number;
+        size: number;
+        speed: number;
+        startTime: [number, number, number];
+        type: NoteType;
+        /** @deprecated */
+        visibleTime: number;
+        visibleBeats: number;
+        yOffset: number;
+        parentNode: NoteNode;
+        tint: HEX;
+        tintHitEffects: HEX;
+        judgeSize: number;
+        constructor(data: NoteDataRPE | NoteDataKPA);
+        static fromKPAJSON(data: NoteDataKPA, timeCalculator: TimeCalculator): Note;
+        computeVisibleBeats(timeCalculator: TimeCalculator): void;
+        /**
+         *
+         * @param offset
+         * @returns
+         */
+        clone(offset: TimeT): Note;
+        dumpRPE(timeCalculator: TimeCalculator): NoteDataRPE;
+        dumpKPA(): NoteDataKPA;
+    }
+    export type NNOrHead = NoteNode | NoteNodeLike<NodeType.HEAD>;
+    export type NNOrTail = NoteNode | NoteNodeLike<NodeType.TAIL>;
+    export type AnyNN = NoteNode | NoteNodeLike<NodeType.HEAD> | NoteNodeLike<NodeType.TAIL>;
+    export class NoteNodeLike<T extends NodeType> {
+        type: T;
+        next: NNOrTail;
+        _previous: WeakRef<NNOrHead> | null;
+        parentSeq: NNList;
+        get previous(): any;
+        set previous(val: any);
+        constructor(type: T);
+    }
+    export class NoteNode extends NoteNodeLike<NodeType.MIDDLE> {
+        totalNode: NNNode;
+        readonly startTime: TimeT;
+        /**
+         * The notes it contains.
+         * If they are holds, they are ordered by their endTime, from late to early.
+         */
+        readonly notes: Note[];
+        parentSeq: NNList;
+        chart: Chart;
+        private static count;
+        id: number;
+        constructor(time: TimeT);
+        static fromKPAJSON(data: NoteNodeDataKPA, timeCalculator: TimeCalculator): NoteNode;
+        get isHold(): boolean;
+        get endTime(): TimeT;
+        add(note: Note): void;
+        sort(note: Note): void;
+        /**
+         * 其他部分均已有序，通过冒泡排序把发生变更的NoteNode移动到正确的位置
+         * @param index 待排序的Note的索引
+         */
+        sort(index: number): void;
+        remove(note: Note): void;
+        static disconnect(note1: NNOrHead, note2: NNOrTail): void;
+        static connect(note1: NNOrHead, note2: NNOrTail): void;
+        static insert(note1: NNOrHead, inserted: NoteNode, note2: NNOrTail): void;
+        dump(): NoteNodeDataKPA;
+    }
+    export class NNList {
+        speed: number;
+        medianYOffset: number;
+        /** 格式为#xxoxx或$xxoxx，亦可自命名 */
+        id: string;
+        head: NoteNodeLike<NodeType.HEAD>;
+        tail: NoteNodeLike<NodeType.TAIL>;
+        currentPoint: NNOrHead;
+        /** 定位上个Note头已过，本身未到的Note */
+        jump: JumpArray<AnyNN>;
+        timesWithNotes: number;
+        timeRanges: [number, number][];
+        effectiveBeats: number;
+        parentLine: JudgeLine;
+        constructor(speed: number, medianYOffset?: number, effectiveBeats?: number);
+        /** 此方法永远用于最新KPAJSON */
+        static fromKPAJSON<T extends boolean>(isHold: T, effectiveBeats: number, data: NNListDataKPA, nnnList: NNNList, timeCalculator: TimeCalculator): T extends true ? HNList : NNList;
+        initJump(): void;
+        /**
+         *
+         * @param beats 目标位置
+         * @param beforeEnd 指定选取该时刻之前还是之后第一个Node，对于非Hold无影响
+         * @param pointer 指针，实现查询位置缓存
+         * @returns
+         */
+        getNodeAt(beats: number, beforeEnd?: boolean): NNOrTail;
+        /**
+         * Get or create a node of given time
+         * @param time
+         * @returns
+         */
+        getNodeOf(time: TimeT): NoteNode;
+        dumpKPA(): NNListDataKPA;
+        getNodesFromOneAndRangeRight(node: NoteNode, rangeRight: TimeT): NoteNode[];
+        getNodesAfterOne(node: NoteNode): NoteNode[];
+        clearEmptyNodes(updatesJump?: boolean): void;
+    }
+    /**
+     * HoldNode的链表
+     * HN is the abbreviation of HoldNode, which is not individually declared.
+     * A NN that contains holds (a type of note) is a HN.
+     */
+    export class HNList extends NNList {
+        /**
+         * 最早的还未结束Hold
+         */
+        holdTailJump: JumpArray<AnyNN>;
+        constructor(speed: number, medianYOffset: number, effectiveBeats?: number);
+        initJump(): void;
+        getNodeAt(beats: number, beforeEnd?: boolean): NNOrTail;
+        insertNoteJumpUpdater(note: NoteNode): () => void;
+    }
+    export type NNNOrHead = NNNode | NNNodeLike<NodeType.HEAD>;
+    export type NNNOrTail = NNNode | NNNodeLike<NodeType.TAIL>;
+    type AnyNNN = NNNode | NNNodeLike<NodeType.HEAD> | NNNodeLike<NodeType.TAIL>;
+    export class NNNodeLike<T extends NodeType> {
+        type: T;
+        previous: NNNOrHead;
+        next: NNNOrTail;
+        startTime: TimeT;
+        constructor(type: T);
+    }
+    export class NNNode extends NNNodeLike<NodeType.MIDDLE> {
+        readonly noteNodes: NoteNode[];
+        readonly holdNodes: NoteNode[];
+        readonly startTime: TimeT;
+        noteOfType: [number, number, number, number];
+        constructor(time: TimeT);
+        get endTime(): TimeT;
+        add(node: NoteNode): void;
+        static connect(note1: NNNOrHead, note2: NNNOrTail): void;
+        static insert(note1: NNNOrHead, inserted: NNNode, note2: NNNOrTail): void;
+    }
+    /**
+     * 二级音符节点链表
+     * contains NNNs
+     * NNN is the abbreviation of NoteNodeNode, which store note (an element in music game) nodes with same startTime
+     * NN is the abbreviation of NoteNode, which stores the notes with the same startTime.
+     */
+    export class NNNList {
+        jump: JumpArray<AnyNNN>;
+        parentChart: Chart;
+        head: NNNodeLike<NodeType.HEAD>;
+        tail: NNNodeLike<NodeType.TAIL>;
+        effectiveBeats: number;
+        timesWithNotes: number;
+        constructor(effectiveBeats: number);
+        initJump(): void;
+        getNodeAt(beats: number, beforeEnd?: boolean): NNNode | NNNodeLike<NodeType.TAIL>;
+        getNode(time: TimeT): NNNode;
+        addNoteNode(noteNode: NoteNode): void;
+    }
+}
+declare module "judgeline" {
+    import type { Chart, JudgeLineGroup } from "chart";
+    import { JudgeLineDataKPA2, type JudgeLineDataKPA, type JudgeLineDataRPE, type NNListDataKPA, type RGB } from "chartTypes";
+    import type { TemplateEasingLib } from "easing";
+    import { EventNodeSequence, SpeedENS } from "event";
+    import { HNList, NNList, Note, NNNList } from "note";
+    import { type TimeCalculator } from "bpm";
+    export interface EventLayer {
+        moveX?: EventNodeSequence;
+        moveY?: EventNodeSequence;
+        rotate?: EventNodeSequence;
+        alpha?: EventNodeSequence;
+    }
+    export interface ExtendedLayer {
+        scaleX?: EventNodeSequence;
+        scaleY?: EventNodeSequence;
+        text?: EventNodeSequence<string>;
+        color?: EventNodeSequence<RGB>;
+    }
+    export class JudgeLine {
+        texture: string;
+        group: JudgeLineGroup;
+        cover: boolean;
+        hnLists: Map<string, HNList>;
+        nnLists: Map<string, NNList>;
+        eventLayers: EventLayer[];
+        speedSequence: SpeedENS;
+        extendedLayer: ExtendedLayer;
+        father: JudgeLine;
+        children: Set<JudgeLine>;
+        zOrder: number;
+        anchor: [number, number];
+        hasAttachUI: boolean;
+        /**
+         * 每帧渲染时所用的变换矩阵，缓存下来用于之后的UI绑定渲染
+         *
+         * 已移除，谱面NPM包不需要这个，播放器侧如要使用，可以用同名接口扩展此类
+         * @removed since 2.0.1
+         */
+        /**
+         * 是否随父线旋转
+         */
+        rotatesWithFather: boolean;
+        id: number;
+        name: string;
+        readonly chart: Chart;
+        constructor(chart: Chart);
+        static fromRPEJSON(chart: Chart, id: number, data: JudgeLineDataRPE, templates: TemplateEasingLib, timeCalculator: TimeCalculator): JudgeLine;
+        static fromKPAJSON(version: number, chart: Chart, id: number, data: JudgeLineDataKPA | JudgeLineDataKPA2, templates: TemplateEasingLib, timeCalculator: TimeCalculator): JudgeLine;
+        getNNListFromOldKPAJSON(lists: Map<string, NNList>, namePrefix: string, isHold: boolean, effectiveBeats: number, listData: NNListDataKPA, nnnList: NNNList, timeCalculator: TimeCalculator): void;
+        getLayer(index: "0" | "1" | "2" | "3" | "ex"): EventLayer | ExtendedLayer;
+        /**
+         * 判定线当前所在的FloorPosition
+         *
+         * 可以理解为：有一个假想的充满音符的瀑布流，判定线在其中或前进或后退
+         */
+        currentFloorPosition: number;
+        cachedFloorPositions: Float64Array;
+        computeCurrentFloorPosition(beats: number, timeCalculator: TimeCalculator): void;
+        getRelativeFloorPositionAt(beats: number, timeCalculator: TimeCalculator): number;
+        /**
+         * 通过速度序列的FloorPosition反解出一个时间范围。
+         *
+         * KPA内核代码中最大的一坨史山，没有之一。
+         *
+         * 谱面渲染时最耗时的函数
+         *
+         * startY and endY must not be negative
+         * @param beats
+         * @param timeCalculator
+         * @param startY
+         * @param endY
+         * @returns
+         * /
+        computeTimeRange(beats: number, timeCalculator: TimeCalculator , startY: number, endY: number): [number, number][] {
+            //return [[0, Infinity]]
+            //*
+            // 提取所有有变化的时间点
+            let times: number[] = [];
+            const result: [number, number][] = [];
+            for (const eventLayer of this.eventLayers) {
+                const sequence = eventLayer?.speed;
+                if (!sequence) {
+                    continue;
+                }
+                let node: EventStartNode = sequence.getNodeAt(beats);
+                let endNode: EventEndNode | EventNodeLike<NodeType.TAIL>
+                while (true) {
+                    times.push(TC.toBeats(node.time))
+                    if ((endNode = node.next).type === NodeType.TAIL) {
+                        break;
+                    }
+    
+                    node = endNode.next
+                }
+            }
+            times = [...new Set(times)].sort((a, b) => a - b)
+            const len = times.length;
+            let nextTime = times[0]
+            let nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator)
+            let nextSpeed = this.getStackedValue("speed", nextTime, true)
+            let range: [number, number] = [undefined, undefined];
+            // console.log(times)
+            const computeTime = (speed: number, currentPos: number, fore: number) => timeCalculator.secondsToBeats(currentPos / (speed * 120) + timeCalculator.toSeconds(fore));
+            for (let i = 0; i < len - 1;) {
+                const thisTime = nextTime;
+                const thisPosY = nextPosY;
+                let thisSpeed = this.getStackedValue("speed", thisTime);
+                if (Math.abs(thisSpeed) < 1e-8) {
+                    thisSpeed = 0; // 不这样做可能导致下面异号判断为真从而死循环
+                }
+                nextTime = times[i + 1]
+                nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator);
+                nextSpeed = this.getStackedValue("speed", nextTime, true)
+                // console.log(thisSpeed, nextSpeed, thisSpeed * nextSpeed < 0, i, [...result])
+                if (thisSpeed * nextSpeed < 0) { // 有变号零点，再次切断，保证处理的每个区间单调性
+                    //debugger;
+                    nextTime = (nextTime - thisTime) * (0 - thisSpeed) / (nextSpeed - thisSpeed) + thisTime;
+                    nextSpeed = 0
+                    nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator)
+                    //debugger
+                } else {
+                    // console.log("i++")
+                    i++
+                }
+                if (range[0] === undefined) {
+                    // 变速区间直接全部囊括，匀速要算一下，因为好算
+                    /*
+                    设两个时间点的位置为a,b
+                    开始结束点为s,e
+                    选中小段一部分在区间内：
+                    a < s <= b
+                    或a > e >= b
+                    全部在区间内
+                    s <= a <= b
+                    * /
+                    if (thisPosY < startY && startY <= nextPosY
+                    || thisPosY > endY && endY >= nextPosY) {
+                        range[0] = thisSpeed !== nextSpeed ? thisTime : computeTime(
+                            thisSpeed,
+                            (thisPosY < nextPosY ? startY : endY) - thisPosY, thisTime)
+                    } else if (startY <= thisPosY && thisPosY <= endY) {
+                        range[0] = thisTime;
+                    }
+                }
+                // 要注意这里不能合成双分支if因为想要的Y片段可能在一个区间内
+                if (range[0] !== undefined) {
+                    if (thisPosY < endY && endY <= nextPosY || thisPosY > startY && startY >= nextPosY) {
+                        range[1] = thisSpeed !== nextSpeed ? nextTime : computeTime(
+                            thisSpeed,
+                            (thisPosY > nextPosY ? startY : endY) - thisPosY, thisTime)
+                        result.push(range)
+                        range = [undefined, undefined];
+                    }
+                }
+            }
+            const thisPosY = nextPosY;
+            const thisTime = nextTime;
+            const thisSpeed = this.getStackedValue("speed", thisTime);
+            const inf = thisSpeed > 0 ? Infinity : (thisSpeed < 0 ? -Infinity : thisPosY)
+            if (range[0] === undefined) {
+                // 变速区间直接全部囊括，匀速要算一下，因为好算
+                if (thisPosY < startY && startY <= inf || thisPosY >= endY && endY > inf) {
+                    range[0] = computeTime(
+                        thisSpeed,
+                        (thisPosY < inf ? startY : endY) - thisPosY,
+                        thisTime)
+                } else if (thisSpeed === 0) {
+                    range[0] = 0;
+                }
+            }
+            // 要注意这里不能合成双分支if因为想要的Y片段可能在一个区间内
+            if (range[0] !== undefined) {
+                if (thisPosY < endY && endY <= inf || thisPosY >= startY && startY > inf) {
+                    range[1] = computeTime(
+                        thisSpeed,
+                        (thisPosY > inf ? startY : endY) - thisPosY,
+                        thisTime)
+                    result.push(range)
+                } else if (thisSpeed === 0) {
+                    range[1] = Infinity;
+                    result.push(range)
+                }
+            }
+            return result;
+            //* /
+        }*/
+        /**
+          * 通过速度序列的FloorPosition反解出一个时间范围。
+          *
+          * KPA内核代码中最大的一坨史山，没有之一。
+          *
+          * 谜面渲染时最耗时的函数
+          *
+          * 调用此方法前需要先更新判定线当前的FP。
+          *
+          * startY and endY must not be negative
+          * @param beats
+          * @param timeCalculator
+          * @param startY
+          * @param endY
+          * @returns
+          */
+        computeTimeRange(beats: number, timeCalculator: TimeCalculator, startY: number, endY: number): [number, number][];
+        /**
+         *
+         * @deprecated 1.7.0
+         * @param beats
+         * @param usePrev 如果取到节点，将使用EndNode的值。默认为FALSE
+         * @returns
+         */
+        getValues(beats: number, usePrev?: boolean): [x: number, y: number, theta: number, alpha: number];
+        getStackedValue(type: keyof EventLayer, beats: number, usePrev?: boolean): number;
+        /**
+         * 获取指定时间点的FloorPosition。
+         *
+         * <del>为了向后兼容，保留了多层速度事件的机制。</del>
+         *
+         * 已经删除了多层速度事件
+         * @param beats
+         * @param timeCalculator
+         * @returns
+         * /
+        getStackedFloorPosition(beats: number, timeCalculator: TimeCalculator) {
+            
+            const length = this.eventLayers.length;
+            let current = 0;
+            for (let index = 0; index < length; index++) {
+                const layer = this.eventLayers[index];
+                if (!layer || !layer.speed) {
+                    break;
+                }
+                current += layer.speed.getFloorPositionAt(beats, timeCalculator);
+            }
+            // console.log("integral", current)
+            return current;
+        }//*/
+        /**
+         * 获取对应速度和类型的Note树,没有则创建
+         */
+        getNNList(speed: number, yOffset: number, isHold: boolean, initsJump: boolean): any;
+        getNode(note: Note, initsJump: boolean): any;
+        /**
+         *
+         * @param eventNodeSequences To Collect the sequences used in this line
+         * @returns
+         */
+        dumpKPA(eventNodeSequences: Set<EventNodeSequence<any>>, judgeLineGroups: JudgeLineGroup[]): JudgeLineDataKPA2;
+        updateEffectiveBeats(EB: number): void;
+        static checkinterdependency(judgeLine: JudgeLine, toBeFather: JudgeLine): boolean;
+    }
+}
+declare module "macro" {
+    import type { Chart } from "chart";
+    import type { EventValueESType, MacroData, MacroEvaluatorBodyData, MacroLink, MacroTimeBodyData, MacroValueBodyData, RGB, TimeT } from "chartTypes";
+    import { ERROR_IDS, KPAError } from "env";
+    import { MacroEvaluator } from "evaluator";
+    import type { EventNode, EventStartNode } from "event";
+    import { Note } from "note";
+    export const EVENT_MACROS: {
+        "line.id": (node: EventStartNode<EventValueESType>, chart: Chart) => number;
+        "line.name": (node: EventStartNode<EventValueESType>, chart: Chart) => string;
+        "line.group": (node: EventStartNode<EventValueESType>, chart: Chart) => import("chart").JudgeLineGroup;
+        "node.time": (node: EventStartNode<EventValueESType>) => TimeT;
+        "node.value": (node: EventStartNode<EventValueESType>) => EventValueESType;
+        "seq.id": (node: EventStartNode<EventValueESType>) => string;
+        "seq.type": (node: EventStartNode<EventValueESType>) => import("chartTypes").EventType;
+    };
+    export type Macroable = number | string | TimeT | RGB | boolean;
+    export type Macroee = EventNode<EventValueESType> | Note;
+    export abstract class Macro<T extends Macroable, C extends Macroee, P extends Macroee> {
+        macro: string;
+        id: string;
+        readonly parametric: boolean;
+        readonly consumers: Map<C, number>;
+        /**
+         * **原形节点**
+         *
+         * 作为参数，向其他节点派生数值。
+         *
+         * 需要parametric为true。
+         *
+         * 如：若节点A存在于这个数组，下标为1：
+         *
+         * 节点B设有数值宏，即这个宏，宏表达式： @proto.value + 2。
+         *
+         * 那么评估B的宏时可以调用节点A的数值。
+         *
+         * 在转储时，是节点存储宏的ID，而不是宏去找节点，因为节点并没有全谱面编号系统。
+         */
+        readonly protoNodes: P[];
+        /**
+         *
+         * @param macro
+         * @param id
+         * @param parametric 是否为参数宏，即是否可以把一个节点作为参数。
+         */
+        constructor(macro: string, id: string, parametric: boolean);
+        abstract eval(consumer: C, chart: Chart): T;
+    }
+    export abstract class EventMacro<T extends Macroable> extends Macro<T, EventNode<EventValueESType>, EventNode<EventValueESType>> {
+        eval(node: EventNode<EventValueESType>, chart: Chart): T;
+        checkSyntax(): KPAError<ERROR_IDS.PROTO_PRESENT_IN_NONPARAMETRIC | ERROR_IDS.UNKNOWN_MACRO_EXPRESSION | ERROR_IDS.JAVASCRIPT_SYNTAX_ERROR> | null;
+        bindNode(node: EventNode<EventValueESType>, macroData: MacroData, pos?: string): void;
+        linkProtoNode(node: EventNode<EventValueESType>, id: number): void;
+        dumpContent(): MacroValueBodyData;
+        /**
+         * 为单个节点导出宏名称和参数（若有）
+         * @param node
+         * @example
+         * return {
+         *     start: node.value,
+         *     end: node.next.value,
+         *     macroStart: node.valueMacro.dumpForNode(node),
+         *     macroEnd: node.valueMacro.dumpForNode(node.next),
+         *     ...
+         * } satisfies EvenDataKPA2
+         *
+         */
+        dumpForNode(node: EventNode<EventValueESType>): MacroData;
+        abstract dumpLinkForNode(node: EventNode<EventValueESType>): MacroLink;
+    }
+    export class EventMacroValue extends EventMacro<EventValueESType> {
+        dumpLinkForNode(node: EventNode<EventValueESType>): MacroLink;
+    }
+    export class EventMacroTime extends EventMacro<TimeT> {
+        dumpLinkForNode(node: EventNode<EventValueESType>): MacroLink;
+    }
+    export class MacroLib {
+        timeMacros: Map<string, EventMacroTime>;
+        valueMacros: Map<string, EventMacroValue>;
+        macroEvaluators: Map<string, MacroEvaluator<EventValueESType>>;
+        dumpTimeMacros(): MacroTimeBodyData[];
+        readTimeMacros(data: MacroTimeBodyData[]): void;
+        dumpValueMacros(): MacroValueBodyData[];
+        readValueMacros(data: MacroValueBodyData[]): void;
+        dumpMacroEvaluators(): MacroEvaluatorBodyData[];
+        readMacroEvaluators(data: MacroEvaluatorBodyData[]): void;
+    }
+}
+declare module "evaluator" {
+    import { Easing } from "easing";
+    import type { EventStartNode, NonLastStartNode } from "event";
+    import { EventValueTypeOfType, InterpreteAs, MacroEvaluatorBodyData, MacroEvaluatorDataKPA2, type ColorEasedEvaluatorKPA2, type EvaluatorDataKPA2, type EventValueESType, type ExpressionEvaluatorDataKPA2, type NumericEasedEvaluatorKPA2, type RGB, type TextEasedEvaluatorKPA2 } from "chartTypes";
+    import { Chart } from "chart";
+    /**
+     * **求值器**
+     *
+     * 基于给定的事件和拍数，返回事件在此点的值。
+     *
+     * 被求值的事件必须是拥有下一个节点的事件。序列尾部的节点（与尾节点相连的节点）不能被求值。
+     * @immutable
+     * @since 2.0.0
+     */
+    export abstract class Evaluator<T extends EventValueESType> {
+        abstract eval(event: NonLastStartNode<T>, beats: number): T;
+        abstract dumpFor(node: EventStartNode<T>): EvaluatorDataKPA2<T>;
+    }
+    export abstract class EasedEvaluator<T extends EventValueESType> extends Evaluator<T> {
+        readonly easing: Easing;
+        constructor(easing: Easing);
+        eval(startNode: NonLastStartNode<T>, beats: number): T;
+        abstract convert(start: T, end: T, progress: number): T;
+        /**
+         * 派生一个类型相同但使用不同缓动的求值器
+         * @param easing
+         * @returns
+         */
+        abstract deriveWithEasing(easing: Easing): EasedEvaluator<T>;
+        static getEvaluatorFromEasing<T extends EventValueESType>(type: EventValueTypeOfType<T>, easing: Easing, interpretedAs?: InterpreteAs): EasedEvaluatorOfType<T>;
+    }
+    export type EasedEvaluatorOfType<T extends EventValueESType> = T extends number ? NumericEasedEvaluator : T extends RGB ? ColorEasedEvaluator : TextEasedEvaluator;
+    export type EasedEvaluatorConstructorOfType<T extends EventValueESType> = T extends number ? typeof NumericEasedEvaluator : T extends RGB ? typeof ColorEasedEvaluator : typeof TextEasedEvaluator;
+    export class NumericEasedEvaluator extends EasedEvaluator<number> {
+        constructor(easing: Easing);
+        private cache?;
+        dumpFor(): NumericEasedEvaluatorKPA2;
+        convert(start: number, end: number, progress: number): number;
+        static default: NumericEasedEvaluator;
+        static evaluatorsOfNormalEasing: NumericEasedEvaluator[];
+        deriveWithEasing(easing: Easing): NumericEasedEvaluator;
+    }
+    export class ColorEasedEvaluator extends EasedEvaluator<RGB> {
+        constructor(easing: Easing);
+        dumpFor(): ColorEasedEvaluatorKPA2;
+        convert(start: RGB, end: RGB, progress: number): RGB;
+        static default: ColorEasedEvaluator;
+        static evaluatorsOfNormalEasing: ColorEasedEvaluator[];
+        deriveWithEasing(easing: Easing): ColorEasedEvaluator;
+    }
+    /**
+     * 文本缓动求值器
+     *
+     * 文本缓动求值器可以将文本解读为字符串、浮点数和整形。
+     *
+     * 行为与RPE的`%P%`相似
+     */
+    export class TextEasedEvaluator extends EasedEvaluator<string> {
+        readonly interpretedAs: InterpreteAs;
+        constructor(easing: Easing, interpretedAs?: InterpreteAs);
+        dumpFor(): TextEasedEvaluatorKPA2;
+        convert(value: string, nextValue: string, progress: number): string;
+        static default: TextEasedEvaluator;
+        static evaluatorsOfNoEzAndItpAs: TextEasedEvaluator[][];
+        deriveWithEasing(easing: Easing): EasedEvaluator<string>;
+    }
+    export class MacroEvaluator<T extends EventValueESType> extends Evaluator<T> {
+        expression: string;
+        id: string;
+        readonly consumers: Map<EventStartNode<T>, ExpressionEvaluator<T>>;
+        constructor(expression: string, id: string);
+        compile(node: EventStartNode<T>, chart: Chart): ExpressionEvaluator<T>;
+        assignTo(node: EventStartNode<T>, chart: Chart): void;
+        eval(event: NonLastStartNode<T>, beats: number): T;
+        dumpFor(node: EventStartNode<T>): MacroEvaluatorDataKPA2;
+        dumpContent(): MacroEvaluatorBodyData;
+    }
+    export class ExpressionEvaluator<T extends EventValueESType> extends Evaluator<T> {
+        readonly jsExpr: string;
+        readonly func: (t: number) => T;
+        constructor(jsExpr: string);
+        eval(startNode: NonLastStartNode<T>, beats: number): T;
+        dumpFor(): ExpressionEvaluatorDataKPA2;
+    }
+}
+declare module "easing" {
+    import { type TemplateEasingBodyData, type EasingDataKPA2, EventType, type SegmentedEasingData, type NormalEasingData, type BezierEasingData, type TemplateEasingData, WrapperEasingData, WrapperEasingBodyData } from "chartTypes";
+    import { type EventNodeSequence } from "event";
+    import { type TupleCoord } from "util";
+    import { type ExpressionEvaluator } from "evaluator";
+    export const easingFns: {
+        linear: (x: number) => number;
+        easeInSine: (x: number) => number;
+        easeOutSine: (x: number) => number;
+        easeInOutSine: (x: number) => number;
+        easeInQuad: (x: number) => number;
+        easeOutQuad: (x: number) => number;
+        easeInOutQuad: (x: number) => number;
+        easeInCubic: (x: number) => number;
+        easeOutCubic: (x: number) => number;
+        easeInOutCubic: (x: number) => number;
+        easeInQuart: (x: number) => number;
+        easeOutQuart: (x: number) => number;
+        easeInOutQuart: (x: number) => number;
+        easeInQuint: (x: number) => number;
+        easeOutQuint: (x: number) => number;
+        easeInOutQuint: (x: number) => number;
+        easeInExpo: (x: number) => number;
+        easeOutExpo: (x: number) => number;
+        easeInOutExpo: (x: number) => number;
+        easeInCirc: (x: number) => number;
+        easeOutCirc: (x: number) => number;
+        easeInOutCirc: (x: number) => number;
+        easeInBack: (x: number) => number;
+        easeOutBack: (x: number) => number;
+        easeInOutBack: (x: number) => number;
+        easeInElastic: (x: number) => number;
+        easeOutElastic: (x: number) => number;
+        easeInOutElastic: (x: number) => number;
+        easeInBounce: (x: number) => number;
+        easeOutBounce: (x: number) => number;
+        easeInOutBounce: (x: number) => number;
+    };
+    type FuncType = "linear" | "sine" | "quad" | "cubic" | "quart" | "quint" | "expo" | "circ" | "back" | "elastic" | "bounce";
+    export const easingFnMap: {
+        [k in FuncType]: [(x: number) => number, (x: number) => number, (x: number) => number];
+    };
+    /**
+     * 缓动基类
+     * Easings are used to describe the rate of change of a parameter over time.
+     * They are used in events, curve note filling, etc.
+     */
+    export abstract class Easing {
+        constructor();
+        /**
+         * 返回当前变化量与变化量之比
+         * 或者当前数值。（参数方程）
+         * @param t 一个0-1的浮点数，代表当前经过时间与总时间之比
+         */
+        abstract getValue(t: number): number;
+        abstract dump(): EasingDataKPA2;
+        segmentedValueGetter(easingLeft: number, easingRight: number): (t: number) => number;
+    }
+    /**
+     * @immutable
+     */
+    export class SegmentedEasing extends Easing {
+        readonly easing: Easing;
+        readonly left: number;
+        readonly right: number;
+        getter: (t: number) => number;
+        constructor(easing: Easing, left: number, right: number);
+        getValue(t: number): number;
+        replace(easing: Easing): Easing;
+        dump(): SegmentedEasingData;
+    }
+    /**
+     * 普通缓动
+     * See https://easings.net/zh-cn to learn about the basic types of easing.
+     *
+     */
+    export class NormalEasing extends Easing {
+        rpeId: number;
+        id: number;
+        funcType: string;
+        easeType: string;
+        _getValue: (t: number) => number;
+        constructor(fn: (t: number) => number);
+        constructor(fn: (t: number) => number);
+        getValue(t: number): number;
+        private dumpCache;
+        dump(): NormalEasingData;
+    }
+    /**
+     * 贝塞尔曲线缓动
+     * uses the Bezier curve formula to describe an easing.
+     */
+    export class BezierEasing extends Easing {
+        readonly cp1: TupleCoord;
+        readonly cp2: TupleCoord;
+        readonly xs: Float64Array;
+        readonly ys: Float64Array;
+        readonly jumper: Uint8Array;
+        constructor(cp1: TupleCoord, cp2: TupleCoord);
+        /**
+         * 从横坐标获得纵坐标
+         * @param t 并不是贝塞尔曲线的参数，它对应一个横坐标数值，范围[0, 1]
+         * @returns
+         */
+        getValue(t: number): number;
+        dump(): BezierEasingData;
+    }
+    /**
+     * 模板缓动
+     * to implement an easing with an eventNodeSequence.
+     * 这是受wikitext的模板概念启发的。
+     * This is inspired by the "template" concept in wikitext.
+     */
+    export class TemplateEasing extends Easing {
+        eventNodeSequence: EventNodeSequence;
+        name: string;
+        constructor(name: string, sequence: EventNodeSequence);
+        getValue(t: number): number;
+        dump(): TemplateEasingData;
+        get valueDelta(): number;
+        get headValue(): number;
+    }
+    export class WrapperEasing extends Easing {
+        evaluator: ExpressionEvaluator<number>;
+        start: number;
+        end: number;
+        name: string;
+        constructor(evaluator: ExpressionEvaluator<number>, start: number, end: number, name: string);
+        getValue(t: number): number;
+        dump(): WrapperEasingData;
+    }
+    /**
+     * 缓动库
+     * 用于管理模板缓动
+     * for template easing management
+     *
+     * 谱面的一个属性
+     * a property of chart
+     *
+     * 加载谱面时，先加载事件序列，所需的模板缓动会被加入到缓动库，但并不立即实现，在读取模板缓动时，才实现缓动。
+     * To load a chart, the eventNodeSquences will be first loaded, during which process
+     * the easings will be added to the easing library but not implemented immediately.
+     * They will be implemented when the template easings are read from data.
+     *
+     */
+    export class TemplateEasingLib {
+        getNewSequence: (type: EventType, effectiveBeats: number) => EventNodeSequence<number>;
+        ExpressionEvaluatorCon: typeof ExpressionEvaluator;
+        easings: Map<string, TemplateEasing>;
+        wrapperEasings: Map<string, WrapperEasing>;
+        constructor(getNewSequence: (type: EventType, effectiveBeats: number) => EventNodeSequence<number>, ExpressionEvaluatorCon: typeof ExpressionEvaluator);
+        getOrNew(name: string): TemplateEasing;
+        readWrapperEasings(data: WrapperEasingBodyData[]): void;
+        getWrapper(name: string): WrapperEasing;
+        /**
+         * 注册一个模板缓动，但不会实现它
+         * register a template easing when reading eventNodeSequences, but does not implement it immediately
+         */
+        require(name: string): void;
+        implement(name: string, sequence: EventNodeSequence): void;
+        /**
+         * 检查所有模板缓动是否实现
+         * check if all easings are implemented
+         * 应当在读取完所有模板缓动后调用
+         * should be invoked after all template easings are read
+         */
+        check(): void;
+        get(key: string): TemplateEasing | undefined;
+        dump(eventNodeSequences: Set<EventNodeSequence>): TemplateEasingBodyData[];
+        dumpWrapperEasings(): WrapperEasingBodyData[];
+    }
+    export const linearEasing: NormalEasing;
+    export const fixedEasing: NormalEasing;
+    export const easingMap: {
+        fixed: {
+            out: NormalEasing;
+            in: NormalEasing;
+            inout: NormalEasing;
+        };
+        linear: {
+            out: NormalEasing;
+            in: NormalEasing;
+            inout: NormalEasing;
+        };
+        sine: {
+            in: NormalEasing;
+            out: NormalEasing;
+            inout: NormalEasing;
+        };
+        quad: {
+            in: NormalEasing;
+            out: NormalEasing;
+            inout: NormalEasing;
+        };
+        cubic: {
+            in: NormalEasing;
+            out: NormalEasing;
+            inout: NormalEasing;
+        };
+        quart: {
+            in: NormalEasing;
+            out: NormalEasing;
+            inout: NormalEasing;
+        };
+        quint: {
+            in: NormalEasing;
+            out: NormalEasing;
+            inout: NormalEasing;
+        };
+        expo: {
+            in: NormalEasing;
+            out: NormalEasing;
+            inout: NormalEasing;
+        };
+        circ: {
+            in: NormalEasing;
+            out: NormalEasing;
+            inout: NormalEasing;
+        };
+        back: {
+            in: NormalEasing;
+            out: NormalEasing;
+            inout: NormalEasing;
+        };
+        elastic: {
+            in: NormalEasing;
+            out: NormalEasing;
+            inout: NormalEasing;
+        };
+        bounce: {
+            in: NormalEasing;
+            out: NormalEasing;
+            inout: NormalEasing;
+        };
+    };
+    /**
+     * 按照KPA的编号
+     */
+    export const easingArray: NormalEasing[];
+    export const rpeEasingArray: NormalEasing[];
+}
+declare module "chart" {
+    import { TimeCalculator } from "bpm";
+    import { Easing, TemplateEasingLib } from "easing";
+    import { EventNodeSequence, EventStartNode, EventEndNode, EventNode } from "event";
+    import { JudgeLine } from "judgeline";
+    import { NNNList, NNNode } from "note";
+    import { type TimeT, type ValueTypeOfEventType, type BPMSegmentData, type ChartDataRPE, type ChartDataKPA, type EasingDataKPA2, type EvaluatorDataKPA2, type EasedEvaluatorDataOfType, EventType, type EventValueTypeOfType, type EventValueESType, type ExpressionEvaluatorDataKPA2, type ChartDataKPA2, type EventDataKPA2, InterpreteAs, MacroEvaluatorDataKPA2, FinalEventStartNodeDataKPA2, MacroData, MacroLink } from "chartTypes";
+    import { ExpressionEvaluator, type EasedEvaluatorOfType } from "evaluator";
+    import { MacroLib } from "macro";
+    export type BasicEventName = "moveX" | "moveY" | "rotate" | "alpha" | "speed";
+    export type UIName = "combo" | "combonumber" | "score" | "pause" | "bar" | "name" | "level";
+    /**
+     * 表示一张谱面的核心数据结构
+     *
+     * 包含了谱面的所有元素：判定线、音符、事件序列等信息
+     */
+    export class Chart {
+        /** 谱面中所有的判定线列表 */
+        judgeLines: JudgeLine[];
+        /** 时间计算器，用于处理BPM变化和时间转换 */
+        readonly timeCalculator: TimeCalculator;
+        /** 无父级的根判定线列表 */
+        orphanLines: JudgeLine[];
+        /** 谱面名称 */
+        name: string;
+        /** 谱面难度等级 */
+        level: string;
+        /** 曲师信息 */
+        composer: string;
+        /** 谱师信息 */
+        charter: string;
+        /** 插画师信息 */
+        illustrator: string;
+        /** 谱面偏移时间（秒） */
+        offset: number;
+        /** 模板缓动库，用于管理和复用缓动函数 */
+        readonly templateEasingLib: TemplateEasingLib;
+        readonly macroLib: MacroLib;
+        /** 事件序列映射表，通过ID索引事件序列 */
+        readonly sequenceMap: Map<string, EventNodeSequence<EventValueESType>>;
+        /** 有效节拍数（基于谱面持续时间计算得出） */
+        effectiveBeats: number;
+        /** 音符节点列表，用于管理谱面上的所有音符 */
+        nnnList: NNNList;
+        /** 判定线组列表，用于组织和分类判定线 */
+        judgeLineGroups: JudgeLineGroup[];
+        /** 谱面持续时间（秒） */
+        duration: number;
+        /** 谱面制作所用时间（以秒计） */
+        chartingSeconds: number;
+        /** RPE格式的谱面制作时间（以秒计） */
+        rpeChartingSeconds: number;
+        /** 标记谱面是否已被修改 */
+        modified: boolean;
+        /** 谱面最大连击数 */
+        maxCombo: number;
+        /** 暂停按钮绑定的判定线 */
+        pauseAttach: JudgeLine | null;
+        /** 连击数字绑定的判定线 */
+        combonumberAttach: JudgeLine | null;
+        /** 连击标识绑定的判定线 */
+        comboAttach: JudgeLine | null;
+        /** 进度条绑定的判定线 */
+        barAttach: JudgeLine | null;
+        /** 分数显示绑定的判定线 */
+        scoreAttach: JudgeLine | null;
+        /** 歌曲名称显示绑定的判定线 */
+        nameAttach: JudgeLine | null;
+        /** 难度等级显示绑定的判定线 */
+        levelAttach: JudgeLine | null;
+        constructor();
+        /**
+         * 获取有效节拍数
+         * @returns 基于谱面持续时间计算的有效节拍数
+         */
+        getEffectiveBeats(): number;
+        /**
+         * 从RPE格式的JSON数据创建谱面对象
+         * @param data RPE格式的谱面数据
+         * @param duration 谱面持续时间（秒）
+         * @returns 创建的Chart对象
+         */
+        static fromRPEJSON(data: ChartDataRPE, duration: number): Chart;
+        /**
+         * 从KPA格式的JSON数据创建谱面对象
+         * @param data KPA格式的谱面数据
+         * @returns 创建的Chart对象
+         */
+        static fromKPAJSON(data: ChartDataKPA | ChartDataKPA2): Chart;
+        /**
+         * 初始化时间计算器
+         * @param bpmList BPM变化列表
+         */
+        initCalculator(bpmList: BPMSegmentData[]): void;
+        /**
+         * 更新有效节拍数
+         * @param duration 新的持续时间
+         */
+        updateEffectiveBeats(duration: number): void;
+        /**
+         * 导出为KPA格式数据
+         * @returns KPA格式的谱面数据对象
+         */
+        dumpKPA(): Required<ChartDataKPA2>;
+        /**
+         * 创建一个新的二级音符节点
+         * @param time 节点时间
+         * @returns 新创建的NNNode对象
+         */
+        createNNNode(time: TimeT): NNNode;
+        /**
+         * 创建一个新的事件节点序列
+         * @param type 事件类型
+         * @param name 序列名称（ID）
+         * @returns 新创建的事件节点序列
+         * @throws {KPAError<ERROR_IDS.SEQUENCE_NAME_OCCUPIED>}
+         */
+        createEventNodeSequence<T extends EventType>(type: T, name: string): EventNodeSequence<ValueTypeOfEventType<T>>;
+        registerEventNodeSequence<T extends EventType>(type: T, name: string, seq: EventNodeSequence<T>): void;
+        /**
+         * 对谱面物量进行重新计数。
+         *
+         * 不会返回值，谱面物量存储在 `this.maxCombo` 中。
+         */
+        countMaxCombo(): void;
+        /**
+         * 将UI绑定到某判定线
+         * @param ui UI名称，与RPEJSON中的代号相同
+         * @param judgeLine 所要绑定的目标判定线
+         * @throws {KPAError<ERROR_IDS.UI_OCCUPIED>}
+         */
+        attachUIToLine(ui: UIName, judgeLine: JudgeLine): void;
+        /**
+         * 移除谱面中某个UI的绑定，使UI进入未绑定状态
+         * @param ui UI名称，与RPEJSON中的相同
+         * @returns
+         */
+        detachUI(ui: UIName): void;
+        /**
+         * 查询指定判定线上绑定的UI组件
+         * @param judgeLine 目标判定线
+         * @returns 绑定到该判定线上的UI组件名称数组
+         */
+        queryJudgeLineUI(judgeLine: JudgeLine): UIName[];
+        /**
+         * 扫描所有用到的判定线贴图（纹理）并返回
+         *
+         * 给谱面播放器的接口，谱面播放器需要在初加载时提供贴图
+         * @returns 所有使用的纹理名称集合
+         */
+        scanAllTextures(): Set<string>;
+        /**
+         * 使用KPA2数据创建一个缓动对象。
+         *
+         * 只有对贝塞尔缓动和截段缓动才会创建新对象，其他几种缓动从缓动库等中的对象池获取
+         * @param data 缓动数据
+         * @returns 创建的缓动对象
+         */
+        createEasingFromData(data: EasingDataKPA2): any;
+        /**
+         * 使用KPA2数据创建一个求值器对象。
+         *
+         * 求值器只有缓动型和表达式型两类。
+         * @param data 求值器数据
+         * @param type 事件值类型
+         * @returns 创建的求值器对象
+         */
+        bindEvaluator<T extends EventValueESType>(node: EventStartNode<T>, data: EvaluatorDataKPA2<T>, type: EventValueTypeOfType<T>, pos: string): void;
+        /**
+         * 使用KPA2数据创建一个缓动求值器。
+         *
+         * 对于普通缓动，这些求值器是从对应类构造器的静态对象池属性中获取的。
+         * @param data 缓动求值器数据
+         * @param type 事件值类型
+         * @returns 创建的缓动求值器对象
+         */
+        createEasedEvaluator<T extends EventValueESType>(data: EasedEvaluatorDataOfType<T>, type: EventValueTypeOfType<T>): EasedEvaluatorOfType<T>;
+        /**
+         * 用一个缓动和事件类型获取一个缓动求值器
+         * @param easing 缓动对象
+         * @param type 事件值类型
+         * @param interpreteAs 文本解释方式
+         * @returns 对应类型的缓动求值器
+         */
+        getEasedEvaluator<T extends EventValueESType>(easing: Easing, type: EventValueTypeOfType<T>, interpreteAs?: InterpreteAs): EasedEvaluatorOfType<T>;
+        /**
+         * 根据JavaScript表达式创建表达式求值器
+         * @param data 表达式求值器数据
+         * @returns 创建的表达式求值器对象
+         */
+        createExpressionEvaluator<T extends EventValueESType>(data: ExpressionEvaluatorDataKPA2): ExpressionEvaluator<T>;
+        bindMacroEvaluator(node: EventStartNode<EventValueESType>, data: MacroEvaluatorDataKPA2, pos: string): void;
+        /**
+         * 使用KPA2JSON创建一对面对面节点
+         * @param data 事件数据
+         * @param type 事件值类型
+         * @returns 包含起始节点和结束节点的元组
+         */
+        createEventFromData<VT extends EventValueESType>(data: EventDataKPA2<VT>, type: EventValueTypeOfType<VT>, pos: string): [EventStartNode<VT>, EventEndNode<VT>];
+        createFinalEventStartNodeFromData<VT extends EventValueESType>(data: FinalEventStartNodeDataKPA2<VT>, type: EventValueTypeOfType<VT>, pos: string): EventStartNode<VT>;
+        bindTimeMacro(node: EventStartNode<any>, macroData: MacroData, pos: string): any;
+        bindValueMacro(node: EventNode<any>, macroData: MacroData, pos: string): any;
+        linkMacro(node: EventNode<EventValueESType>, linkData: MacroLink, pos: string): any;
+    }
+    /**
+     * 表示一组判定线的容器
+     *
+     * 用于组织和管理具有相同属性或用途的判定线集合
+     */
+    export class JudgeLineGroup {
+        name: string;
+        /**
+         * 该只读标记只是为了防止外部修改，内部可以修改
+         *
+         * 属于该组的判定线列表，按ID升序排列
+         */
+        judgeLines: readonly JudgeLine[];
+        /**
+         * 创建一个新的判定线组
+         * @param name 组名称
+         */
+        constructor(name: string);
+        /**
+         * 向判定线组添加一条判定线，并且保证其内部的判定线ID是升序排列的。
+         * @param judgeLine 要添加的判定线
+         * @returns
+         */
+        add(judgeLine: JudgeLine): void;
+        /**
+         * 从判定线组移除一条判定线
+         * @param judgeLine 要移除的判定线
+         */
+        remove(judgeLine: JudgeLine): void;
+        /**
+         * 检查该判定线组是否为默认组
+         * @returns 该判定线组是否为默认判定线组，默认的判断标准是：名称为 "Default"（大小写不敏感）
+         */
+        isDefault(): boolean;
+    }
+}
+declare module "event" {
+    import type { Chart } from "chart";
+    import { EventType, type TimeT, type EventDataKPA, type RGB, type EventDataRPELike, InterpreteAs, type ValueTypeOfEventType, type EventDataKPA2, type EventNodeSequenceDataKPA2, type EventValueESType, FinalEventStartNodeDataKPA2 } from "chartTypes";
+    import { TemplateEasingLib, Easing } from "easing";
+    import { type Evaluator } from "evaluator";
+    import { JumpArray } from "jumparray";
+    import { type TimeCalculator } from "bpm";
+    import { NodeType } from "util";
+    import { JudgeLine } from "judgeline";
+    import { EventMacro, EventMacroTime, EventMacroValue, Macroable } from "macro";
+    export class EventNodeLike<T extends NodeType, VT extends EventValueESType = number> {
+        type: T;
+        /** 后一个事件节点 */
+        next: [EventStartNode<VT>, null, ENOrTail<VT>][T] | null;
+        /** 前一个事件节点 */
+        previous: [null, EventStartNode<VT>, ENOrHead<VT>][T] | null;
+        parentSeq: EventNodeSequence<VT>;
+        constructor(type: T);
+    }
+    export type ENOrTail<VT extends EventValueESType = number> = EventNode<VT> | EventNodeLike<NodeType.TAIL, VT>;
+    export type ENOrHead<VT extends EventValueESType = number> = EventNode<VT> | EventNodeLike<NodeType.HEAD, VT>;
+    export type AnyEN<VT extends EventValueESType = number> = EventNode<VT> | EventNodeLike<NodeType.HEAD, VT> | EventNodeLike<NodeType.TAIL, VT>;
+    export type EvSoE<VT extends EventValueESType = number> = EventEndNode<VT> | EventStartNode<VT>;
+    /**
+     * 事件节点基类
+     * event node.
+     * 用于代表事件的开始和结束。（EventStartNode表开始，EventEndNode表结束）
+     * Used to represent the starts (EventStartNode) and ends (EventEndNode) of events.
+     * 事件指的是判定线在某个时间段上的状态变化。
+     * Events is the changing of judge line's state in a certain time.
+     * 五种事件类型：移动X，移动Y，旋转，透明度，速度。
+     * 5 basic types of events: moveX, moveY, rotate, alpha, speed.
+     * 事件节点没有类型，类型由它所属的序列决定。
+     * Type is not event nodes' property; it is the property of EventNodeSequence.
+     * Events' type is determined by which sequence it belongs to.
+     * 与RPE不同的是，KPA使用两个节点来表示一个事件，而不是一个对象。
+     * Different from that in RPE, KPA uses two nodes rather than one object to represent an event.
+     */
+    export abstract class EventNode<VT extends EventValueESType = number> extends EventNodeLike<NodeType.MIDDLE, VT> {
+        time: TimeT;
+        value: VT;
+        evaluator: Evaluator<VT>;
+        macroValue: EventMacroValue;
+        linkedMacros: Set<EventMacro<Macroable>>;
+        constructor(time: TimeT, value: VT);
+        clone(offset: TimeT): EventStartNode<VT> | EventEndNode<VT>;
+        /**
+         *
+         * @param data
+         * @param templates
+         * @returns
+         * @deprecated
+         */
+        static getEasing(data: EventDataKPA<EventValueESType>, templates: TemplateEasingLib, notSegmented?: boolean): Easing;
+        /**
+         *
+         * @param data
+         * @param templates
+         * @returns
+         * @deprecated
+         */
+        static getEvaluator<VT extends EventValueESType>(data: EventDataKPA<VT>, templates: TemplateEasingLib, interpreteAs?: InterpreteAs): Evaluator<VT>;
+        /**
+         * constructs EventStartNode and EventEndNode from EventDataRPE
+         * @param data
+         * @param templates
+         * @returns
+         */
+        static fromEvent<VT extends RGB | number>(data: EventDataRPELike<VT>, chart: Chart): [EventStartNode<VT>, EventEndNode<VT>];
+        static fromTextEvent(data: EventDataRPELike<string>, templates: TemplateEasingLib): [EventStartNode<string>, EventEndNode<string>];
+        static connect<VT extends EventValueESType>(node1: EventStartNode<VT>, node2: EventEndNode<VT> | EventNodeLike<NodeType.TAIL, VT>): void;
+        static connect<VT extends EventValueESType>(node1: EventEndNode<VT> | EventNodeLike<NodeType.HEAD, VT>, node2: EventStartNode<VT>): void;
+        /**
+         *
+         * @param endNode
+         * @param startNode
+         * @returns 应该在何范围内更新跳数组
+         */
+        static removeNodePair<VT extends EventValueESType>(endNode: EventEndNode<VT>, startNode: EventStartNode<VT>): [EventStartNode<VT> | EventNodeLike<NodeType.HEAD, VT>, EventStartNode<VT> | EventNodeLike<NodeType.TAIL, VT>];
+        static insert<VT extends EventValueESType>(node: EventStartNode<VT>, tarPrev: EventStartNode<VT>): [EventNodeLike<NodeType.HEAD, VT> | EventStartNode<VT>, EventStartNode<VT> | EventNodeLike<NodeType.TAIL, VT>];
+        /**
+         *
+         * @param node
+         * @returns the next node if it is a tailer, otherwise the next start node
+         */
+        static nextStartOfStart<VT extends EventValueESType>(node: EventStartNode<VT>): EventStartNode<VT> | EventNodeLike<NodeType.TAIL, VT>;
+        /**
+         *
+         * @param node
+         * @returns itself if node is a tailer, otherwise the next start node
+         */
+        static nextStartOfEnd<VT extends EventValueESType>(node: EventEndNode<VT> | EventNodeLike<NodeType.TAIL, VT>): EventNodeLike<NodeType.TAIL, VT> | EventStartNode<VT>;
+        static previousStartOfStart<VT extends EventValueESType>(node: EventStartNode<VT>): EventStartNode<VT> | EventNodeLike<NodeType.HEAD, VT>;
+        /**
+         * It does not return the start node which form an event with it.
+         * @param node
+         * @returns
+         */
+        static secondPreviousStartOfEnd<VT extends EventValueESType>(node: EventEndNode<VT>): EventStartNode<VT> | EventNodeLike<NodeType.HEAD, VT>;
+        static nextStartInJumpArray<VT extends EventValueESType>(node: EventStartNode<VT>): EventStartNode<VT> | EventNodeLike<NodeType.TAIL, VT>;
+        /**
+         * 获得一对背靠背的节点。不适用于第一个StartNode
+         * @param node
+         * @returns
+         */
+        static getEndStart<VT extends EventValueESType>(node: EventStartNode<VT> | EventEndNode<VT>): [EventEndNode<VT>, EventStartNode<VT>];
+        static getStartEnd<VT extends EventValueESType>(node: EventStartNode<VT> | EventEndNode<VT>): [EventStartNode<VT>, EventEndNode<VT>];
+        static setToNewOrderedArray<VT extends EventValueESType>(dest: TimeT, set: Set<EventStartNode<VT>>): [EventStartNode<VT>[], EventStartNode<VT>[]];
+        static belongToSequence(nodes: Set<EventStartNode>, sequence: EventNodeSequence): boolean;
+        /**
+         * 检验这些节点对是不是连续的
+         * 如果不是不能封装为模板缓动
+         * @param nodes 有序开始节点数组，必须都是带结束节点的（背靠背）（第一个除外）
+         * @returns
+         */
+        static isContinuous(nodes: EventStartNode[]): boolean;
+    }
+    export class EventStartNode<VT extends EventValueESType = number> extends EventNode<VT> {
+        next: EventEndNode<VT> | EventNodeLike<NodeType.TAIL, VT>;
+        previous: EventEndNode<VT> | EventNodeLike<NodeType.HEAD, VT>;
+        macroTime: EventMacroTime | null;
+        /**
+         * 对于速度事件，从0时刻到此节点的总积分
+         */
+        floorPosition: number;
+        constructor(time: TimeT, value: VT);
+        parentSeq: EventNodeSequence<VT>;
+        /**
+         * 因为是RPE和KPA共用的方法所以easingType可以为字符串
+         * @returns
+         */
+        dump(): EventDataKPA2<VT>;
+        dumpAsFinal(): FinalEventStartNodeDataKPA2<VT>;
+        getValueAt(beats: number): VT;
+        getSpeedValueAt(this: EventStartNode<number>, beats: number): number;
+        /**
+         * 积分获取位移
+         */
+        getLocalFloorPos(this: EventStartNode<number>, beats: number, timeCalculator: TimeCalculator): number;
+        getFullLocalFloorPos(this: EventStartNode<number>, timeCalculator: TimeCalculator): number;
+        isFirstStart(): boolean;
+        isLastStart(): boolean;
+        isSpeed(): boolean;
+        clone(offset?: TimeT): EventStartNode<VT>;
+        clonePair(offset: TimeT): EventStartNode<VT>;
+    }
+    export type NonLastStartNode<VT extends EventValueESType> = EventStartNode<VT> & {
+        next: EventEndNode<VT>;
+    };
+    export class EventEndNode<VT extends EventValueESType = number> extends EventNode<VT> {
+        next: EventStartNode<VT>;
+        previous: EventStartNode<VT>;
+        get parentSeq(): EventNodeSequence<VT>;
+        set parentSeq(_parent: EventNodeSequence<VT>);
+        constructor(time: TimeT, value: VT);
+        getValueAt(beats: number): VT;
+        clone(offset?: TimeT): EventEndNode<VT>;
+    }
+    export enum Monotonicity {
+        increasing = 0,
+        decreasing = 1,
+        swinging = 2
+    }
+    /**
+     * 为一个链表结构。会有一个数组进行快跳。
+     * is the list of event nodes, but not purely start nodes.
+     *
+     * 结构如下：Header -> (StartNode -> [EndNode) -> (StartNode] -> [EndNode) -> ... -> StartNode] -> Tailer.
+     * The structure is like this: Header -> (StartNode -> [EndNode) -> (StartNode] -> [EndNode) -> ... -> StartNode] -> Tailer.
+     *
+     * 用括号标出的两个节点是一个事件，用方括号标出的两个节点是同一时间点的节点。
+     * The each 2 nodes marked by parentheses is an event; the each 2 nodes marked by brackets have the same time.
+     *
+     * 注意尾节点之前的节点不是一个结束节点，而是一个开始节点，其缓动无效。
+     * Note that the node before the tailer is not an end node, but a start node whose easing is meaningless.
+     *
+     * 就是说最后一个节点后取值，显然会取得这个节点的值，与缓动无关。
+     * (i. e. the value after the last event node is its value, not subject to easing, obviously.)
+     *
+     * 如果尾之前的节点是一个结束节点，那么取值会返回undefined，这是不期望的。
+     * If so, the value after that will be undefined, which is not expected.
+     * ("so" refers to the assumption that the node before the tailer is an end node)
+     *
+     * 和NNList和NNNList一样，有跳数组以加速随机读取。
+     * Like NNList and NNNList, it has a jump array to speed up random reading.
+     *
+     * 插入或删除节点时，需要更新跳数组。
+     * Remember to update the jump array when inserting or deleting nodes.
+     */
+    export class EventNodeSequence<VT extends EventValueESType = number> {
+        type: EventType;
+        effectiveBeats: number;
+        /**
+         * @deprecated 谱面属性未实装，以后有必要的时候会添加为其赋值的逻辑
+         */
+        chart: Chart;
+        /** 标识名默认遵循`#${lineid}.${layerid}.${typename}`格式
+         * id follows the format `#${lineid}.${layerid}.${typename}` by default
+         */
+        id: string;
+        head: EventNodeLike<NodeType.HEAD, VT>;
+        tail: EventNodeLike<NodeType.TAIL, VT>;
+        jump?: JumpArray<AnyEN<VT>>;
+        listLength: number;
+        /** 一定是二的幂，避免浮点误差 */
+        jumpAverageBeats: number;
+        /**
+         * 用于速度事件优化
+         */
+        monotonicity: Monotonicity;
+        /**
+         * 使用了该序列的判定线，当前仅用于速度事件对fp的更新
+         */
+        consumerLines: Set<JudgeLine>;
+        constructor(type: EventType, effectiveBeats: number);
+        /**
+         * 获取指定事件类型的事件默认值。
+         * Get the default value of the specified event type.
+         *
+         * 对于文字事件，默认值为空字符串。
+         *
+         * 对于缩放事件，默认值为1.0。
+         *
+         * 对于颜色事件，默认值为黑色（[0, 0, 0]）。
+         *
+         * 对于速度事件，默认值为10（1200像素/秒）。
+         *
+         * 对于一般数值事件，默认值为0。
+         */
+        static getDefaultValueFromEventType(type: EventType): number[] | 0 | "" | 1 | 10;
+        /**
+         * 从RPEJSON数据创建一个事件序列。
+         *
+         * KPAJSON 1.x也会使用此接口
+         * @param type 事件类型（不是数值类型，也不是数值ECMAScript类型）
+         * @param data 事件数据的数组
+         * @param chart
+         * @param pos 当前事件序列应当具有什么ID（用于报错和警告，外部调用可以写空字符串）
+         * @param endValue 结束值（RPEJSON没有）
+         * @returns
+         */
+        static fromRPEJSON<T extends EventType, VT extends EventValueESType = number>(type: T, data: EventDataRPELike<VT>[], chart: Chart, pos: string, endValue?: number): EventNodeSequence<VT>;
+        /**
+         * 从KPAJSON 2.x数据创建一个事件序列。
+         * @param type 事件类型（不是数值类型，也不是数值ECMAScript类型）
+         * @param data 事件数据的数组
+         * @param chart
+         * @param pos 当前事件序列应当具有什么ID（用于报错和警告）
+         * @param finalNodeData 最终节点数据
+         * @returns
+         */
+        static fromKPA2JSON<T extends EventType, VT extends EventValueESType = number>(type: T, data: EventDataKPA2<VT>[], chart: Chart, pos: string, finalNodeData: FinalEventStartNodeDataKPA2<VT>): EventNodeSequence<VT>;
+        /**
+         * 生成一个新的事件节点序列，仅拥有一个节点。
+         * 需要分配ID！！！！！！
+         * @param type
+         * @param effectiveBeats
+         * @returns
+         */
+        static newSeq<T extends EventType>(type: T, effectiveBeats: number): EventNodeSequence<ValueTypeOfEventType<T>>;
+        initJump(): void;
+        updateJump(from: ENOrHead<VT>, to: ENOrTail<VT>): void;
+        getNodeAt(beats: number, usePrev?: boolean): EventStartNode<VT>;
+        getValueAt(beats: number, usePrev?: boolean): VT;
+        getFloorPositionAt(this: EventNodeSequence<number>, beats: number, timeCalculator: TimeCalculator): number;
+        /**
+         * 更新某个速度节点之后的FP
+         *
+         * 注意，修改节点并不会影响它的FP，而是它后面的所有节点的FP，节点存的是它所在位置的FP，节点在事件头部
+         * @param this
+         * @param node
+         * @param tc
+         *
+         * @example
+         * node.value += 1;
+         * (node.parentSequence as SpeedENS).updateFloorPositionAfter(node, tc);
+         */
+        updateFloorPositionAfter(this: SpeedENS, node: EventStartNode, tc: TimeCalculator): void;
+        dump(): EventNodeSequenceDataKPA2<VT>;
+        getNodesFromOneAndRangeRight(node: EventStartNode<VT>, rangeRight: TimeT): EventStartNode<VT>[];
+        getNodesAfterOne(node: EventStartNode<VT>): EventStartNode<VT>[];
+        /**
+         * 将多个事件层上的数值性事件节点序列合为一个
+         *
+         * 目前仅用于速度序列，因为就他是线性的（
+         *
+         * 会创建新序列
+         * @param sequences
+         * @throws {KPAError<ERROR_IDS.NEEDS_AT_LEAST_ONE_ENS>}
+         */
+        static mergeSequences(sequences: EventNodeSequence[]): EventNodeSequence<number>;
+    }
+    export type SpeedENS = EventNodeSequence<number> & {
+        type: EventType.speed;
+    };
+}
+declare module "env" {
+    import { type TimeT, type EventValueType } from "chartTypes";
+    export enum ERROR_IDS {
+        UI_OCCUPIED = 272,
+        SEQUENCE_NAME_OCCUPIED = 1552,
+        SEQUENCE_NODE_TIME_OCCUPIED = 1553,
+        INVALID_EVENT_NODE_SEQUENCE_TYPE = 1568,
+        EVENT_NODE_TIME_NOT_INCREMENTAL = 1569,
+        PARENT_SEQUENCE_NOT_FOUND = 1585,
+        NEEDS_AT_LEAST_ONE_ENS = 1586,
+        SEQUENCE_TYPE_NOT_CONSISTENT = 1587,
+        EXPECTED_TYPED_ENS = 1600,
+        CANNOT_SUBSTITUTE_EXPRESSION_EVALUATOR = 2096,
+        CANNOT_INSERT_BEFORE_HEAD = 2097,
+        CANNOT_GET_FULL_INTEGRAL_OF_FINAL_START_NODE = 2098,
+        CANNOT_INTERPOLATE_TAILING_START_NODE = 2099,
+        INVALID_EASING_ID = 2592,
+        CANNOT_IMPLEMENT_TEMEAS_WITH_NON_EASING_ENS = 2593,
+        CANNOT_IMPLEMENT_TEMEAS_WITH_NON_NUMERIC_ENS = 2594,
+        UNIMPLEMENTED_TEMPLATE_EASING = 2595,
+        MUST_INTERPOLATE_TEMPLATE_EASING = 2608,
+        NODES_NOT_CONTINUOUS = 2609,
+        NODES_NOT_BELONG_TO_SAME_SEQUENCE = 2610,
+        NODES_HAS_ZERO_DELTA = 2611,
+        CANNOT_DIVIDE_EXPRESSION_EVALUATOR = 2352,
+        MISSING_MACRO_EVALUATOR_KEY = 2336,
+        MACRO_EVALUATOR_NOT_FOUND = 2337,
+        INVALID_NOTE_PROP_TYPE = 2880,
+        INVALID_TIME_TUPLE = 3104,
+        TIME_MACRO_NOT_FOUND = 3360,
+        VALUE_MACRO_NOT_FOUND = 3361,
+        UNKNOWN_MACRO_EXPRESSION = 3362,
+        JAVASCRIPT_SYNTAX_ERROR = 3363,
+        PROTO_PRESENT_IN_NONPARAMETRIC = 3376,
+        PARAMETRIC_MACRO_REQUIRES_PROTO_KEY = 3364,
+        MACRO_NOT_PARAMETRIC = 3365
+    }
+    export const ERRORS: {
+        UI_OCCUPIED: (name: string) => string;
+        SEQUENCE_NAME_OCCUPIED: (name: string) => string;
+        SEQUENCE_NODE_TIME_OCCUPIED: (time: TimeT, id: string) => string;
+        INVALID_EVENT_NODE_SEQUENCE_TYPE: (type: any) => string;
+        EXPECTED_TYPED_ENS: (typeStr: keyof typeof EventValueType, id: string, value: unknown) => string;
+        EVENT_NODE_TIME_NOT_INCREMENTAL: (pos: string) => string;
+        PARENT_SEQUENCE_NOT_FOUND: (nodeTime: TimeT) => string;
+        NEEDS_AT_LEAST_ONE_ENS: () => string;
+        SEQUENCE_TYPE_NOT_CONSISTENT: (typeStr: string, but: string) => string;
+        CANNOT_SUBSTITUTE_EXPRESSION_EVALUATOR: () => string;
+        CANNOT_INSERT_BEFORE_HEAD: () => string;
+        CANNOT_GET_FULL_INTEGRAL_OF_FINAL_START_NODE: () => string;
+        CANNOT_INTERPOLATE_TAILING_START_NODE: () => string;
+        INVALID_EASING_ID: (id: string) => string;
+        CANNOT_IMPLEMENT_TEMEAS_WITH_NON_EASING_ENS: (temEasName: string) => string;
+        CANNOT_IMPLEMENT_TEMEAS_WITH_NON_NUMERIC_ENS: (temEasName: string) => string;
+        MUST_INTERPOLATE_TEMPLATE_EASING: () => string;
+        NODES_NOT_CONTINUOUS: () => string;
+        NODES_NOT_BELONG_TO_SAME_SEQUENCE: () => string;
+        NODES_HAS_ZERO_DELTA: () => string;
+        INVALID_NOTE_PROP_TYPE: (prop: string, value: any, type: any) => string;
+        INVALID_TIME_TUPLE: (tuple: any) => string;
+        CANNOT_DIVIDE_EXPRESSION_EVALUATOR: (id: string) => string;
+        UNIMPLEMENTED_TEMPLATE_EASING: (temEasName: string) => string;
+        MISSING_MACRO_EVALUATOR_KEY: (pos: string) => string;
+        MACRO_EVALUATOR_NOT_FOUND: (evaluatorId: string, pos: string) => string;
+        TIME_MACRO_NOT_FOUND: (macroId: string, pos: string) => string;
+        VALUE_MACRO_NOT_FOUND: (macroId: string, pos: string) => string;
+        UNKNOWN_MACRO_EXPRESSION: (expression: string, macroId: string) => string;
+        PROTO_PRESENT_IN_NONPARAMETRIC: (macroId: string) => string;
+        JAVASCRIPT_SYNTAX_ERROR: (error: Error, macroId: string) => string;
+        PARAMETRIC_MACRO_REQUIRES_PROTO_KEY: (pos: any) => string;
+        MACRO_NOT_PARAMETRIC: (macroId: string, pos: any) => string;
+    };
+    export class KPAError<ET extends ERROR_IDS> extends Error {
+        id: ET;
+        constructor(message: string, id: ET);
+        /**
+         * 对于解析谱面等场景，有时可能需要找出全部的错误，不宜直接抛出错误中断代码执行
+         *
+         * 此时可以调用该方法，该方法会输出错误并把它保存到KPAError的一个`buffer`静态属性下。
+         */
+        warn(): void;
+        static buffer: KPAError<ERROR_IDS>[];
+        static flush(): void;
+    }
+    export const err: { [key in keyof typeof ERRORS]: (...args: Parameters<(typeof ERRORS)[key]>) => KPAError<(typeof ERROR_IDS)[key]>; };
+    const _default: {
+        DEFAULT_TEMPLATE_LENGTH: number;
+        BEZIER_INTERPOLATION_DENSITY: number;
+        NNLIST_Y_OFFSET_HALF_SPAN: number;
+        JUMPARRAY_MIN_LENGTH: number;
+        JUMPARRAY_MAX_LENGTH: number;
+        JUMPARRAY_MINOR_SCALE_COUNT: number;
+        ERROR_IDS: typeof ERROR_IDS;
+        err: {
+            UI_OCCUPIED: (name: string) => KPAError<ERROR_IDS.UI_OCCUPIED>;
+            SEQUENCE_NAME_OCCUPIED: (name: string) => KPAError<ERROR_IDS.SEQUENCE_NAME_OCCUPIED>;
+            SEQUENCE_NODE_TIME_OCCUPIED: (time: TimeT, id: string) => KPAError<ERROR_IDS.SEQUENCE_NODE_TIME_OCCUPIED>;
+            INVALID_EVENT_NODE_SEQUENCE_TYPE: (type: any) => KPAError<ERROR_IDS.INVALID_EVENT_NODE_SEQUENCE_TYPE>;
+            EXPECTED_TYPED_ENS: (typeStr: "numeric" | "color" | "text", id: string, value: unknown) => KPAError<ERROR_IDS.EXPECTED_TYPED_ENS>;
+            EVENT_NODE_TIME_NOT_INCREMENTAL: (pos: string) => KPAError<ERROR_IDS.EVENT_NODE_TIME_NOT_INCREMENTAL>;
+            PARENT_SEQUENCE_NOT_FOUND: (nodeTime: TimeT) => KPAError<ERROR_IDS.PARENT_SEQUENCE_NOT_FOUND>;
+            NEEDS_AT_LEAST_ONE_ENS: () => KPAError<ERROR_IDS.NEEDS_AT_LEAST_ONE_ENS>;
+            SEQUENCE_TYPE_NOT_CONSISTENT: (typeStr: string, but: string) => KPAError<ERROR_IDS.SEQUENCE_TYPE_NOT_CONSISTENT>;
+            CANNOT_SUBSTITUTE_EXPRESSION_EVALUATOR: () => KPAError<ERROR_IDS.CANNOT_SUBSTITUTE_EXPRESSION_EVALUATOR>;
+            CANNOT_INSERT_BEFORE_HEAD: () => KPAError<ERROR_IDS.CANNOT_INSERT_BEFORE_HEAD>;
+            CANNOT_GET_FULL_INTEGRAL_OF_FINAL_START_NODE: () => KPAError<ERROR_IDS.CANNOT_GET_FULL_INTEGRAL_OF_FINAL_START_NODE>;
+            CANNOT_INTERPOLATE_TAILING_START_NODE: () => KPAError<ERROR_IDS.CANNOT_INTERPOLATE_TAILING_START_NODE>;
+            INVALID_EASING_ID: (id: string) => KPAError<ERROR_IDS.INVALID_EASING_ID>;
+            CANNOT_IMPLEMENT_TEMEAS_WITH_NON_EASING_ENS: (temEasName: string) => KPAError<ERROR_IDS.CANNOT_IMPLEMENT_TEMEAS_WITH_NON_EASING_ENS>;
+            CANNOT_IMPLEMENT_TEMEAS_WITH_NON_NUMERIC_ENS: (temEasName: string) => KPAError<ERROR_IDS.CANNOT_IMPLEMENT_TEMEAS_WITH_NON_NUMERIC_ENS>;
+            MUST_INTERPOLATE_TEMPLATE_EASING: () => KPAError<ERROR_IDS.MUST_INTERPOLATE_TEMPLATE_EASING>;
+            NODES_NOT_CONTINUOUS: () => KPAError<ERROR_IDS.NODES_NOT_CONTINUOUS>;
+            NODES_NOT_BELONG_TO_SAME_SEQUENCE: () => KPAError<ERROR_IDS.NODES_NOT_BELONG_TO_SAME_SEQUENCE>;
+            NODES_HAS_ZERO_DELTA: () => KPAError<ERROR_IDS.NODES_HAS_ZERO_DELTA>;
+            INVALID_NOTE_PROP_TYPE: (prop: string, value: any, type: any) => KPAError<ERROR_IDS.INVALID_NOTE_PROP_TYPE>;
+            INVALID_TIME_TUPLE: (tuple: any) => KPAError<ERROR_IDS.INVALID_TIME_TUPLE>;
+            CANNOT_DIVIDE_EXPRESSION_EVALUATOR: (id: string) => KPAError<ERROR_IDS.CANNOT_DIVIDE_EXPRESSION_EVALUATOR>;
+            UNIMPLEMENTED_TEMPLATE_EASING: (temEasName: string) => KPAError<ERROR_IDS.UNIMPLEMENTED_TEMPLATE_EASING>;
+            MISSING_MACRO_EVALUATOR_KEY: (pos: string) => KPAError<ERROR_IDS.MISSING_MACRO_EVALUATOR_KEY>;
+            MACRO_EVALUATOR_NOT_FOUND: (evaluatorId: string, pos: string) => KPAError<ERROR_IDS.MACRO_EVALUATOR_NOT_FOUND>;
+            TIME_MACRO_NOT_FOUND: (macroId: string, pos: string) => KPAError<ERROR_IDS.TIME_MACRO_NOT_FOUND>;
+            VALUE_MACRO_NOT_FOUND: (macroId: string, pos: string) => KPAError<ERROR_IDS.VALUE_MACRO_NOT_FOUND>;
+            UNKNOWN_MACRO_EXPRESSION: (expression: string, macroId: string) => KPAError<ERROR_IDS.UNKNOWN_MACRO_EXPRESSION>;
+            PROTO_PRESENT_IN_NONPARAMETRIC: (macroId: string) => KPAError<ERROR_IDS.PROTO_PRESENT_IN_NONPARAMETRIC>;
+            JAVASCRIPT_SYNTAX_ERROR: (error: Error, macroId: string) => KPAError<ERROR_IDS.JAVASCRIPT_SYNTAX_ERROR>;
+            PARAMETRIC_MACRO_REQUIRES_PROTO_KEY: (pos: any) => KPAError<ERROR_IDS.PARAMETRIC_MACRO_REQUIRES_PROTO_KEY>;
+            MACRO_NOT_PARAMETRIC: (macroId: string, pos: any) => KPAError<ERROR_IDS.MACRO_NOT_PARAMETRIC>;
+        };
+        freeze(): void;
+    };
+    export default _default;
+}
+declare module "time" {
+    import { TimeT } from "chartTypes";
+    /**
+     * @static @final
+     */
+    export default class TC {
+        private constructor();
+        static toBeats(beaT: TimeT): number;
+        static getDelta(beaT1: TimeT, beaT2: TimeT): number;
+        /**
+         * @returns beaT1 == beaT2
+         */
+        static eq(beaT1: TimeT, beaT2: TimeT): boolean;
+        /** @returns beaT1 > beaT2 */
+        static gt(beaT1: TimeT, beaT2: TimeT): boolean;
+        /** @returns beaT1 < beaT2 */
+        static lt(beaT1: TimeT, beaT2: TimeT): boolean;
+        /** @returns beaT1 != beaT2 */
+        static ne(beaT1: TimeT, beaT2: TimeT): boolean;
+        /**
+         * @returns beaT1 + beaT2
+         */
+        static add(beaT1: TimeT, beaT2: TimeT): TimeT;
+        /**
+         * @returns beaT1 - beaT2
+         */
+        static sub(beaT1: TimeT, beaT2: TimeT): TimeT;
+        /**
+         * @returns Ratio(a 2-number tuple) = beaT1 / beaT2
+         */
+        static div(beaT1: TimeT, beaT2: TimeT): [number, number];
+        /**
+         * @returns beaT1 * [numerator, denominator]
+         */
+        static mul(beaT: TimeT, ratio: [number, number]): TimeT;
+        /**
+         * 原地规范化时间元组，但仍然返回这个元组，方便使用
+         * validate TimeT in place
+         * @param beaT
+         */
+        static validateIp(beaT: TimeT): TimeT;
+        /**
+         * 相加并约简
+         */
+        static vadd(beaT1: TimeT, beaT2: TimeT): TimeT;
+        /**
+         * 相减并约简
+         */
+        static vsub(beaT1: TimeT, beaT2: TimeT): TimeT;
+        /**
+         * 相乘并约简
+         */
+        static vmul(beaT: TimeT, ratio: [number, number]): TimeT;
+        static gcd(a: number, b: number): number;
+    }
+}
+declare module "operation/basic" {
+    import { Chart } from "chart";
+    export type OpEventType = "do" | "undo" | "redo" | "error" | "needsupdate" | "maxcombochanged" | "noundo" | "noredo" | "firstmodified" | "needsreflow";
+    interface DirectlyInstaciableEventMap {
+        "noundo": OpEvent;
+        "noredo": OpEvent;
+        "firstmodified": OpEvent;
+    }
+    type CheckFinalOverrides<T> = {
+        [K in keyof T]: K extends keyof OpEventMap ? T[K] extends OpEventMap[K] ? T[K] : never : T[K];
+    };
+    interface OpEventMap extends CheckFinalOverrides<DirectlyInstaciableEventMap> {
+        "error": OperationErrorEvent;
+        "maxcombochanged": MaxComboChangeEvent;
+        "undo": OperationEvent;
+        "redo": OperationEvent;
+        "do": OperationEvent;
+        "needsupdate": OperationEvent;
+        "needsreflow": NeedsReflowEvent;
+    }
+    class OpEvent extends Event {
+        protected constructor(type: OpEventType);
+        /**
+         * 如果这个类型没有对应子类应该用这个
+         */
+        static create(type: keyof DirectlyInstaciableEventMap): OpEvent;
+    }
+    export class NeedsReflowEvent extends OpEvent {
+        condition: number;
+        constructor(condition: number);
+    }
+    export class OperationEvent extends OpEvent {
+        operation: Operation;
+        constructor(t: "do" | "undo" | "redo" | "error" | "needsupdate", operation: Operation);
+    }
+    export class OperationErrorEvent extends OperationEvent {
+        error: Error;
+        constructor(operation: Operation, error: Error);
+    }
+    export class MaxComboChangeEvent extends OpEvent {
+        comboDelta: number;
+        constructor(comboDelta: number);
+    }
+    export class OperationList extends EventTarget {
+        readonly chart: Chart;
+        operations: Operation[];
+        undoneOperations: Operation[];
+        constructor(chart: Chart);
+        undo(): void;
+        redo(): void;
+        do(operation: Operation): void;
+        processFlags(operation: Operation): void;
+        clear(): void;
+        addEventListener<T extends OpEventType>(type: T, listener: (event: OpEventMap[T]) => void, options?: boolean | AddEventListenerOptions): void;
+    }
+    export abstract class Operation {
+        ineffective: boolean;
+        updatesEditor: boolean;
+        reflows: number;
+        /**
+         * 此操作对谱面总物量产生了多少影响，正增负减。
+         *
+         * 如果操作自身无法评估，应返回NaN，导致全谱重新数清物量
+         */
+        comboDelta: number;
+        constructor();
+        abstract do(chart: Chart): void;
+        abstract undo(chart: Chart): void;
+        rewrite(op: this, chart: Chart): boolean;
+        toString(): string;
+        static lazy<C extends new (...args: any[]) => any = typeof this>(this: C, ...args: ConstructorParameters<C>): LazyOperation<C>;
+    }
+    /**
+     * 懒操作，实例化的时候不记录任何数据，do的时候才执行真正实例化
+     * 防止连续的操作中状态改变导致的错误
+     */
+    export class LazyOperation<C extends new (...args: any[]) => any> extends Operation {
+        operationClass: C;
+        args: ConstructorParameters<C>;
+        operation: InstanceType<C> | null;
+        constructor(operationClass: C, ...args: ConstructorParameters<C>);
+        do(chart: Chart): void;
+        undo(chart: Chart): void;
+    }
+    /**
+     * C语言借来的概念
+     *
+     * 一个不确定类型的子操作
+     *
+     * 注意这个操作不懒，会在构造时就实例化子操作
+     */
+    export class UnionOperation<T extends Operation> extends Operation {
+        operation: T;
+        constructor(matcher: () => T);
+        do(chart?: Chart): void;
+        undo(chart?: Chart): void;
+    }
+    export class ComplexOperation<T extends Operation[]> extends Operation {
+        subOperations: T;
+        length: number;
+        constructor(...sub: T);
+        do(chart?: Chart): void;
+        undo(chart?: Chart): void;
+    }
+}
+declare module "operation/event" {
+    import type { Chart } from "chart";
+    import { type EventValueESType, type TimeT } from "chartTypes";
+    import { TemplateEasing, TemplateEasingLib } from "easing";
+    import { Evaluator } from "evaluator";
+    import { EventEndNode, EventStartNode, EventNodeSequence, EventNode, NonLastStartNode, EventNodeLike } from "event";
+    import { NodeType } from "util";
+    import { ComplexOperation, LazyOperation, Operation, UnionOperation } from "operation/basic";
+    /**
+     * 移除一对节点（背靠背）
+     */
+    export class EventNodePairRemoveOperation extends Operation {
+        updatesEditor: boolean;
+        endNode: EventEndNode<any>;
+        startNode: EventStartNode<any>;
+        sequence: EventNodeSequence<any>;
+        originalPrev: EventStartNode<any>;
+        updatesFP: boolean;
+        constructor(node: EventStartNode<any>, updatesFP?: boolean);
+        do(chart: Chart): void;
+        undo(chart: Chart): void;
+    }
+    /**
+     * 将一对孤立的节点对插入到一个开始节点之后的操作。
+     *
+     * 如果这个节点对的时刻与节点对的时刻相同，那么抛出错误。
+     */
+    export class EventNodePairInsertOperation<VT extends EventValueESType> extends Operation {
+        updatesEditor: boolean;
+        node: EventStartNode<VT>;
+        tarPrev: EventStartNode<VT>;
+        sequence: EventNodeSequence<VT>;
+        originalValue: VT;
+        value: VT;
+        updatesFP: boolean;
+        /**
+         *
+         * @param node 要插入的节点 the node to insert
+         * @param targetPrevious 要插在谁后面 The node to insert after, accessed through `EventNodeSequence.getNodeAt(TC.toBeats(node))`
+         */
+        constructor(node: EventStartNode<VT>, targetPrevious: EventStartNode<VT>, updatesFP?: boolean);
+        do(): void;
+        undo(): void;
+    }
+    export class EventNodePairInsertOrOverwriteOperation<VT extends EventValueESType> extends UnionOperation<LazyOperation<typeof EventNodePairInsertOperation<VT>> | EventNodeValueChangeOperation<VT>> {
+        overlapping: boolean;
+        constructor(node: EventStartNode<VT>, targetPrevious: EventStartNode<VT>, updatesFP?: boolean);
+    }
+    export class EventNodeValueChangeOperation<VT extends EventValueESType> extends Operation {
+        updatesEditor: boolean;
+        node: EventNode<VT>;
+        value: VT;
+        originalValue: VT;
+        constructor(node: EventNode<VT>, val: VT);
+        do(chart: Chart): void;
+        undo(chart: Chart): void;
+        updateSpeedENS(chart: Chart): void;
+        rewrite(operation: EventNodeValueChangeOperation<VT>, chart: Chart): boolean;
+    }
+    export class EventNodeTimeChangeOperation extends Operation {
+        updatesEditor: boolean;
+        sequence: EventNodeSequence;
+        /**
+         * 这里两个node不是面对面，而是背靠背
+         * i. e. EndNode -> StartNode
+         */
+        startNode: EventStartNode<any>;
+        endNode: EventEndNode<any>;
+        value: TimeT;
+        originalValue: TimeT;
+        originalPrevious: EventStartNode<any>;
+        newPrevious: EventStartNode<any>;
+        constructor(node: EventStartNode<any> | EventEndNode<any>, val: TimeT);
+        do(): void;
+        undo(): void;
+    }
+    export class EventNodeEvaluatorChangeOperation<VT extends EventValueESType> extends Operation {
+        node: EventStartNode<VT>;
+        value: Evaluator<VT>;
+        updatesEditor: boolean;
+        originalValue: Evaluator<VT>;
+        constructor(node: EventStartNode<VT>, value: Evaluator<VT>);
+        do(): void;
+        undo(): void;
+    }
+    export class EventInterpolationOperation<VT extends EventValueESType> extends ComplexOperation<LazyOperation<typeof EventNodePairInsertOperation>[]> {
+        eventStartNode: EventStartNode<VT>;
+        step: TimeT;
+        updatesEditor: boolean;
+        constructor(eventStartNode: EventStartNode<VT>, step: TimeT);
+    }
+    export class EventSubstituteOperation<VT extends EventValueESType> extends ComplexOperation<[...LazyOperation<typeof EventNodePairInsertOperation>[], EventNodeEvaluatorChangeOperation<VT>, EventNodeValueChangeOperation<VT>]> {
+        node: NonLastStartNode<VT>;
+        updatesEditor: boolean;
+        /**
+         *
+         * @param node
+         * @throws {KPAError<ERROR_IDS.CANNOT_SUBSTITUTE_EXPRESSION_EVALUATOR>}
+         * @throws {KPAError<ERROR_IDS.MUST_INTERPOLATE_TEMPLATE_EASING>}
+         */
+        constructor(node: NonLastStartNode<VT>);
+    }
+    export class EncapsuleOperation extends ComplexOperation<[MultiNodeDeleteOperation, EventNodeEvaluatorChangeOperation<number>, EventNodeValueChangeOperation<number>]> {
+        updatesEditor: boolean;
+        constructor(nodes: EventStartNode<number>[], easing: TemplateEasing);
+        /**
+         * 将一些来自sourceSequence的节点打包为一个用于模板缓动的事件序列
+         * 然后把sourceSequence中的源节点集合替换为单个使用了该模板的事件
+         * @param sourceSequence
+         * @param sourceNodes
+         */
+        static encapsule(templateEasingLib: TemplateEasingLib, sourceSequence: EventNodeSequence, sourceNodes: Set<EventStartNode>, name: string): EncapsuleOperation;
+    }
+    /**
+     * 批量添加节点对
+     *
+     * 节点对需要有序的，且不能有重叠
+    
+     */
+    export class MultiNodeAddOperation<VT extends EventValueESType> extends ComplexOperation<EventNodePairInsertOrOverwriteOperation<VT>[]> {
+        nodes: EventStartNode<VT>[];
+        seq: EventNodeSequence<VT>;
+        updatesEditor: boolean;
+        updatesFP: boolean;
+        constructor(nodes: EventStartNode<VT>[], seq: EventNodeSequence<VT>);
+        do(chart: Chart): void;
+        undo(chart: Chart): void;
+    }
+    export class MultiNodeDeleteOperation extends ComplexOperation<LazyOperation<typeof EventNodePairRemoveOperation>[]> {
+        updatesEditor: boolean;
+        constructor(nodes: EventStartNode<any>[]);
+    }
+    export class EventNodeSequenceRenameOperation extends Operation {
+        sequence: EventNodeSequence<EventValueESType>;
+        newName: string;
+        updatesEditor: boolean;
+        originalName: string;
+        constructor(sequence: EventNodeSequence<EventValueESType>, newName: string);
+        do(chart: Chart): void;
+        undo(chart: Chart): void;
+    }
+    type TimeRange = [TimeT, TimeT];
+    /**
+     * 所有节点事件加上一个值。
+     * 此操作假定了节点被偏移时不会产生“碰撞”。
+     * 节点要有序
+     * @private
+     */
+    export class MultiNodeOffsetOperation extends Operation {
+        nodes: readonly EventStartNode<any>[];
+        offset: TimeT;
+        constructor(nodes: readonly EventStartNode<any>[], offset: TimeT);
+        do(): void;
+        undo(): void;
+    }
+    export class ENSTimeRangeDeleteOperation extends ComplexOperation<[MultiNodeDeleteOperation, MultiNodeOffsetOperation]> {
+        eventNodeSequence: EventNodeSequence<any>;
+        timeRange: TimeRange;
+        beforeToStart: EventStartNode<any> | EventNodeLike<NodeType.HEAD, any>;
+        constructor(eventNodeSequence: EventNodeSequence<any>, timeRange: TimeRange);
+        do(): void;
+        undo(): void;
+    }
+    export class ENSAddBlankOperation extends MultiNodeOffsetOperation {
+        ens: EventNodeSequence<any>;
+        updatesEditor: boolean;
+        constructor(ens: EventNodeSequence<any>, pos: TimeT, length: TimeT);
+        do(): void;
+        undo(): void;
+    }
+}
+declare module "operation/note" {
+    import { Operation, ComplexOperation, UnionOperation } from "operation/basic";
+    import { TimeT } from "chartTypes";
+    import { JudgeLine } from "judgeline";
+    import { Note, NoteNode, NNList } from "note";
+    type NotePropNamePhiZone = "judgeSize" | "tint" | "tintHitEffects";
+    export type NotePropName = "speed" | "type" | "positionX" | "startTime" | "endTime" | "alpha" | "size" | "visibleBeats" | "yOffset" | "above" | "isFake" | NotePropNamePhiZone;
+    /**
+     * 修改 Note 的任意属性值
+     * @example
+     * // 修改 note 的 above 属性
+     * operationList.do(new NotePropChangeOperation(note, "above", true));
+     * // 修改 note 的 speed 属性
+     * // 一般不会这样做，因为修改 note 的 speed 需要把note换到另一个序列（`NNList`）中
+     * // 应使用NoteSpeedChangeOperation。YOffset也是同样的道理。
+     * operationList.do(new NotePropChangeOperation(note, "speed", 1.5));
+     * @template T - 要修改的属性名，必须是 `NotePropName` 类型
+     */
+    export class NotePropChangeOperation<T extends NotePropName> extends Operation {
+        field: T;
+        note: Note;
+        previousValue: Note[T];
+        value: Note[T];
+        updatesEditor: boolean;
+        constructor(note: Note, field: T, value: Note[T]);
+        do(): void;
+        undo(): void;
+        rewrite(operation: NotePropChangeOperation<T>): boolean;
+    }
+    export class NoteRemoveOperation extends Operation {
+        noteNode: NoteNode;
+        note: Note;
+        isHold: boolean;
+        constructor(note: Note);
+        do(): void;
+        undo(): void;
+    }
+    /**
+     * 删除一个 note（语义层面的删除）
+     * 从语义上删除 Note 要用这个操作
+     * 注意：实际移除由 NoteRemoveOperation 完成，NoteDeleteOperation 仅负责更新编辑器
+     * @example
+     * operationList.do(new NoteDeleteOperation(note));
+     */
+    export class NoteDeleteOperation extends NoteRemoveOperation {
+        updatesEditor: boolean;
+    }
+    export class MultiNoteDeleteOperation extends ComplexOperation<NoteDeleteOperation[]> {
+        updatesEditor: boolean;
+        constructor(notes: Set<Note> | Note[]);
+    }
+    export class NoteAddOperation extends Operation {
+        noteNode: NoteNode;
+        note: Note;
+        isHold: boolean;
+        updatesEditor: boolean;
+        constructor(note: Note, node: NoteNode);
+        do(): void;
+        undo(): void;
+    }
+    export class MultiNoteAddOperation extends ComplexOperation<NoteAddOperation[]> {
+        updatesEditor: boolean;
+        constructor(notes: Set<Note> | Note[], judgeLine: JudgeLine);
+    }
+    /**
+     * 修改 Note 的时间位置（不直接修改 startTime，而是将 Note 移动到另一个 NoteNode）
+     * 注意：不能直接修改 note.startTime 属性，需要通过 getNodeOf 获取目标时间的 NoteNode
+     * @example
+     * // 将 note 移动到目标时间位置
+     * const targetNode = note.parentNode.parentSeq.getNodeOf(targetTime);
+     * operationList.do(new NoteTimeChangeOperation(note, targetNode));
+     */
+    export class NoteTimeChangeOperation extends ComplexOperation<[
+        NoteRemoveOperation,
+        NotePropChangeOperation<"startTime">,
+        NoteAddOperation,
+        UnionOperation<NotePropChangeOperation<"endTime"> | null>
+    ]> {
+        note: Note;
+        comboDelta: number;
+        constructor(note: Note, noteNode: NoteNode);
+        rewrite(operation: NoteTimeChangeOperation): boolean;
+    }
+    /**
+     * 修改 hold 音符的 endTime 属性
+     * 直接修改 hold 音符的 endTime（不同于 NoteTimeChangeOperation）
+     * @example
+     * // 修改 hold 音符的结束时间
+     * operationList.do(new HoldEndTimeChangeOperation(note, newEndTime));
+     */
+    export class HoldEndTimeChangeOperation extends NotePropChangeOperation<"endTime"> {
+        constructor(note: Note, value: TimeT);
+        do(): void;
+        undo(): void;
+        rewrite(operation: HoldEndTimeChangeOperation): boolean;
+    }
+    /**
+     * 修改 Note 的 speed 属性
+     * 需要传入 JudgeLine 参数，因为 speed 变化会影响 note 在何 NNList 中
+     * @example
+     * // 修改 note 的 speed 值
+     * operationList.do(new NoteSpeedChangeOperation(note, 2.0, judgeLine));
+     */
+    export class NoteSpeedChangeOperation extends ComplexOperation<[NotePropChangeOperation<"speed">, NoteRemoveOperation, NoteAddOperation]> {
+        note: Note;
+        updatesEditor: boolean;
+        constructor(note: Note, value: number, line: JudgeLine);
+    }
+    export class NoteYOffsetChangeOperation extends ComplexOperation<[NotePropChangeOperation<"yOffset">, NoteRemoveOperation, NoteAddOperation]> {
+        note: Note;
+        updatesEditor: boolean;
+        constructor(note: Note, value: number, line: JudgeLine);
+    }
+    /**
+     * 修改 Note 的 type 属性（音符类型）
+     * 在 tap/drag/flick/hold 之间切换，切换到/从 hold 时需要重新定位 NoteNode
+     * @example
+     * // 将 note 改为 hold 类型
+     * operationList.do(new NoteTypeChangeOperation(note, NoteType.hold));
+     */
+    export class NoteTypeChangeOperation extends ComplexOperation<[NotePropChangeOperation<"type">, NoteRemoveOperation, NoteAddOperation] | [NotePropChangeOperation<"type">]> {
+        note: Note;
+        value: number;
+        constructor(note: Note, value: number);
+    }
+    /**
+     * @author Zes Minkey Young
+     */
+    export class MultiNoteOffsetOperation extends Operation {
+        nnList: NNList;
+        notes: readonly Note[];
+        offset: TimeT;
+        constructor(nnList: NNList, notes: readonly Note[], offset: TimeT);
+        do(): void;
+        undo(): void;
+        private static lazy;
+    }
+    type TimeRange = [TimeT, TimeT];
+    export class NNListTimeRangeDeleteOperation extends ComplexOperation<[MultiNoteDeleteOperation, MultiNoteOffsetOperation]> {
+        nnList: NNList;
+        timeRange: TimeRange;
+        updatesJump: boolean;
+        constructor(nnList: NNList, timeRange: TimeRange, updatesJump?: boolean);
+        do(): void;
+        undo(): void;
+    }
+    export class NNListAddBlankOperation extends MultiNoteOffsetOperation {
+        updatesEditor: boolean;
+        constructor(nnList: NNList, pos: TimeT, length: TimeT);
+    }
+}
+declare module "operation/line" {
+    import { Chart, JudgeLineGroup, BasicEventName, UIName } from "chart";
+    import { ExtendedEventTypeName, RGB } from "chartTypes";
+    import { EventNodeSequence } from "event";
+    import { JudgeLine } from "judgeline";
+    import { ComplexOperation, LazyOperation, Operation } from "operation/basic";
+    import { EventNodeSequenceRenameOperation } from "operation/event";
+    enum JudgeLinesEditorLayoutType {
+        ordered = 1,
+        tree = 2,
+        grouped = 4
+    }
+    export class JudgeLineInheritanceChangeOperation extends Operation {
+        chart: Chart;
+        judgeLine: JudgeLine;
+        value: JudgeLine | null;
+        originalValue: JudgeLine | null;
+        updatesEditor: boolean;
+        static REFLOWS: JudgeLinesEditorLayoutType;
+        reflows: JudgeLinesEditorLayoutType;
+        constructor(chart: Chart, judgeLine: JudgeLine, value: JudgeLine | null);
+        do(): void;
+        undo(): void;
+    }
+    export class JudgeLineRenameOperation extends Operation {
+        judgeLine: JudgeLine;
+        value: string;
+        updatesEditor: boolean;
+        originalValue: string;
+        constructor(judgeLine: JudgeLine, value: string);
+        do(): void;
+        undo(): void;
+    }
+    type JudgeLinePropName = "name" | "rotatesWithFather" | "anchor" | "texture" | "cover" | "zOrder";
+    export class JudgeLinePropChangeOperation<T extends JudgeLinePropName> extends Operation {
+        judgeLine: JudgeLine;
+        field: T;
+        value: JudgeLine[T];
+        updatesEditor: boolean;
+        originalValue: JudgeLine[T];
+        constructor(judgeLine: JudgeLine, field: T, value: JudgeLine[T]);
+        do(): void;
+        undo(): void;
+    }
+    export class JudgeLineRegroupOperation extends Operation {
+        judgeLine: JudgeLine;
+        value: JudgeLineGroup;
+        updatesEditor: boolean;
+        reflows: JudgeLinesEditorLayoutType;
+        originalValue: JudgeLineGroup;
+        constructor(judgeLine: JudgeLine, value: JudgeLineGroup);
+        do(): void;
+        undo(): void;
+    }
+    export class JudgeLineCreateOperation extends Operation {
+        chart: Chart;
+        judgeLine: JudgeLine;
+        reflows: number;
+        constructor(chart: Chart, judgeLine: JudgeLine);
+        do(): void;
+        undo(): void;
+    }
+    class JudgeLineRemoveOperation extends Operation {
+        chart: Chart;
+        judgeLine: JudgeLine;
+        readonly originalGroup: JudgeLineGroup;
+        constructor(chart: Chart, judgeLine: JudgeLine);
+        do(): void;
+        undo(): void;
+    }
+    export class JudgeLineDeleteOperation extends ComplexOperation<[JudgeLineRemoveOperation, ...LazyOperation<typeof JudgeLineIdChangeOperation>[]]> {
+        chart: Chart;
+        judgeLine: JudgeLine;
+        constructor(chart: Chart, judgeLine: JudgeLine);
+    }
+    export class JudgeLineENSChangeOperation extends Operation {
+        judgeLine: JudgeLine;
+        layerId: number;
+        typeStr: BasicEventName;
+        value: EventNodeSequence;
+        originalValue: EventNodeSequence;
+        constructor(judgeLine: JudgeLine, layerId: number, typeStr: BasicEventName, value: EventNodeSequence);
+        do(): void;
+        undo(): void;
+    }
+    export type ENSOfTypeName<T extends ExtendedEventTypeName> = {
+        "scaleX": EventNodeSequence<number>;
+        "scaleY": EventNodeSequence<number>;
+        "text": EventNodeSequence<string>;
+        "color": EventNodeSequence<RGB>;
+    }[T];
+    export class JudgeLineExtendENSChangeOperation<T extends ExtendedEventTypeName> extends Operation {
+        judgeLine: JudgeLine;
+        typeStr: T;
+        value: ENSOfTypeName<T> | null;
+        originalValue: ENSOfTypeName<T>;
+        constructor(judgeLine: JudgeLine, typeStr: T, value: ENSOfTypeName<T> | null);
+        do(): void;
+        undo(): void;
+    }
+    export class UIAttachOperation extends Operation {
+        chart: Chart;
+        judgeLine: JudgeLine;
+        ui: UIName;
+        updatesEditor: boolean;
+        constructor(chart: Chart, judgeLine: JudgeLine, ui: UIName);
+        do(): void;
+        undo(): void;
+    }
+    export class UIDetachOperation extends Operation {
+        chart: Chart;
+        ui: UIName;
+        updatesEditor: boolean;
+        judgeLine: JudgeLine;
+        constructor(chart: Chart, ui: UIName);
+        do(): void;
+        undo(): void;
+    }
+    export class JudgeLineDetachAllUIOperation extends Operation {
+        chart: Chart;
+        judgeLine: JudgeLine;
+        updatesEditor: boolean;
+        uinames: UIName[];
+        constructor(chart: Chart, judgeLine: JudgeLine);
+        do(): void;
+        undo(): void;
+    }
+    /**
+     * 修改判定线id
+     * 不需要自己传入ID
+     */
+    export class JudgeLineIdChangeOperation extends ComplexOperation<EventNodeSequenceRenameOperation[]> {
+        originalValue: number;
+        value: number;
+        judgeLine: JudgeLine;
+        /**
+         *
+         * @param judgeLine
+         * @param renamesENS 是否对事件序列进行重命名
+         */
+        constructor(judgeLine: JudgeLine, renamesENS?: boolean);
+        do(chart: Chart): void;
+        undo(chart: Chart): void;
+    }
+}
+declare module "operation/chart" {
+    import { Chart } from "chart";
+    import { Operation } from "operation/basic";
+    export type ChartPropName = "name" | "level" | "composer" | "illustrator" | "charter" | "offset";
+    export class ChartPropChangeOperation<T extends ChartPropName> extends Operation {
+        chart: Chart;
+        field: T;
+        value: Chart[T];
+        originalValue: Chart[T];
+        constructor(chart: Chart, field: T, value: Chart[T]);
+        do(): void;
+        undo(): void;
+    }
+}
+declare module "operation/macro" {
+    import { Operation, ComplexOperation } from "operation/basic";
+    import { EventMacroTime } from "macro";
+    import { EventStartNode } from "event";
+    import { Chart } from "chart";
+    import { EventNodeTimeChangeOperation } from "operation/event";
+    export class EventNodeMacroTimeReevaluateOperation extends EventNodeTimeChangeOperation {
+        constructor(node: EventStartNode<any>, chart: Chart);
+    }
+    export class MacroTimeAssignOperation extends Operation {
+        macroTime: EventMacroTime;
+        node: EventStartNode<any>;
+        originalMacroTime: EventMacroTime;
+        private timeChangeOperation;
+        constructor(macroTime: EventMacroTime, node: EventStartNode<any>);
+        do(chart: Chart): void;
+        undo(_chart: Chart): void;
+    }
+    export class MacroTimeDeassginOperation extends Operation {
+        node: EventStartNode<any>;
+        originalMacroTime: EventMacroTime;
+        constructor(node: EventStartNode<any>);
+        do(chart: Chart): void;
+        undo(_chart: Chart): void;
+    }
+    export class MacroTimeReevaluateOperation extends ComplexOperation<EventNodeMacroTimeReevaluateOperation[]> {
+        constructor(macroTime: EventMacroTime, chart: Chart);
+    }
+}
+declare module "operation/index" {
+    export * from "operation/basic";
+    export * from "operation/event";
+    export * from "operation/note";
+    export * from "operation/line";
+    export * from "operation/chart";
+    export * from "operation/macro";
+}
+declare module "rpeChartCompiler" {
+    import type { Chart } from "chart";
+    import { type TimeT, type ChartDataRPE, type JudgeLineDataRPE, type EventDataRPELike, type NoteDataRPE, type EventValueESType } from "chartTypes";
+    import { type EasedEvaluatorOfType } from "evaluator";
+    import { EventEndNode, EventNodeSequence, EventStartNode } from "event";
+    import type { JudgeLine } from "judgeline";
+    import type { NNList, HNList } from "note";
+    /**
+     * 全生命周期只会编译一次，想多次就再构造一个
+     */
+    export class RPEChartCompiler {
+        chart: Chart;
+        sequenceMap: Map<EventNodeSequence<any>, EventNodeSequence<any>>;
+        interpolationStep: TimeT;
+        constructor(chart: Chart);
+        compileChart(): ChartDataRPE;
+        compileJudgeLine(judgeLine: JudgeLine): JudgeLineDataRPE;
+        compileEasedEvent<VT extends EventValueESType>(snode: EventStartNode<VT> & {
+            evaluator: EasedEvaluatorOfType<VT>;
+        }, getValue: (node: EventStartNode<VT> | EventEndNode<VT>) => VT): EventDataRPELike<VT>;
+        dumpEventNodeSequence<VT extends EventValueESType>(sequence: EventNodeSequence<VT>): EventDataRPELike<VT>[];
+        compileNNLists(nnLists: NNList[], hnLists: HNList[]): NoteDataRPE[];
+        /**
+         * 倒序转换为数组
+         * @param nnList
+         * @returns 一个按照时间降序排列的数组
+         */
+        nnListToArray(nnList: NNList): NoteDataRPE[];
+        /**
+         * 将当前序列中所有通过模板缓动引用了其他序列的事件直接展开为被引用的序列内容
+         * transform all events that reference other sequences by template easing
+         * into the content of the referenced sequence
+         *
+         * 有点类似于MediaWiki的`{{subst:templateName}}`
+         * @returns
+         */
+        substitute<VT extends EventValueESType>(seq: EventNodeSequence<VT>): EventNodeSequence<VT>;
+    }
+}
+declare module "index" {
+    export * from "time";
+    export { default as TC } from "time";
+    export * from "chartTypes";
+    export * from "easing";
+    export * from "evaluator";
+    export * from "macro";
+    export * from "event";
+    export * from "note";
+    export * from "judgeline";
+    export * from "bpm";
+    export * from "util";
+    export * from "chart";
+    export * from "jumparray";
+    export * as Op from "operation/index";
+    export * from "version";
+    export { default as Environment, KPAError } from "env";
+    export { RPEChartCompiler } from "rpeChartCompiler";
+}