export declare const ACTION: {
    readonly NONE: -1;
    readonly PAN: 1;
    readonly KEYMOVE: 2;
    readonly ROTATE: 3;
    readonly FLY: 4;
    readonly ORBIT: 5;
    readonly STRAFE: 6;
};

export declare type Action = (typeof ACTION)[keyof typeof ACTION];

export declare type Attachment = {
    id: number;
    content_type: string;
    name: string;
    size: number;
    url: string;
};

export declare type AutodeskFormatClipBox = {
    Type: 'OrientedBox3D';
    Version: 1;
    Box: [[number, number, number], [number, number, number]];
    Rotation: [number, number, number];
};

export declare type AutodeskFormatClipPlane = {
    Type: 'ClipPlane';
    Version: 1;
    Normal: [number, number, number];
    Distance: number;
    Enabled: boolean;
};

export declare type BcfCameraPerspective = {
    camera_view_point: {
        x: number;
        y: number;
        z: number;
    };
    camera_direction: {
        x: number;
        y: number;
        z: number;
    };
    camera_up_vector: {
        x: number;
        y: number;
        z: number;
    };
    target_distance: number;
    unit: string;
    field_of_view: number;
};

export declare namespace Benchmark {
    const result: (metricId: MetricId) => number | null;
    const setWorker: (w: Worker) => void;
    const report: (params: {
        value: number;
        metricId: MetricId;
    }) => void;
    const engage: <T>(metricId: MetricId, callback: Function) => Promise<T>;
    const clear: () => void;
}

export declare type BimFileUpload = {
    id: number;
    file_version: FileVersion;
    attachment: Attachment;
};

declare type BootstrapperResult = {
    isComplete: boolean;
};

export declare type BoundingBox = {
    max: Vector3;
    min: Vector3;
};

declare class BVHTree {
    static maxChunkSize: number;
    constructor(pwf: any);
    pwf: any;
    meshnodes: any;
    currentIndex: number;
    buildTree(): {
        isComplete: boolean;
    };
    rollupBBox(meshnode: any): void;
}

declare const Cache_2: {
    removeModel: (options: any) => Promise<boolean>;
    hasModel: (geometryBundle: GeometryBundle) => Promise<boolean>;
};
export { Cache_2 as Cache }

declare type Camera = any;

declare type Color = {
    color: string;
    opacity: number;
};

export declare type CommonOptions = {
    /**
     * Always required
     */
    projectId: Project['id'];
    parentElement: HTMLElement;
    companyId: number;
    /**
     * Sometimes required
     */
    /**
     * Always optional
     */
    tools?: Tool[];
    bcfCamera?: any;
    min_boundary?: {
        x: string;
        y: string;
        z: string;
    };
    max_boundary?: {
        x: string;
        y: string;
        z: string;
    };
    rotation?: {
        x: string;
        y: string;
        z: string;
    };
    plans?: any[];
    levels?: any[];
    locale?: string;
    baseUrl?: string;
    accessToken?: string;
    debug?: boolean;
    multiselect?: boolean;
    selection?: string;
    enableWebWorker?: boolean;
    featureFlags?: Partial<FeatureFlags>;
    logInitializationTimes?: boolean;
    sceneGraph?: string;
    bimFileId?: number;
};

export declare type CssColor = RGB | RGBA | HEX | string;

export declare const DISPLAY_UNIT: {
    readonly Meters: "m";
    readonly Millimeters: "mm";
    readonly FeetInches: "ftin";
};

export declare type DisplayUnit = (typeof DISPLAY_UNIT)[keyof typeof DISPLAY_UNIT];

declare type DownloadMetaData = {
    modelCached: boolean;
    timeToDownload: number;
};

export declare namespace ErrorLogger {
    let logger: Logger;
    const init: (params: {
        bugsnagConfig: {
            apiKey: string;
            releaseStage?: string;
        };
    }) => void;
    const logError: <T extends Error>(error: T) => void;
    const dispose: () => void;
}

export declare type FeatureFlags = {
    /**
     * @beta Enables writing mesh data to OPFS for partitioned models, which allows users to use features that use mesh data, notably Point to Point.
     */
    enableMeshDataOnOPFS: boolean;
};

declare type File_2 = {
    url: string;
};

export declare type FileExtraction = {
    id: number;
    extraction_items: FileExtractionItem[];
    bim_file_upload: BimFileUpload;
    viewpoint_id?: number | null;
};

export declare type FileExtractionItem = WebFormatExtractionItem | PropertiesExtractionItem;

export declare type FileExtractionModeOptions = CommonOptions & {
    fileExtractionId: FileExtraction['id'];
};

export declare type FileExtractionModePwfV1OverrideOptions = FileExtractionModeOptions & PwfV1Bundle;

export declare type FileExtractionModePwfV1OverrideResource = PwfV1Bundle & {
    fileExtractionId: FileExtraction['id'];
};

export declare type FileExtractionModePwfV2OverrideOptions = FileExtractionModeOptions & PwfV2Bundle;

export declare type FileExtractionModePwfV2OverrideResource = PwfV2Bundle & {
    fileExtractionId: FileExtraction['id'];
};

export declare type FileExtractionModeResource = {
    fileExtractionId: FileExtraction['id'];
};

export declare type FileVersion = {
    id: number;
    file_id: number;
};

export declare const FILTER_FIELD: {
    readonly NAME: "name";
};

export declare type FilterField = (typeof FILTER_FIELD)[keyof typeof FILTER_FIELD];

/**
 * API Configurations
 *
 * The Web Viewer can be configured to fetch resources (basically PWF files and
 * properties) in a variety of ways. These types attempt to accurately declare
 * the valid configurations that we support.
 */
export declare type GeometryBundle = {
    nodeUrl: string;
    meshnodeUrl: string;
    meshUrl?: string;
    manifestUrl?: string;
};

declare class GeometryFactory {
    private static maxArraySize;
    private vbuffers;
    private fbuffers;
    private curVertexPos;
    private curIndexPos;
    private cylinderVBuffer;
    private cylinderFBuffer;
    protected gl: WebGL2RenderingContext;
    constructor(gl: WebGL2RenderingContext);
    createDataBuffer(vertexArray: Float32Array, indexArray: Uint16Array): GPUMeshData;
    bindBuffer(meshData: GPUMeshData): void;
    createCylinderBuffer(vertexArray: Float32Array, indexArray: Uint16Array): GPUMeshData;
    protected newVertexBuffer(_size?: number): void;
    protected newIndexBuffer(_size?: number): void;
    createCylinderGeometry(_vertices: Float32Array, _faces: Uint16Array, _color: number, _opacity: number, _drawType: number): StreamedMeshGeometry;
    createMeshGeometry(_vertices: Float32Array, _faces: Uint16Array, _color: number, _opacity: number, _drawType: number): StreamedMeshGeometry;
}

