import * as THREE from 'three';
import EventEmitter from './EventEmitter';
import CameraHandler from './context/CameraHanlder';
import SectionBox from './SectionBox';
import { Assets } from './Assets';
import { CanonicalView, InlineView, IViewer, PolarView, SpeckleView, SunLightConfiguration, ViewerEvent, ViewerParams } from '../IViewer';
import { World } from './World';
import { WorldTree } from './tree/WorldTree';
import SpeckleRenderer from './SpeckleRenderer';
import { FilteringState } from './filtering/FilteringManager';
import { PropertyInfo } from './filtering/PropertyManager';
import { DataTree } from './tree/DataTree';
import { Query, QueryArgsResultMap, QueryResult } from './queries/Query';
import { Utils } from './Utils';
import { DiffResult, Differ, VisualDiffMode } from './Differ';
import { BatchObject } from './batching/BatchObject';
import { MeasurementOptions } from './measurements/Measurements';
export declare class Viewer extends EventEmitter implements IViewer {
    /** Container and optional stats element */
    private container;
    private stats;
    /** Viewer params used at init time */
    private startupParams;
    /** Viewer components */
    private tree;
    private world;
    static Assets: Assets;
    protected speckleRenderer: SpeckleRenderer;
    private filteringManager;
    private propertyManager;
    differ: Differ;
    /** Legacy viewer components (will revisit soon) */
    sectionBox: SectionBox;
    cameraHandler: CameraHandler;
    /** Misc members */
    private inProgressOperations;
    private clock;
    private loaders;
    /** various utils/helpers */
    private utils;
    /** Gets the World object. Currently it's used for info mostly */
    get World(): World;
    get Utils(): Utils;
    constructor(container: HTMLElement, params?: ViewerParams);
    getObjects(id: string): BatchObject[];
    setSectionBox(box?: {
        min: {
            x: number;
            y: number;
            z: number;
        };
        max: {
            x: number;
            y: number;
            z: number;
        };
    }, offset?: number): void;
    getSectionBoxFromObjects(objectIds: string[]): THREE.Box3;
    setSectionBoxFromObjects(objectIds: string[], offset?: number): void;
    getCurrentSectionBox(): THREE.Box3;
    resize(): void;
    requestRender(): void;
    private frame;
    private update;
    private render;
    init(): Promise<void>;
    on(eventType: ViewerEvent, listener: (arg: any) => void): void;
    getObjectProperties(resourceURL?: string, bypassCache?: boolean): PropertyInfo[];
    selectObjects(objectIds: string[]): Promise<FilteringState>;
    resetSelection(): Promise<FilteringState>;
    hideObjects(objectIds: string[], stateKey?: string, includeDescendants?: boolean, ghost?: boolean): Promise<FilteringState>;
    showObjects(objectIds: string[], stateKey?: string, includeDescendants?: boolean): Promise<FilteringState>;
    isolateObjects(objectIds: string[], stateKey?: string, includeDescendants?: boolean, ghost?: boolean): Promise<FilteringState>;
    unIsolateObjects(objectIds: string[], stateKey?: string, includeDescendants?: boolean): Promise<FilteringState>;
    highlightObjects(objectIds: string[], ghost?: boolean): Promise<FilteringState>;
    resetHighlight(): Promise<FilteringState>;
    setColorFilter(property: PropertyInfo, ghost?: boolean): Promise<FilteringState>;
    removeColorFilter(): Promise<FilteringState>;
    setUserObjectColors(groups: {
        objectIds: string[];
        color: string;
    }[]): Promise<FilteringState>;
    resetFilters(): Promise<FilteringState>;
    /**
     * LEGACY: Handles (or tries to handle) old viewer filtering.
     * @param args legacy filter object
     */
    applyFilter(filter: unknown): Promise<void>;
    getDataTree(): DataTree;
    getWorldTree(): WorldTree;
    query<T extends Query>(query: T): QueryArgsResultMap[T['operation']];
    queryAsync(query: Query): Promise<QueryResult>;
    toggleSectionBox(): void;
    sectionBoxOff(): void;
    sectionBoxOn(): void;
    zoom(objectIds?: string[], fit?: number, transition?: boolean): void;
    setProjectionMode(mode: typeof CameraHandler.prototype.activeCam): void;
    setOrthoCameraOn(): void;
    setPerspectiveCameraOn(): void;
    toggleCameraProjection(): void;
    setLightConfiguration(config: SunLightConfiguration): void;
    getViews(): SpeckleView[];
    setView(view: CanonicalView | SpeckleView | InlineView | PolarView, transition?: boolean): void;
    screenshot(): Promise<string>;
    explode(time: number): void;
    /**
     * OBJECT LOADING/UNLOADING
     */
    private downloadObject;
    loadObject(url: string, token?: string, enableCaching?: boolean, zoomToObject?: boolean): Promise<void>;
    loadObjectAsync(url: string, token?: string, enableCaching?: boolean, priority?: number, zoomToObject?: boolean): Promise<void>;
    cancelLoad(url: string, unload?: boolean): Promise<void>;
    unloadObject(url: string): Promise<void>;
    unloadAll(): Promise<void>;
    private dynamicallyLoadedDiffResources;
    diff(urlA: string, urlB: string, mode: VisualDiffMode, authToken?: string): Promise<DiffResult>;
    undiff(): Promise<void>;
    setDiffTime(diffResult: DiffResult, time: number): void;
    setVisualDiffMode(diffResult: DiffResult, mode: VisualDiffMode): void;
    enableMeasurements(value: boolean): void;
    setMeasurementOptions(options: MeasurementOptions): void;
    removeMeasurement(): void;
    dispose(): void;
}
