higlass 1.13.5 → 2.0.0

package/dist/app/scripts/configs/dense-data-extrema-config.d.ts

@@ -0,0 +1,2 @@
+export const NUM_PRECOMP_SUBSETS_PER_1D_TTILE: 8;
+export const NUM_PRECOMP_SUBSETS_PER_2D_TTILE: 8;

package/dist/app/scripts/configs/globals.d.ts

@@ -0,0 +1,5 @@
+export default GLOBALS;
+declare namespace GLOBALS {
+    export { PIXI };
+}
+import * as PIXI from 'pixi.js';

package/dist/app/scripts/configs/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./primitives";
+export { default as GLOBALS } from "./globals";
+export { default as DATATYPE_TO_TRACK_TYPE } from "./datatype-to-track-type";
+export { default as HEATED_OBJECT_MAP } from "./colormaps";
+export { default as TRACKS_INFO } from "./tracks-info";
+export { default as TRACKS_INFO_BY_TYPE } from "./tracks-info-by-type";
+export { default as POSITIONS_BY_DATATYPE } from "./positions-by-datatype";
+export { default as DEFAULT_TRACKS_FOR_DATATYPE } from "./default-tracks-for-datatype";
+export { default as AVAILABLE_TRACK_TYPES } from "./available-track-types";
+export const SIZE_MODE_DEFAULT: "default";
+export const SIZE_MODE_BOUNDED: "bounded";
+export const SIZE_MODE_OVERFLOW: "overflow";
+export const SIZE_MODE_BOUNDED_OVERFLOW: "bounded-overflow";
+export const SIZE_MODE_SCROLL: "scroll";
+export { THEME_LIGHT, THEME_DARK, THEME_DEFAULT } from "./themes";
+export { NUM_PRECOMP_SUBSETS_PER_1D_TTILE, NUM_PRECOMP_SUBSETS_PER_2D_TTILE } from "./dense-data-extrema-config";

package/dist/app/scripts/configs/positions-by-datatype.d.ts

@@ -0,0 +1,2 @@
+export const POSITIONS_BY_DATATYPE: {};
+export default POSITIONS_BY_DATATYPE;

package/dist/app/scripts/configs/primitives.d.ts

@@ -0,0 +1,20 @@
+export const DEFAULT_VIEW_MARGIN: 0;
+export const DEFAULT_VIEW_PADDING: 5;
+export const DEFAULT_CONTAINER_PADDING_X: 10;
+export const DEFAULT_CONTAINER_PADDING_Y: 10;
+export const MAX_CLICK_DELAY: 300;
+export const MOUSE_TOOL_MOVE: "move";
+export const MOUSE_TOOL_SELECT: "select";
+export const MOUSE_TOOL_TRACK_SELECT: "track-select";
+export const TILE_FETCH_DEBOUNCE: 100;
+export const ZOOM_DEBOUNCE: 10;
+export const SHORT_DRAG_TIMEOUT: 110;
+export const LONG_DRAG_TIMEOUT: 3000;
+export const LOCATION_LISTENER_PREFIX: "locationListenerPrefix";
+export const ZOOM_TRANSITION_DURATION: 1000;
+export const DEFAULT_SERVER: "http://higlass.io/api/v1";
+export const VIEW_HEADER_MED_WIDTH_SEARCH_BAR: 400;
+export const VIEW_HEADER_MIN_WIDTH_SEARCH_BAR: 300;
+export const TRACK_LOCATIONS: readonly ["top", "left", "right", "bottom", "center", "whole", "gallery"];
+export const MIN_HORIZONTAL_HEIGHT: 20;
+export const MIN_VERTICAL_WIDTH: 20;

package/dist/app/scripts/configs/themes.d.ts

@@ -0,0 +1,3 @@
+export const THEME_LIGHT: unique symbol;
+export const THEME_DARK: unique symbol;
+export const THEME_DEFAULT: symbol;

package/dist/app/scripts/configs/tracks-info-by-type.d.ts