export declare type GeometryFileBundle = {
    manifest_file?: File_2 | null;
    mesh_file: File_2;
    mesh_node_file: File_2;
    node_file: File_2;
};

declare type GPUMeshData = {
    index: number;
    f_byte_size: number;
    vertexBufferIndex: number;
    indexBufferIndex: number;
    vertexPosition: number;
};

export declare type HEX = `#${string}`;

declare interface Logger {
    logError(error: any): void;
}

declare class LRUCache<K, V> {
    private readonly maxEntries;
    private cache;
    private keys;
    constructor(maxEntries: number);
    get(key: K): V | undefined;
    set(key: K, value: V): void;
    remove(key: K): void;
    clear(): void;
    size(): number;
    getMaxEntries(): number;
    getKeys(): K[];
}

declare type Manifest = {
    version: PWFVersion;
    globalAABB: BoundingBox;
    reducedGlobalAABB: BoundingBox;
    meshnodeOffset: number;
    numMeshnodes: number;
    numMeshes: number;
    numNodes: number;
    globalOffset: Vector3;
    numFaces: number;
    numVertices: number;
    isPartitioned: boolean;
    numPartitions: number;
};

export declare const MEASURE_MODES: {
    POINT_TO_POINT: string;
    SHORTEST_DISTANCE: string;
};

export declare type MeasureMode = (typeof MEASURE_MODES)[keyof typeof MEASURE_MODES];

declare class Mesh {
    private pwfMesh;
    constructor(pwfMesh: PWFMesh);
    offset(): number;
    color(): number;
    opacity(): number;
    drawType(): number;
    numVertices(): number;
    lenVertices(): number;
    numFaces(): number;
    lenFaces(): number;
    vertices(): Float32Array;
    faces(): Uint16Array;
    asObject(): MeshObject_2;
}

declare class Mesh_2 {
    private pwfMesh;
    constructor(pwfMesh: PWFMesh_2);
    offset(): number;
    color(): number;
    opacity(): number;
    drawType(): number;
    numVertices(): number;
    lenVertices(): number;
    numFaces(): number;
    lenFaces(): number;
    vertices(): Float32Array;
    faces(): Uint16Array;
    asObject(): MeshObject;
}

