gosling.js 1.0.5 → 2.0.0-alpha.2

package/dist/src/higlass/higlass-vendored.d.ts

@@ -0,0 +1,1297 @@
+export type SelectedRowsOptions = {
+    /**
+     * - Row indices, for ordering and filtering rows. Used by the HorizontalMultivecTrack.
+     */
+    selectedRows: number[] | number[][];
+    /**
+     * - The aggregation function to use ("mean", "sum", etc).
+     */
+    selectedRowsAggregationMode: "mean" | "sum" | "variance" | "deviation";
+    /**
+     * - Whether the height of row groups should be relative to the size of the group.
+     */
+    selectedRowsAggregationWithRelativeHeight: boolean;
+    /**
+     * - Where will the aggregation be performed? Possible values: "client", "server".
+     */
+    selectedRowsAggregationMethod: "client" | "server";
+};
+/**
+ * <Server>
+ */
+export type TileData = {
+    server: string;
+    tileId: string;
+    zoomLevel: number;
+    tilePos: [number] | [number, number];
+    tilesetUid: string;
+};
+export type DenseTileData = {
+    server: string;
+    tileId: string;
+    zoomLevel: number;
+    tilePos: [number] | [number, number];
+    tilesetUid: string;
+    dense: Float32Array;
+    dtype: string;
+    denseDataExtrema: DenseDataExtrema1D | DenseDataExtrema2D;
+    minNonZero: number;
+    maxNonZero: number;
+};
+export type CompletedTileData<T> = Omit<T, keyof DenseTileData> & (TileData | DenseTileData);
+export type TileResponse = {
+    /**
+     * - a base64 encoded string
+     */
+    dense?: string | undefined;
+};
+export type DataConfig = any;
+export type TilesetInfo = any;
+export type AbstractDataFetcher<T> = any;
+export type Tile = {
+    min_value: number;
+    max_value: number;
+    denseDataExtrema: DenseDataExtrema1D | DenseDataExtrema2D;
+    minNonZero: number;
+    maxNonZero: number;
+    dense: Array<number> | Float32Array;
+    dtype: string;
+    server: string;
+    tilePos: number[];
+    tilePositionId: string;
+    tilesetUid: string;
+    zoomLevel: number;
+};
+export type DividedTileA = Pick<Tile, "zoomLevel" | "tilePos" | "tilePositionId">;
+export type DividedTileB = Pick<Tile, "zoomLevel" | "tilePos" | "tilePositionId" | "dense" | "denseDataExtrema" | "minNonZero" | "maxNonZero">;
+export type DividedTile = DividedTileA | DividedTileB;
+export type ResolvedDataConfig = Omit<DataConfig, "children"> & {
+    children?: DataFetcher[];
+    tilesetUid?: string;
+    tilesetInfo: TilesetInfo;
+};
+export type ChromsizeRow = [string, number];
+export type CumulativeChromsizeEntry = {
+    id: number;
+    chr: string;
+    pos: number;
+};
+export type ParsedChromsizes = {
+    cumPositions: CumulativeChromsizeEntry[];
+    chrPositions: Record<string, CumulativeChromsizeEntry>;
+    totalLength: number;
+    chromLengths: Record<string, number>;
+};
+export type DataTask<T> = {
+    data: T;
+    handler: (data: T) => void;
+    trackId?: string | undefined;
+};
+export type NullDataTask = {
+    data: null;
+    handler: () => void;
+    trackId?: string | undefined;
+};
+export type Task = DataTask<any> | NullDataTask;
+export type TrackContext = {
+    /**
+     * - The track ID.
+     */
+    id: string;
+    /**
+     * - The pub-sub channel.
+     */
+    pubSub?: (import("pub-sub-es/dist/pub-sub").PubSub & {
+        __fake__?: boolean;
+    }) | undefined;
+};
+export type ExtendedTrackContext<T> = T & TrackContext;
+export type PixiTrackOptions = {
+    /**
+     * - If the label is to be drawn, where should it be drawn?
+     */
+    labelPosition: string;
+    /**
+     * - What should be drawn in the label.
+     * If either labelPosition or labelText are false, no label will be drawn.
+     */
+    labelText: string;
+    trackBorderWidth?: number | undefined;
+    trackBorderColor?: string | undefined;
+    backgroundColor?: string | undefined;
+    labelColor?: string | undefined;
+    lineStrokeColor?: string | undefined;
+    barFillColor?: string | undefined;
+    name?: string | undefined;
+    labelTextOpacity?: number | undefined;
+    labelBackgroundColor?: string | undefined;
+    labelLeftMargin?: number | undefined;
+    labelRightMargin?: number | undefined;
+    labelTopMargin?: number | undefined;
+    labelBottomMargin?: number | undefined;
+    labelBackgroundOpacity?: number | undefined;
+    labelShowAssembly?: boolean | undefined;
+    labelShowResolution?: boolean | undefined;
+    dataTransform?: string | undefined;
+};
+export type View2D = {
+    get: (i: number, j: number) => number;
+    set: (i: number, j: number, v: number) => void;
+};
+export type Aggregation = (values: number[]) => number | undefined;
+export type ChromosomePosition<Name extends string> = [name: Name, pos: number, offset: number, insertPoint: number];
+export type MouseTrackOptions = {
+    /**
+     * - Color of the mouse position.
+     */
+    mousePositionColor?: string | undefined;
+    /**
+     * - Alpha of the mouse position.
+     */
+    mousePositionAlpha?: number | undefined;
+};
+export type ClassContext = {
+    pForeground?: import("pixi.js").Container | undefined;
+    pMasked?: import("pixi.js").Container | undefined;
+    pMain?: import("pixi.js").Container | undefined;
+    xScale: () => any;
+    yScale: () => any;
+    getPosition: () => [number, number];
+    getDimensions: () => [number, number];
+    pubSub: import("pub-sub-es").PubSub;
+    pubSubs: Array<import("pub-sub-es").Subscription>;
+    getProp: (prop: "flipText") => () => boolean;
+    options: {};
+};
+/** @implements {AbstractDataFetcher<Tile | DividedTile>} */
+export class DataFetcher implements AbstractDataFetcher<Tile | DividedTile> {
+    /**
+     * @param {import('../types').DataConfig} dataConfig
+     * @param {import('pub-sub-es').PubSub} pubSub
+     */
+    constructor(dataConfig: any, pubSub: import("pub-sub-es").PubSub);
+    /** @type {boolean} */
+    tilesetInfoLoading: boolean;
+    /** @type {ResolvedDataConfig} */
+    dataConfig: ResolvedDataConfig;
+    /** @type {string} */
+    uuid: string;
+    /** @type {import('pub-sub-es').PubSub} */
+    pubSub: import("pub-sub-es").PubSub;
+    /**
+     * We don't a have a tilesetUid for this track. But we do have a url, filetype
+     * and server. Using these, we can use the server to fullfill tile requests
+     * from this dataset.
+     *
+     * @param {object} opts
+     * @param {string} opts.server - The server api location (e.g. 'localhost:8000/api/v1')
+     * @param {string} opts.url - The location of the data file (e.g. 'encode.org/my.file.bigwig')
+     * @param {string} opts.filetype - The type of file being served (e.g. 'bigwig')
+     * @param {string=} opts.coordSystem - The coordinate system being served (e.g. 'hg38')
+     */
+    registerFileUrl({ server, url, filetype, coordSystem }: {
+        server: string;
+        url: string;
+        filetype: string;
+        coordSystem?: string | undefined;
+    }): Promise<Response>;
+    /**
+     * Obtain tileset infos for all of the tilesets listed
+     * @param {import('../types').HandleTilesetInfoFinished} finished - A callback that will be called
+     */
+    tilesetInfo(finished: any): Promise<any>;
+    /**
+     * Obtain tileset infos for all of the tilesets listed
+     *
+     * If there is more than one tileset info, this function
+     * should (not currently implemented) check if the tileset
+     * infos have the same dimensions and then return a common
+     * one.
+     *
+     * @param {import('../types').HandleTilesetInfoFinished} finished - A callback that will be called
+     *  when all tileset infos are loaded
+     */
+    tilesetInfoAfterRegister(finished: any): void;
+    /**
+     * @param {string} tilesetUid - Uid of the tileset on the server
+     * @param {string} tileId - The tileId of the tile
+     * @returns {string} The full tile id that the server will parse.
+     *
+     * @example
+     * ```javascript
+     * // returns 'xyxx.0.0.0'
+     * fullTileId('xyxx', '0.0.0');
+     * ```
+     */
+    fullTileId(tilesetUid: string, tileId: string): string;
+    /**
+     * Fetch a set of tiles.
+     *
+     * Because the track shouldn't care about tileset ids, the tile ids
+     * should just include positions and any necessary transforms.
+     *
+     * @param {(tiles: Record<string, DividedTile | Tile>) => void} receivedTiles - A function to call once the tiles have been fetched
+     * @param {string[]} tileIds - The tile ids to fetch
+     * @returns {Promise<Record<string, DividedTile | Tile>>}
+     */
+    fetchTilesDebounced(receivedTiles: (tiles: Record<string, DividedTile | Tile>) => void, tileIds: string[]): Promise<Record<string, DividedTile | Tile>>;
+    /**
+     * Return an array consisting of the division of the numerator
+     * array by the denominator array
+     *
+     * @param {ArrayLike<number>} numeratorData - An array of numerical values
+     * @param {ArrayLike<number>} denominatorData - An array of numerical values
+     *
+     * @returns {Float32Array} An array consisting of the division of the numerator by the denominator
+     */
+    divideData(numeratorData: ArrayLike<number>, denominatorData: ArrayLike<number>): Float32Array;
+    horizontalSlice(): null;
+    /**
+     * Extract a slice from a matrix at a given position.
+     *
+     * @param {Array<number>} inputData - An array containing a matrix stored row-wise
+     * @param {Array<number>} arrayShape - The shape of the array, should be a
+     *  two element array e.g. [256,256].
+     * @param {number} sliceIndex - The index across which to take the slice
+     * @param {number=} axis - The axis along which to take the slice
+     * @returns {Array<number>} an array corresponding to a slice of this matrix
+     */
+    extractDataSlice(inputData: Array<number>, arrayShape: Array<number>, sliceIndex: number, axis?: number | undefined): Array<number>;
+    /**
+     * Fetch a horizontal section of a 2D dataset
+     * @param {(tiles: Record<string, Tile>) => void} receivedTiles - A function to call once the tiles have been fetched
+     * @param {string[]} tileIds - The tile ids to fetch
+     * @param {boolean=} vertical - Whether to fetch a vertical section
+     * @returns {Promise<Record<string, Tile>>}
+     */
+    fetchHorizontalSection(receivedTiles: (tiles: Record<string, Tile>) => void, tileIds: string[], vertical?: boolean | undefined): Promise<Record<string, Tile>>;
+    /**
+     * @typedef {{ zoomLevel: number, tilePos: number[], dense?: ArrayLike<number> }} Dividable
+     * @param {[Record<string, Dividable>, Record<string, Dividable>]} returnedTiles
+     * @param {string[]} tileIds
+     * @returns {Record<string, DividedTile>}
+     */
+    makeDivided(returnedTiles: [Record<string, {
+        zoomLevel: number;
+        tilePos: number[];
+        dense?: ArrayLike<number>;
+    }>, Record<string, {
+        zoomLevel: number;
+        tilePos: number[];
+        dense?: ArrayLike<number>;
+    }>], tileIds: string[]): Record<string, DividedTile>;
+}
+/**
+ * @template {ArrayLike<number>} [T=ArrayLike<number>]
+ */
+export class DenseDataExtrema1D<T extends ArrayLike<number> = ArrayLike<number>> {
+    /**
+     * This module efficiently computes extrema of arbitrary subsets of a given data array.
+     * The array is subdivided into 'numSubsets' subsets where extrema are precomputed.
+     * These values are used to compute extrema given arbitrary start and end indices via
+     * the getMinNonZeroInSubset and getMaxNonZeroInSubset methods.
+     * @param {T}  data
+     */
+    constructor(data: T);
+    /** @type {number} */
+    epsilon: number;
+    /** @type {T} */
+    data: T;
+    /** @type {number} */
+    tileSize: number;
+    /** @type {number} */
+    paddedTileSize: number;
+    /** @type {number} */
+    numSubsets: number;
+    /** @type {number} */
+    subsetSize: number;
+    subsetMinimums: number[];
+    subsetMaximums: number[];
+    minNonZeroInTile: number;
+    maxNonZeroInTile: number;
+    /**
+     * Computes the non-zero minimum in a subset using precomputed values,
+     * if possible. data[end] is not considered.
+     *
+     * @param {[start: number, end: number]} indexBounds
+     * @return {number} non-zero minium of the subset
+     */
+    getMinNonZeroInSubset(indexBounds: [start: number, end: number]): number;
+    /**
+     * Computes the non-zero maximum in a subset using precomputed values, if possible
+     *
+     * @param {[start: number, end: number]}  indexBounds
+     * @return {number} non-zero maxium of the subset
+     */
+    getMaxNonZeroInSubset(indexBounds: [start: number, end: number]): number;
+    /**
+     * Precomputes non-zero minimums of subsets of the given data vector
+     *
+     * @returns {Array<number>} - Minimums of the regularly subdivided data vector
+     */
+    computeSubsetNonZeroMinimums(): Array<number>;
+    /**
+     * Precomputes non-zero maximums of subsets of the given data vector
+     * @return {Array<number>} Maximums of the regularly subdivided data vector
+     */
+    computeSubsetNonZeroMaximums(): Array<number>;
+    /**
+     * Computes the non-zero minimum in the entire data array using precomputed values
+     *
+     * @return {number} Non-zeros maximum of the data
+     */
+    getMinNonZeroInTile(): number;
+    /**
+     * Computes the non-zero maximum in the entire data array using precomputed values
+     *
+     * @return {number} Non-zeros maximum of the data
+     */
+    getMaxNonZeroInTile(): number;
+    /**
+     * Calculate the minimum non-zero value in the data from start
+     * to end. No precomputations are used to compute the min.
+     *
+     * @param {ArrayLike<number>} data
+     * @param {number} start
+     * @param {number} end
+     * @return {number} non-zero min in subset
+     */
+    minNonZero(data: ArrayLike<number>, start: number, end: number): number;
+    /**
+     * Calculate the maximum non-zero value in the data from start
+     * to end. No precomputations are used to compute the max.
+     *
+     * @param {ArrayLike<number>} data
+     * @param {number} start
+     * @param {number} end
+     * @return {number} non-zero max in subset
+     */
+    maxNonZero(data: ArrayLike<number>, start: number, end: number): number;
+}
+export class HeatmapTiledPixiTrack extends TiledPixiTrack {
+    constructor(context: any, options: any);
+    is2d: boolean;
+    uid: string;
+    scaleBrush: import("d3-brush").BrushBehavior<any>;
+    onTrackOptionsChanged: any;
+    isShowGlobalMousePosition: any;
+    isValueScaleLocked: any;
+    pColorbarArea: PIXI.Graphics;
+    pColorbar: PIXI.Graphics;
+    axis: AxisPixi;
+    colorScale: number[][];
+    gBase: import("d3-selection").Selection<SVGGElement, any, null, undefined>;
+    gMain: import("d3-selection").Selection<SVGGElement, any, null, undefined>;
+    gColorscaleBrush: import("d3-selection").Selection<SVGGElement, any, null, undefined>;
+    brushing: boolean;
+    prevIndUpperLeftTile: string;
+    onMouseMoveZoom: any;
+    dataLens: Float32Array<ArrayBuffer>;
+    mouseMoveHandlerBound: (e: Object) => void;
+    hideMousePosition: Function | undefined;
+    /**
+     * Mouse move handler
+     *
+     * @param  {Object}  e  Event object.
+     */
+    mouseMoveHandler(e: Object): void;
+    mouseX: any;
+    mouseY: any;
+    /**
+     * Mouse move and zoom handler. Is triggered on both events.
+     *
+     * @param  {Number}  absX  Absolute X coordinate.
+     * @param  {Number}  absY  Absolute Y coordinate
+     */
+    mouseMoveZoomHandler(absX?: number, absY?: number): void;
+    scheduleRerender(): void;
+    handleRerender(): void;
+    /**
+     * Get absolute (i.e., display) tile dimension and position.
+     *
+     * @param {Number}  zoomLevel  Current zoom level.
+     * @param {Array}  tilePos  Tile position.
+     * @return {Object}  Object holding the absolute x, y, width, and height.
+     */
+    getAbsTileDim(zoomLevel: number, tilePos: any[], mirrored: any): Object;
+    updateValueScale(): any[];
+    valueScale: any;
+    limitedValueScale: any;
+    rerender(options: any, force: any): void;
+    tileDataToCanvas(pixData: any): HTMLCanvasElement;
+    exportData(): void;
+    /**
+     * Position sprite (the rendered tile)
+     *
+     * @param  {Object}  sprite  PIXI sprite object.
+     * @param  {Number}  zoomLevel  Current zoom level.
+     * @param  {Array}  tilePos  X,Y position of tile.
+     * @param  {Boolean}  mirrored  If `true` tile is mirrored.
+     */
+    setSpriteProperties(sprite: Object, zoomLevel: number, tilePos: any[], mirrored: boolean): void;
+    refXScale(_: any): void;
+    refYScale(_: any): void;
+    newBrushOptions(selection: any): any;
+    brushStart(): void;
+    brushMoved(event: any): void;
+    brushEnd(): void;
+    removeColorbar(): void;
+    drawColorbar(): void;
+    colorbarHeight: number | undefined;
+    northHandle: import("d3-selection").Selection<SVGRectElement, {
+        type: string;
+    }, SVGGElement, any> | undefined;
+    exportColorBarSVG(): HTMLElement;
+    /**
+     * Set data lens size
+     *
+     * @param  {Integer}  newDataLensSize  New data lens size. Needs to be an odd
+     *   integer.
+     */
+    setDataLensSize(newDataLensSize: Integer): void;
+    dataLensPadding: number | undefined;
+    dataLensSize: number | undefined;
+    binsPerTile(): any;
+    /**
+     * Get the data in the visible rectangle
+     *
+     * The parameter coordinates are in pixel coordinates
+     *
+     * @param {int} x: The upper left corner of the rectangle in pixel coordinates
+     * @param {int} y: The upper left corner of the rectangle in pixel coordinates
+     * @param {int} width: The width of the rectangle (pixels)
+     * @param {int} height: The height of the rectangle (pixels)
+     *
+     * @returns {Array} A numjs array containing the data in the visible region
+     *
+     */
+    getVisibleRectangleData(x: int, y: int, width: int, height: int): any[];
+    /**
+     * Convert the raw tile data to a rendered array of values which can be represented as a sprite.
+     *
+     * @param tile: The data structure containing all the tile information. Relevant to
+     *              this function are tile.tileData = \{'dense': [...], ...\}
+     *              and tile.graphics
+     */
+    initTile(tile: any): void;
+    updateTile(tile: any): void;
+    destroyTile(tile: any): void;
+    pixDataFunction(tile: any, pixData: any): void;
+    /**
+     * Render / draw a tile.
+     *
+     * @param {Object}  tile  Tile data to be rendered.
+     */
+    renderTile(tile: Object): void;
+    refScalesChanged(refXScale: any, refYScale: any): void;
+    /**
+     * Bypass this track's exportSVG function
+     */
+    superSVG(): [HTMLElement, HTMLElement];
+    exportSVG(): HTMLElement[];
+    getVisiblePartOfUppLeftTile(): any[] | null;
+    getIndicesOfVisibleDataInTile(tile: any): number[];
+    minVisibleValue(ignoreFixedScale?: boolean): number | null;
+    maxVisibleValue(ignoreFixedScale?: boolean): number | null;
+    zoomed(newXScale: any, newYScale: any, k: any, tx: any, ty: any): void;
+    /**
+     * Helper method for adding a tile ID in place. Used by `tilesToId()`.
+     *
+     * @param  {Array}  tiles  Array tile ID should be added to.
+     * @param  {Integer}  zoomLevel  Zoom level.
+     * @param  {Integer}  row  Column ID, i.e., y.
+     * @param  {Integer}  column  Column ID, i.e., x.
+     * @param  {Objwect}  dataTransform  ??
+     * @param  {Boolean}  mirrored  If `true` tile is mirrored.
+     */
+    addTileId(tiles: any[], zoomLevel: Integer, row: Integer, column: Integer, dataTransform: Objwect, mirrored?: boolean): void;
+    /**
+     * Convert tile positions to tile IDs
+     *
+     * @param  {Array}  xTiles  X positions of tiles
+     * @param  {Array}  yTiles  Y positions of tiles
+     * @param  {Array}  zoomLevel  Current zoom level
+     * @return  {Array}  List of tile IDs
+     */
+    tilesToId(xTiles: any[], yTiles: any[], zoomLevel: any[]): any[];
+    calculateVisibleTiles(): void;
+    zoomLevel: number | undefined;
+    xTiles: number[] | undefined;
+    yTiles: number[] | undefined;
+    mirrorTiles(): boolean;
+    getMouseOverHtml(trackX: any, trackY: any): string;
+    /**
+     * Get the tile's position in its coordinate system.
+     *
+     * @description
+     * Normally the absolute coordinate system are the genome basepair positions
+     */
+    getTilePosAndDimensions(zoomLevel: any, tilePos: any, binsPerTileIn: any): {
+        tileX: any;
+        tileY: any;
+        tileWidth: number;
+        tileHeight: number;
+    };
+    /**
+     * The local tile identifier
+     *
+     * @param {array}  tile  Tile definition array to be converted to id. Tile
+     *   array must contain `[zoomLevel, xPos, yPos]` and two props `mirrored` and
+     *   `dataTransform`.
+     */
+    tileToLocalId(tile: array): string;
+    /**
+     * The tile identifier used on the server
+     */
+    tileToRemoteId(tile: any): string;
+    localToRemoteId(remoteId: any): any;
+}
+/**
+ * @typedef PixiTrackOptions
+ * @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.
+ * If either labelPosition or labelText are false, no label will be drawn.
+ * @property {number=} trackBorderWidth
+ * @property {string=} trackBorderColor
+ * @property {string=} backgroundColor
+ * @property {string=} labelColor
+ * @property {string=} lineStrokeColor
+ * @property {string=} barFillColor
+ * @property {string=} name
+ * @property {number=} labelTextOpacity
+ * @property {string=} labelBackgroundColor
+ * @property {number=} labelLeftMargin
+ * @property {number=} labelRightMargin
+ * @property {number=} labelTopMargin
+ * @property {number=} labelBottomMargin
+ * @property {number=} labelBackgroundOpacity
+ * @property {boolean=} labelShowAssembly
+ * @property {boolean=} labelShowResolution
+ * @property {string=} dataTransform
+ */
+/** @extends {Track<PixiTrackOptions>} */
+export class PixiTrack extends Track<PixiTrackOptions> {
+    /**
+     * @param {import('./Track').ExtendedTrackContext<{ scene: import('pixi.js').Container}>} context - Includes the PIXI.js scene to draw to.
+     * @param {PixiTrackOptions} options - The options for this track.
+     */
+    constructor(context: any, options: PixiTrackOptions);
+    /** @type {import('pixi.js').Container} */
+    scene: import("pixi.js").Container;
+    /** @type {boolean} */
+    delayDrawing: boolean;
+    /** @type {import('pixi.js').Graphics} */
+    pBase: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pMasked: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pMask: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pMain: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pBorder: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pBackground: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pForeground: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pLabel: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pMobile: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pAxis: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pMouseOver: import("pixi.js").Graphics;
+    /** @type {string} */
+    prevOptions: string;
+    /** @type {string} */
+    labelTextFontFamily: string;
+    /** @type {number} */
+    labelTextFontSize: number;
+    /**
+     * Used to avoid label/colormap clashes
+     * @type {number}
+     */
+    labelXOffset: number;
+    /** @type {import('pixi.js').Text} */
+    labelText: import("pixi.js").Text;
+    /** @type {import('pixi.js').Text} */
+    errorText: import("pixi.js").Text;
+    /** @type {string} */
+    errorTextText: string;
+    /** @type {boolean} */
+    flipText: boolean;
+    /** @type {import('./types').TilesetInfo | undefined} */
+    tilesetInfo: any | undefined;
+    setLabelText(): void;
+    /**
+     * @param {[number, number]} position
+     * @param {[number, number]} dimensions
+     */
+    setMask(position: [number, number], dimensions: [number, number]): void;
+    setForeground(): void;
+    /**
+     * Draw a border around each track.
+     */
+    drawBorder(): void;
+    drawError(): void;
+    drawBackground(): void;
+    /**
+     * Determine the label color based on the number of options.
+     *
+     * @return {string} The color to use for the label.
+     */
+    getLabelColor(): string;
+    getName(): any;
+    drawLabel(): void;
+    /** @param {PixiTrackOptions} options */
+    rerender(options: PixiTrackOptions): void;
+    /**
+     * Export an SVG representation of this track
+     *
+     * @returns {[HTMLElement, HTMLElement]} The two returned DOM nodes are both SVG
+     * elements [base, track]. Base is a parent which contains track as a
+     * child. Track is clipped with a clipping rectangle contained in base.
+     *
+     */
+    exportSVG(): [HTMLElement, HTMLElement];
+    /**
+     * @returns {number}
+     */
+    calculateZoomLevel(): number;
+}
+export class SVGTrack extends Track<any> {
+    constructor(context: any, options: any);
+    /**
+     * Create a new SVG track. It will contain a g element
+     * that maintains all of its element.
+     */
+    gMain: import("d3-selection").Selection<SVGGElement, any, null, undefined>;
+    clipUid: string;
+    clipRect: import("d3-selection").Selection<SVGRectElement, any, null, undefined>;
+    setPosition(newPosition: any): void;
+    setDimensions(newDimensions: any): void;
+    draw(): this;
+}
+export class TiledPixiTrack extends PixiTrack {
+    /**
+     * A track that must pull remote tiles
+     *
+     * @param (PIXI.scene) scene A PIXI.js scene to draw everything to.
+     * @param (Object) dataConfig: A data source. Usually a
+     *  ``{{server: 'x/api/v1/', tilesetUuid: 'y'}}`` Object.
+     * @param {Object} handleTilesetInfoReceived: A callback to do something once once the tileset
+     *  info is received. Usually it registers some information about the tileset with its
+     * definition
+     * @param {Object} options The track's options
+     * @param {function} animate A function to redraw this track. Typically called when an
+     *  asynchronous event occurs (i.e. tiles loaded)
+     * @param {function} 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.
+     */
+    constructor(context: any, options: Object);
+    renderVersion: number;
+    visibleTiles: Set<any>;
+    visibleTileIds: Set<any>;
+    renderingTiles: Set<any>;
+    fetching: Set<any>;
+    scale: {};
+    fetchedTiles: {};
+    tileGraphics: {};
+    maxZoom: number;
+    medianVisibleValue: number | null | undefined;
+    backgroundTaskScheduler: BackgroundTaskScheduler;
+    continuousScaling: boolean;
+    valueScaleMin: number | null;
+    fixedValueScaleMin: number | null;
+    valueScaleMax: number | null;
+    fixedValueScaleMax: number | null;
+    listeners: {};
+    pubSub: any;
+    animate: any;
+    onValueScaleChanged: any;
+    prevValueScale: any;
+    dataFetcher: any;
+    uuid: string;
+    trackNotFoundText: PIXI.Text;
+    refreshTilesDebounced: (request: unknown) => void;
+    tilesetUid: any;
+    server: any;
+    chromInfo: ParsedChromsizes;
+    setError(error: any): void;
+    setFixedValueScaleMin(value: any): void;
+    setFixedValueScaleMax(value: any): 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;
+    off(event: any, callback: any): void;
+    rerender(options: any): void;
+    /**
+     * Return the set of ids of all tiles which are both visible and fetched.
+     */
+    visibleAndFetchedIds(): string[];
+    visibleAndFetchedTiles(): any[];
+    /**
+     * Set which tiles are visible right now.
+     *
+     * @param tiles: A set of tiles which will be considered the currently visible
+     * tile positions.
+     */
+    setVisibleTiles(tilePositions: any): void;
+    removeOldTiles(): void;
+    refreshTiles(): void;
+    parentInFetched(tile: any): boolean;
+    parentTileId(tile: any): string;
+    /**
+     * Remove obsolete tiles
+     *
+     * @param toRemoveIds: An array of tile ids to remove from the list of fetched tiles.
+     */
+    removeTiles(toRemoveIds: any): void;
+    zoomed(newXScale: any, newYScale: any, k?: number, tx?: number): void;
+    setPosition(newPosition: any): void;
+    setDimensions(newDimensions: any): 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;
+    minValue(_: any): any;
+    maxValue(_: any): any;
+    minRawValue(): any;
+    maxRawValue(): any;
+    initTile(): void;
+    updateTile(): void;
+    destroyTile(): void;
+    addMissingGraphics(): void;
+    /**
+     * Change the graphics for existing tiles
+     */
+    updateExistingGraphics(): void;
+    synchronizeTilesAndGraphics(): void;
+    loadTileData(tile: any, dataLoader: any): any;
+    fetchNewTiles(toFetch: any): void;
+    /**
+     * We've gotten a bunch of tiles from the server in
+     * response to a request from fetchTiles.
+     */
+    receivedTiles(loadedTiles: any): void;
+    /**
+     * Draw a tile on some graphics
+     */
+    drawTile(): void;
+    calculateMedianVisibleValue(): number | undefined;
+    allVisibleValues(): never[];
+    minVisibleValue(ignoreFixedScale?: boolean): number;
+    minVisibleValueInTiles(ignoreFixedScale?: boolean): number;
+    maxVisibleValue(ignoreFixedScale?: boolean): number;
+    maxVisibleValueInTiles(ignoreFixedScale?: boolean): number;
+    makeValueScale(minValue: any, medianValue: any, maxValue: any, inMargin: any): (number | import("d3-scale").ScaleQuantile<number, never>)[] | (number | import("d3-scale").ScaleLinear<number, number, never>)[];
+}
+/**
+ * @typedef TrackContext
+ * @property {string} id - The track ID.
+ * @property {import('pub-sub-es').PubSub & { __fake__?: boolean }} [pubSub] - The pub-sub channel.
+ */
+/**
+ * @template T
+ * @typedef {T & TrackContext} ExtendedTrackContext
+ */
+/** @template Options */
+export 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: any;
+    /** @type {import('./types').Scale} */
+    _yScale: any;
+    /** @type {import('./types').Scale} */
+    _refXScale: any;
+    /** @type {import('./types').Scale} */
+    _refYScale: any;
+    /** @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>;
+    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(): any;
+    /**
+     * @overload
+     * @param {import('./types').Scale} scale
+     * @return {this}
+     */
+    refXScale(scale: any): this;
+    /**
+     * @overload
+     * @return {import('./types').Scale}
+     */
+    refYScale(): any;
+    /**
+     * @overload
+     * @param {import('./types').Scale} scale
+     * @return {this}
+     */
+    refYScale(scale: any): this;
+    /**
+     * @overload
+     * @return {import('./types').Scale}
+     */
+    xScale(): any;
+    /**
+     * @overload
+     * @param {import('./types').Scale} scale
+     * @return {this}
+     */
+    xScale(scale: any): this;
+    /**
+     * @overload
+     * @return {import('./types').Scale}
+     */
+    yScale(): any;
+    /**
+     * @overload
+     * @param {import('./types').Scale} scale
+     * @return {this}
+     */
+    yScale(scale: any): this;
+    /**
+     * @param {import('./types').Scale} newXScale
+     * @param {import('./types').Scale} newYScale
+     * @returns {void}
+     */
+    zoomed(newXScale: any, newYScale: any): void;
+    /**
+     * @param {import('./types').Scale} refXScale
+     * @param {import('./types').Scale} refYScale
+     * @returns {void}
+     */
+    refScalesChanged(refXScale: any, refYScale: any): 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(): void;
+    /** @returns {void} */
+    remove(): void;
+    /**
+     * @param {Options} options
+     * @returns {void}
+     */
+    rerender(): 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(): void;
+    /**
+     * @param {number} dY
+     * @returns {void}
+     */
+    movedY(): void;
+}
+export class ViewportTrackerHorizontal extends SVGTrack {
+    uid: string;
+    hasFromView: boolean;
+    removeViewportChanged: any;
+    setDomainsCallback: any;
+    viewportXDomain: any;
+    viewportYDomain: number[] | null;
+    brush: import("d3-brush").BrushBehavior<any>;
+    gBrush: import("d3-selection").Selection<SVGGElement, any, null, undefined>;
+    brushed(event: any): void;
+    viewportChanged(viewportXScale: any, viewportYScale: any): void;
+    draw(): void;
+    zoomed(newXScale: any, newYScale: any): void;
+}
+/**
+ * @typedef ClassContext
+ * @property {import('pixi.js').Container=} pForeground
+ * @property {import('pixi.js').Container=} pMasked
+ * @property {import('pixi.js').Container=} pMain
+ * @property {() => import('../types').Scale} xScale
+ * @property {() => import('../types').Scale} yScale
+ * @property {() => [number, number]} getPosition
+ * @property {() => [number, number]} getDimensions
+ * @property {import('pub-sub-es').PubSub} pubSub
+ * @property {Array<import('pub-sub-es').Subscription>} pubSubs
+ * @property {(prop: 'flipText') => () => boolean} getProp
+ * @property {{}} options
+ */
+/**
+ * Public API for showing the mouse location.
+ *
+ * @description
+ * This is just a convenience wrapper to avoid code duplication.
+ * `showMousePosition` is the actual function and could be called from within
+ * each class as well.
+ *
+ * @param {ClassContext} context - Class context, i.e., `this`.
+ * @param {Boolean} is2d - If `true` both dimensions of the mouse location
+ *   should be shown. E.g., on a central track.
+ * @param {Boolean} isGlobal - If `true` local and global events will trigger
+ *   the mouse position drawing.
+ * @return {Function} - Method to remove graphics showing the mouse location.
+ */
+declare function setupShowMousePosition(context: ClassContext, is2d?: boolean, isGlobal?: boolean): Function;
+declare namespace api {
+    export { calculateResolution };
+    export { calculateTileAndPosInTile };
+    export { calculateTiles };
+    export { calculateTilesFromResolution };
+    export { calculateTileWidth };
+    export { calculateZoomLevel };
+    export { calculateZoomLevelFromResolutions };
+    export { fetchTilesDebounced };
+    export { json };
+    export { text };
+    export { tileDataToPixData };
+    export { trackInfo };
+}
+/**
+ * @typedef View2D
+ * @property {(i: number, j: number) => number} get
+ * @property {(i: number, j: number, v: number) => void} set
+ */
+declare class DenseDataExtrema2D {
+    /**
+     * This module efficiently computes extrema of subsets of a given data matrix.
+     * The matrix is subdivided into 'numSubsets' subsets where extrema are precomputed.
+     * These values are used to efficiently approximate extrema given arbitrary subsets.
+     * Larger values of 'numSubsets' lead to more accurate approximations (more expensive).
+     *
+     * @param {ArrayLike<number>} data array of quadratic length
+     */
+    constructor(data: ArrayLike<number>);
+    /** @type {number} */
+    epsilon: number;
+    /** @type {number} */
+    tileSize: number;
+    /** @type {number} */
+    numSubsets: number;
+    /** @type {number} */
+    subsetSize: number;
+    /** @type {View2D} */
+    subsetMinimums: View2D;
+    /** @type {View2D} */
+    subsetMaximums: View2D;
+    /** @type {number} */
+    minNonZeroInTile: number;
+    /** @type {number} */
+    maxNonZeroInTile: number;
+    /**
+     * Computes an approximation of the non-zero minimum in a subset
+     *
+     * @param {[startX: number, startY: number, endX: number, endY: number]} indexBounds
+     * @return {number} Non-zero minium of the subset
+     */
+    getMinNonZeroInSubset(indexBounds: [startX: number, startY: number, endX: number, endY: number]): number;
+    /**
+     * Computes an approximation of the non-zero maximum in a subset
+     *
+     * @param {[startX: number, startY: number, endX: number, endY: number]} indexBounds
+     * @return {number} Non-zero maxium of the subset
+     */
+    getMaxNonZeroInSubset(indexBounds: [startX: number, startY: number, endX: number, endY: number]): number;
+    /**
+     * Precomputes non-zero minimums of subsets of a given matrix
+     * @param {View2D} dataMatrix
+     * @return {View2D} Matrix containing minimums of the dataMatrix after subdivision using a regular grid
+     */
+    computeSubsetNonZeroMinimums(dataMatrix: View2D): View2D;
+    /**
+     * Precomputes non-zero maximums of subsets of a given matrix
+     *
+     * @param {View2D} dataMatrix
+     * @return {View2D} Matrix containing maximums of the dataMatrix after subdivision using a regular grid
+     */
+    computeSubsetNonZeroMaximums(dataMatrix: View2D): View2D;
+    /**
+     * Computes the non-zero minimum of a subset of a matrix (ndarray)
+     * @param {View2D} arr
+     * @param {number} rowOffset - Starting row of the subset
+     * @param {number} colOffset - Starting column of the subset
+     * @param {number} width - Width (num columns) of the subset
+     * @param {number} height - Height (num rows) of the subset
+     * @return {number} Non-zeros - minimum of the subset
+     */
+    getMinNonZeroInNdarraySubset(arr: View2D, rowOffset: number, colOffset: number, width: number, height: number): number;
+    /**
+     * Computes the non-zero maximum of a subset of a matrix (ndarray)
+     * @param {View2D} arr
+     * @param {number} rowOffset - Starting row of the subset
+     * @param {number} colOffset - Starting column of the subset
+     * @param {number} width - Width (num columns) of the subset
+     * @param {number} height - Height (num rows) of the subset
+     * @return {number} Non-zeros maximum of the subset
+     */
+    getMaxNonZeroInNdarraySubset(arr: View2D, rowOffset: number, colOffset: number, width: number, height: number): number;
+    mirrorPrecomputedExtrema(): void;
+    /**
+     * Computes the non-zero minimum in the entire data array using precomputed values
+     *
+     * @return {number} Non-zeros minimum of the data
+     */
+    getMinNonZeroInTile(): number;
+    /**
+     * Computes the non-zero maximum in the entire data array using precomputed values
+     *
+     * @return {number} Non-zeros maximum of the data
+     */
+    getMaxNonZeroInTile(): number;
+}
+import * as PIXI from 'pixi.js';
+declare class AxisPixi {
+    constructor(track: any);
+    pAxis: PIXI.Graphics;
+    track: any;
+    axisTexts: any[];
+    axisTextFontFamily: string;
+    axisTextFontSize: number;
+    startAxis(axisHeight: any): void;
+    createAxisTexts(valueScale: any, axisHeight: any): void;
+    tickValues: any;
+    tickFormat: ((n: number | {
+        valueOf(): number;
+    }) => string) | ((x: any) => any) | undefined;
+    calculateAxisTickValues(valueScale: any, axisHeight: any): any;
+    drawAxisLeft(valueScale: any, axisHeight: any): void;
+    drawAxisRight(valueScale: any, axisHeight: any): void;
+    hideOverlappingAxisLabels(): void;
+    exportVerticalAxis(axisHeight: any): HTMLElement;
+    createAxisSVGLine(): HTMLElement;
+    createAxisSVGText(text: any): HTMLElement;
+    exportAxisLeftSVG(valueScale: any, axisHeight: any): HTMLElement;
+    exportAxisRightSVG(valueScale: any, axisHeight: any): HTMLElement;
+    clearAxis(): void;
+}
+/**
+ */
+declare class BackgroundTaskScheduler {
+    /** @type {Task[]} */
+    taskList: 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;
+    /**
+     * @param {{ timeRemaining(): number, didTimeout: boolean }} deadline
+     */
+    runTaskQueue(deadline: {
+        timeRemaining(): number;
+        didTimeout: boolean;
+    }): void;
+}
+declare function calculateResolution(tilesetInfo: any, zoomLevel: any): any;
+/**
+ * Calculate the element within this tile containing the given
+ * position.
+ *
+ * Returns the tile position and position within the tile for
+ * the given element.
+ *
+ * @param {object} tilesetInfo: The information about this tileset
+ * @param {Number} maxDim: The maximum width of the dataset (only used for
+ *        tilesets without resolutions)
+ * @param {Number} dataStartPos: The position where the data begins
+ * @param {int} zoomLevel: The current zoomLevel
+ * @param {Number} position: The position (in absolute coordinates) to caculate
+ *                 the tile and position in tile for
+ */
+declare function calculateTileAndPosInTile(tilesetInfo: object, maxDim: number, dataStartPos: number, zoomLevel: int, position: number): number[];
+/**
+ * Calculate the tiles that should be visible get a data domain
+ * and a tileset info
+ *
+ * All the parameters except the first should be present in the
+ * tileset_info returned by the server.
+ *
+ * @param {number} zoomLevel - The zoom level at which to find the tiles (can be
+ *   calculated using this.calcaulteZoomLevel, but needs to synchronized across
+ *   both x and y scales so should be calculated externally)
+ * @param {import('../type').Scale} scale - A d3 scale mapping data domain to visible values
+ * @param {number} minX - The minimum possible value in the dataset
+ * @param {number} maxX - The maximum possible value in the dataset
+ * @param {number} maxZoom - The maximum zoom value in this dataset
+ * @param {number} maxDim - The largest dimension of the tileset (e.g., width or height)
+ *   (roughlty equal to 2 ** maxZoom * tileSize * tileResolution)
+ * @returns {number[]} The indices of the tiles that should be visible
+ */
+declare function calculateTiles(zoomLevel: number, scale: any, minX: number, maxX: number, maxZoom: number, maxDim: number): number[];
+/**
+ * Calculate the tiles that sould be visisble given the resolution and
+ * the minX and maxX values for the region
+ *
+ * @param {number} resolution - The number of base pairs per bin
+ * @param {import('../type').Scale} scale - The scale to use to calculate the currently visible tiles
+ * @param {number} minX - The minimum x position of the tileset
+ * @param {number} maxX - The maximum x position of the tileset
+ * @param {number=} pixelsPerTile - The number of pixels per tile
+ * @returns {number[]} The indices of the tiles that should be visible
+ */
+declare function calculateTilesFromResolution(resolution: number, scale: any, minX: number, maxX: number, pixelsPerTile?: number | undefined): number[];
+declare function calculateTileWidth(tilesetInfo: any, zoomLevel: any, binsPerTile: any): number;
+/**
+ * Calculate the current zoom level.
+ */
+declare function calculateZoomLevel(scale: any, minX: any, maxX: any, binsPerTile: any): number;
+/**
+ * Calculate the zoom level from a list of available resolutions
+ */
+declare function calculateZoomLevelFromResolutions(resolutions: any, scale: any): any;
+declare function fetchTilesDebounced(request: any, ...args: any[]): void;
+/**
+ * Send a JSON request and mark it so that we can tell how many are in flight
+ *
+ * @param url: URL to fetch
+ * @param callback: Callback to execute with content from fetch
+ */
+declare function json(url: any, callback: any, pubSub: any): Promise<any>;
+/**
+ * Send a text request and mark it so that we can tell how many are in flight
+ *
+ * @param url: URL to fetch
+ * @param callback: Callback to execute with content from fetch
+ */
+declare function text(url: any, callback: any, pubSub: any): Promise<any>;
+/**
+ * Render 2D tile data. Convert the raw values to an array of
+ * color values
+ *
+ * @param finished: A callback to let the caller know that the worker thread
+ *   has converted tileData to pixData
+ * @param minVisibleValue: The minimum visible value (used for setting the color
+ *   scale)
+ * @param maxVisibleValue: The maximum visible value
+ * @param valueScaleType: Either 'log' or 'linear'
+ * @param valueScaleDomain: The domain of the scale (the range is always [254,0])
+ * @param colorScale: a 255 x 4 rgba array used as a color scale
+ * @param synchronous: Render this tile synchronously or pass it on to the threadpool (which doesn't exist yet).
+ * @param ignoreUpperRight: If this is a tile along the diagonal and there will
+ * be mirrored tiles present ignore the upper right values
+ * @param ignoreLowerLeft: If this is a tile along the diagonal and there will be
+ * mirrored tiles present ignore the lower left values
+ * @param {array} zeroValueColor: The color to use for rendering zero data values, [r, g, b, a].
+ * @param {object} selectedRowsOptions Rendering options when using a `selectRows` track option.
+ */
+declare function tileDataToPixData(tile: any, valueScaleType: any, valueScaleDomain: any, pseudocount: any, colorScale: any, finished: any, ignoreUpperRight: any, ignoreLowerLeft: any, zeroValueColor: array, selectedRowsOptions: object): void;
+/**
+ * Request a tilesetInfo for a track
+ *
+ * @param {string} server: The server where the data resides
+ * @param {string} tilesetUid: The identifier for the dataset
+ * @param {func} doneCb: A callback that gets called when the data is retrieved
+ * @param {func} errorCb: A callback that gets called when there is an error
+ */
+declare function trackInfo(server: string, tilesetUid: string, doneCb: func, errorCb: func, pubSub: any): void;
+export { setupShowMousePosition as showMousePosition, api as tileProxy };
+//# sourceMappingURL=higlass-vendored.d.ts.map