@@ -0,0 +1,4 @@
+/** @typedef {Record<string, import('./tracks-info').TrackInfo>} TracksInfoByType */
+export const TRACKS_INFO_BY_TYPE: TracksInfoByType;
+export default TRACKS_INFO_BY_TYPE;
+export type TracksInfoByType = Record<string, import("./tracks-info").TrackInfo>;

package/dist/app/scripts/configs/tracks-info.d.ts

@@ -0,0 +1,24 @@
+/** @type {TrackInfo[]} */
+export const TRACKS_INFO: TrackInfo[];
+export default TRACKS_INFO;
+export type TrackInfo = {
+    type: string;
+    datatype: string | string[];
+    orientation: string;
+    aliases?: string[] | undefined;
+    local?: boolean | undefined;
+    rotatable?: boolean | undefined;
+    hidden?: boolean | undefined;
+    name?: string | undefined;
+    thumbnail?: (HTMLElement | null | string) | undefined;
+    availableOptions?: string[] | undefined;
+    defaultOptions?: Record<string, unknown> | undefined;
+    exportable?: boolean | undefined;
+    defaultOptionsByTheme?: Record<string, Record<string, unknown>> | undefined;
+    minHeight?: number | undefined;
+    defaultHeight?: number | undefined;
+    defaultWidth?: number | undefined;
+    chromInfoPath?: string | undefined;
+    projection?: boolean | undefined;
+    optionsInfo?: Record<string, unknown> | undefined;
+};

package/dist/app/scripts/d3-context-menu.d.ts

@@ -0,0 +1,2 @@
+export default contextMenu;
+declare function contextMenu(menu: any, optsIn: any): (data: any, index: any, pMouseUp: boolean | undefined, clickAwayFunc: any, useMouse?: boolean) => string;

package/dist/app/scripts/data-fetchers/DataFetcher.d.ts