declare class MeshData {
    private _meshIndex;
    private compressedMeshData;
    private uncompressedMeshData?;
    private meshGeometry?;
    constructor(meshIndex: number, compressedMeshData: ArrayBuffer);
    meshIndex(): number;
    color(): number;
    opacity(): number;
    drawType(): number;
    vertices(): Float32Array;
    faces(): Uint16Array;
    uploadToGPU(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
    uploadToGPUPreFetching(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
    getCompressedMeshData(): ArrayBuffer;
    getUncompressedMeshData(): ArrayBuffer;
}

declare class MeshData_2 {
    private _meshIndex;
    private compressedMeshData;
    private uncompressedMeshData?;
    private meshGeometry?;
    constructor(meshIndex: number, compressedMeshData: ArrayBuffer);
    meshIndex(): number;
    color(): number;
    opacity(): number;
    drawType(): number;
    vertices(): Float32Array;
    faces(): Uint16Array;
    uploadToGPU(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
    uploadToGPUPreFetching(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
    getCompressedMeshData(): ArrayBuffer;
    getUncompressedMeshData(): ArrayBuffer;
}

declare class MeshGeometry {
    index: number;
    indexLength: number;
    color: number;
    opacity: number;
    drawType: number;
    numFaces: number;
    vertexBufferIndex: number;
    indexBufferIndex: number;
    vertexPosition: number;
    constructor(meshData: GPUMeshData, color: number, opacity: number, drawType: number);
}

declare type Meshnode = Meshnode_2 | Meshnode_3;

declare class Meshnode_2 {
    protected pwfMeshnode: PWFMeshnode;
    private hiddenValue;
    private box3Value?;
    private centerValue?;
    private meshDataValue?;
    private meshGeometriesValue?;
    private matrixWorldValue?;
    protected pwf: PWFV1;
    selected: boolean;
    private _parent?;
    constructor(pwfMeshnode: PWFMeshnode, pwf: PWFV1);
    offset(): number;
    parentOffset(): number;
    parent(): Node_3;
    children(): never[];
    nodeId(): number;
    bbox(): Float32Array;
    box3(): NonNullable<Meshnode_2['box3Value']>;
    center(): THREE.Vector3;
    matrix(): Float32Array;
    matrixWorld(): THREE.Matrix4;
    group(): number;
    opaque(): number;
    numChild(): number;
    childRefs(): Uint32Array;
    isNode(): boolean;
    isMeshnode(): this is Meshnode_2;
    index(): number;
    virtualIndex(): number;
    meshGeometries(): MeshGeometry[];
    protected geometries(): MeshGeometry[];
    meshData(): NonNullable<Meshnode_2['meshDataValue']>;
    isRoot(): boolean;
    hidden(): Meshnode_2['hiddenValue'];
    setHidden(hidden: boolean): void;
    setParent(node: Node_3): void;
    asObject(): MeshnodeObject;
}

declare class Meshnode_3 {
    protected pwfMeshnode: PWFMeshnode_2;
    private hiddenValue;
    private box3Value?;
    private centerValue?;
    private meshDataValue?;
    private meshGeometriesValue?;
    private matrixWorldValue?;
    protected pwf: PWFV2;
    selected: boolean;
    private _parent?;
    constructor(pwfMeshnode: PWFMeshnode_2, pwf: PWFV2);
    offset(): number;
    parentOffset(): number;
    parent(): Node_4;
    children(): never[];
    nodeId(): number;
    bbox(): Float32Array;
    box3(): NonNullable<Meshnode_3['box3Value']>;
    center(): THREE.Vector3;
    matrix(): Float32Array;
    matrixWorld(): THREE.Matrix4;
    group(): number;
    opaque(): number;
    numChild(): number;
    childRefs(): Uint32Array;
    isNode(): boolean;
    isMeshnode(): this is Meshnode_3;
    index(): number;
    virtualIndex(): number;
    meshGeometries(): MeshGeometry[];
    protected geometries(): MeshGeometry[];
    meshData(): NonNullable<Meshnode_3['meshDataValue']>;
    isRoot(): boolean;
    hidden(): Meshnode_3['hiddenValue'];
    setHidden(hidden: boolean): void;
    setParent(node: Node_4): void;
    asObject(): MeshnodeObject_2;
}

declare type MeshnodeObject = {
    bbox: Float32Array;
    matrix: Float32Array;
    numChild: number;
    childRefs: Uint32Array;
    meshData: MeshObject[];
    nodeId: number;
    meshnodeIndex: number;
    hidden: boolean;
    selected: boolean;
};

declare type MeshnodeObject_2 = {
    bbox: Float32Array;
    matrix: Float32Array;
    numChild: number;
    childRefs: Uint32Array;
    meshData: MeshObject_2[];
    nodeId: number;
    meshnodeIndex: number;
    hidden: boolean;
    selected: boolean;
};

declare class MeshnodeServices {
    private meshnodeCount;
    private meshnodes;
    protected pwf: PWFV2;
    protected cachedMeshnodes: Map<number, Meshnode_3>;
    constructor(pwfMeshnodes: PWFMeshnode_2[], pwf: PWFV2);
    getMeshnodeFromIndex(index: number): Meshnode_3;
    getMeshnode(offset: number): Meshnode_3;
    numMeshnodes(): number;
    allMeshnodes(): NonNullable<MeshnodeServices['meshnodes']>;
    protected createMeshnode(pwfMeshnode: PWFMeshnode_2): Meshnode_3;
}

declare class MeshnodeServices_2 {
    private meshnodeCount;
    private meshnodes;
    protected pwf: PWFV1;
    protected cachedMeshnodes: Map<number, Meshnode_2>;
    constructor(pwfMeshnodes: PWFMeshnode[], pwf: PWFV1);
    getMeshnodeFromIndex(index: number): Meshnode_2;
    getMeshnode(offset: number): Meshnode_2;
    numMeshnodes(): number;
    allMeshnodes(): NonNullable<MeshnodeServices_2['meshnodes']>;
    protected createMeshnode(pwfMeshnode: PWFMeshnode): Meshnode_2;
}

declare type MeshObject = {
    color: number;
    faces: Uint16Array;
    offset: number;
    opacity: number;
    vertices: Float32Array;
    drawType: number;
};

declare type MeshObject_2 = {
    color: number;
    faces: Uint16Array;
    offset: number;
    opacity: number;
    vertices: Float32Array;
    drawType: number;
};

declare type MeshObject_3 = MeshObject | MeshObject_2;

declare class MeshServices {
    protected pwf: PWFV2;
    protected geometryFactory?: GeometryFactory;
    private meshGeometryMap;
    private readonly pwfMeshes;
    private pwfMeshOffsetMap;
    private readonly meshCount;
    private currentIndex;
    constructor(pwfMeshes: PWFMesh[], pwf: PWFV2);
    setGeometryFactory(geometryFactory: GeometryFactory): void;
    getMeshGeometryForOffsets(meshOffset: number, _meshnodeOffset: number | undefined): MeshGeometry | undefined;
    meshFromOffset(offset: number): Mesh;
    numMeshes(): number;
    meshes(): PWFMesh[];
    loadAllMeshGeometryToGPU(): {
        isComplete: boolean;
    };
    private loadToGPU;
    getMeshObject(meshOffset: number): MeshObject_2;
    private loadMeshGeometryToGPU;
    dispose(): void;
}

declare class MeshServices_2 {
    protected pwf: PWFV1;
    protected geometryFactory?: GeometryFactory;
    private meshGeometryMap;
    private readonly pwfMeshes;
    private pwfMeshOffsetMap;
    private readonly meshCount;
    private currentIndex;
    constructor(pwfMeshes: PWFMesh_2[], pwf: PWFV1);
    setGeometryFactory(geometryFactory: GeometryFactory): void;
    getMeshGeometryForOffsets(meshOffset: number, _meshnodeOffset: number | undefined): MeshGeometry | undefined;
    meshFromOffset(offset: number): Mesh_2;
    numMeshes(): number;
    meshes(): PWFMesh_2[];
    loadAllMeshGeometryToGPU(): {
        isComplete: boolean;
    };
    private loadToGPU;
    getMeshObject(meshOffset: number): MeshObject;
    private loadMeshGeometryToGPU;
    dispose(): void;
}

declare type MetricId = string;

export declare type Model = {
    id: number;
};

declare type ModelAnalyticsData = {
    node_size: number;
    meshnode_size: number;
    num_nodes: number;
    num_meshnodes: number;
    mesh_size?: number;
    num_meshes?: number;
    partition_proxy_size?: number;
};

export declare type ModelRevision = {
    id: number;
    revision: number;
    viewpoints: ModelRevisionViewpoint[];
    geometry_file_bundle: GeometryFileBundle;
};

export declare type ModelRevisionModeOptions = CommonOptions & {
    modelId: Model['id'];
    modelRevisionId: ModelRevision['id'];
};

export declare type ModelRevisionModePwfV1OverrideOptions = ModelRevisionModeOptions & PwfV1Bundle;

export declare type ModelRevisionModePwfV1OverrideResource = PwfV1Bundle & {
    modelId: Model['id'];
    modelRevisionId: ModelRevision['id'];
};

export declare type ModelRevisionModePwfV2OverrideOptions = ModelRevisionModeOptions & PwfV2Bundle;

export declare type ModelRevisionModePwfV2OverrideResource = PwfV2Bundle & {
    modelId: Model['id'];
    modelRevisionId: ModelRevision['id'];
};

export declare type ModelRevisionModeResource = {
    modelId: Model['id'];
    modelRevisionId: ModelRevision['id'];
};

export declare type ModelRevisionViewpoint = Viewpoint & {
    primary: boolean;
};

export declare const NAV_MODE: {
    readonly DEFAULT: 0;
    readonly FLY: 1;
    readonly ORBIT: 2;
    readonly MEASURE: 3;
    readonly STRAFE: 4;
    readonly PAN: 5;
    readonly SURVEY: 6;
};

export declare type NavigationMode = (typeof NAV_MODE)[keyof typeof NAV_MODE];

declare type Node_2 = Node_3 | Node_4;

declare class Node_3 {
    private pwfNode;
    private pwf;
    private readonly box3Value;
    isFirstObjectValue: boolean;
    private _parent?;
    constructor(pwfNode: PWFNode, pwf: PWFV1);
    box3(): Node_3['box3Value'];
    unionBBox(bbox: THREE.Box3): void;
    isRoot(): boolean;
    offset(): number;
    nodeId(): number;
    parentOff(): number;
    setParent(node: Node_3): void;
    parent(): Node_3 | undefined;
    numChild(): number;
    hasChildren(): boolean;
    group(): number;
    isSelectable(): boolean;
    nodeType(): number;
    childOffsets(): Uint32Array;
    children(): (Node_3 | Meshnode_2)[];
    isNode(): this is Node_3;
    isMeshnode(): boolean;
    isFirstObject(): boolean;
    hasMeshnodeChildren(): boolean;
    numMeshnodeChildren(): number;
    asObject(): NodeObject_2;
}

declare class Node_4 {
    private pwfNode;
    private pwf;
    private readonly box3Value;
    isFirstObjectValue: boolean;
    private _parent?;
    constructor(pwfNode: PWFNode_2, pwf: PWFV2);
    box3(): Node_4['box3Value'];
    unionBBox(bbox: THREE.Box3): void;
    isRoot(): boolean;
    offset(): number;
    nodeId(): number;
    parentOff(): number;
    setParent(node: Node_4): void;
    parent(): Node_4 | undefined;
    numChild(): number;
    hasChildren(): boolean;
    group(): number;
    isSelectable(): boolean;
    nodeType(): number;
    childOffsets(): Uint32Array;
    children(): (Node_4 | Meshnode_3)[];
    isNode(): this is Node_4;
    isMeshnode(): boolean;
    isFirstObject(): boolean;
    hasMeshnodeChildren(): boolean;
    numMeshnodeChildren(): number;
    asObject(): NodeObject;
}

export declare type NodeBoundingBox = {
    min: number[];
    max: number[];
};

declare type NodeId = ReturnType<Node_2['nodeId']>;

declare type NodeObject = {
    offset: number;
    nodeId: number;
    parentOff: number;
    childOffsets: Uint32Array;
    numChild: number;
    nodeType: number;
    hasChildren: boolean;
    hasMeshnodeChildren: boolean;
    bbox: NodeBoundingBox;
    parentId: number | undefined;
    children: number[];
};

declare type NodeObject_2 = {
    offset: number;
    nodeId: number;
    parentOff: number;
    childOffsets: Uint32Array;
    numChild: number;
    nodeType: number;
    hasChildren: boolean;
    hasMeshnodeChildren: boolean;
    bbox: NodeBoundingBox;
    parentId: number | undefined;
    children: number[];
};

declare class NodeServices {
    private nodes;
    private nodeIdToOffsetMap;
    private pwf;
    protected meshnodeOffPointerValue: number;
    private stack;
    private queue;
    private _numFirstObjects;
    nodesOffset: number;
    private _pwfRootNode;
    private _numNodes;
    private _pwfNodeOffsetMap;
    private _rootNode?;
    constructor(pwfNodes: PWFNode_2[], meshnodeOffPointer: number, pwf: PWFV2);
    nodeFromOffset(offset: number): Node_4;
    buildNodes(): {
        nodes: NodeServices['nodes'];
        isComplete: boolean;
    };
    root(): Node_4;
    getNode(offset: number): Node_4 | Meshnode_3;
    getNodeById(id: number): Node_4;
    hasNode(id: number): boolean;
    breadthFirstTraversal(callback: (n: Node_4 | Meshnode_3) => void): {
        isComplete: boolean;
    };
    private buildNodesRecursively;
    private buildChildren;
    meshnodeOffPointer(): NonNullable<NodeServices['meshnodeOffPointerValue']>;
    findFirstObject(meshnode: Meshnode_3): Node_4;
    numNodes(): number;
    allNodes(): Node_4[];
    numFirstObjects(): number;
}

declare class NodeServices_2 {
    private nodes;
    private nodeIdToOffsetMap;
    private pwf;
    protected meshnodeOffPointerValue: number;
    private stack;
    private queue;
    private _numFirstObjects;
    nodesOffset: number;
    private _pwfRootNode;
    private _numNodes;
    private _pwfNodeOffsetMap;
    private _rootNode?;
    constructor(pwfNodes: PWFNode[], meshnodeOffPointer: number, pwf: PWFV1);
    nodeFromOffset(offset: number): Node_3;
    buildNodes(): {
        isComplete: boolean;
    };
    root(): Node_3;
    getNode(offset: number): Node_3 | Meshnode_2;
    getNodeById(id: number): Node_3;
    hasNode(id: number): boolean;
    breadthFirstTraversal(callback: (n: Node_3 | Meshnode_2) => void): {
        isComplete: boolean;
    };
    private buildNodesRecursively;
    private buildChildren;
    meshnodeOffPointer(): NonNullable<NodeServices_2['meshnodeOffPointerValue']>;
    findFirstObject(meshnode: Meshnode_2): Node_3;
    numNodes(): number;
    allNodes(): Node_3[];
    numFirstObjects(): number;
}

export declare type ObjectFilter = {
    filterField: FilterField;
    filterValue: string;
};

declare class OPFSFile {
    private path;
    private syncAccessHandle?;
    private directoryHandle?;
    private fileName?;
    private static stats;
    constructor(path: string);
    open(): Promise<void>;
    delete(): Promise<void>;
    close(): void;
    truncate(offset: number): void;
    write(buffer: ArrayBuffer, byteOffset?: number): number | undefined;
    read(byteOffset?: number, byteLength?: number): ArrayBuffer;
    private updateReadStats;
}

export declare type Options = FileExtractionModePwfV2OverrideOptions | FileExtractionModePwfV1OverrideOptions | FileExtractionModeOptions | ModelRevisionModePwfV2OverrideOptions | ModelRevisionModePwfV1OverrideOptions | ModelRevisionModeOptions | ResourceOptions;

declare type Palette = {
    default?: Color;
    xray?: Color;
    selected?: Color;
};

export declare type PaletteParams = {
    palette: Palette;
    objectIds: NodeId[];
};

declare class Partition {
    private pwfPartition;
    constructor(pwfPartition: PWFPartition);
    partitionId(): number;
    meshData(): MeshData[];
}

declare class Partition_2 {
    private pwfPartition;
    constructor(pwfPartition: PWFPartition_2);
    partitionId(): number;
    meshData(): MeshData_2[];
}

declare class PartitionProxy {
    private pwfPartitionProxy;
    private meshServices;
    static numberOfPartitions: number;
    static numberOfPartitionsLoaded: number;
    static currentNumberOfDownloading: number;
    static prefetchingPartitions: boolean;
    loadedToGPU: boolean;
    isLoading: boolean;
    private _meshnodes;
    private _byteLength?;
    private _compressedByteLength?;
    private stats;
    constructor(params: {
        pwfPartitionProxy: PWFPartitionProxy;
        meshServices: StreamedMeshServices;
    });
    meshCount(): number;
    incrementMeshCount(numMeshes: number): void;
    vertexCount(): number;
    incrementVertexCount(numVertices: number): void;
    faceCount(): number;
    incrementFaceCount(numFaces: number): void;
    partitionId(): number;
    partitionUrl(): Promise<string>;
    meshnodeOffsets(): Uint32Array;
    meshnodes(): StreamedMeshnode[];
    setMeshnodes(meshnodes: StreamedMeshnode[]): void;
    loadPartitionData(callbackFn: (partition: Partition) => void): Promise<void>;
    loadPartition(factory: StreamedGeometryFactory): Promise<void>;
    size(): {
        compressed: number;
        size: number;
    };
    static processPartitionProxiesAB(partitionProxiesAB: ArrayBuffer, meshServices: StreamedMeshServices, callback: (partitionProxy: PartitionProxy) => void): void;
    static getPartitionProxies(partitionProxiesAB: ArrayBuffer): PWFPartitionProxy[];
    getContentOfPartitionUrl(): string;
}

declare class PartitionProxy_2 {
    private pwfPartitionProxy;
    private meshServices;
    static numberOfPartitions: number;
    static numberOfPartitionsLoaded: number;
    static currentNumberOfDownloading: number;
    static prefetchingPartitions: boolean;
    loadedToGPU: boolean;
    isLoading: boolean;
    private _meshnodes;
    private _byteLength?;
    private _compressedByteLength?;
    private stats;
    constructor(params: {
        pwfPartitionProxy: PWFPartitionProxy_2;
        meshServices: StreamedMeshServices_2;
    });
    meshCount(): number;
    incrementMeshCount(numMeshes: number): void;
    vertexCount(): number;
    incrementVertexCount(numVertices: number): void;
    faceCount(): number;
    incrementFaceCount(numFaces: number): void;
    partitionId(): number;
    partitionUrl(): Promise<string>;
    meshnodeOffsets(): Uint32Array;
    meshnodes(): StreamedMeshnode_2[];
    setMeshnodes(meshnodes: StreamedMeshnode_2[]): void;
    loadPartitionData(callbackFn: (partition: Partition_2) => void): Promise<void>;
    loadPartition(factory: StreamedGeometryFactory): Promise<void>;
    size(): {
        compressed: number;
        size: number;
    };
    static processPartitionProxiesAB(partitionProxiesAB: ArrayBuffer, meshServices: StreamedMeshServices_2, callback: (partitionProxy: PartitionProxy_2) => void): void;
    static getPartitionProxies(partitionProxiesAB: ArrayBuffer): PWFPartitionProxy_2[];
    getContentOfPartitionUrl(): string;
}

declare type Point = {
    position: {
        x: number;
        y: number;
        z: number;
    };
    lookAt: {
        x: number;
        y: number;
        z: number;
    };
};

export declare type ProcoreFormatClipPlane = {
    unit?: string;
    direction: Vector3;
    location: Vector3;
};

export declare type Project = {
    id: number;
};

export declare type ProjectSettings = {
    displayUnits: DisplayUnit;
};

export declare type PropertiesExtractionItem = {
    item_type: 'Properties';
    artifact: {
        properties: PropertiesFile;
    };
};

export declare type PropertiesFile = {
    id: number;
    url: string;
};

export declare type PublicNode = {
    id: number;
    bbox: NodeBoundingBox;
    nodeType: number;
    hidden: boolean;
    selected: boolean;
    partiallySelected: boolean;
    parentId?: number;
    children: number[];
};

declare interface PWF {
    setStandardModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer): void;
    setPartitionedModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, partitionAB: ArrayBuffer): void;
    initPwfParser(): void;
    parsePwfNodes(): BootstrapperResult;
    parsePwfMeshnodes(): BootstrapperResult;
    parsePwfMeshes(): void;
    initMeshServices(): BootstrapperResult;
    initNodeServices(): void;
    initMeshnodeServices(): void;
    initNodeTree(): BootstrapperResult;
    initNodeTreeBoundingBoxes(): void;
    allMeshnodes(): Meshnode[];
    breadthFirstTraversalNodes(callback: (n: Node_2 | Meshnode) => void): BootstrapperResult;
    getMeshnodeFromIndex(meshnodeIndex: number): Meshnode;
    getParentNodeIds(nodeId: number): number[];
    getSubtreeNodeIds(nodeId: number): number[];
    getVirtualMeshnodeIndexesByNodeId(nodeId: number): number[];
    getNamedNode(nodeId: number): Node_2;
    globalOffset(): Vector3;
    getPwfPartitionContentUrls(): string[];
    numNodes(): number;
    numMeshnodes(): number;
    numMeshes(): number;
    prefetchPartitions(geometryFactory: StreamedGeometryFactory): BootstrapperResult;
    setGeometryFactory(geometryFactory: GeometryFactory): void;
    numFirstObjects(): number;
    getNodeById(id: number): Node_2;
    getMeshnodeFromNodeId(nodeId: number): Meshnode;
    getMeshnode(offset: number): Meshnode;
    getNode(offset: number): Node_2 | Meshnode;
    getMeshObject(meshRef: number): MeshObject_3;
    findFirstObject(meshnodeIndex: number): Node_2;
    root(): Node_2;
    forEachMeshnode(callback: (meshnode: Meshnode) => void): void;
    forEachNode(callback: (node: Node_2) => void): void;
    hasNode(id: number): boolean;
    loadAllMeshGeometryToGPU(): BootstrapperResult;
    loadAllPartitionProxies(): void;
    captureModelStats(): void;
    getModelAnalyticsData(): ModelAnalyticsData;
    get virtualMeshnodeIndexOffset(): number;
    set virtualMeshnodeIndexOffset(offset: number);
    dispose(): void;
}

declare interface PWFMesh {
    offset(): number;
    color(): number;
    vertices(): Float32Array;
    faces(): Uint16Array;
    opacity(): number;
    drawType(): number;
}

declare interface PWFMesh_2 {
    offset(): number;
    color(): number;
    vertices(): Float32Array;
    faces(): Uint16Array;
    opacity(): number;
    drawType(): number;
}

declare interface PWFMeshnode {
    index(): number;
    offset(): number;
    opaque(): number;
    nodeType(): number;
    nodeId(): number;
    parentOffset(): number;
    numChildren(): number;
    childRefs(): Uint32Array;
    bbox(): Float32Array;
    box3(): THREE.Box3;
    matrix(): Float32Array;
    group(): number;
}

declare interface PWFMeshnode_2 {
    index(): number;
    offset(): number;
    opaque(): number;
    nodeType(): number;
    nodeId(): number;
    parentOffset(): number;
    numChildren(): number;
    childRefs(): Uint32Array;
    bbox(): Float32Array;
    box3(): THREE.Box3;
    matrix(): Float32Array;
    group(): number;
}

declare class PWFModelParser {
    private nodeAB;
    private nodeBufferReader;
    private meshnodeAB;
    private meshnodeBufferReader;
    private meshAB;
    private meshBufferReader?;
    constructor(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer, manifest: Manifest);
    parseNodes(): {
        nodes: PWFNode_2[];
        isComplete: boolean;
    };
    parseMeshnodes(): {
        meshnodes: PWFMeshnode_2[];
        isComplete: boolean;
    };
    parseMeshes(): PWFMesh[];
}

declare class PWFModelParser_2 {
    private nodeAB;
    private nodeBufferReader;
    private meshnodeAB;
    private meshnodeBufferReader;
    private meshAB;
    private meshBufferReader?;
    constructor(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer);
    getGlobalOffset(): Vector3;
    getMeshnodeOffPointer(): number;
    parseNodes(): {
        nodes: PWFNode[];
        isComplete: boolean;
    };
    parseMeshnodes(): {
        meshnodes: PWFMeshnode[];
        isComplete: boolean;
    };
    getNumMeshnodes(): number;
    getNumMeshes(): number;
    getNumNodes(): number;
    parseMeshes(): PWFMesh_2[];
}

declare interface PWFNode {
    offset(): number;
    nodeId(): number;
    parentOffset(): number;
    numChildren(): number;
    group(): number;
    childOffs(): number;
    childrenOffsets(): Uint32Array;
    nodeType(): number;
    opaque(): number;
    toString(): string;
}

declare interface PWFNode_2 {
    offset(): number;
    nodeId(): number;
    parentOffset(): number;
    numChildren(): number;
    group(): number;
    childOffs(): number;
    childrenOffsets(): Uint32Array;
    nodeType(): number;
    opaque(): number;
    toString(): string;
}

declare interface PWFPartition {
    partitionId(): number;
    meshData(): MeshData[];
}

declare interface PWFPartition_2 {
    partitionId(): number;
    meshData(): MeshData_2[];
}

declare interface PWFPartitionProxy {
    partitionId(): number;
    partitionUrl(): string;
    meshnodeOffsets(): Uint32Array;
}

declare interface PWFPartitionProxy_2 {
    partitionId(): number;
    partitionUrl(): string;
    meshnodeOffsets(): Uint32Array;
}

declare class PWFV1 implements PWF {
    private readonly downloadMetaData;
    resourceId: number;
    resource: ResourceDiscriminator;
    streaming: boolean;
    nodeAB?: ArrayBuffer;
    meshnodeAB?: ArrayBuffer;
    meshAB?: ArrayBuffer;
    partitionProxiesAB?: ArrayBuffer;
    pwfModelParser?: PWFModelParser_2;
    private _numMeshnodes;
    private _numMeshes;
    private _numNodes;
    private globalOffsetValue;
    pwfModel: {
        nodes: PWFNode[];
        meshnodes: PWFMeshnode[];
        meshes: PWFMesh_2[];
    };
    meshServices?: MeshServices_2 | StreamedMeshServices_2;
    nodeServices?: NodeServices_2;
    meshnodeServices?: MeshnodeServices_2 | StreamedMeshnodeServices_2;
    bvhTree?: BVHTree;
    _virtualMeshnodeIndexOffset: number;
    private readonly featureFlags;
    loadPartitionPromises: Promise<void>[];
    currentIndex: number;
    partitionProxies: PartitionProxy_2[];
    partitionsCache: LRUCache<string, Partition_2>;
    private meshServicesOPFSInitialized;
    constructor(params: {
        downloadMetaData: DownloadMetaData;
        resourceId: number;
        resource: ResourceDiscriminator;
        featureFlags: ValidatedFeatureFlags;
    });
    setStandardModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer): void;
    setPartitionedModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, partitionProxiesAB: ArrayBuffer): void;
    getPwfPartitionContentUrls(): string[];
    initPwfParser(): void;
    parsePwfNodes(): BootstrapperResult;
    parsePwfMeshnodes(): BootstrapperResult;
    parsePwfMeshes(): void;
    initMeshServices(): BootstrapperResult;
    initNodeServices(): void;
    initMeshnodeServices(): void;
    initNodeTree(): BootstrapperResult;
    initNodeTreeBoundingBoxes(): BootstrapperResult;
    allMeshnodes(): Meshnode_2[];
    getMeshnodeFromIndex(index: number): Meshnode_2;
    getParentNodeIds(nodeId: number): number[];
    getNodeById(id: number): Node_3;
    hasNode(id: number): boolean;
    private crawlAndCollectParentNodeIds;
    getSubtreeNodeIds(nodeId: number): number[];
    getVirtualMeshnodeIndexesByNodeId(nodeId: number): number[];
    private crawlAndCollectSubtreeNodeIds;
    private getSubTreeVirtualMeshnodeIndexes;
    getMeshnodeFromNodeId(nodeId: number): Meshnode_2;
    getMeshnode(offset: number): Meshnode_2;
    getNode(offset: number): Node_3 | Meshnode_2;
    numNodes(): number;
    numMeshnodes(): number;
    numMeshes(): number;
    loadAllMeshGeometryToGPU(): BootstrapperResult;
    loadAllPartitionProxies(): void;
    prefetchPartitions(geometryFactory: StreamedGeometryFactory): BootstrapperResult;
    setGeometryFactory(geometryFactory: GeometryFactory): void;
    globalOffset(): Vector3;
    root(): Node_3;
    forEachMeshnode(callback: (meshnode: Meshnode_2) => void): void;
    forEachNode(callback: (node: Node_3) => void): void;
    getMeshObject(meshRef: number): MeshObject;
    findFirstObject(meshnodeIndex: number): Node_3;
    numFirstObjects(): number;
    breadthFirstTraversalNodes(callback: (n: Node_3 | Meshnode_2) => void): BootstrapperResult;
    getNamedNode(nodeId: number): Node_3;
    captureModelStats(): number;
    private captureStandardModelStats;
    private capturePartitionedModelStats;
    getModelAnalyticsData(): ModelAnalyticsData;
    get virtualMeshnodeIndexOffset(): number;
    set virtualMeshnodeIndexOffset(value: number);
    dispose(): void;
}

