import { PluginBase } from './base/PluginBase';
import { Viewer } from './Viewer';
import * as BABYLON from '@babylonjs/core';
import type { Building, IDict, CoverPathLine, Point3D, GroundHideOption, IList, LevelInfo } from './Types';
import { DeviceBuilder } from './device/DeviceBuilder';
import { BuildBase } from './base/BuildBase';
declare class BuildingBuilder extends BuildBase {
    Buildings: BABYLON.TransformNode[];
    ExplodeDistance: number;
    BuildingLevels: {
        [key: string]: {
            buildingName: string;
            floorName: string;
            modelName: string;
        }[];
    };
    constructor(builderMgr: ComponentMgr);
    toModelName(name: string): string;
    toDisplayName(name: string): string;
    parse(): void;
    getScaleAnimation(buildingName: string): BABYLON.AnimationGroup;
    genScaleAnimation(building: BABYLON.TransformNode, second?: number): void;
    genScaleAnimationByBuildingName(buildingName: string, second?: number): void;
    animationBuild(): void;
    BuildingShell: IDict<BABYLON.AbstractMesh[]>;
    attachEvents(): void;
    detachEvents(): void;
    getBuildingLevels(): Building[];
    getLevelInfos(): LevelInfo[];
}
declare class WallBodyBuilder extends BuildBase {
    Enable: boolean;
    Distance: number;
    Opacity: number;
    ExitRestoreDistance: number;
    WallBody: {
        [key: string]: BABYLON.TransformNode[];
    };
    open(): void;
    close(): void;
    parse(): void;
    private restoreMesh;
    private _ctrlChangedObserver;
    private _cameraChangedObserver;
    attachEvents(): void;
    detachEvents(): void;
    constructor(builderMgr: ComponentMgr);
    setOptions(opts: {
        distance: number;
        opacity: number;
        exitRestoreDistance?: number;
    }): void;
}
declare class GroundBuilder extends BuildBase {
    Meshes: BABYLON.AbstractMesh[];
    GroundNames: string[];
    HideOption: GroundHideOption;
    constructor(builderMgr: ComponentMgr);
    parse(): void;
    private setEnabled;
    hide(): void;
    show(): void;
}
declare class TreeBuilder extends BuildBase {
    TreeNodes: BABYLON.TransformNode[];
    constructor(builderMgr: ComponentMgr);
    parse(): void;
}
declare class WaterBuilder extends BuildBase {
    constructor(builderMgr: ComponentMgr);
    parse(): void;
}
declare class SmallItemBuilder extends BuildBase {
    Nodes: IList<BABYLON.TransformNode>;
    parse(): void;
}
declare class PathLineBuilder extends BuildBase {
    private _mainNode;
    private _sphereNode;
    private _texMapping;
    private _lines;
    private _pickEnable;
    private _positions;
    private _anchorDiameter;
    private _anchorSpheres;
    private _sphereMaterial;
    private _character;
    constructor(builderMgr: ComponentMgr);
    parse(): void;
    init(): void;
    add(name: string, points?: Point3D[]): void;
    setAnchorDiameter(diameter: number): void;
    regen(cover: CoverPathLine): void;
    getPathLines(): CoverPathLine[];
    rename(pathLine: CoverPathLine, destName: string): void;
    private getCoverMesh;
    private addAnchorSphere;
    private regenAnchorSphere;
    private clearAnchorSphere;
    private getAnchorIndex;
    private clearPathLine;
    private drawPreviewPath;
    private clearPreviewPath;
    private hidePathLine;
    private showPathLine;
    private _pointerObserver;
    private _keyBoardObserver;
    private _downX;
    private _downY;
    attachEvents(): void;
    detachEvents(): void;
    private _editCover;
    private _editCb;
    edit(cover: CoverPathLine, cb?: () => void): void;
    exitEdit(): void;
}
declare class ComponentMgr extends PluginBase {
    BuildingBuilder: BuildingBuilder;
    WallBodyBuilder: WallBodyBuilder;
    GroundBuilder: GroundBuilder;
    TreeBuilder: TreeBuilder;
    DeviceBuilder: DeviceBuilder;
    WaterBuilder: WaterBuilder;
    SmallItemBuilder: SmallItemBuilder;
    PathLineBuilder: PathLineBuilder;
    getClassName(): string;
    toJson(): Object;
    parseJson(json: Object): void;
    constructor(viewer: Viewer);
    private getPlugins;
    init(): void;
    getHighLightMeshes(): BABYLON.AbstractMesh[];
    clearMeshSelectionFlag(mesh?: BABYLON.AbstractMesh): void;
    build(): void;
    attachComponentEvents(): void;
    detachComponentEvents(): void;
    addShadowCaster(shadowGen: BABYLON.ShadowGenerator): void;
    getLevelInfos(): LevelInfo[];
}
export { ComponentMgr };