import { type ProjectSettings } from './controllers/SettingsController';
import { Options } from './types/WebviewerOptions';
import { BoundingBox, Vector2, Vector3 } from './types/Math';
import { BcfCameraPerspective } from './types/BcfCamera';
import { PaletteParams } from './types/Palette';
import { ObjectFilter } from './types/ObjectFilter';
import { PublicNode } from './types/PublicNode';
import { NavigationMode } from './navigation/NavigationModes';
import { SectionDataAutodeskFormat, SectionDataProcoreFormat } from './sectioning/SectionController';
import type { Viewpoint, Visibility } from './api/types/Viewpoint';
import type { CssColor } from './components/Markup/SvgRenderer';
import { RenderMode } from './utils/constants';
import { Uom, DisplayUnit } from './unit_util';
import { MeasureMode } from './measuring/MeasurementManager';
export type ResourceDiscriminator = {
    fileExtractionId: number;
} | {
    modelRevisionId: number;
};
export declare class Webviewer {
    options: Options;
    private readonly measurementRenderer;
    private readonly measurementManager;
    static readonly tools: {
        readonly ALL: 0;
        readonly BOTTOMTOOL: 1;
        readonly FLOORPLAN: 2;
        readonly OBJECTMODELTREE: 3;
        readonly MODELVIEWS: 4;
        readonly COACHMARKS: 5;
        readonly COACHMARKSHIDDEN: 6;
        readonly COACHMARKSECTION: 7;
        readonly MEASUREMENT_SD: 8;
        readonly SETTINGS: 9;
        readonly CONTEXTMENU: 10;
        readonly COACHMARKSFOV: 11;
        readonly VIEW_PROPERTIES: 12;
        readonly LOADING: 13;
        readonly XRAY_MODE: 14;
        readonly SECTION_BOX: 15;
    };
    static readonly toolbar_enum: {
        readonly NONE: 0;
        readonly HOME: 1;
        readonly NAV_DEFAULT: 2;
        readonly NAV_FLY: 3;
        readonly NAV_ORBIT: 4;
        readonly OBJECT: 5;
        readonly PREMEASURE: 6;
        readonly MEASURE: 7;
        readonly SETTING: 8;
        readonly VIEW: 9;
        readonly PROPERTIES: 10;
        readonly CONTEXT_MENU: 11;
        readonly XRAY_MODE: 12;
        readonly SECTION_BOX: 13;
    };
    static readonly action: {
        readonly NONE: -1;
        readonly PAN: 1;
        readonly KEYMOVE: 2;
        readonly ROTATE: 3;
        readonly FLY: 4;
        readonly ORBIT: 5;
        readonly STRAFE: 6;
    };
    events: {
        addEventListener: (eventName: string, callback: any) => void;
        removeEventListener: (eventName: string, callback: any) => void;
        dispatchEvent: (eventName: string, payload: any) => void;
    };
    dom: {
        addPanel: (domElement: HTMLElement) => boolean;
        removePanel: (domElement: HTMLElement) => boolean;
    };
    camera: {
        setMarkup: (markupData: any, fov: number) => void;
        getCameraDirection: () => Promise<Vector3>;
        getPosition: () => Promise<Vector3>;
        setPosition: (x: number, y: number, z: number) => Promise<{
            position: Vector3;
            direction: Vector3;
        }>;
        getSnapshot: (params: {
            color?: CssColor;
            aspectRatio?: {
                width: number;
                height: number;
            };
        }) => Promise<void>;
        getSnapshotDataUrl: (params: {
            color?: CssColor;
            aspectRatio?: {
                width: number;
                height: number;
            };
        }) => Promise<string>;
        setLookAt: (x: number, y: number, z: number) => Promise<{
            position: Vector3;
            direction: Vector3;
        }>;
        getLookAt: () => Promise<Vector3>;
        getBenchmarkPoint: () => Promise<{
            position: Vector3;
            lookAt: Vector3;
        }>;
        setBenchmarkPoint: (params: {
            position: Vector3;
            lookAt: Vector3;
        }) => Promise<void>;
        setBcfCamera: (bcfCamera: any, applyOffset?: boolean) => Promise<{
            perspective_camera: BcfCameraPerspective;
        } | false>;
        getBcfCamera: () => Promise<{
            perspective_camera: BcfCameraPerspective;
        }>;
        navToHomeView: () => Promise<void>;
        getScreenPosition: (x: number, y: number, z: number) => Promise<Vector3 | Vector3[]>;
        setEulerAngles: (x: number, y: number, z: number) => Promise<void>;
        getFieldOfView: () => Promise<number>;
        setFieldOfView: (deg: number) => Promise<void>;
        zoomToSelection: () => Promise<void>;
        zoomToObjects: (objectIds: number[]) => Promise<void>;
        zoomToBoundingBox: (bbox: BoundingBox) => Promise<void>;
        zoomToGlobal: () => Promise<void>;
        setPose: (params: {
            pose: string | {
                position: Vector3;
                lookAt: Vector3;
            };
            cameraUp?: Vector3;
        }) => Promise<void>;
    };
    markup: {
        setRedlines: (markupData: any, fov: number) => void;
        draw: (markupData: any) => void;
        drawAnchored: (markupData: any) => Promise<void>;
        clear: () => void;
    };
    model: {
        getMeshnode: (meshnodeIndex: number) => Promise<any | null>;
        getMeshnodeFromObjectId: (objectId: number) => Promise<any>;
        getHiddenMeshnodeIndices: () => Promise<number[]>;
        addHiddenMeshnodeIndices: (meshnodeIndices: number[]) => Promise<void>;
        hasHiddenMeshnodeIndices: (meshnodeIndices: number[]) => Promise<boolean>;
        clearHiddenMeshnodeIndices: () => Promise<boolean>;
        getSelectedMeshnodeIndices: () => Promise<number[]>;
        addSelectedMeshnodeIndices: (meshnodeIndices: number[]) => Promise<boolean>;
        hasSelectedMeshnodeIndices: (meshnodeIndices: number[]) => Promise<boolean>;
        clearSelectedMeshnodeIndices: () => Promise<boolean>;
        setMeshnodeColor: (meshnodeIndex: number, hexColor: string, opacity: number) => void;
        getSections: (format: string) => Promise<SectionDataProcoreFormat | SectionDataAutodeskFormat | null>;
        setSectionsData: (sectionsData: any, unit: string, showCoachmark: boolean) => Promise<boolean>;
        setSectionBox: (minXYZ: Vector3, maxXYZ: Vector3, rotation: Vector3, showCoachmark: boolean) => Promise<void>;
        resetSectionBox: () => Promise<void>;
        removeSectionBox: () => Promise<void>;
        addSectionPlane: (distance: number, normal: Vector3, showCoachmark: boolean) => void;
        removeSectionPlane: (uuid: string) => void;
        clearSection: () => Promise<void>;
        configureSectionBoxDisplay: (config: {
            dropdown?: boolean;
            hidePlanes?: boolean;
            overrideSectionBoxSetup?: boolean;
        }) => void;
        toggleSectionBoxDisplay: (enable: boolean, opts: {
            overrideSectionBoxSetup?: boolean;
        }) => void;
        getSectionBoxDisplay: () => Promise<{
            enabled: boolean;
            configuration: Required<{
                dropdown?: boolean;
                hidePlanes?: boolean;
                overrideSectionBoxSetup?: boolean;
            }>;
            bbox: BoundingBox;
        }>;
        setNavigationMode: (mode: NavigationMode) => void;
        setOptions: (opts: {
            selection: string;
        }) => void;
        setCanvasSelectionEnabled: (enabled: boolean) => void;
        MapToModelSpace: (point: Vector2, modelA: Vector2, modelB: Vector2, planA: Vector2, planB: Vector2, imgSize: Vector2, rect: Vector2, direction: Vector2, applyOffset: boolean) => Promise<{
            x?: number;
            y?: number;
            dir_x?: number;
            dir_y?: number;
        }>;
        ModelToMapSpace: (point: Vector2, modelA: Vector2, modelB: Vector2, planA: Vector2, planB: Vector2, imgSize: Vector2, rect: Vector2, direction: Vector2, applyOffset: boolean) => Promise<{
            x?: number;
            y?: number;
            dir_x?: number;
            dir_y?: number;
        }>;
        getGlobalOffsetDoNotUse: () => Promise<Vector3 | null>;
        setXRayMode: () => void;
        setNormalMode: () => void;
        setRenderMode: (mode: RenderMode) => void;
        getRenderMode: () => Promise<RenderMode>;
        getObject: (id: number, objectTreeName?: string) => Promise<PublicNode | undefined>;
        getObjects: (objectIds: number[], objectTreeName?: string) => Promise<PublicNode[]>;
        getNumObjectsSelected: (method: string) => Promise<{
            count: number;
        }>;
        getNumObjectsHidden: () => Promise<{
            count: number;
        }>;
        getRootObject: (objectTreeName?: string) => Promise<PublicNode | undefined>;
        hideObjects: (objectIds: number[], objectTreeName?: string) => Promise<boolean>;
        hideAllObjects: (objectTreeName?: string) => Promise<boolean>;
        unhideAllObjects: () => Promise<boolean>;
        unhideObjects: (objectIds: number[], objectTreeName?: string) => Promise<boolean>;
        getHiddenObjects: () => Promise<number[]>;
        selectObjects: (objectIds: number[], objectTreeName?: string) => Promise<boolean>;
        deselectAllObjects: () => Promise<boolean>;
        deselectObjects: (objectIds: number[], objectTreeName?: string) => Promise<boolean>;
        selectAllObjects: (objectTreeName?: string) => Promise<boolean>;
        getSelectedObjects: () => Promise<number[]>;
        setMeasurement: (enable: boolean, options?: {
            measurementMode?: MeasureMode;
        }) => void;
        setObjectColor: (palettes: PaletteParams[], options?: {
            resourceId?: number;
        }) => void;
        clearObjectColor: (objectIds: number[], options?: {
            resourceId?: number;
        }) => Promise<void> | void;
        clearAllObjectColor: (options?: {
            resourceId?: number;
        }) => Promise<void> | void;
        filterObjectTree: (objectIds: number[]) => Promise<void>;
        clearObjectTreeFilter: () => Promise<void>;
        getViewpoint: (options?: {
            defaultVisibilityAlwaysTrue?: boolean;
        }) => Promise<Viewpoint>;
        setViewpoint: (viewpoint: Viewpoint) => Promise<void>;
        getVisibility: (options?: {
            defaultVisibilityAlwaysTrue?: boolean;
        }) => Promise<Visibility>;
        setVisibility: (visibility: Visibility) => Promise<void>;
    };
    api: {
        getNamesForObjects: (ids: number[]) => Promise<any>;
        filterObjects: (filter: ObjectFilter) => Promise<Response>;
    };
    gui: {
        addContextMenuItem: ({ label, id, shortcut, onClick, singleObject, }: {
            label: string;
            id: string;
            shortcut: string[];
            onClick: any;
            singleObject: boolean;
        }) => HTMLDivElement;
        removeContextMenuItems: ({ contextMenuItemIds, }: {
            contextMenuItemIds: string[];
        }) => void;
        showCoachmark: (params: {
            id: string;
            label: string;
            buttonLabel: string;
            buttonOnClick: () => void;
            tooltipMessage?: string;
        }) => void;
        hideCoachmark: (coachmarkId: string) => void;
        getSettings: () => ProjectSettings;
        setToolbarHidden: (hidden: boolean) => void;
        setHotkeysEnabled: (enabled: boolean) => void;
        getEquivalentUnitForDisplayUnit: (unit: Uom, displayUnit: DisplayUnit) => Uom;
        convertUnit: (value: number, from: Uom, to: Uom) => number;
        formatUnit: (value: number, unit: Uom) => string;
    };
    constructor(options: Options);
    /**
     * Starts the application.
     * This method initializes the necessary variables and subscribes to events.
     * It also checks the BimPropertyService and handles different status codes.
     * It listens for events related to markup display, dismissal, and camera updates.
     */
    start: () => void;
    /**
     * Terminates the WebViewer instance and cleans up any resources.
     */
    terminate: () => void;
}