export declare type PwfV1Bundle = {
    nodeUrl: string;
    meshnodeUrl: string;
    meshUrl: string;
};

declare class PWFV2 implements PWF {
    private readonly downloadMetaData;
    resourceId: number;
    resource: ResourceDiscriminator;
    streaming: boolean;
    nodeAB?: ArrayBuffer;
    meshnodeAB?: ArrayBuffer;
    meshAB?: ArrayBuffer;
    partitionProxiesAB?: ArrayBuffer;
    pwfModelParser?: PWFModelParser;
    private _numMeshnodes;
    private _numMeshes;
    private _numNodes;
    private globalOffsetValue;
    pwfModel: {
        nodes: PWFNode_2[];
        meshnodes: PWFMeshnode_2[];
        meshes: PWFMesh[];
    };
    meshServices?: MeshServices | StreamedMeshServices;
    nodeServices?: NodeServices;
    meshnodeServices?: MeshnodeServices | StreamedMeshnodeServices;
    manifest?: Manifest;
    meshnodeOffPointer: number;
    bvhTree?: BVHTree;
    _virtualMeshnodeIndexOffset: number;
    private readonly featureFlags;
    loadPartitionPromises: Promise<void>[];
    currentIndex: number;
    partitionProxies: PartitionProxy[];
    partitionsCache: LRUCache<string, Partition>;
    private meshServicesOPFSInitialized;
    constructor(params: {
        downloadMetaData: DownloadMetaData;
        resourceId: number;
        resource: ResourceDiscriminator;
        manifest: Manifest;
        featureFlags: ValidatedFeatureFlags;
    });
    setStandardModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer): void;
    setPartitionedModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, partitionProxiesAB: ArrayBuffer): void;
    getPwfPartitionContentUrls(): string[];
    initPwfParser(): void;
    parsePwfNodes(): BootstrapperResult;
    parsePwfMeshnodes(): BootstrapperResult;
    parsePwfMeshes(): void;
    initMeshServices(): BootstrapperResult;
    initNodeServices(): void;
    initMeshnodeServices(): void;
    initNodeTree(): BootstrapperResult;
    initNodeTreeBoundingBoxes(): BootstrapperResult;
    allMeshnodes(): Meshnode_3[];
    getMeshnodeFromIndex(index: number): Meshnode_3;
    getParentNodeIds(nodeId: number): number[];
    getNodeById(id: number): Node_4;
    hasNode(id: number): boolean;
    private crawlAndCollectParentNodeIds;
    getSubtreeNodeIds(nodeId: number): number[];
    getVirtualMeshnodeIndexesByNodeId(nodeId: number): number[];
    private crawlAndCollectSubtreeNodeIds;
    private getSubTreeVirtualMeshnodeIndexes;
    getMeshnodeFromNodeId(nodeId: number): Meshnode_3;
    getMeshnode(offset: number): Meshnode_3;
    getNode(offset: number): Node_4 | Meshnode_3;
    numNodes(): number;
    numMeshnodes(): number;
    numMeshes(): number;
    loadAllMeshGeometryToGPU(): BootstrapperResult;
    loadAllPartitionProxies(): void;
    prefetchPartitions(geometryFactory: StreamedGeometryFactory): BootstrapperResult;
    setGeometryFactory(geometryFactory: GeometryFactory): void;
    globalOffset(): Vector3;
    root(): Node_4;
    forEachMeshnode(callback: (meshnode: Meshnode_3) => void): void;
    forEachNode(callback: (node: Node_4) => void): void;
    getMeshObject(meshRef: number): MeshObject_2;
    findFirstObject(meshnodeIndex: number): Node_4;
    numFirstObjects(): number;
    breadthFirstTraversalNodes(callback: (n: Node_4 | Meshnode_3) => void): BootstrapperResult;
    getNamedNode(nodeId: number): Node_4;
    captureModelStats(): number;
    private captureStandardModelStats;
    private capturePartitionedModelStats;
    getModelAnalyticsData(): ModelAnalyticsData;
    get virtualMeshnodeIndexOffset(): number;
    set virtualMeshnodeIndexOffset(value: number);
    dispose(): void;
}