@@ -0,0 +1,151 @@
+/** @implements {AbstractDataFetcher<Tile | DividedTile, ResolvedDataConfig>} */
+export default class DataFetcher implements AbstractDataFetcher {
+    /**
+     * @param {DataConfig} dataConfig
+     * @param {PubSub} pubSub
+     * @param {TileSource<Tile>} [tileSource]
+     */
+    constructor(dataConfig: DataConfig, pubSub: PubSub, tileSource?: TileSource<Tile>);
+    _tileSource: TileSource<Tile>;
+    /** @type {boolean} */
+    tilesetInfoLoading: boolean;
+    /** @type {ResolvedDataConfig} */
+    dataConfig: ResolvedDataConfig;
+    /** @type {string} */
+    uuid: string;
+    /** @type {PubSub} */
+    pubSub: 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 {HandleTilesetInfoFinished} finished - A callback that will be called
+     */
+    tilesetInfo(finished: HandleTilesetInfoFinished): 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 {HandleTilesetInfoFinished} finished - A callback that will be called
+     *  when all tileset infos are loaded
+     */
+    tilesetInfoAfterRegister(finished: HandleTilesetInfoFinished): 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> | Float32Array} 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> | Float32Array} an array corresponding to a slice of this matrix
+     */
+    extractDataSlice(inputData: Array<number> | Float32Array, arrayShape: Array<number>, sliceIndex: number, axis?: number | undefined): Array<number> | Float32Array;
+    /**
+     * 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>;
+}
+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;
+};
+import type { AbstractDataFetcher } from '../types';
+import type { TileSource } from '../types';
+import type { PubSub } from 'pub-sub-es';
+import type { HandleTilesetInfoFinished } from '../types';
+import type { DataConfig } from '../types';
+import DenseDataExtrema1D from '../utils/DenseDataExtrema1D';
+import DenseDataExtrema2D from '../utils/DenseDataExtrema2D';
+import type { DataConfig as DataConfig_1 } from '../types';
+import type { TilesetInfo } from '../types';

package/dist/app/scripts/data-fetchers/genbank-fetcher.d.ts

@@ -0,0 +1,86 @@
+export default GBKDataFetcher;
+export type FillerSegment = {
+    start: number;
+    end: number;
+    type: "filler";
+    strand: "+" | "-";
+};
+export type GenbankFeature = import("genbank-parser").ParsedGenbank["features"][number];
+export type FillerGeneAnnotation = {
+    xStart: number;
+    xEnd: number;
+    strand: "+" | "-";
+    uid: string;
+    type: "filler";
+    fields: [];
+};
+export type CompleteGeneAnnotation = {
+    xStart: number;
+    xEnd: number;
+    strand: "+" | "-";
+    chrOffset: number;
+    importance: number;
+    uid: string;
+    type?: string | undefined;
+    fields: [chr: "chrom", start: number, end: number, name: string, importance: number, strand: "+" | "-", _unknown0: string, _unknown1: string, type: string, name: string, start: string, end: string, start: string, end: string];
+};
+export type GeneAnnotation = CompleteGeneAnnotation | FillerGeneAnnotation;
+export type GenbankDataConfig = {
+    url?: string | undefined;
+    text?: string | undefined;
+};
+export type GenbankTile = Array<GeneAnnotation> & {
+    tilePositionId?: string;
+};
+/**
+ * @typedef GenbankDataConfig
+ * @prop {string=} url
+ * @prop {string=} text
+ */
+/**
+ * @typedef {Array<GeneAnnotation> & { tilePositionId?: string }} GenbankTile
+ */
+/** @implements {AbstractDataFetcher<GenbankTile, GenbankDataConfig>} */
+declare class GBKDataFetcher implements AbstractDataFetcher {
+    /** @param {GenbankDataConfig} dataConfig */
+    constructor(dataConfig: GenbankDataConfig);
+    /** @type {GenbankDataConfig} */
+    dataConfig: GenbankDataConfig;
+    /** @type {string} */
+    trackUid: string;
+    /** @type {string} */
+    errorTxt: string;
+    /** @type {Promise<ReturnType<typeof gbToJsonAndFeatures>>} */
+    gbDataPromise: Promise<ReturnType<typeof gbToJsonAndFeatures>>;
+    /**
+     * @param {import('../types').HandleTilesetInfoFinished} [callback]
+     * @returns {Promise<import('../types').LegacyTilesetInfo | undefined>}
+     */
+    tilesetInfo(callback?: import("../types").HandleTilesetInfoFinished): Promise<import("../types").LegacyTilesetInfo | undefined>;
+    tilesetInfoLoading: boolean | undefined;
+    /**
+     * @param {(tiles: Record<string, GenbankTile>) => void} receivedTiles
+     * @param {string[]} tileIds
+     * @returns {Promise<Record<string, GenbankTile>>}
+     */
+    fetchTilesDebounced(receivedTiles: (tiles: Record<string, GenbankTile>) => void, tileIds: string[]): Promise<Record<string, GenbankTile>>;
+    /**
+     * @param {number} z
+     * @param {number} x
+     * @returns {Promise<GeneAnnotation[]>}
+     */
+    tile(z: number, x: number): Promise<GeneAnnotation[]>;
+}
+import type { AbstractDataFetcher } from '../types';
+/**
+ * Convert genbank text to a JSON representation and extract features
+ * @param {string} gbText
+ * @returns {{
+ *  json: import('genbank-parser').ParsedGenbank[],
+ *  features: GenbankFeature[],
+ * }}
+ */
+declare function gbToJsonAndFeatures(gbText: string): {
+    json: import("genbank-parser").ParsedGenbank[];
+    features: GenbankFeature[];
+};

package/dist/app/scripts/data-fetchers/index.d.ts

@@ -0,0 +1,3 @@
+export { default as DataFetcher } from "./DataFetcher";
+export { default as GBKDataFetcher } from "./genbank-fetcher";
+export { default as LocalDataFetcher } from "./local-tile-fetcher";

package/dist/app/scripts/data-fetchers/local-tile-fetcher.d.ts

