import type { AnimationAction, AnimationMixer, CurvePath, Vector2 } from "three";
import { Vector3, Quaternion, Euler, EventDispatcher, EventListener } from "three";
import { AnimationClipKeyframe } from "./AnimationClipKeyframe";
/**
 * 关键帧
 */
export type KeyframeInfo = ReturnType<AnimationClipKeyframe["getTracksKeyframes"]>[number];
/**
 * 关键帧集合
 */
export type KeyframeInfos = {
    [name: string]: KeyframeInfo;
};
/**
 * 折线的关键帧
 */
export interface PolylineKeyframe {
    index: number;
    value: Vector2 | Vector3;
    length: number;
}
/**
 * 动画事件的基本类型
 */
export declare enum AnimationEventBaseType {
    /**
     * 关键帧
     * @remarks
     * 到达任意关键帧时都触发
     */
    keyframe = "keyframe",
    /**
     * 位置关键帧
     * @remarks
     * 到达位置关键帧时触发
     */
    position = ".position",
    /**
     * 四元数关键帧
     * @remarks
     * 到达四元数关键帧时触发
     */
    quaternion = ".quaternion",
    /**
     * 旋转关键帧
     * @remarks
     * 到达旋转关键帧时触发
     */
    rotation = ".rotation",
    /**
     * 缩放关键帧
     * @remarks
     * 到达缩放关键帧时触发
     */
    scale = ".scale",
    /**
     * 当动画完成一次循环时触发
     */
    loop = "loop",
    /**
     * 当动画完成时触发
     */
    finished = "finished",
    /**
     * 折线的点事件
     */
    point = "point"
}
/**
 * 动画事件的类型
 */
export type AnimationEventType = AnimationEventBaseType | string;
/**
 * 动画事件
 */
export interface AnimationEvent<T, Frame extends KeyframeInfos | KeyframeInfo | PolylineKeyframe = KeyframeInfo> {
    type: T;
    preFrame: Frame;
    frame: Frame;
}
/**
 * loop 类型的事件对象
 */
export interface AnimationLoopEvent {
    type: "loop";
    action: AnimationActionKeyframe;
    loopDelta: number;
}
/**
 * finished 类型的事件对象
 */
export interface AnimationFinishedEvent {
    type: "finished";
    action: AnimationActionKeyframe;
    direction: number;
}
/**
 * 动画事件的类型映射
 */
export type AnimationEventMap = {
    keyframe: AnimationEvent<"keyframe", KeyframeInfos>;
    point: AnimationEvent<"point", PolylineKeyframe>;
    loop: AnimationLoopEvent;
    finished: AnimationFinishedEvent;
} & {
    [T: string]: KeyframeInfo;
};
/**
 * 获取 AnimationAction 的动画的关键帧信息
 */