export declare type PwfV2Bundle = {
    nodeUrl: string;
    meshnodeUrl: string;
    meshUrl: string;
    manifestUrl: string;
};

declare type PWFVersion = `${number}.${number}`;

export declare const RENDER_MODE: {
    readonly SHADED: "shaded";
    readonly XRAY: "xray";
};

export declare type RenderMode = (typeof RENDER_MODE)[keyof typeof RENDER_MODE];

export declare type Resource = FileExtractionModePwfV1OverrideResource | FileExtractionModePwfV2OverrideResource | FileExtractionModeResource | ModelRevisionModePwfV1OverrideResource | ModelRevisionModePwfV2OverrideResource | ModelRevisionModeResource;

declare type ResourceDiscriminator = {
    fileExtractionId: number;
} | {
    modelRevisionId: number;
};

export declare type ResourceOptions = CommonOptions & {
    resources: Resource[];
};

export declare type RGB = `rgb(${number}, ${number}, ${number})`;

export declare type RGBA = `rgba(${number}, ${number}, ${number}, ${number})`;

export declare type SectionDataAutodeskFormat = {
    Type: 'ClipPlaneSet';
    Version: 1;
    Unit?: string;
    OrientedBox?: AutodeskFormatClipBox | null;
    Planes?: AutodeskFormatClipPlane[] | null;
    Linked: boolean;
    Enabled: boolean;
};

