import { StreamTrackEntity } from '../../data';
import { Animation } from '../animation';
import { Keyframe } from '../keyframe';
import { LayerClip } from '../layerclip';
import { Stream, StreamState } from '../stream';
import { Track } from './track';
/**
 * Allows a stream (e.g a video, audio, 3D model animation, anything extending the Stream interface) to be added to a clip.
 *
 * @param animation The associated Animation instance.
 * @param _entity The entity whose stream is being managed.
 * @param _property The property or array of properties targeted by the stream.
 */
export declare class StreamTrack extends Track {
    readonly animation: Animation;
    private _entity;
    private _property;
    private _stream;
    private _entities;
    private _entitiesById;
    private _entitiesDirty;
    private _weights;
    private _weightsById;
    private _weightsDirty;
    private _lastTick?;
    private _lastLoopNumber?;
    private _lastState;
    private _lastRate;
    constructor(animation: Animation, _entity: any, _property: (string | number)[]);
    /**
     * Getter for the list of paths influenced by the track.
     * As this track does not influence any paths, it returns an empty array.
     *
     * @returns An empty array.
     */
    get influencedPaths(): string[];
    /**
     * Getter for the stream associated with the entity.
     *
     * @returns The Stream associated with the entity, if available.
     */
    get stream(): Stream | undefined;
    computePathProperty(t: number, p: string, valueBefore: any, parentWeight?: number): any;
    /**
     * Sets the weight keyframes for the track using an id-indexed object.
     *
     * @param weights An object mapping weight keyframe IDs to keyframes.
     */
    setWeightsById(weights: {
        [id: string]: Keyframe;
    }): void;
    /**
     * Getter for sorted weight keyframes by their time values.
     *
     * @returns A sorted array of weight keyframes.
     */
    get sortedWeights(): Keyframe[];
    /**
     * Adds a block (StreamTrackEntity) representing a stream state in the timeline.
     *
     * @param k The block to be added.
     */
    addBlock(k: StreamTrackEntity): void;
    /**
     * Sets the blocks for the track using an id-indexed object.
     *
     * @param blocks An object mapping block IDs to StreamTrackEntities.
     */
    setBlocksById(weights: {
        [id: string]: StreamTrackEntity;
    }): void;
    /**
     * Getter for sorted blocks by their start time.
     *
     * @returns A sorted array of StreamTrackEntities.
     */
    get sortedBlocks(): StreamTrackEntity[];
    /** @internal */
    streamPause(isActive: boolean, active: LayerClip | null | undefined): void;
    /** @internal */
    streamSeek(t: number, resolvedRate: number, isActive: boolean, active: LayerClip | null | undefined): void;
    private _isPlayingInClip;
    private _isPlayingInLayerClip;
    /** @internal */
    streamTick(clipState: StreamState, t: number, rate: number, isActive: boolean, active: LayerClip | null | undefined, force?: boolean, stalled?: boolean, parentWeight?: number): void;
    private _applyState;
    private _resolveBlock;
    /**
     * Determines if the track's stream is stalled.
     *
     * @returns A boolean indicating if the stream is stalled.
     */
    isStalled(): boolean;
}