import { LoadedCallbackFunction, ErrorCallbackFunction } from '../scene/SceneCallbacks';
import { MetaEvents } from './MetaEvents';
import { ElementData } from '../scene/ElementData';
import { PropTools } from './PropTools.ts';
/**
 * Model tree node status.
 */
export declare enum ModelStatus {
    /**
     * Model tree node created.
     */
    Created = 0,
    /**
     * Model tree node enqueued.
     */
    Enqueued = 1,
    /**
     * Model tree node processing.
     * */
    Processing = 2,
    /**
     * Model tree node completed.
     */
    Completed = 3,
    /**
     * Model tree node with error.
     */
    Error = 4,
    /**
     * Model tree node unloaded.
     */
    Unloaded = 5
}
/**
 * Model item common information.
 */
export declare class MetaModelItem {
    /**Model Version. */
    version: number;
    /**Model version GUID. */
    guid: string;
    /**Model GUID. */
    modelGuid?: string;
    /**Model name. */
    name: string;
    /**Model index. */
    geomNum: number;
    /**Model status. */
    status: ModelStatus;
}
/**
 * Model common information.
 */
export declare class MetaModel {
    constructor(guid: string, geomNum: number, name: string);
    /**Model Version. */
    version: number;
    /**Model version GUID. */
    guid: string;
    /**Model name. */
    name: string;
    /**Model index. */
    geomNum: number;
    /**Map for mapping elements GUIDs to numbers. */
    guidToNums: Map<string, number>;
    /**Map for mapping elements numbers to GUIDs. */
    numsToGuids: Map<number, string>;
}
/**
 * Base class for model tree nodes.
 */
export declare class NodeBase {
    key: string;
    name: string;
    count: number | undefined;
    level: number;
    isLeaf?: boolean;
    children?: NodeBase[] | undefined;
    geomNum?: number;
}
/**
 * Model tree node.
 */
export declare class ModelNode extends NodeBase {
    guid: string;
    geomNum: number;
    children: GroupNode[] | undefined;
    status: ModelStatus;
    state: {
        isHidden?: boolean | undefined;
        color?: string | undefined;
    };
    isWrongOrigin: boolean;
    wrongOriginDistance: number;
}
/**
 * Element tree node.
 */
export declare class ElementNode extends NodeBase {
    guid: string;
    category: string;
    type: string;
    id: string;
    elIdx?: number | undefined;
    elNum: number;
    geomNum: number;
    isRef: boolean;
    sourceFile?: string | null;
}
/**
 * Group tree node.
 */
export declare class GroupNode extends NodeBase {
    state: {
        isHidden?: boolean | undefined;
        color?: number | undefined;
    };
    children: Array<GroupNode | ElementNode>;
}
export interface FileNode extends GroupNode {
    fileName?: string | null;
    isMainModel?: boolean;
}
/**
 * Loads model`s metadata (properties) from buckets and provides functions to manage elements properties.
 */