export declare type SectionDataProcoreFormat = ProcoreFormatClipPlane[];

declare class StreamedGeometryFactory extends GeometryFactory {
    createMeshGeometry(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
    createMeshGeometryPrefetching(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
    createCylinderGeometry(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
    protected newVertexBufferStream(size: number): WebGLBuffer;
    protected newIndexBufferStream(size: number): WebGLBuffer;
}

declare class StreamedMeshGeometry extends MeshGeometry {
    color: number;
    opacity: number;
    drawType: number;
    numFaces: number;
    verticesLength: number;
    verticesGLBuffer: WebGLBuffer | null;
    facesLength: number;
    facesGLBuffer: WebGLBuffer | null;
    constructor(color: number, opacity: number, drawType: number, numVertices: number, verticesBuffer: WebGLBuffer | null, numFaces: number, facesBuffer: WebGLBuffer | null, facesBytesLength: number, index: number, vertexBufferIndex: number, indexBufferIndex: number, vertexPosition: number);
}

declare class StreamedMeshnode extends Meshnode_3 {
    private _partitionProxy?;
    private _meshGeometries;
    setPartitionProxy(partitionProxy: PartitionProxy): void;
    partitionProxy(): PartitionProxy;
    meshGeometries(): MeshGeometry[];
    setMeshGeometry(meshIndex: number, meshGeometry: StreamedMeshGeometry): void;
    getMeshGeometry(meshIndex: number): StreamedMeshGeometry | undefined;
    asObject(): MeshnodeObject_2;
    private getMeshObject;
}

declare class StreamedMeshnode_2 extends Meshnode_2 {
    private _partitionProxy?;
    private _meshGeometries;
    setPartitionProxy(partitionProxy: PartitionProxy_2): void;
    partitionProxy(): PartitionProxy_2;
    meshGeometries(): MeshGeometry[];
    setMeshGeometry(meshIndex: number, meshGeometry: StreamedMeshGeometry): void;
    getMeshGeometry(meshIndex: number): StreamedMeshGeometry | undefined;
    asObject(): MeshnodeObject;
    private getMeshObject;
}

declare class StreamedMeshnodeServices extends MeshnodeServices {
    protected createMeshnode(pwfMeshnode: PWFMeshnode_2): Meshnode_3;
}

declare class StreamedMeshnodeServices_2 extends MeshnodeServices_2 {
    protected createMeshnode(pwfMeshnode: PWFMeshnode): Meshnode_2;
}

declare class StreamedMeshServices extends MeshServices {
    private readonly featureFlags;
    private meshIndexToOPFSRecord;
    private opfsFile?;
    private opfsOffset;
    private resource;
    constructor(params: {
        pwf: PWFV2;
        featureFlags: ValidatedFeatureFlags;
        resource: ResourceDiscriminator;
    });
    initOPFS(): Promise<void>;
    private deleteOPFSFile;
    getOPFSFile(): OPFSFile | undefined;
    closeOPFS(): Promise<void>;
    writeMeshDataToOPFS(meshData: MeshData): Promise<void>;
    getMeshObject(meshIndex: number): MeshObject_2;
    loadPartitionContainingMeshnode(streamedMeshnode: StreamedMeshnode): Promise<void>;
    getMeshGeometryForOffsets(meshOffset: number, meshnodeOffset: number): StreamedMeshGeometry | undefined;
    meshFromOffset(meshIndex: number): Mesh;
    private getCompressedMeshDataFromOPFS;
    dispose(): Promise<void>;
}

declare class StreamedMeshServices_2 extends MeshServices_2 {
    private readonly featureFlags;
    private meshIndexToOPFSRecord;
    private opfsFile?;
    private opfsOffset;
    private resource;
    constructor(params: {
        pwf: PWFV1;
        featureFlags: ValidatedFeatureFlags;
        resource: ResourceDiscriminator;
    });
    initOPFS(): Promise<void>;
    private deleteOPFSFile;
    getOPFSFile(): OPFSFile | undefined;
    closeOPFS(): Promise<void>;
    writeMeshDataToOPFS(meshData: MeshData_2): Promise<void>;
    getMeshObject(meshIndex: number): MeshObject;
    loadPartitionContainingMeshnode(streamedMeshnode: StreamedMeshnode_2): Promise<void>;
    getMeshGeometryForOffsets(meshOffset: number, meshnodeOffset: number): StreamedMeshGeometry | undefined;
    meshFromOffset(meshIndex: number): Mesh_2;
    private getCompressedMeshDataFromOPFS;
    dispose(): Promise<void>;
}

export declare class TestRoutineRecorder {
    camera: Camera;
    points: Point[];
    constructor(params: {
        camera: Camera;
    });
    here(): any;
    reset(): void;
    print(): void;
}

export declare const TOOL: {
    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;
};

export declare type Tool = (typeof TOOL)[keyof typeof TOOL];

export declare const TOOL_BAR_TOOLS: {
    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;
};

export declare type ToolBarTools = (typeof TOOL_BAR_TOOLS)[keyof typeof TOOL_BAR_TOOLS];

export declare const UOM: {
    readonly rad: "rad";
    readonly deg: "°";
    readonly cdsqm: "cd/m²";
    readonly cuum: "um³";
    readonly cumm: "mm³";
    readonly cucm: "cm³";
    readonly cum: "m³";
    readonly cukm: "km³";
    readonly cuuin: "uin³";
    readonly cumil: "mil³";
    readonly cuin: "in³";
    readonly cuft: "ft³";
    readonly cuyd: "yd³";
    readonly cumi: "mi³";
    readonly squm: "um²";
    readonly sqmm: "mm²";
    readonly sqcm: "cm²";
    readonly sqm: "m²";
    readonly sqkm: "km²";
    readonly squin: "uin²";
    readonly sqmil: "mil²";
    readonly sqin: "in²";
    readonly sqft: "ft²";
    readonly sqyd: "yd²";
    readonly sqmi: "mi²";
    readonly um: "um";
    readonly mm: "mm";
    readonly cm: "cm";
    readonly m: "m";
    readonly km: "km";
    readonly uin: "uin";
    readonly mil: "mil";
    readonly in: "in";
    readonly ft: "ft";
    readonly yd: "yd";
    readonly mi: "mi";
};

export declare type Uom = (typeof UOM)[keyof typeof UOM];

declare type ValidatedFeatureFlags = Readonly<FeatureFlags>;

export declare type Vector2 = {
    x: number;
    y: number;
};

export declare type Vector3 = {
    x: number;
    y: number;
    z: number;
};

export declare const version: string;

export declare type Viewpoint = {
    camera_data: string;
    sections_data: string;
    redlines_data: string;
    visibility?: Visibility | null;
    render_mode?: RenderMode | null;
};

export declare type Visibility = {
    default_visibility: boolean;
    exceptions: {
        object_ids: number[];
        object_ranges: [number, number][];
    };
};

export declare type WebFormatExtractionItem = {
    item_type: 'WebFormat';
    artifact: {
        web_format: GeometryFileBundle;
    };
};

export declare class Webviewer {
    options: Options;
    private readonly measurementRenderer;
    private readonly measurementManager;
    private readonly escapeOperationsManager;
    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;
    };
    private readonly openTelemetryManager?;
    private readonly activeSessionManager?;
    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;
}

export { }