import { Box3, DirectionalLight, Object3D, Plane, Scene, Sphere, Texture, Vector3, WebGLRenderer } from 'three';
import { FilterMaterial } from './filtering/FilteringManager';
import Input from './input/Input';
import { Intersections } from './Intersections';
import SpeckleStandardMaterial from './materials/SpeckleStandardMaterial';
import { NodeRenderView } from './tree/NodeRenderView';
import { Viewer } from './Viewer';
import { TreeNode } from './tree/WorldTree';
import { CanonicalView, InlineView, PolarView, SpeckleView, SunLightConfiguration } from '../IViewer';
import { PipelineOptions } from './pipeline/Pipeline';
import { Shadowcatcher } from './Shadowcatcher';
import { ExtendedIntersection } from './objects/SpeckleRaycaster';
import { BatchObject } from './batching/BatchObject';
import SpecklePointMaterial from './materials/SpecklePointMaterial';
import SpeckleLineMaterial from './materials/SpeckleLineMaterial';
import { Measurements } from './measurements/Measurements';
export declare enum ObjectLayers {
    STREAM_CONTENT_MESH = 10,
    STREAM_CONTENT_LINE = 11,
    STREAM_CONTENT_POINT = 12,
    STREAM_CONTENT_TEXT = 13,
    STREAM_CONTENT_POINT_CLOUD = 14,
    STREAM_CONTENT = 1,
    PROPS = 2,
    SHADOWCATCHER = 3,
    MEASUREMENTS = 4
}
export default class SpeckleRenderer {
    private readonly SHOW_HELPERS;
    private readonly IGNORE_ZERO_OPACITY_OBJECTS;
    SHOW_BVH: boolean;
    private container;
    private _renderer;
    _scene: Scene;
    private _needsRender;
    private rootGroup;
    private batcher;
    private _intersections;
    input: Input;
    private sun;
    private sunTarget;
    private sunConfiguration;
    viewer: Viewer;
    private filterBatchRecording;
    private pipeline;
    private lastSectionPlanes;
    private sectionPlanesChanged;
    private sectionBoxOutlines;
    private _shadowcatcher;
    private _measurements;
    private cancel;
    private explodeTime;
    private explodeRange;
    get renderer(): WebGLRenderer;
    set needsRender(value: boolean);
    set indirectIBL(texture: Texture);
    set indirectIBLIntensity(value: number);
    /** TEMPORARY for backwards compatibility */
    get allObjects(): Object3D<import("three").Event>;
    subtree(subtreeId: string): Object3D<import("three").Event>;
    get sceneBox(): Box3;
    get sceneSphere(): Sphere;
    get sceneCenter(): Vector3;
    get sunLight(): DirectionalLight;
    get camera(): import("three").PerspectiveCamera | import("three").OrthographicCamera;
    get scene(): Scene;
    set pipelineOptions(value: PipelineOptions);
    get pipelineOptions(): PipelineOptions;
    set showBVH(value: boolean);
    get shadowcatcher(): Shadowcatcher;
    get intersections(): Intersections;
    get currentSectionBox(): Box3;
    get measurements(): Measurements;
    constructor(viewer: Viewer /** TEMPORARY */);
    create(container: HTMLElement): void;
    update(deltaTime: number): void;
    private updateRTEShadows;
    private updateTransforms;
    private updateFrustum;
    resetPipeline(force?: boolean): void;
    render(): void;
    resize(width: number, height: number): void;
    addRenderTree(subtreeId: string): Promise<void>;
    addRenderTreeAsync(subtreeId: string, priority?: number, zoomToObject?: boolean): Promise<void>;
    private addBatch;
    removeRenderTree(subtreeId: string): void;
    cancelRenderTree(subtreeId: string): void;
    clearFilter(): void;
    applyFilter(ids: NodeRenderView[], filterMaterial: FilterMaterial): void;
    applyDirectFilter(ids: NodeRenderView[], filterMaterial: FilterMaterial): string;
    removeDirectFilter(id: string): void;
    applyMaterial(ids: NodeRenderView[], material: SpeckleStandardMaterial | SpecklePointMaterial): void;
    beginFilter(): void;
    endFilter(): void;
    getBatchMaterials(): {
        [id: string]: SpeckleStandardMaterial | SpecklePointMaterial | SpeckleLineMaterial;
    };
    updateClippingPlanes(planes?: Plane[]): void;
    private setSectionPlaneChanged;
    onSectionBoxDragStart(): void;
    onSectionBoxDragEnd(): void;
    updateSectionBoxCapper(planes?: Plane[]): void;
    enableSectionBoxCapper(value: boolean): void;
    updateShadowCatcher(): void;
    private addDirectLights;
    updateDirectLights(): void;
    setSunLightConfiguration(config: SunLightConfiguration): void;
    updateHelpers(): void;
    queryHits(results: Array<ExtendedIntersection>): Array<{
        node: TreeNode;
        point: Vector3;
    }>;
    queryHitIds(results: Array<ExtendedIntersection>): Array<{
        nodeId: string;
        point: Vector3;
    }>;
    private onObjectClick;
    private onObjectDoubleClick;
    boxFromObjects(objectIds: string[]): Box3;
    zoom(objectIds?: string[], fit?: number, transition?: boolean): void;
    /** Taken from InteractionsHandler. Will revisit in the future */
    private zoomExtents;
    /** Taken from InteractionsHandler. Will revisit in the future */
    zoomToBox(box: any, fit?: number, transition?: boolean): void;
    private isSpeckleView;
    private isCanonicalView;
    private isInlineView;
    private isPolarView;
    setView(view: CanonicalView | SpeckleView | InlineView | PolarView, transition?: boolean): void;
    private setViewSpeckle;
    /**
     * Rotates camera to some canonical views
     * @param  {string}  side       Can be any of front, back, up (top), down (bottom), right, left.
     * @param  {Number}  fit        [description]
     * @param  {Boolean} transition [description]
     * @return {[type]}             [description]
     */
    private setViewCanonical;
    private setViewInline;
    private setViewPolar;
    screenToNDC(clientX: number, clientY: number, width?: number, height?: number): {
        x: number;
        y: number;
    };
    NDCToScreen(clientX: number, clientY: number, width?: number, height?: number): {
        x: number;
        y: number;
    };
    /** DEBUG */
    debugShowBatches(): void;
    getBatchIds(): any[];
    getBatchSize(batchId: string): number;
    isolateBatch(batchId: string): void;
    setExplode(time: number, range: number): void;
    private explode;
    getObjects(id: string): BatchObject[];
    markTransformsDirty(batchId: string): void;
    enableLayers(layers: ObjectLayers[], value: boolean): void;
}