export declare class MetaManager extends EventTarget {
    readonly tag = "MetaManager";
    /**Tools for batch fetching properties for list of elements or all elements. */
    propTools: PropTools;
    /**Loaded model GUIDs.*/
    models: Map<string, MetaModel>;
    /**Unique instance id. */
    instanceId: string;
    /**Tree with metadata nodes structure. */
    metaTree: ModelNode[];
    /**Fetch model data from shared endpoints. */
    isShared: boolean;
    /**Shared link id. */
    linkId?: string;
    /** @deprecated Cache is always on. */
    useCache: boolean;
    /**Is if the ID of this Meta Manager matches the one stored in the IndexedDb "meta" table. */
    isIdbInstanceIncorrect: boolean;
    /** Maximum number of models that will be saved to the browser cache for faster later opening. */
    maxModelsCache: number;
    private server;
    private serverPath;
    private cacheServer;
    private cacheServerPath;
    private token;
    private loadedCallback;
    private changedCallback;
    private errorCallback;
    private metaWorker;
    private metaTreeWorker;
    elementDatas: Map<number, ElementData>;
    private fetchMetaAc;
    ax: import('axios').AxiosInstance;
    private processRetry;
    /**
     * Set access token for manager`s requests.
     * @param token - access token.
     */
    setToken(token: string): MetaManager;
    /**
     * Get access token for manager`s requests.
     */
    getToken(): string;
    constructor();
    /**
     * Set server path to REST point for data loading.
     * @param path - path to server REST point.
     */
    setServerPath(path?: string): MetaManager;
    /**
     * Get server path to REST point for data loading.
     */
    getServerPath(): string;
    /**
     * Set server path to REST point for cache data loading.
     * @param path - path to server REST point.
     */
    setCacheServerPath(path?: string): MetaManager;
    /**
     * Get server path to REST point for cache data loading.
     */
    getCacheServerPath(): string;
    /**
     * Set server URI for data loading.
     * @param server - server URI.
     * @param cacheServer - cache server URI
     */
    setServer(server?: string, cacheServer?: string): MetaManager;
    /**
     * Get cache server URI for data loading.
     */
    getCacheServer(): string;
    /**
     * Set callback function for event when each model is loaded.
     * @group Callbacks
     * @param loadedCallback - function with LoadedCallbackFunction signature.
     */
    onLoaded(loadedCallback: LoadedCallbackFunction): MetaManager;
    /**
     * Set a callback for an event when a model will not be loaded due to an error.
     * @group Callbacks
     * @param errorCallback - function with ErrorCallbackFunction signature.
     */
    onError(errorCallback: ErrorCallbackFunction): MetaManager;
    /**
     * Set callback function for event when models list are changed.
     * @group Callbacks
     * @param changedCallback - function with plain Function signature.
     */
    onChanged(changedCallback: Function): MetaManager;
    /**
     * Clear all nodes in model tree.
     */
    clearAllNodes(): void;
    /**
     * Reset children and count of a model tree node, and optionally set its status.
     * @param guid - Model version GUID of the node to clear.
     * @param status - Status to assign after clearing (defaults to {@link ModelStatus.Created}).
     */
    clearModelNode(guid: string, status?: ModelStatus): void;
    /**
     * Add new model nodes in model tree.
     * @param versionIds - model version GUIDS and names list.
     */
    addModelNodes(versionIds: MetaModelItem[]): void;
    /**
     * Set element datas map to MetaManager.
     * @param elementDatas - element datas map.
     */
    setElementDatas(elementDatas: Map<number, ElementData>): void;
    /**
     * Assign a meta tree and status to the model node identified by `versionId`.
     * @param versionId - Model version GUID of the target node.
     * @param status - New status for the model node.
     * @param progress - Reserved; not currently used.
     * @param tree - Meta tree to insert, or `undefined` to clear existing children.
     */
    setByModelVersionGuid(versionId: string, status: ModelStatus, progress: number, tree: GroupNode[] | undefined): void;
    private processMetaTreeData;
    private processMetaTreeNodes;
    /**
     * Load meta trees by version GUIDS into existing model nodes.
     * @param versionIds - version GUIDs list.
     */
    loadByModelVersionGuids(versionIds: MetaModelItem[]): Promise<void>;
    /**
     * Fetch meta trees by version GUIDs list in parallel async mode. Meta tree will not be inserted into model node.
     * @param versionIds - version GUIDs list.
     * @param onLoadedCallback - callback function for each loaded meta tree.
     */
    fetchByModelVersionGuidsParallel(versionIds: MetaModelItem[], onLoadedCallback: (res: {
        isError: boolean;
        modelVersionId: string;
        tree: any;
    }) => void): void;
    /**
     * Fetch meta trees by version GUIDs list. Meta tree will not be inserted into model node.
     * @param versionIds - version GUIDs list.
     */
    fetchByModelVersionGuids(versionIds: MetaModelItem[]): Promise<{
        isError: boolean;
        modelVersionId: string;
        tree: any;
    }[]>;
    /**
     * Fetch meta trees by version GUIDs list. Meta tree will not be inserted into model node.
     * @param versionIds - version GUIDs list.
     */
    /**
     * Load meta trees by version GUIDs list and create new model nodes.
     * @param versionIds - List of model version items to load.
     * @param isShared - When true, trees are fetched via shared link endpoints instead of model version GUIDs.
     * @param linkId - Shared link ID; required when `isShared` is true.
     */
    load(versionIds: MetaModelItem[], isShared?: boolean, linkId?: string): Promise<void>;
    /**
     * Get element GUID by its combined element number.
     * @param elNum - Full element number as produced by {@link GeometryBase.getModelElNumber}.
     */
    getElementGuid(elNum: number): string;
    /**
     * Get the combined element number for a given element GUID.
     * @param guid - Element GUID.
     */
    getElementNums(guid: string): number | undefined;
    /**
     * Get full metadata for the specified elements.
     * @param guids - Element GUIDs to fetch.
     * @param excludeModelRefs - When true, model-reference properties are excluded from the result.
     */
    getElementsMetasByGuids(guids: string[], excludeModelRefs?: boolean): Promise<any[]>;
    private collectDataRefs;
    private getRefMetas;
    /**
     * Get element metadata by element numbers.
     * @param elNum - Element number.
     */
    getElementMetaByNumbers(elNum: number): Promise<any>;
    /**
     * Get element metadata by GUID.
     * @param guid - element GUID.
     */
    getElementMetaByGuid(guid: string): Promise<any>;
    /**
     * Traverse meta tree nodes and invoke a callback for matching elements.
     * When `elNums` is omitted, the callback is called for every element node.
     * @param onNodeCallback - Callback invoked for each matching node.
     * @param elNums - Element number or array of element numbers to match; omit to visit all nodes.
     * @param startNode - Root node to begin traversal from; defaults to the full meta tree.
     * @param isReversed - When true (default), children are visited before their parent (post-order).
     */
    traverse(onNodeCallback?: Function, elNums?: number | number[], startNode?: any, isReversed?: boolean): any[];
    /**
     * Collects tree nodes by element nums.
     * @param elNums - Element number or array of element numbers.
     */
    collect(elNums?: number | number[]): any[];
    private traverseNodes;
    /**
     * Collect all element nodes for any parent node in meta tree.
     * @param node - Any parent node.
     */
    collectEndNodes(node?: any | undefined): any[];
    private getElementMetaFromCache;
    private getMetaTreeFromCache;
    private processCachedMetaTreeNode;
    private processCachedMetaTreeData3;
    private processCachedMetaTreeData2;
    private processCachedMetaTreeData;
    /**
     * Add an event listener that is automatically removed when the provided `signal` aborts.
     * @param eventType - Event type to listen for.
     * @param eventListener - Listener function or object.
     * @param signal - AbortSignal that controls the lifetime of this listener.
     */
    addAutoEventListener(eventType: MetaEvents, eventListener: EventListenerOrEventListenerObject, signal: AbortSignal): void;
    /**
     * Destroy MetaManager and delete all data from browser store.
     */
    destroy(): void;
    processNodesState(): void;
}