/**
 * AnimationClip.ts
 *
 * Keyframe-based animation clip: multi-track keyframes,
 * interpolation modes, animation events, looping, and blending.
 *
 * @module animation
 */
export type ScalarInterpolationMode = 'step' | 'linear' | 'cubic';
export type QuaternionInterpolationMode = 'nlerp';
/** @deprecated Legacy label retained as a typed migration input. It sampled linearly. */
export type LegacyInterpolationMode = 'slerp';
export type InterpolationMode = ScalarInterpolationMode | QuaternionInterpolationMode | LegacyInterpolationMode;
export type QuaternionValue = [number, number, number, number];
export type ClipSampleValue = number | QuaternionValue;
export interface ScalarClipKeyframe {
    time: number;
    value: number;
    inTangent?: number;
    outTangent?: number;
}
/** Legacy component-vector keyframe sampled through its track's component. */
export interface ComponentClipKeyframe {
    time: number;
    value: number[];
    inTangent?: number;
    outTangent?: number;
}
export interface QuaternionClipKeyframe {
    time: number;
    value: QuaternionValue;
}
export type ScalarTrackKeyframe = ScalarClipKeyframe | ComponentClipKeyframe;
export type ClipKeyframe = ScalarTrackKeyframe | QuaternionClipKeyframe;
interface ClipTrackBase {
    id: string;
    targetPath: string;
    property: string;
}
export interface ScalarClipTrack extends ClipTrackBase {
    component?: string;
    interpolation: ScalarInterpolationMode;
    keyframes: ScalarTrackKeyframe[];
}
export interface QuaternionClipTrack extends ClipTrackBase {
    property: 'rotation';
    component?: never;
    interpolation: QuaternionInterpolationMode;
    keyframes: QuaternionClipKeyframe[];
}
/**
 * @deprecated Component-valued `slerp` tracks never performed quaternion
 * interpolation. `AnimClip.addTrack()` accepts this shape so 6.1 callers can
 * migrate without a cast and stores it as an honest scalar `linear` track.
 */
export interface LegacySlerpClipTrack extends ClipTrackBase {
    component?: string;
    interpolation: LegacyInterpolationMode;
    keyframes: ScalarTrackKeyframe[];
}
export type ClipTrack = ScalarClipTrack | QuaternionClipTrack | LegacySlerpClipTrack;
export interface ClipEvent {
    time: number;
    name: string;
    data: Record<string, unknown>;
}
export declare class AnimClip {
    readonly id: string;
    readonly name: string;
    private tracks;
    private events;
    private _duration;
    private loop;
    private speed;
    private wrapMode;
    constructor(id: string, name: string, duration: number);
    setLoop(loop: boolean): void;
    isLooping(): boolean;
    setSpeed(speed: number): void;
    getSpeed(): number;
    setWrapMode(mode: typeof this.wrapMode): void;
    getWrapMode(): string;
    getDuration(): number;
    addTrack(track: ClipTrack): void;
    getTrack(id: string): ClipTrack | undefined;
    getTracks(): ClipTrack[];
    getTrackCount(): number;
    addEvent(time: number, name: string, data?: Record<string, unknown>): void;
    getEventsInRange(fromTime: number, toTime: number): ClipEvent[];
    getEvents(): ClipEvent[];
    /**
     * Backward-compatible scalar/component sampling view.
     *
     * Quaternion tracks are exposed through the four component keys used by the
     * pre-nlerp API, keeping the established `Map<string, number>` boundary.
     * Quaternion-aware code should call `sampleValues()` for tuple values.
     */
    sample(time: number): Map<string, number>;
    /** Sample scalar tracks and tuple-valued quaternion tracks without flattening. */
    sampleValues(time: number): Map<string, ClipSampleValue>;
    private segmentIndex;
    private sampleTrack;
    private sampleScalarTrack;
    private sampleQuaternionTrack;
    private wrapTime;
    static blend(a: ReadonlyMap<string, number>, b: ReadonlyMap<string, number>, weight: number): Map<string, number>;
    static blend(a: ReadonlyMap<string, ClipSampleValue>, b: ReadonlyMap<string, ClipSampleValue>, weight: number): Map<string, ClipSampleValue>;
}
export {};
//# sourceMappingURL=AnimationClip.d.ts.map