/** @import * as t from './types' */
/**
 * Get a valueScale for a heatmap.
 *
 * If the scalingType isn't specified, then default to the defaultScaling.
 *
 * @param {string} scalingType: The type of the (e.g. 'linear', or 'log')
 * @param {number} minValue: The minimum data value to which this scale will apply
 * @param {number} pseudocountIn: A value to add to all numbers to prevent taking the log of 0
 * @param {number} maxValue: The maximum data value to which this scale will apply
 * @param {string} defaultScaling: The default scaling type to use in case
 * 'scalingType' is null (e.g. 'linear' or 'log')
 *
 * @returns {[string, import('d3-scale').ScaleLogarithmic<number, number> | import('d3-scale').ScaleLinear<number, number>]}
 * An array of [string, scale] containing the scale type and a scale with an appropriately set domain and range
 */
export function getValueScale(scalingType: string, minValue: number, pseudocountIn: number, maxValue: number, defaultScaling: string): [string, import("d3-scale").ScaleLogarithmic<number, number> | import("d3-scale").ScaleLinear<number, number>];
export default TiledPixiTrack;
export type Scale = {
    minValue?: number | null | undefined;
    maxValue?: number | null | undefined;
    maxRawValue?: number | null | undefined;
    minRawValue?: number | null | undefined;
};
/**
 * An alternative to Tile. Perhaps the worst data type. An array of numbers with some extra properties.
 */
export type TilePositionArrayObject = Array<number> & Pick<Tile, "mirrored" | "tilePositionId">;
export type Tile = {
    tileId: string;
    tileData: TileData;
    remoteId: string;
    mirrored: unknown;
    tilePositionId: string;
    graphics: import("pixi.js").Graphics;
};
export type TileData = {
    tilesetUid: string;
    zoomLevel: number;
    tilePos: Array<number>;
    error: string;
    dense: Float32Array;
    minNonZero: number;
    maxNonZero: number;
    /**
     * - Optional 1D or 2D array dimensions
     */
    shape?: number[] | undefined;
};
export type TiledPixiTrackContextBase = {
    dataFetcher: DataFetcher;
    dataConfig: t.DataConfig;
    /**
     * A function to redraw this track. Typically called when an
     * asynchronous event occurs (i.e. tiles loaded)
     */
    animate: Function;
    /**
     * The range of values has changed so we need to inform
     * the higher ups that the value scale has changed. Only occurs on tracks with ``dense`` data.
     */
    onValueScaleChanged: () => void;
    /**
     * A callback to do something once once the tileset
     * info is received. Usually it registers some information about the tileset with its definition
     */
    handleTilesetInfoReceived?: ((t: t.TilesetInfo) => void) | undefined;
};
export type TiledPixiTrackContext = import("./PixiTrack").ExtendedPixiContext<TiledPixiTrackContextBase>;
export type TiledPixiTrackOptions = {
    /**
     * - If the label is to be drawn, where should it be drawn?
     */
    labelPosition: string;
    /**
     * - What should be drawn in the label.
     */
    labelText: string;
    maxZoom: number;
    name: string;
};
export type ExtendedTiledPixiTrackOptions<T> = T & TiledPixiTrackOptions;
/**
 * @typedef Scale
 * @property {number | null} [minValue]
 * @property {number | null} [maxValue]
 * @property {number | null} [maxRawValue]
 * @property {number | null} [minRawValue]
 */
/**
 * An alternative to Tile. Perhaps the worst data type. An array of numbers with some extra properties.
 * @typedef {Array<number> & Pick<Tile, 'mirrored' | 'tilePositionId'>} TilePositionArrayObject
 */
/**
 * @typedef Tile
 * @property {string} tileId
 * @property {TileData} tileData
 * @property {string} remoteId
 * @property {unknown} mirrored
 * @property {string} tilePositionId
 * @property {import("pixi.js").Graphics} graphics
 */
/**
 * @typedef TileData
 * @property {string} tilesetUid
 * @property {number} zoomLevel
 * @property {Array<number>} tilePos
 * @property {string} error
 * @property {Float32Array} dense
 * @property {number} minNonZero
 * @property {number} maxNonZero
 * @property {Array<number>} [shape] - Optional 1D or 2D array dimensions
 */
/**
 * @typedef TiledPixiTrackContextBase
 * @property {DataFetcher} dataFetcher
 * @property {t.DataConfig} dataConfig
 * @property {Function} animate A function to redraw this track. Typically called when an
 *  asynchronous event occurs (i.e. tiles loaded)
 * @property {() => void} onValueScaleChanged The range of values has changed so we need to inform
 *  the higher ups that the value scale has changed. Only occurs on tracks with ``dense`` data.
 * @property {(t: t.TilesetInfo) => void} [handleTilesetInfoReceived] A callback to do something once once the tileset
 *  info is received. Usually it registers some information about the tileset with its definition
 */
