export default Track;
export type TrackContext = {
    /**
     * - The track ID.
     */
    id: string;
    /**
     * - The pub-sub channel.
     */
    pubSub?: (import("pub-sub-es").PubSub & {
        __fake__?: boolean;
    }) | undefined;
    /**
     * - A function that returns the current theme.
     */
    getTheme?: (() => import("./types").Theme) | undefined;
};
export type ExtendedTrackContext<T> = T & TrackContext;
/**
 * @typedef TrackContext
 * @property {string} id - The track ID.
 * @property {import('pub-sub-es').PubSub & { __fake__?: boolean }} [pubSub] - The pub-sub channel.
 * @property {() => import('./types').Theme} [getTheme] - A function that returns the current theme.
 */
/**
 * @template T
 * @typedef {T & TrackContext} ExtendedTrackContext
 */
/** @template Options */
declare class Track<Options> {
    /**
     * @param {TrackContext} context
     * @param {Options} options
     */
    constructor(context: TrackContext, options: Options);
    context: TrackContext;
    /** @type {import('pub-sub-es').PubSub} */
    pubSub: import("pub-sub-es").PubSub;
    /** @type {string} */
    id: string;
    /** @type {import('./types').Scale} */
    _xScale: import("./types").Scale;
    /** @type {import('./types').Scale} */
    _yScale: import("./types").Scale;
    /** @type {import('./types').Scale} */
    _refXScale: import("./types").Scale;
    /** @type {import('./types').Scale} */
    _refYScale: import("./types").Scale;
    /** @type {[number, number]} */
    position: [number, number];
    /** @type {[number, number]} */
    dimensions: [number, number];
    /** @type {Options} */
    options: Options;
    /** @type {Array<import('pub-sub-es').Subscription>} */
    pubSubs: Array<import("pub-sub-es").Subscription>;
    /** @type {() => (import('./types').Theme | undefined)} */
    getTheme: () => (import("./types").Theme | undefined);
    isLeftModified: boolean;
    /**
     * Check if a 2d location (x, y) is within the bounds of this track.
     *
     * @param {number} x - X position to be tested.
     * @param {number} y - Y position to be tested.
     * @return {boolean}  If `true` location is within the track.
     */
    isWithin(x: number, y: number): boolean;
    /**
     * Get a property from the track.
     * @template {keyof this} T
     * @param {T} prop - The property to get.
     * @return {() => this[T]}
     */
    getProp<T extends keyof this>(prop: T): () => this[T];
    getData(): void;
    /**
     * Capture click events. x and y are relative to the track position
     * @template T
     * @param {number} x - X position of the click event.
     * @param {number} y - Y position of the click event.
     * @param {T} evt - The event.
     * @return {{ type: 'generic', event: T, payload: null }}
     */
    click<T>(x: number, y: number, evt: T): {
        type: "generic";
        event: T;
        payload: null;
    };
    /** There was a click event outside the track * */
    clickOutside(): void;
    /** @returns {[number, number]} */
    getDimensions(): [number, number];
    /** @param {[number, number]} newDimensions */
    setDimensions(newDimensions: [number, number]): void;
    /**
     * @overload
     * @return {import('./types').Scale}
     */
    refXScale(): import("./types").Scale;
    /**
     * @overload
     * @param {import('./types').Scale} scale
     * @return {this}
     */
    refXScale(scale: import("./types").Scale): this;
    /**
     * @overload
     * @return {import('./types').Scale}
     */
    refYScale(): import("./types").Scale;
    /**
     * @overload
     * @param {import('./types').Scale} scale
     * @return {this}
     */
    refYScale(scale: import("./types").Scale): this;
    /**
     * @overload
     * @return {import('./types').Scale}
     */
    xScale(): import("./types").Scale;
    /**
     * @overload
     * @param {import('./types').Scale} scale
     * @return {this}
     */
    xScale(scale: import("./types").Scale): this;
    /**
     * @overload
     * @return {import('./types').Scale}
     */
    yScale(): import("./types").Scale;
    /**
     * @overload
     * @param {import('./types').Scale} scale
     * @return {this}
     */
    yScale(scale: import("./types").Scale): this;
    /**
     * @param {import('./types').Scale} newXScale
     * @param {import('./types').Scale} newYScale
     * @returns {void}
     */
    zoomed(newXScale: import("./types").Scale, newYScale: import("./types").Scale): void;
    /**
     * @param {import('./types').Scale} refXScale
     * @param {import('./types').Scale} refYScale
     * @returns {void}
     */
    refScalesChanged(refXScale: import("./types").Scale, refYScale: import("./types").Scale): void;
    /** @returns {void} */
    draw(): void;
    /** @returns {[number, number]} */
    getPosition(): [number, number];
    /**
     * @param {[number, number]} newPosition
     * @returns {void}
     */
    setPosition(newPosition: [number, number]): void;
    /**
     * A blank handler for MouseMove / Zoom events. Should be overriden
     * by individual tracks to provide
     *
     * @param {{}} evt
     * @returns {void}
     */
    defaultMouseMoveHandler(evt: {}): void;
    /** @returns {void} */
    remove(): void;
    /**
     * @param {Options} options
     * @returns {void}
     */
    rerender(options: Options): void;
    /**
     * This function is for seeing whether this track should respond
     * to events at this mouse position. The difference to `isWithin()` is that it
     * can be overwritten if a track is inactive for example.
     *
     * @param {number} x - X position to be tested.
     * @param {number} y - Y position to be tested.
     * @returns {boolean}
     */
    respondsToPosition(x: number, y: number): boolean;
    /**
     * @param {number} trackY
     * @param {number} kMultiplier
     * @returns {void}
     */
    zoomedY(trackY: number, kMultiplier: number): void;
    /**
     * @param {number} dY
     * @returns {void}
     */
    movedY(dY: number): void;
}