@@ -0,0 +1,47 @@
+export default LocalTileDataFetcher;
+export type LocalTile = {
+    tilePositionId?: string;
+};
+export type LocalTileDataConfig = {
+    tiles: Record<string, LocalTile>;
+    tilesetInfo: Record<string, TilesetInfo>;
+};
+/** @import { AbstractDataFetcher, TilesetInfo } from '../types' */
+/** @typedef {{tilePositionId?: string}} LocalTile */
+/**
+ * @typedef LocalTileDataConfig
+ * @property {Record<string, LocalTile>} tiles
+ * @property {Record<string, TilesetInfo>} tilesetInfo
+ */
+/** @implements {AbstractDataFetcher<LocalTile, LocalTileDataConfig>} */
+declare class LocalTileDataFetcher implements AbstractDataFetcher {
+    /** @param {LocalTileDataConfig} dataConfig */
+    constructor(dataConfig: LocalTileDataConfig);
+    /** @type {LocalTileDataConfig} */
+    dataConfig: LocalTileDataConfig;
+    /** @type {TilesetInfo} */
+    tilesetInfoData: TilesetInfo;
+    /** @type {Record<string, LocalTile>} */
+    tilesData: Record<string, LocalTile>;
+    /** @type {boolean} */
+    tilesetInfoLoading: boolean;
+    /** @param {import('../types').HandleTilesetInfoFinished} callback */
+    tilesetInfo(callback: import("../types").HandleTilesetInfoFinished): Promise<TilesetInfo>;
+    /** We expect there to be a tilesetUid in the provided tilesetInfo
+     * and tiles data since tileResponseToData needs it
+     *
+     * It is also easier for users to paste in request responses for debugging.
+     *
+     * @param {(tiles: Record<string, LocalTile>) => void} receivedTiles
+     * @param {string[]} tileIds
+     */
+    fetchTilesDebounced(receivedTiles: (tiles: Record<string, LocalTile>) => void, tileIds: string[]): Promise<Record<string, LocalTile>>;
+    /**
+     * @param {number} z
+     * @param {number} x
+     * @returns {void}
+     */
+    tile(z: number, x: number): void;
+}
+import type { TilesetInfo } from '../types';
+import type { AbstractDataFetcher } from '../types';

package/dist/app/scripts/gosling-exports.d.ts

@@ -0,0 +1,17 @@
+export { default as Track } from "./Track";
+export { default as PixiTrack } from "./PixiTrack";
+export { default as TiledPixiTrack } from "./TiledPixiTrack";
+export { default as SVGTrack } from "./SVGTrack";
+export { default as ViewportTrackerHorizontal } from "./ViewportTrackerHorizontal";
+export { default as HeatmapTiledPixiTrack } from "./HeatmapTiledPixiTrack";
+export { default as DataFetcher } from "./data-fetchers/DataFetcher";
+export { default as tileProxy } from "./services/tile-proxy";
+export { default as fakePubSub } from "./utils/fake-pub-sub";
+export { default as DenseDataExtrema1D } from "./utils/DenseDataExtrema1D";
+export { default as absToChr } from "./utils/abs-to-chr";
+export { default as chrToAbs } from "./utils/chr-to-abs";
+export { default as colorToHex } from "./utils/color-to-hex";
+export { default as chromInfoBisector } from "./utils/chrom-info-bisector";
+export { default as pixiTextToSvg } from "./utils/pixi-text-to-svg";
+export { default as svgLine } from "./utils/svg-line";
+export { default as showMousePosition } from "./utils/show-mouse-position";

package/dist/app/scripts/hglib.d.ts

