import type React from 'react';
import type PluginManager from '../PluginManager';
import type { BaseBlock } from './blockTypes';
import type { Feature } from './simpleFeature';
import type { AssemblyManager, Region, TypeTestedByPredicate } from './types';
import type { Region as MUIRegion } from './types/mst';
import type { BaseOptions } from '../data_adapters/BaseAdapter';
import type { GenericFilehandle } from 'generic-filehandle2';
import type { IAnyStateTreeNode, IStateTreeNode, Instance } from 'mobx-state-tree';
export * from './types';
export * from './when';
export * from './range';
export * from './dedupe';
export * from './offscreenCanvasPonyfill';
export * from './offscreenCanvasUtils';
export declare function useDebounce<T>(value: T, delay: number): T;
export declare function useWidthSetter(view: {
    setWidth: (arg: number) => void;
}, padding: string): React.RefObject<HTMLDivElement | null>;
export declare function useDebouncedCallback<T>(callback: (...args: T[]) => void, wait?: number): (...args: T[]) => void;
export declare function findParentThat(node: IAnyStateTreeNode, predicate: (thing: IAnyStateTreeNode) => boolean): IAnyStateTreeNode;
export declare function springAnimate(fromValue: number, toValue: number, setValue: (value: number) => void, onFinish?: () => void, precision?: number, tension?: number, friction?: number, clamp?: boolean): (() => void)[];
export declare function findParentThatIs<T extends (a: IAnyStateTreeNode) => boolean>(node: IAnyStateTreeNode, predicate: T): TypeTestedByPredicate<T>;
export declare function getSession(node: IAnyStateTreeNode): import("./types").AbstractSessionModel;
export declare function getContainingView(node: IAnyStateTreeNode): import("./types").AbstractViewModel;
export declare function getContainingTrack(node: IAnyStateTreeNode): import("./types").AbstractTrackModel;
export declare function getContainingDisplay(node: IAnyStateTreeNode): import("./types").AbstractDisplayModel;
export declare function assembleLocString(region: ParsedLocString): string;
export declare function assembleLocStringFast(region: ParsedLocString, cb?: (n: number) => string | number): string;
export interface ParsedLocString {
    assemblyName?: string;
    refName: string;
    start?: number;
    end?: number;
    reversed?: boolean;
}
export declare function parseLocStringOneBased(locString: string, isValidRefName: (refName: string, assemblyName?: string) => boolean): ParsedLocString;
export declare function parseLocString(locString: string, isValidRefName: (refName: string, assemblyName?: string) => boolean): ParsedLocString;
export declare function compareLocs(locA: ParsedLocString, locB: ParsedLocString): number;
export declare function compareLocStrings(a: string, b: string, isValidRefName: (refName: string, assemblyName?: string) => boolean): number;
export declare function clamp(num: number, min: number, max: number): number;
export declare function bpToPx(bp: number, { reversed, end, start, }: {
    start?: number;
    end?: number;
    reversed?: boolean;
}, bpPerPx: number): number;
export declare function radToDeg(radians: number): number;
export declare function degToRad(degrees: number): number;
export declare function polarToCartesian(rho: number, theta: number): [number, number];
export declare function cartesianToPolar(x: number, y: number): [number, number];
interface MinimalRegion {
    start: number;
    end: number;
    reversed?: boolean;
}
export declare function featureSpanPx(feature: Feature, region: MinimalRegion, bpPerPx: number): readonly [number, number];
export declare function bpSpanPx(leftBp: number, rightBp: number, region: MinimalRegion, bpPerPx: number): readonly [number, number];
export declare function iterMap<T, U>(iter: Iterable<T>, func: (arg: T) => U, sizeHint?: number): U[];
export declare function findLastIndex<T>(array: T[], predicate: (value: T, index: number, obj: T[]) => boolean): number;
export declare function findLast<T>(array: T[], predicate: (value: T, index: number, obj: T[]) => boolean): T | undefined;
export declare function renameRegionIfNeeded(refNameMap: Record<string, string> | undefined, region: Region | Instance<typeof MUIRegion>): Region & {
    originalRefName?: string;
};
export declare function renameRegionsIfNeeded<ARGTYPE extends {
    assemblyName?: string;
    regions?: Region[];
    stopToken?: string;
    adapterConfig: Record<string, unknown>;
    sessionId: string;
    statusCallback?: (arg: string) => void;
}>(assemblyManager: AssemblyManager, args: ARGTYPE): Promise<ARGTYPE & {
    regions: (Region & {
        originalRefName?: string;
    })[];
}>;
export declare function minmax(a: number, b: number): readonly [number, number];
export declare function shorten(name: string, max?: number, short?: number): string;
export declare function stringify({ refName, coord, assemblyName, oob, }: {
    assemblyName?: string;
    coord: number;
    refName?: string;
    oob?: boolean;
}, useAssemblyName?: boolean): string;
export declare const isElectron: boolean;
export declare const complementTable: Record<string, string>;
export declare function revcom(str: string): string;
export declare function reverse(str: string): string;
export declare function complement(str: string): string;
export declare const rIC: (((callback: IdleRequestCallback, options?: IdleRequestOptions) => number) & typeof requestIdleCallback) | ((cb: () => void) => void);
export declare function measureText(str: unknown, fontSize?: number): number;
export type Frame = 1 | 2 | 3 | -1 | -2 | -3;
export declare function getFrame(start: number, end: number, strand: 1 | -1, phase: 0 | 1 | 2): Frame;
export declare const defaultStarts: string[];
export declare const defaultStops: string[];
export declare const defaultCodonTable: {
    TCA: string;
    TCC: string;
    TCG: string;
    TCT: string;
    TTC: string;
    TTT: string;
    TTA: string;
    TTG: string;
    TAC: string;
    TAT: string;
    TAA: string;
    TAG: string;
    TGC: string;
    TGT: string;
    TGA: string;
    TGG: string;
    CTA: string;
    CTC: string;
    CTG: string;
    CTT: string;
    CCA: string;
    CCC: string;
    CCG: string;
    CCT: string;
    CAC: string;
    CAT: string;
    CAA: string;
    CAG: string;
    CGA: string;
    CGC: string;
    CGG: string;
    CGT: string;
    ATA: string;
    ATC: string;
    ATT: string;
    ATG: string;
    ACA: string;
    ACC: string;
    ACG: string;
    ACT: string;
    AAC: string;
    AAT: string;
    AAA: string;
    AAG: string;
    AGC: string;
    AGT: string;
    AGA: string;
    AGG: string;
    GTA: string;
    GTC: string;
    GTG: string;
    GTT: string;
    GCA: string;
    GCC: string;
    GCG: string;
    GCT: string;
    GAC: string;
    GAT: string;
    GAA: string;
    GAG: string;
    GGA: string;
    GGC: string;
    GGG: string;
    GGT: string;
};
export declare function generateCodonTable(table: any): Record<string, string>;
export declare function updateStatus<U>(msg: string, cb: (arg: string) => void, fn: () => U | Promise<U>): Promise<U>;
export declare function updateStatus2<U>(msg: string, cb: (arg: string) => void, stopToken: string | undefined, fn: () => U | Promise<U>): Promise<U>;
export declare function hashCode(str: string): number;
export declare function objectHash(obj: Record<string, any>): string;
interface VirtualOffset {
    blockPosition: number;
}
interface Block {
    minv: VirtualOffset;
    maxv: VirtualOffset;
}
export declare function bytesForRegions(regions: Region[], index: {
    blocksForRange: (ref: string, start: number, end: number) => Promise<Block[]>;
}): Promise<number>;
export interface ViewSnap {
    bpPerPx: number;
    interRegionPaddingWidth: number;
    minimumBlockWidth: number;
    width: number;
    offsetPx: number;
    staticBlocks: {
        contentBlocks: BaseBlock[];
        blocks: BaseBlock[];
    };
    displayedRegions: (IStateTreeNode & {
        start: number;
        end: number;
        refName: string;
        reversed?: boolean;
        assemblyName: string;
    })[];
}
export declare function isSupportedIndexingAdapter(type?: string): boolean;
export declare function getBpDisplayStr(total: number): string;
export declare function getProgressDisplayStr(current: number, total: number): string;
export declare function toLocale(n: number): string;
export declare function getTickDisplayStr(totalBp: number, bpPerPx: number): string;
export declare function getViewParams(model: IAnyStateTreeNode, exportSVG?: boolean): {
    offsetPx: number;
    offsetPx1: number;
    start: number;
    end: number;
};
export declare function getLayoutId({ sessionId, layoutId, }: {
    sessionId: string;
    layoutId: string;
}): string;
export declare function useLocalStorage<T>(key: string, initialValue: T): readonly [T, (value: T | ((val: T) => T)) => void];
export declare function getUriLink(value: {
    uri: string;
    baseUri?: string;
}): string;
export declare function getStr(obj: unknown): string;
export declare function coarseStripHTML(s: string): string;
export declare function linkify(s: string): string;
export declare function measureGridWidth(elements: unknown[], args?: {
    minWidth?: number;
    fontSize?: number;
    maxWidth?: number;
    padding?: number;
    stripHTML?: boolean;
}): number;
export declare function getEnv(obj: any): {
    pluginManager: PluginManager;
};
export declare function localStorageGetItem(item: string): string | null | undefined;
export declare function localStorageSetItem(str: string, item: string): void;
export declare function max(arr: Iterable<number>, init?: number): number;
export declare function min(arr: Iterable<number>, init?: number): number;
export declare function sum(arr: Iterable<number>): number;
export declare function avg(arr: number[]): number;
export declare function groupBy<T>(array: Iterable<T>, predicate: (v: T) => string): Record<string, T[]>;
export declare function notEmpty<T>(value: T | null | undefined): value is T;
export declare function mergeIntervals<T extends {
    start: number;
    end: number;
}>(intervals: T[], w?: number): T[];
export interface BasicFeature {
    end: number;
    start: number;
    refName: string;
}
export declare function gatherOverlaps<T extends BasicFeature>(regions: T[], w?: number): T[];
export declare function stripAlpha(str: string): string;
export declare function getStrokeProps(str: string): {
    strokeOpacity: number;
    stroke: string;
};
export declare function getFillProps(str: string): {
    fillOpacity: number;
    fill: string;
};
export declare function renderToStaticMarkup(node: React.ReactElement): string;
export declare function isGzip(buf: Uint8Array): boolean;
export declare function fetchAndMaybeUnzip(loc: GenericFilehandle, opts?: BaseOptions): Promise<Uint8Array<ArrayBufferLike>>;
export declare function fetchAndMaybeUnzipText(loc: GenericFilehandle, opts?: BaseOptions): Promise<string>;
export declare function isObject(x: unknown): x is Record<string | symbol | number, unknown>;
export declare function localStorageGetNumber(key: string, defaultVal: number): number;
export declare function localStorageGetBoolean(key: string, defaultVal: boolean): boolean;
export declare function forEachWithStopTokenCheck<T>(iter: Iterable<T>, stopToken: string | undefined, arg: (arg: T) => void, durationMs?: number): void;
export declare function testAdapter(fileName: string, regex: RegExp, adapterHint: string | undefined, expected: string): boolean;
export { type Feature, type SimpleFeatureSerialized, type SimpleFeatureSerializedNoId, default as SimpleFeature, isFeature, } from './simpleFeature';
export { blobToDataURL } from './blobToDataURL';
export { makeAbortableReaction } from './makeAbortableReaction';
export * from './aborting';