/**
 * @typedef {import('./PixiTrack').ExtendedPixiContext<TiledPixiTrackContextBase>} TiledPixiTrackContext
 */
/**
 * @typedef TiledPixiTrackOptions
 * @property {string} labelPosition - If the label is to be drawn, where should it be drawn?
 * @property {string} labelText - What should be drawn in the label.
 * @property {number} maxZoom
 * @property {string} name
 */
/**
 * @template T
 * @typedef {T & TiledPixiTrackOptions} ExtendedTiledPixiTrackOptions
 */
/**
 * The TiledPixiTrack requires an options parameter, which should be an object containing properties specified in
 * TiledPixiTrackOptions. It is capable of accepting any property defined in any of its superclasses.
 * @template {ExtendedTiledPixiTrackOptions<{[key: string]: any}>} Options
 * @extends {PixiTrack<Options>}
 * */
declare class TiledPixiTrack<Options extends ExtendedTiledPixiTrackOptions<{
    [key: string]: any;
}>> extends PixiTrack<Options> {
    /**
     *
     * @param {TiledPixiTrackContext} context
     * @param {Options} options
     */
    constructor(context: TiledPixiTrackContext, options: Options);
    /** @type {number} */
    renderVersion: number;
    /** @type {Array<Pick<Tile, 'tileId' |'remoteId' | 'mirrored'>>} */
    visibleTiles: Array<Pick<Tile, "tileId" | "remoteId" | "mirrored">>;
    /** @type {Set<string>} */
    visibleTileIds: Set<string>;
    renderingTiles: Set<any>;
    fetching: Set<any>;
    /** @type {Scale} */
    scale: Scale;
    /** @type {{[id: string]: Tile}} */
    fetchedTiles: {
        [id: string]: Tile;
    };
    /** @type {Record<string, import('pixi.js').DisplayObject>} */
    tileGraphics: Record<string, import("pixi.js").DisplayObject>;
    /** @type {number} */
    maxZoom: number;
    medianVisibleValue: number | null | undefined;
    backgroundTaskScheduler: {
        taskList: import("./utils/background-task-scheduler").Task[];
        taskHandle: number | null;
        requestIdleCallbackTimeout: number;
        /**
         * @template T
         * @overload
         * @param {(data: T) => void} taskHandler
         * @param {T} taskData
         * @param {string | null=} trackId
         * @return {void}
         */
        enqueueTask<T>(taskHandler: (data: T) => void, taskData: T, trackId?: (string | null) | undefined): void;
        /**
         * If `taskData` is `null` the `taskHandler` will eventaully be called without any arguments.
         *
         * @overload
         * @param {() => void} taskHandler
         * @param {null} taskData
         * @param {string | null=} trackId
         * @return {void}
         */
        enqueueTask(taskHandler: () => void, taskData: null, trackId?: (string | null) | undefined): void;
        runTaskQueue(deadline: {
            timeRemaining(): number;
            didTimeout: boolean;
        }): void;
    };
    continuousScaling: boolean;
    valueScaleMin: number | null;
    fixedValueScaleMin: number | null;
    valueScaleMax: number | null;
    fixedValueScaleMax: number | null;
    /** @type {Record<string, Array<Function>>} */
    listeners: Record<string, Array<Function>>;
    animate: Function;
    onValueScaleChanged: () => void;
    prevValueScale: any;
    dataFetcher: DataFetcher;
    /** @type {null | string} */
    tilesetInfoError: null | string;
    uuid: string;
    trackNotFoundText: import("pixi.js").Text;
    refreshTilesDebounced: (request: unknown) => void;
    chromInfo: import("./utils/parse-chromsizes-rows.js").ParsedChromsizes;
    tilesetUid: string | undefined;
    server: string;
    /** @param {number | string} value */
    setFixedValueScaleMin(value: number | string): void;
    /** @param {number | string} value */
    setFixedValueScaleMax(value: number | string): void;
    checkValueScaleLimits(): void;
    /**
     * Register an event listener for track events. Currently, the only supported
     * event is ``dataChanged``.
     *
     * @param {string} event The event to listen for
     * @param {Function} callback The callback to call when the event occurs. The
     *  parameters for the event depend on the event called.
     *
     * @example
     *
     *  trackObj.on('dataChanged', (newData) => {
     *   console.log('newData:', newData)
     *  });
     */
    on(event: string, callback: Function): void;
    /**
     * @param {string} event The event to listen for
     * @param {Function} callback The callback to call when the event occurs. The
     *  parameters for the event depend on the event called.
     */
    off(event: string, callback: Function): void;
    /** Called when tileset info is received. The actual tileset info
     * can be found in this.tilesetInfo.
     *
     * Child tracks can implement this method.
     */
    tilesetInfoReceived(): void;
    /**
     * Return the set of ids of all tiles which are both visible and fetched.
     */
    visibleAndFetchedIds(): string[];
    visibleAndFetchedTiles(): Tile[];
    /**
     * Set which tiles are visible right now.
     *
     * @param {Array<TilePositionArrayObject>} tilePositions - A set of tiles which will be considered the currently visible tile positions.
     */
    setVisibleTiles(tilePositions: Array<TilePositionArrayObject>): void;
    removeOldTiles(): void;
    refreshTiles(): void;
    /** @param {Tile} tile */
    parentInFetched(tile: Tile): boolean;
    /** @param {Tile} tile */
    parentTileId(tile: Tile): string;
    /**
     * Remove obsolete tiles
     *
     * @param {Array<string>} toRemoveIds: An array of tile ids to remove from the list of fetched tiles.
     */
    removeTiles(toRemoveIds: Array<string>): void;
    /**
     * @param {t.Scale} newXScale
     * @param {t.Scale} newYScale
     */
    zoomed(newXScale: t.Scale, newYScale: t.Scale, k?: number, tx?: number, ty?: number): void;
    /**
     * Check to see if all the visible tiles are loaded.
     *
     * If they are, remove all other tiles.
     */
    areAllVisibleTilesLoaded(): boolean;
    /**
     * Function is called when all tiles that should be visible have
     * been received.
     */
    allTilesLoaded(): void;
    /** @param {number} [_] - Optional value to set */
    minValue(_?: number): number | this | null | undefined;
    /** @param {number} [_] - Optional value to set */
    maxValue(_?: number): number | this | null | undefined;
    minRawValue(): number | null | undefined;
    maxRawValue(): number | null | undefined;
    /** @param {Tile} tile */
    initTile(tile: Tile): void;
    /** @param {Tile} tile */
    updateTile(tile: Tile): void;
    /** @param {Tile} tile */
    destroyTile(tile: Tile): void;
    addMissingGraphics(): void;
    /**
     * Change the graphics for existing tiles
     */
    updateExistingGraphics(): void;
    synchronizeTilesAndGraphics(): void;
    /**
     * @typedef TiledAreaTile
     * @property {string} tileId
     * @property {string} type
     * @property {unknown} data
     */
    /**
     *
     * @param {TiledAreaTile} tile A tile returned by a TiledArea.
     * @param {function} dataLoader A function for extracting drawable data from a tile. This
     * usually means differentiating the between dense and sparse tiles and putting the data into an array.
     * @returns
     */
    loadTileData(tile: {
        tileId: string;
        type: string;
        data: unknown;
    }, dataLoader: Function): any;
    /** @param {Pick<Tile,'remoteId'>[]} toFetch */
    fetchNewTiles(toFetch: Pick<Tile, "remoteId">[]): void;
    /**
     * We've gotten a bunch of tiles from the server in
     * response to a request from fetchTiles.
     * @param {Object<string, import('./data-fetchers/DataFetcher').DividedTile | Tile | TilePositionArrayObject>} loadedTiles
     */
    receivedTiles(loadedTiles: {
        [x: string]: import("./data-fetchers/DataFetcher").DividedTile | Tile | TilePositionArrayObject;
    }): void;
    _checkForErrors(): string[];
    /**
     * Draw a tile on some graphics
     * @param {Tile} tile
     */
    drawTile(tile: Tile): void;
    calculateMedianVisibleValue(): number | undefined;
    allVisibleValues(): number[];
    minVisibleValue(ignoreFixedScale?: boolean): number | null;
    minVisibleValueInTiles(ignoreFixedScale?: boolean): number | null;
    maxVisibleValue(ignoreFixedScale?: boolean): number | null;
    maxVisibleValueInTiles(ignoreFixedScale?: boolean): number | null;
    /** @typedef {import('d3-scale').ScaleQuantile<number, never> & { ticks?: (count: number) => number[] }} ScaleQuantile */
    /**
     * Create a value scale that will be used to position values
     * along the y axis.
     * @param {number} minValue The minimum value of the data
     * @param {number} medianValue The median value of the data. Potentially used for adding a pseudocount
     * @param {number} maxValue The maximum value of the data
     * @param {number} [inMargin] A number of pixels to be left free on the top and bottom
     *    of the track. For example if the glyphs have a certain
     *    width and we want all of them to fit into the space
     * @returns {[t.Scale | ScaleQuantile, number]}
     */
    makeValueScale(minValue: number, medianValue: number, maxValue: number, inMargin?: number): [t.Scale | (import("d3-scale").ScaleQuantile<number, never> & {
        ticks?: (count: number) => number[];
    }), number];
}
import { DataFetcher } from './data-fetchers';
import type * as t from './types';
import PixiTrack from './PixiTrack';