@@ -0,0 +1,24 @@
+export { default as ChromosomeInfo } from "./ChromosomeInfo";
+export { default as HiGlassComponent } from "./HiGlassComponent";
+export namespace tracks {
+    export { SVGTrack };
+    export { TiledPixiTrack };
+    export { HorizontalGeneAnnotationsTrack };
+}
+export { default as schema } from "../schema.json";
+export { version } from "../../package.json";
+export { TRACKS_INFO_BY_TYPE } from "./configs";
+export { OPTIONS_INFO } from "./options-info";
+export function viewer(element: HTMLElement, viewConfig: HiGlassViewConfig | string, options?: HiGlassOptions): Promise<HiGlassApi>;
+export * as hggos from "./gosling-exports";
+export type HiGlassApi = api.HiGlassApi["public"];
+export type HiGlassOptions = types.HiGlassOptions;
+export type HiGlassViewConfig = types.HiGlassViewConfig;
+import SVGTrack from './SVGTrack';
+import TiledPixiTrack from './TiledPixiTrack';
+import HorizontalGeneAnnotationsTrack from './HorizontalGeneAnnotationsTrack';
+import type * as api from './api';
+import type * as types from './types';
+export { default as HiGlassTrackComponent, trackViewer } from "./HiGlassTrackComponent";
+export { waitForJsonComplete, waitForTilesLoaded, waitForTransitionsFinished, mountHGComponent } from "./test-helpers";
+export { debounce, getDefaultTracksForDatatype, getTrackByUid, getTrackObjectFromHGC } from "./utils";

package/dist/app/scripts/hocs/with-modal.d.ts

@@ -0,0 +1,19 @@
+export default withModal;
+export type Modal = {
+    open: () => void;
+    close: () => void;
+};
+/** @typedef {{ open: () => void, close: () => void }} Modal  */
+/**
+ * @template {typeof React.Component<{ modal?: Modal }>} T
+ * @param {T} Component
+ * @returns {T}
+ */
+declare function withModal<T extends typeof React.Component<{
+    modal?: Modal;
+}>>(Component: T): T;
+export const Provider: React.Provider<{
+    close: (...args: any[]) => void;
+    open: (...args: any[]) => void;
+}>;
+import React from 'react';

package/dist/app/scripts/hocs/with-pub-sub.d.ts

@@ -0,0 +1,22 @@
+export default withPubSub;
+/** @import { PubSub } from 'pub-sub-es' */
+/**
+ * @template {typeof React.Component<{ pubSub?: PubSub }>} T
+ * @param {T} Component
+ * @returns {T}
+ */
+declare function withPubSub<T extends typeof React.Component<{
+    pubSub?: PubSub;
+}>>(Component: T): T;
+export const Provider: React.Provider<{
+    __fake__: boolean;
+    publish: () => void;
+    subscribe: () => {
+        event: string;
+        handler: () => void;
+    };
+    unsubscribe: () => void;
+    clear: () => void;
+}>;
+import React from 'react';
+import type { PubSub } from 'pub-sub-es';

package/dist/app/scripts/hocs/with-theme.d.ts

@@ -0,0 +1,13 @@
+export default withTheme;
+export type Theme = typeof themes.THEME_LIGHT | typeof themes.THEME_DARK;
+/**
+ * @template {typeof React.Component<{ theme?: Theme }>} T
+ * @param {T} Component
+ * @returns {T}
+ */
+declare function withTheme<T extends typeof React.Component<{
+    theme?: Theme;
+}>>(Component: T): T;
+export const Provider: React.Provider<Theme>;
+import * as themes from '../configs/themes';
+import React from 'react';

package/dist/app/scripts/icons.d.ts

