/// <reference types="jquery" />
/// <reference types="jquery" />
/// <reference types="jstree" />
import CachedProperty from './CachedProperty';
import { RuleSet, RuleSetParams, RuleWithId } from './oncoprintruleset';
import { InitParams } from './oncoprint';
import { ComputedShapeParams } from './oncoprintshape';
import { OncoprintGapConfig } from './oncoprintwebglcellview';
export declare enum GAP_MODE_ENUM {
    SHOW_GAPS = "SHOW_GAPS",
    SHOW_GAPS_PERCENT = "SHOW_GAPS_PERCENT",
    HIDE_GAPS = "HIDE_GAPS"
}
export type ColumnId = string;
export type ColumnIndex = number;
export type TrackId = number;
export type Datum = any;
export type RuleSetId = number;
export type TrackGroupHeader = {
    label: {
        text: string;
    };
    options: CustomTrackGroupOption[];
};
export type TrackGroup = {
    header?: TrackGroupHeader;
    tracks: TrackId[];
};
export type TrackGroupIndex = number;
export type TrackSortDirection = 0 | 1 | -1;
export type TrackSortComparator<D> = (d1: D, d2: D) => number;
export type TrackSortVector<D> = (d: D) => (number | string)[];
export type TrackTooltipFn<D> = (cell_data: D[]) => HTMLElement | string | any;
export type TrackSortSpecificationComparators<D> = {
    mandatory: TrackSortComparator<D>;
    preferred: TrackSortComparator<D>;
    isVector?: false;
};
export type TrackSortSpecificationVectors<D> = {
    mandatory: TrackSortVector<D>;
    preferred: TrackSortVector<D>;
    isVector: true;
    compareEquals?: TrackSortComparator<D>;
};
export type TrackSortSpecification<D> = TrackSortSpecificationComparators<D> | TrackSortSpecificationVectors<D>;
export type ActiveRules = {
    [ruleId: number]: boolean;
};
export type ActiveRulesCount = {
    [ruleId: number]: number;
};
export type TrackSortDirectionChangeCallback = (track_id: TrackId, dir: number) => void;
export type TrackGapChangeCallBack = (track_id: TrackId, mode: GAP_MODE_ENUM) => void;
export type CustomTrackOption = {
    label?: string;
    separator?: boolean;
    onClick?: (id: TrackId) => void;
    weight?: string;
    disabled?: boolean;
    gapLabelsFn?: (model: OncoprintModel) => OncoprintGapConfig[];
};
export type CustomTrackGroupOption = {
    label?: string;
    separator?: boolean;
    onClick?: (id: TrackGroupIndex) => void;
    weight?: () => string;
    disabled?: () => boolean;
};
export type UserTrackSpec<D> = {
    target_group?: TrackGroupIndex;
    cell_height?: number;
    track_padding?: number;
    has_column_spacing?: boolean;
    data_id_key?: string & keyof D;
    tooltipFn?: TrackTooltipFn<D>;
    movable?: boolean;
    removable?: boolean;
    removeCallback?: (track_id: TrackId) => void;
    onClickRemoveInTrackMenu?: (track_id: TrackId) => void;
    label?: string;
    sublabel?: string;
    gapLabelFn?: (model: OncoprintModel) => string[];
    html_label?: string;
    track_label_color?: string;
    track_label_circle_color?: string;
    track_label_font_weight?: string;
    track_label_left_padding?: number;
    link_url?: string;
    description?: string;
    track_info?: string;
    sortCmpFn: TrackSortSpecification<D>;
    sort_direction_changeable?: boolean;
    onSortDirectionChange?: TrackSortDirectionChangeCallback;
    onGapChange?: TrackGapChangeCallBack;
    init_sort_direction?: TrackSortDirection;
    data?: D[];
    rule_set_params?: RuleSetParams;
    expansion_of?: TrackId;
    expandCallback?: (id: TrackId) => void;
    expandButtonTextGetter?: (is_expanded: boolean) => string;
    important_ids?: string[];
    custom_track_options?: CustomTrackOption[];
    $track_info_tooltip_elt?: JQuery;
    track_can_show_gaps?: boolean;
    show_gaps_on_init?: boolean;
};
export type LibraryTrackSpec<D> = UserTrackSpec<D> & {
    rule_set: RuleSet;
    track_id: TrackId;
};
export type TrackOverlappingCells = {
    ids: ColumnId[];
    track: TrackId;
    top: number;
    left: number;
};
export type SortConfig = {
    type: 'alphabetical';
} | {
    type: 'order';
    order: string[];
} | {
    type: 'cluster';
    track_group_index: number;
    clusterValueFn: (datum: any) => number;
} | {
    type?: '';
};
export type IdentifiedShapeList = {
    id: ColumnId;
    shape_list: ComputedShapeParams[];
};
export type ClusterSortResult = {
    track_group_index: TrackGroupIndex;
    track_id_order: TrackId[];
};
export type ColumnLabel = {
    left_padding_percent?: number;
    text_color?: string;
    circle_color?: string;
    angle_in_degrees?: number;
    text: string;
};
export type TrackProp<T> = {
    [trackId: number]: T;
};
export type TrackGroupProp<T> = {
    [trackGroupIndex: number]: T;
};
export type ColumnProp<T> = {
    [columnId: string]: T;
};
export type ColumnIdSet = {
    [columnId: string]: any;
};
export type OncoprintDataGroupsByTrackId<T> = Record<string, OncoprintDataGroups<T>[]>;
export type OncoprintDataGroups<T> = OncoprintDataGroup<T>[];
export type OncoprintDataGroup<T> = T[];
export default class OncoprintModel {
    private sort_config;
    rendering_suppressed_depth: number;
    keep_sorted: boolean;
    readonly max_height: number;
    private cell_width;
    private horz_zoom;
    private vert_zoom;
    private horz_scroll;
    private vert_scroll;
    private bottom_padding;
    private track_group_padding;
    private cell_padding;
    private cell_padding_on;
    private cell_padding_off_cell_width_threshold;
    private cell_padding_off_because_of_zoom;
    private id_order;
    private hidden_ids;
    private highlighted_ids;
    private highlighted_tracks;
    private track_group_legend_order;
    private show_track_sublabels;
    private show_track_labels;
    private column_labels;
    private track_important_ids;
    private track_label;
    private track_label_color;
    private track_label_circle_color;
    private track_label_font_weight;
    private track_label_left_padding;
    private track_sublabel;
    private track_html_label;
    private track_link_url;
    private track_description;
    private cell_height;
    private track_padding;
    private track_data_id_key;
    private track_tooltip_fn;
    private track_movable;
    private track_removable;
    private track_remove_callback;
    private track_remove_option_callback;
    private track_sort_cmp_fn;
    private track_sort_direction_changeable;
    private track_sort_direction;
    private track_sort_direction_change_callback;
    private track_gap_change_callback;
    private track_data;
    private track_rule_set_id;
    private track_active_rules;
    private track_info;
    private $track_info_tooltip_elt;
    private track_has_column_spacing;
    private track_expansion_enabled;
    private track_expand_callback;
    private track_expand_button_getter;
    track_expansion_tracks: TrackProp<TrackId[]>;
    private track_expansion_parent;
    private track_custom_options;
    private track_can_show_gaps;
    private track_show_gaps;
    private rule_sets;
    private rule_set_active_rules;
    private visible_id_order;
    private track_id_to_datum;
    private track_present_ids;
    private present_ids;
    private id_to_index;
    private visible_id_to_index;
    private track_tops;
    private cell_tops;
    private label_tops;
    private track_tops_zoomed;
    private header_tops_zoomed;
    private cell_tops_zoomed;
    private label_tops_zoomed;
    private column_left;
    private column_left_always_with_padding;
    private zoomed_column_left;
    private column_left_no_padding;
    private precomputed_comparator;
    ids_after_a_gap: CachedProperty<ColumnIdSet>;
    data_groups: CachedProperty<OncoprintDataGroupsByTrackId<TrackProp<ColumnProp<Datum>>>>;
    private column_indexes_after_a_gap;
    private track_groups;
    private unclustered_track_group_order?;
    private track_group_sort_priority;
    constructor(params: InitParams);
    setTrackShowGaps(trackId: TrackId, show: GAP_MODE_ENUM): void;
    getTrackShowGaps(trackId: TrackId): GAP_MODE_ENUM;
    getTrackCanShowGaps(trackId: TrackId): boolean;
    getColumnIndexesAfterAGap(): number[];
    setTrackGroupHeader(index: TrackGroupIndex, header?: TrackGroupHeader): void;
    getTrackGroupHeaderHeight(trackGroup: TrackGroup): 0 | 32;
    toggleCellPadding(): boolean;
    getCellPadding(base?: boolean, dont_consider_zoom?: boolean): number;
    getHorzZoom(): number;
    getIdsInZoomedLeftInterval(left: number, right: number): string[];
    getHorzZoomToFitCols(width: number, left_col_incl: ColumnIndex, right_col_excl: ColumnIndex): number;
    getHorzZoomToFit(width: number, ids: ColumnId[]): number;
    getMinHorzZoom(): number;
    getMinVertZoom(): number;
    setHorzScroll(s: number): number;
    setVertScroll(s: number): number;
    setScroll(h: number, v: number): void;
    getHorzScroll(): number;
    getVertScroll(): number;
    setZoom(zoom_x: number, zoom_y: number): void;
    private setCellPaddingOffBecauseOfZoom;
    setHorzZoom(z: number): number;
    getVertZoom(): number;
    setVertZoom(z: number): number;
    setShowTrackLabels(s: boolean): void;
    getShowTrackLabels(): boolean;
    hideTrackLegends(track_ids: TrackId[]): void;
    showTrackLegends(track_ids: TrackId[]): void;
    private clearTrackActiveRules;
    private setTrackActiveRules;
    getTrackUniversalShapes(track_id: TrackId, use_base_size: boolean): ComputedShapeParams[];
    getSpecificShapesForData(track_id: TrackId, use_base_size: boolean): IdentifiedShapeList[];
    getActiveRules(rule_set_id: RuleSetId): RuleWithId[];
    setTrackImportantIds(track_id: TrackId, ids?: ColumnId[]): void;
    getTrackImportantIds(track_id: TrackId): ColumnProp<boolean>;
    getRuleSets(): RuleSet[];
    getTrackHasColumnSpacing(track_id: TrackId): boolean;
    getGapSize(): number;
    getCellWidth(base?: boolean): number;
    getCellHeight(track_id: TrackId, base?: boolean): number;
    getTrackInfo(track_id: TrackId): string;
    setTrackInfo(track_id: TrackId, msg: string): void;
    getTrackHeight(track_id: TrackId, base?: boolean): number;
    getTrackPadding(track_id: TrackId, base?: boolean): number;
    getBottomPadding(): number;
    getTrackSortDirection(track_id: TrackId): TrackSortDirection;
    setTrackSortDirection(track_id: TrackId, dir: TrackSortDirection, no_callback?: boolean): void;
    resetSortableTracksSortDirection(no_callback?: boolean): void;
    setCellPaddingOn(cell_padding_on: boolean): void;
    getIdOrder(all?: boolean): string[];
    getClosestColumnIndexToLeft(left: number, zoomed?: boolean, roundUp?: boolean): number;
    getIdToIndexMap(): ColumnProp<number>;
    getVisibleIdToIndexMap(): ColumnProp<number>;
    getHiddenIds(): string[];
    isSortAffected(modified_ids: TrackId | TrackId[], group_or_track: 'track' | 'group'): boolean;
    setIdOrder(ids: ColumnId[]): void;
    hideIds(to_hide: ColumnId[], show_others?: boolean): void;
    setHighlightedTracks(track_ids: TrackId[]): void;
    getHighlightedTracks(): number[];
    setHighlightedIds(ids: ColumnId[]): void;
    getVisibleHighlightedIds(): string[];
    restoreClusteredTrackGroupOrder(): void;
    setTrackGroupOrder(index: TrackGroupIndex, track_order: TrackId[]): void;
    moveTrackGroup(from_index: TrackGroupIndex, to_index: TrackGroupIndex): TrackGroup[];
    addTracks(params_list: LibraryTrackSpec<Datum>[]): Promise<void>;
    private addTrack;
    getAllIds(): string[];
    releaseRendering(): Promise<void>;
    private ensureTrackGroupExists;
    private _getMajorTrackGroup;
    private _getEffectiveTrackGroupTracks;
    private isRuleSetUsed;
    private removeRuleSet;
    removeTrack(track_id: TrackId): void;
    getOverlappingCells(x: number, y: number): TrackOverlappingCells | null;
    getTrackDatum(track_id: TrackId, id: ColumnId): any;
    getTrackTops(): TrackProp<number>;
    getTrackTops(desired_track_id: TrackId): number;
    getZoomedTrackTops(): TrackProp<number>;
    getZoomedTrackTops(desired_track_id: TrackId): number;
    getZoomedHeaderTops(): TrackGroupProp<number>;
    getZoomedHeaderTops(track_group_index: TrackGroupIndex): number;
    getCellTops(desired_track_id?: undefined, base?: boolean): TrackProp<number>;
    getCellTops(desired_track_id: TrackId, base?: boolean): number;
    getLabelTops(): TrackProp<number>;
    getLabelTops(desired_track_id: TrackId): number;
    getContainingTrackGroup(track_id: TrackId): number[];
    getContainingTrackGroupIndex(track_id: TrackId): number;
    getTrackGroups(): TrackGroup[];
    getTracks(): number[];
    getColumnLeft(): ColumnProp<number>;
    getColumnLeft(id: ColumnId): number;
    getColumnLeftNoPadding(): ColumnProp<number>;
    getColumnLeftNoPadding(id: ColumnId): number;
    getZoomedColumnLeft(): ColumnProp<number>;
    getZoomedColumnLeft(id: ColumnId): number;
    getOncoprintHeight(base?: boolean): number;
    getOncoprintWidth(base?: boolean): number;
    showGaps(): boolean;
    gapMode(): GAP_MODE_ENUM;
    getOncoprintWidthNoColumnPaddingNoGaps(): number;
    getColumnLabels(): ColumnProp<ColumnLabel>;
    setColumnLabels(labels: ColumnProp<ColumnLabel>): void;
    moveTrack(track_id: TrackId, new_previous_track: TrackId): void;
    getTrackLabel(track_id: TrackId): string;
    getTrackSublabel(track_id: TrackId): string;
    getShowTrackSublabels(): boolean;
    setShowTrackSublabels(show: boolean): boolean;
    getTrackLabelColor(track_id: TrackId): string;
    getTrackLabelCircleColor(track_id: TrackId): string;
    getTrackLabelFontWeight(track_id: TrackId): string;
    getTrackLabelLeftPadding(track_id: TrackId): number;
    getOptionalHtmlTrackLabel(track_id: TrackId): string;
    getTrackLinkUrl(track_id: TrackId): string;
    getTrackDescription(track_id: TrackId): string;
    getTrackTooltipFn(track_id: TrackId): TrackTooltipFn<any>;
    setTrackTooltipFn(track_id: TrackId, tooltipFn: TrackTooltipFn<Datum>): void;
    getTrackDataIdKey(track_id: TrackId): string;
    getTrackGroupPadding(base?: boolean): number;
    isTrackRemovable(track_id: TrackId): boolean;
    getTrackRemoveOptionCallback(track_id: TrackId): (track_id: number) => void;
    isTrackSortDirectionChangeable(track_id: TrackId): boolean;
    isTrackExpandable(track_id: TrackId): boolean;
    expandTrack(track_id: TrackId): void;
    disableTrackExpansion(track_id: TrackId): void;
    enableTrackExpansion(track_id: TrackId): void;
    isTrackExpanded(track_id: TrackId): boolean;
    getExpandButtonText(track_id: TrackId): string;
    /**
     * Checks if one track is the expansion of another
     *
     * @param {number} expansion_track_id - the ID of the track to check
     * @param {number} set_track_id - the ID of the track it may be an expansion of
     */
    isExpansionOf(expansion_track_id: TrackId, set_track_id: TrackId): boolean;
    /**
     * Finds the bottom-most track in a track's expansion group
     *
     * @param track_id - the ID of the track to start from
     * @returns the ID of its last expansion, or the unchanged param if none
     */
    getLastExpansion(track_id: TrackId): number;
    getTrackCustomOptions(track_id: TrackId): CustomTrackOption[];
    setTrackCustomOptions(track_id: TrackId, options: CustomTrackOption[] | undefined): void;
    getGapOffsets(): any;
    setTrackInfoTooltip(track_id: TrackId, $tooltip_elt: JQuery | undefined): void;
    $getTrackInfoTooltip(track_id: TrackId): JQuery<HTMLElement>;
    getRuleSet(track_id: TrackId): RuleSet;
    shareRuleSet(source_track_id: TrackId, target_track_id: TrackId): void;
    setRuleSet(track_id: TrackId, rule_set: RuleSet): void;
    getTrackSortComparator(track_id: TrackId): TrackSortSpecification<any>;
    setTrackSortComparator(track_id: TrackId, sortCmpFn: TrackSortSpecification<Datum>): void;
    getTrackData(track_id: TrackId): any[];
    clusterTrackGroup(track_group_index: TrackGroupIndex, clusterValueFn: (d: Datum) => number): Promise<void | ClusterSortResult>;
    /**
     * Sets the data for an Oncoprint track.
     *
     * @param track_id - the ID that identifies the track
     * @param {Object[]} data - the list of data for the cells
     * @param {string} data_id_key - name of the property of the
     * data objects to use as the (column) key
     */
    setTrackData(track_id: TrackId, data: Datum[], data_id_key: string & keyof Datum): void;
    setTrackGroupLegendOrder(group_order: TrackGroupIndex[]): void;
    getTrackGroupLegendOrder(): number[];
    setTrackGroupSortPriority(priority: TrackGroupIndex[]): void;
    private sortAlphabetical;
    private sortByTracks;
    sort(): Promise<void | ClusterSortResult>;
    setSortConfig(params: SortConfig): void;
    getTrackMovable(track_id: TrackId): boolean;
    setTrackMovable(track_id: TrackId, movable: boolean): void;
    isTrackInClusteredGroup(track_id: TrackId): boolean;
}