export declare class AnimationActionKeyframe extends AnimationClipKeyframe {
    readonly action: AnimationAction;
    readonly isAnimationActionKeyframe = true;
    constructor(action: AnimationAction);
    /**
     * 动画的当前时间
     * @remarks
     * 表示一个循环周期中动画的执行时间；
     */
    get time(): number;
    /**
     * 动画的持续时间
     */
    get duration(): number;
    /**
     * 动画的进度时间
     * @remarks
     * 反应动画在一个周期内的动画运动位置处的时间；
     */
    get progressTime(): number;
    set progressTime(value: number);
    /**
     * 动画的进度
     */
    get progress(): number;
    set progress(value: number);
    /**
     * 动画循环的次数
     * @remarks
     * 从 0 开始
     */
    get loopCount(): number;
    /**
     * 是否正在反向循环
     * @remarks
     * 表示当循环模式为 `LoopPingPong` 时，当前是否正处于反向的循环情况；
     */
    get isReverseLoop(): boolean;
    /**
     * 循环方向系数
     * @remarks
     * 当处理正向循环时 为 1；
     * 处理反向循环时 为 -1；
     *
     * 与 {@link AnimationActionKeyframe.isReverseLoop} 表达相同的意思；
     */
    get loopDirFactor(): 1 | -1;
    /**
     * 是否正在反向运动
     * @remarks
     * 与 {@link AnimationActionKeyframe.isReverseLoop} 不同的是，该属性还会考虑 `timeScale` 的影响；
     * 即：该属性表示的是最终的效果是否是在反向动画；
     */
    get isReverse(): boolean;
    /**
     * 方向系数
     * @remarks
     * 当处理正向动画时 为 1；
     * 处理反向动画时 为 -1；
     *
     * 与 {@link AnimationActionKeyframe.isReverseLoop} 表达相同的意思；
     */
    get dirFactor(): 1 | -1;
    protected _trackNames?: string[];
    /**
     * 动画的所有轨道的名字
     */
    get trackNames(): string[];
    /**
     * 动画所有轨道的当前关键帧的索引
     */
    get keyframeIndexs(): {
        [name: string]: number;
    };
    /**
     * 所有轨道当前的关键帧
     */
    get keyframes(): KeyframeInfos;
    protected _positionTrackName?: string | null;
    /**
     * 位置轨道的名字
     */
    get positionTrackName(): string | null;
    /**
     * 位置轨道的当前关键帧索引
     */
    get positionkeyframeIndex(): number | null;
    get positionKeyframe(): {
        index: number;
        value: Vector3 | null;
    } | null;
    protected _quaternionTrackName?: string | null;
    /**
     * 四元数的轨道名字
     */
    get quaternionTrackName(): string | null;
    /**
     * 四元数轨道的当前关键帧索引
     */
    get quaternionKeyframeIndex(): number | null;
    /**
     * 四元数轨道的当前关键帧
     */
    get quaternionKeyframe(): {
        index: number;
        value: Quaternion | null;
    } | null;
    protected _rotationTrackName?: string | null;
    /**
     * 旋转轨道的名字
     */
    get rotationTrackName(): string | null;
    /**
     * 旋转轨道的当前关键帧索引
     */
    get rotationkeyframeIndex(): number | null;
    /**
     * 旋转轨道的当前关键帧
     */
    get rotationKeyframe(): {
        index: number;
        value: Euler | null;
    } | null;
    protected _scaleTrackName?: string | null;
    /**
     * 缩放轨道的名字
     */
    get scaleTrackName(): string | null;
    /**
     * 缩放轨道的当前关键帧索引
     */
    get scaleKeyframeIndex(): number | null;
    /**
     * 缩放轨道的当前关键帧
     */
    get scaleKeyframe(): {
        index: number;
        value: Vector3 | null;
    } | null;
    /**
     * 事件派发器
     */
    protected event: EventDispatcher<import("three").Event>;
    protected _frameEventNames?: string[] | null;
    get frameEventNames(): string[];
    /**
     * AnimationMixer事件的监听器
     */
    protected mixerListener: (event: any) => void;
    get mixer(): AnimationMixer;
    /**
     * 添加事件监听器
     * @param type - 事件的类型
     * @param listener - 监听器
     * @returns
     */
    addEventListener<T extends AnimationEventType>(type: T, listener: EventListener<AnimationEventMap[T], T, EventDispatcher>): boolean;
    /**
     * 移除事件监听器
     * @param type
     * @param listener
     */
    removeEventListener<T extends AnimationEventType>(type: T, listener: EventListener<AnimationEventMap[T], T, EventDispatcher>): void;
    protected _points: (Vector2 | Vector3)[];
    /**
     * 组成折线的点
     * @remarks
     * 用于 point 事件
     */
    get points(): (Vector3 | Vector2)[];
    set points(value: (Vector3 | Vector2)[]);
    protected _polyline?: CurvePath<Vector2 | Vector3> | null;
    /**
     * 折线
     * @remarks
     * 通过 points 生成 或 直接设置；
     * 用于 point 事件
     */
    get polyline(): CurvePath<Vector3 | Vector2> | null | undefined;
    set polyline(value: CurvePath<Vector3 | Vector2> | null | undefined);
    protected _polylineLengths: number[];
    /**
     * 折线中每个点的长度
     * @remarks
     * 通过 polyline 生成 或 直接设置；
     * 用于 point 事件
     */
    get polylineLengths(): number[];
    set polylineLengths(value: number[]);
    /**
     * 折线的总长度
     */
    get polylineLength(): number;
    /**
     * 折线的进度长度
     * @remarks
     * 当前进度下的长度
     */
    get polylineProgressLength(): number;
    protected _pointsProgress: number[];
    /**
     * 各个点的进度列表
     * @remarks
     * 以均速计算
     */
    get pointsProgress(): number[];
    set pointsProgress(value: number[]);
    /**
     * 获取当前进度下点的索引
     */
    get pointIndex(): number;
    protected lastGetProgress: number;
    protected lastGetPointIndex: number;
    /**
     * 获取点的索引
     * @param progress
     * @returns
     */
    getPointIndex(progress: number): number;
    protected _enablePointEvent: boolean;
    /**
     * 是否开启 point 相关的事件
     */
    get enablePointEvent(): boolean;
    set enablePointEvent(value: boolean);
    /**
     * 是否允许  point 相关的事件
     */
    get pointEventEnabled(): boolean;
    protected _enableKeyframeEvent: boolean;
    /**
     * 是否开启 point 相关的事件
     */
    get enableKeyframeEvent(): boolean;
    set enableKeyframeEvent(value: boolean);
    /**
     * 允许帧事件
     */
    get enableFrameEvent(): boolean;
    /**
     * 最后一次的关键帧
     */
    protected lastKeyframes: KeyframeInfos | null;
    /**
     * 最后一次的点索引
     */
    protected lastPolylineKeyframe: PolylineKeyframe | null;
    /**
     * 帧回调函数
     */
    protected frameFun: () => void;
    /**
     * 停止监听函数
     */
    protected _stopListenFun?: null | (() => void);
    /**
     * 停止监听的函数
     */
    protected get stopListenFun(): (() => void) | null | undefined;
    protected set stopListenFun(value: (() => void) | null | undefined);
    /**
     * 开始监听
     */
    startListen(): void;
    /**
     * 停止监听
     */
    stopListen(): void;
    /**
     * 自动开始监听
     */
    protected autoStartListen(): void;
    /**
     * 获取所有的监听器
     */
    get listeners(): {
        [type: string]: EventListener<any, any, any>[];
    } | null;
    /**
     * 是否有监听者
     */
    get hasListeners(): boolean;
    /**
     * 获取指定类型的所有监听者
     */
    getListeners(type: AnimationEventType): EventListener<any, any, any>[];
    /**
     * 销毁
     * @param keepAction - 是否保留 action
     * @returns
     */
    destroy(keepAction: boolean): void;
}
/**
 * 渲染循环
 * @param frameFun
 * @returns 返回一个函数，调用该函数会停止渲染循环
 */
export declare function renderLoop(frameFun: (time: DOMHighResTimeStamp) => void): () => void;
//# sourceMappingURL=AnimationActionKeyframe.d.ts.map