@@ -0,0 +1,161 @@
+export function SearchIcon({ theStyle, onClick }: {
+    theStyle: any;
+    onClick: any;
+}): React.JSX.Element;
+export namespace SearchIcon {
+    namespace propTypes {
+        let theStyle: PropTypes.Requireable<string>;
+        let onClick: PropTypes.Requireable<(...args: any[]) => any>;
+    }
+}
+export namespace COG {
+    let id: string;
+    let paths: string[];
+    let viewBox: string;
+}
+export namespace CROSS {
+    let id_1: string;
+    export { id_1 as id };
+    let paths_1: string[];
+    export { paths_1 as paths };
+    let viewBox_1: string;
+    export { viewBox_1 as viewBox };
+}
+export namespace ENLARGE {
+    let id_2: string;
+    export { id_2 as id };
+    let paths_2: string[];
+    export { paths_2 as paths };
+    let viewBox_2: string;
+    export { viewBox_2 as viewBox };
+}
+export namespace MINUS {
+    let id_3: string;
+    export { id_3 as id };
+    let paths_3: string[];
+    export { paths_3 as paths };
+    let viewBox_3: string;
+    export { viewBox_3 as viewBox };
+}
+export namespace MOVE {
+    let id_4: string;
+    export { id_4 as id };
+    let paths_4: string[];
+    export { paths_4 as paths };
+    let viewBox_4: string;
+    export { viewBox_4 as viewBox };
+}
+export namespace PLAY {
+    let id_5: string;
+    export { id_5 as id };
+    let paths_5: string[];
+    export { paths_5 as paths };
+    let viewBox_5: string;
+    export { viewBox_5 as viewBox };
+}
+export namespace PLUS {
+    let id_6: string;
+    export { id_6 as id };
+    let paths_6: string[];
+    export { paths_6 as paths };
+    let viewBox_6: string;
+    export { viewBox_6 as viewBox };
+}
+export namespace CONTENT_COPY {
+    let id_7: string;
+    export { id_7 as id };
+    let paths_7: string[];
+    export { paths_7 as paths };
+    let viewBox_7: string;
+    export { viewBox_7 as viewBox };
+}
+export namespace TRACK_LINE {
+    let id_8: string;
+    export { id_8 as id };
+    let paths_8: string[];
+    export { paths_8 as paths };
+    let viewBox_8: string;
+    export { viewBox_8 as viewBox };
+}
+export namespace SELECT {
+    let id_9: string;
+    export { id_9 as id };
+    let viewBox_9: string;
+    export { viewBox_9 as viewBox };
+    let paths_9: string[];
+    export { paths_9 as paths };
+}
+export namespace CHECK_SQUARE_O {
+    let id_10: string;
+    export { id_10 as id };
+    let viewBox_10: string;
+    export { viewBox_10 as viewBox };
+    let paths_10: string[];
+    export { paths_10 as paths };
+}
+export namespace SQUARE_O {
+    let id_11: string;
+    export { id_11 as id };
+    let viewBox_11: string;
+    export { viewBox_11 as viewBox };
+    let paths_11: string[];
+    export { paths_11 as paths };
+}
+export namespace FILE_O {
+    let id_12: string;
+    export { id_12 as id };
+    let viewBox_12: string;
+    export { viewBox_12 as viewBox };
+    let paths_12: string[];
+    export { paths_12 as paths };
+}
+export namespace CHEVRON_RIGHT {
+    let id_13: string;
+    export { id_13 as id };
+    let viewBox_13: string;
+    export { viewBox_13 as viewBox };
+    let paths_13: string[];
+    export { paths_13 as paths };
+}
+export namespace CHEVRON_DOWN {
+    let id_14: string;
+    export { id_14 as id };
+    let viewBox_14: string;
+    export { viewBox_14 as viewBox };
+    let paths_14: string[];
+    export { paths_14 as paths };
+}
+export namespace FOLDER_O {
+    let id_15: string;
+    export { id_15 as id };
+    let viewBox_15: string;
+    export { viewBox_15 as viewBox };
+    let paths_15: string[];
+    export { paths_15 as paths };
+}
+export namespace FOLDER_OPEN_O {
+    let id_16: string;
+    export { id_16 as id };
+    let viewBox_16: string;
+    export { viewBox_16 as viewBox };
+    let paths_16: string[];
+    export { paths_16 as paths };
+}
+export const all: {
+    id: string;
+    paths: string[];
+    viewBox: string;
+}[];
+export const svgGeoMapIcon: HTMLElement;
+export const svgHorizontal1dHeatmap: HTMLElement;
+export const svgHorizontalLineIcon: HTMLElement;
+export const svg2DTilesIcon: HTMLElement;
+export const svg2DHeatmapIcon: HTMLElement;
+export const svg1DAxisIcon: HTMLElement;
+export const svgVertical1DAxisIcon: HTMLElement | null;
+export const svgGeneAnnotationsIcon: HTMLElement;
+export const svg1DTilesIcon: HTMLElement;
+export const svgVertical1DTilesIcon: HTMLElement | null;
+export const svgArrowheadDomainsIcon: HTMLElement;
+import React from 'react';
+import PropTypes from 'prop-types';