/// <reference path="../library/typings/pixi.js.d.ts" />
/// <reference path="../library/typings/native.d.ts" />
/// <reference path="../library/typings/cross-runtime.d.ts" />
/// <reference path="../library/typings/cross-editor.d.ts" />
/// <reference path="../typings/private/foundation-editor-base.d.ts" />
/// <reference path="../typings/private/foundation-editor-ui.d.ts" />
/// <reference path="../typings/private/foundation-editor-view.d.ts" />
/// <reference path="../typings/private/sk-data-logic.d.ts" />
/// <reference path="../typings/private/sk-data-family.d.ts" />
/// <reference path="../typings/private/sk-data-resource.d.ts" />
/// <reference path="../typings/private/sk-data-scheme.d.ts" />
/// <reference path="../typings/private/sk-rule-data.d.ts" />
/// <reference path="../typings/private/sk-editor-view.d.ts" />
/// <reference path="../typings/private/sk-editor-render.d.ts" />
/// <reference types="react" />
declare module "copyright" {
    export class EditorLogicCopyright {
        static toString(): string;
    }
}
declare module "sk/editor/logic/IndexSpace" {
    export class IndexSpace {
        static namespaces(): string[];
    }
}
declare module "sk/editor/logic/action/camera/CameraActionEvent" {
    import { CameraActionEvent as BaseCameraActionEvent } from 'foundation/editor/view/action/camera/CameraActionEvent';
    export class CameraActionEvent extends BaseCameraActionEvent {
        select: string;
        wallSnapEnable: boolean;
        fov: number;
        fovDelta: number;
        pitch: number;
        position: any;
        free(): void;
    }
}
declare module "sk/editor/logic/action/camera/Camera2dMoveAction" {
    import { Action } from 'foundation/editor/view/action/Action';
    import { CameraActionEvent } from "sk/editor/logic/action/camera/CameraActionEvent";
    export class Camera2dMoveAction extends Action {
        protected _withTarget: boolean;
        protected _wallSnapEnable: boolean;
        constructor();
        moveTo(x: number, y: number): void;
        move(x: number, y: number): void;
        onExecute(event: CameraActionEvent): void;
        onReceive(code: string, event: CameraActionEvent): boolean;
    }
}
declare module "sk/editor/logic/action/camera/Camera3dMoveAction" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { Action } from 'foundation/editor/view/action/Action';
    import { CameraActionEvent } from "sk/editor/logic/action/camera/CameraActionEvent";
    export class Camera3dMoveAction extends Action {
        protected static CompatibleKeys: number[];
        protected _isMouseDown: boolean;
        protected _lastPosition: Vector3;
        protected _lastTargetPos: Vector3;
        protected _pressedKey: Types<number>;
        protected _selectionService: SelectionService;
        constructor();
        protected isKeyUp(): boolean;
        protected isCompatibleKey(event: KeyboardEvent): boolean;
        protected addPressedKey(event: KeyboardEvent): void;
        protected removePressedKey(event: KeyboardEvent): void;
        protected moveTarget(cx: number, cy: number, cz: number): void;
        protected movePosition(point: Vector3): void;
        protected move(cx: number, cy: number, cz: number): void;
        protected moveAlongAxis(axisName: string, value: number): void;
        onExecute(event: CameraActionEvent): void;
        onReceive(code: string, event: CameraActionEvent): boolean;
    }
}
declare module "sk/editor/logic/action/camera/CameraEventEnum" {
    export class CameraEventEnum {
        static UpdateHorizontalFov: string;
        static AccumulateHorizontalFov: string;
    }
}
declare module "sk/editor/logic/action/camera/CameraChangeFovAction" {
    import { ObserverTypeEnum } from 'foundation/data/common/model/brep/ObserverTypeEnum';
    import { Action } from 'foundation/editor/view/action/Action';
    import { ObserverViewEntity } from 'foundation/editor/view/entity/ObserverViewEntity';
    import { CameraActionEvent } from "sk/editor/logic/action/camera/CameraActionEvent";
    export class CameraChangeFovAction extends Action {
        entity: ObserverViewEntity;
        protected _minHorizontalFov: number;
        protected _maxHorizontalFov: number;
        protected _lengthToAngleFactor: number;
        constructor();
        protected buildHorizontalFovRange(cameraCd: ObserverTypeEnum): void;
        protected updateCameraHorizontalFov(fov: number): void;
        protected accumulateCameraHorizontalFov(delta: number): void;
        onExecute(event: CameraActionEvent): any;
        onReceive(code: string, event: CameraActionEvent): boolean;
    }
}
declare module "sk/editor/logic/action/camera/CameraMoveTarget" {
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { Action } from 'foundation/editor/view/action/Action';
    import { CameraActionEvent } from "sk/editor/logic/action/camera/CameraActionEvent";
    export class CameraMoveTarget extends Action {
        entity: ObserverViewNode;
        constructor();
        move(x: number, y: number): void;
        onExecute(event: CameraActionEvent): void;
        onReceive(code: string, event: CameraActionEvent): boolean;
    }
}
declare module "sk/editor/logic/ui/dataset/UiLogicRow" {
    import { UiDataRow } from 'foundation/editor/ui/data/UiDataRow';
    export class UiLogicRow extends UiDataRow {
        loadChildrenData(row: any): void;
    }
}
declare module "sk/editor/logic/ui/dataset/UiLogicDatasetController" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { UiDataDatasetController } from 'foundation/editor/ui/data/UiDataDatasetController';
    import { UiLogicRow } from "sk/editor/logic/ui/dataset/UiLogicRow";
    export class UiLogicDatasetController extends UiDataDatasetController {
        protected _rows: Types<UiLogicRow>;
        protected _newRows: Types<UiLogicRow>;
        protected _allRows: Types<UiLogicRow>;
        copyRows: Array<any>;
        constructor();
        get currentCategoryId(): string;
        get selectedKey(): string;
        get selectedRow(): any;
        deleteSelectedRow(record: any): any;
        get allRows(): Types<UiLogicRow>;
        get rows(): Types<UiLogicRow>;
        loadArray(rows: Array<any>): void;
        loadRowArray(rows: Array<any>): void;
        getRow(index: number): UiLogicRow;
        updateRow(index: number, rowData: any): void;
        loadAllArray(rows: Array<any>): void;
        loadAsync(): Promise<ResultObject>;
        fetchAsync(): Promise<ResultObject>;
        fetchAllAsync(): Promise<ResultObject>;
        getAsync(id: string): Promise<ResultObject>;
        prepareAsync(): Promise<ResultObject>;
        insertAsync(data: any): Promise<ResultObject>;
        updateAsync(data: any): Promise<ResultObject>;
        updateListAsync(data: Array<any>): Promise<ResultObject>;
        deleteAsync(id: string): Promise<ResultObject>;
        pasteAsync(path?: any): Promise<ResultObject>;
        moveAsync(ids: Array<string>, categoryId: string): Promise<ResultObject>;
    }
}
declare module "sk/editor/logic/command/PdmsLogicTableDataClipCommand" {
    import { EditorClipCommand } from 'foundation/editor/base/service/clip/EditorClipCommand';
    import { EditorClipContext } from 'foundation/editor/base/service/clip/EditorClipContext';
    import { EditorClipData } from 'foundation/editor/base/service/clip/EditorClipData';
    export class PdmsLogicTableDataClipCommand extends EditorClipCommand {
        copyToData(context: EditorClipContext, content: string[]): EditorClipData;
        pasteToContent(context: EditorClipContext, data: EditorClipData): void;
    }
}
declare module "sk/editor/logic/cross/property/NativeElementConditionProperty" {
    import { ElementConditionProperty } from 'sk/data/family/element/config/conditon/ElementConditionProperty';
    export class NativeElementConditionProperty extends ElementConditionProperty {
    }
}
declare module "sk/editor/logic/cross/property/NativeFormulaProperty" {
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    export class NativeFormulaProperty extends FormulaProperty {
    }
}
declare module "sk/editor/logic/cross/CrossElementFactoryUtil" {
    import { ElementConditionProperty } from 'sk/data/family/element/config/conditon/ElementConditionProperty';
    import { FormulaProperty } from 'sk/data/family/element/config/formula/FormulaProperty';
    export class CrossElementFactoryUtil {
        static createFormulaProperty(owner: any, field: string): FormulaProperty;
        static createConditionProperty(owner: any, field: string): ElementConditionProperty;
        static active(): void;
    }
}
declare module "sk/editor/logic/cross/NativeDataElementFactory" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ElementModelFactory } from 'foundation/data/common/element/ElementModelFactory';
    export class NativeDataElementFactory extends ElementModelFactory {
        protected _classes: Dictionary<any>;
        constructor();
        createInstance(type: any): any;
        disposeInstance(instance: any): any;
    }
}
declare module "sk/editor/logic/cross/NativeDataNodeFactory" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { DataModelFactory } from 'foundation/data/common/model/DataModelFactory';
    export class NativeDataNodeFactory extends DataModelFactory {
        protected _classes: Dictionary<any>;
        constructor();
        createInstance(type: any): any;
        disposeInstance(instance: any): any;
    }
}
declare module "sk/editor/logic/cross/CrossFactoryUtil" {
    export class CrossFactoryUtil {
        static active(): void;
    }
}
declare module "sk/editor/logic/entity/AnchorEntity" {
    import { AnchorNode } from 'sk/data/family/model/assistant/AnchorNode';
    export class AnchorEntity extends AnchorNode {
    }
}
declare module "sk/editor/logic/entity/AreaLightEntity" {
    import { AreaLightNode } from 'sk/data/scheme/database/light/model/AreaLightNode';
    export class AreaLightEntity extends AreaLightNode {
        constructor();
    }
}
declare module "sk/editor/logic/entity/BoxSolidEntity" {
    import { BoxGeometry } from 'foundation/runtime/graphics/shape/geometry/BoxGeometry';
    import { BoxSolidNode } from 'foundation/data/common/model/brep/geometric/solid/BoxSolidNode';
    export class BoxSolidEntity extends BoxSolidNode {
        protected _geometry: BoxGeometry;
        get geometry(): BoxGeometry;
    }
}
declare module "sk/editor/logic/entity/HardwareEntity" {
    import { HardwareNode } from 'sk/data/family/model/instance/HardwareNode';
    export class HardwareEntity extends HardwareNode {
    }
}
declare module "sk/editor/logic/entity/PlankEntity" {
    import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
    export class PlankEntity extends PlankNode {
    }
}
declare module "sk/editor/logic/entity/SpaceEntity" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { RelativeDirectionEnum } from 'foundation/data/common/enumeration/RelativeDirectionEnum';
    import { SpaceNode } from 'sk/data/scheme/database/furniture/model/SpaceNode';
    export class SpaceEntity extends SpaceNode {
        static CLASS_NAME: string;
        borderColor: number;
        findTopLinkSpace(): any;
        findTopLinkPlank(): any;
        findBottomLinkSpace(): any;
        findBottomLinkPlank(): any;
        findLeftLinkSpace(): any;
        findLeftLinkPlank(): any;
        findRightLinkSpace(): any;
        findRightLinkPlank(): any;
        testNodeValid(srcSize: Vector3, targetSize: Vector3, direction: Direction): boolean;
        testValidSpace(size: Vector3): boolean;
        findIntersects(type: Function): Array<any>;
        protected findLinkSpace(relativeDirectionCd: RelativeDirectionEnum, directionCd: Direction): any;
        private findLinkPlank;
    }
    export enum Direction {
        HORIZONTAL = 0,
        VERTICAL = 1
    }
}
declare module "sk/editor/logic/entity/ChestEntity" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ChestNode } from 'sk/data/scheme/database/furniture/model/ChestNode';
    import { PlankEntity } from "sk/editor/logic/entity/PlankEntity";
    import { SpaceEntity } from "sk/editor/logic/entity/SpaceEntity";
    export class ChestEntity extends ChestNode {
        spaceNodes: Types<SpaceEntity>;
        _mirror: ContentNode;
        transDataCallBack: Function;
        constructor();
        createSpaceNode(): SpaceEntity;
        reload(): void;
        replace(entity: ChestEntity): void;
        getDecorateMapByType(type: string, result: any): void;
        getHardware(result: Array<string>): void;
        getPlankList(target?: Array<PlankEntity>): Array<PlankEntity>;
        displayAllPlanks(rs?: Array<PlankEntity>): void;
        protected displayChildFromPlank(visible: boolean, plankEntity: PlankEntity): void;
        hideAllPlanks(): void;
        validChildCount(): number;
        hide(): void;
        show(): void;
        reset(): void;
    }
}
declare module "sk/editor/logic/entity/ContainerEntity" {
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    export class ContainerEntity extends ContainerNode {
    }
}
declare module "sk/editor/logic/entity/CountertopEntity" {
    import { CountertopNode } from 'sk/data/scheme/database/furniture/model/CountertopNode';
    export class CountertopEntity extends CountertopNode {
    }
}
declare module "sk/editor/logic/entity/HostEntity" {
    import { HostNode } from 'sk/data/scheme/database/furniture/model/HostNode';
    export class HostEntity extends HostNode {
    }
}
declare module "sk/editor/logic/entity/LightEntity" {
    import { LightNode } from 'sk/data/family/model/instance/LightNode';
    export class LightEntity extends LightNode {
        constructor();
    }
}
declare module "sk/editor/logic/view/canvas2d/renderer/C2dTopview" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { BufferGeometryResource } from 'sk/data/resource/loader/actor/BufferGeometryResource';
    import { ModelDocumentService } from 'sk/data/resource/model/service/ModelDocumentService';
    export class C2dTopview extends InstanceObject {
        resource: BufferGeometryResource;
        meshBox: BoundaryBox;
        protected _modelDocumentService: ModelDocumentService;
        loadAsync(id: string): Promise<ResultObject>;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/base/EditOptionUtil" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { CanvasContext } from 'foundation/editor/view/base/CanvasContext';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    export class EditOptionUtil {
        static useOccMolding: boolean;
        static isVisibleChanged(name: string): boolean;
        static notRoomVisible(info: ISpecificationFamilyInfo): boolean;
        static testEntityVisible(options: any, entity: ContentNode, canvasContext?: CanvasContext): boolean;
        static testVisibleFlatWall(options: any, visibleOptions: any, entity: ContentNode): boolean;
        static testVisibleFlatWallLayer(visibleOptions: any, entity: ContentNode): boolean;
        static testVisible(options: any, info: ISpecificationFamilyInfo, canvasContext?: CanvasContext): boolean;
        static testDecorateVisible(options: any): boolean;
        static testAssembleLayerVisible(options: any, node: DataNode): boolean;
        static testPatternVisible(options: any, info: ISpecificationFamilyInfo, canvasContext?: CanvasContext): boolean;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dConstants" {
    export class C2dConstants {
        static MODEL_TO_CANVAS_FACTOR: number;
        static CANVAS_TO_MODEL_FACTOR: number;
        static CANVAS_SCALE_MIN: number;
        static CANVAS_SCALE_MAX: number;
        static kMinScreenLengthToShowDim: number;
        static CAMERA_DEFAULT_LENGTH: number;
        static GRID_LEVEL_STEPS: Array<number>;
        static GRID_LEVEL_COLORS: Array<number>;
        static PATTERN_GRID_LEVEL_STEPS: Array<number>;
        static PATTERN_GRID_LEVEL_COLORS: Array<number>;
        static POINT_COLOR_NORMAL: string;
        static POINT_COLOR_SELECTED: string;
        static ALIGNMENT_LINE_STROKE_WIDTH: number;
        static ALIGNMENT_LINE_STROKE_COLOR: string;
        static SNAP_OFFSET: number;
        static SNAP_PIXEL_OFFSET: number;
        static SNAP_ALIGN_TOLERANCE: number;
        static DEFAULT_TOP_VIEW: string;
        static DIMENSION_LINE_COLOR: number;
        static DIMENSION_BOX_COLOR: number;
        static CONTENT_COLOR_NORMAL: number;
        static CONTENT_COLOR_HOVER: number;
        static CONTENT_COLOR_SELECT2: number;
        static CONTENT_COLOR_SELECT: number;
        static CONTENT_COLOR_HIGHLIGHT: number;
        static PATTERN_COLOR_TECHNOLOGY_INVALID: number;
        static PATTERN_COLOR_TECHNOLOGY_MANUAL: number;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dCanvasEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { Rect } from 'foundation/runtime/math/Rect';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class C2dCanvasEvent extends EventObject {
        x: number;
        y: number;
        scale: Vector2;
        viewRect: Rect;
        constructor();
        free(): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dLayer" {
    import { Display } from 'foundation/editor/view/base/Display';
    import { V2dLayer } from 'foundation/editor/view/view2d/V2dLayer';
    export class C2dLayer extends V2dLayer {
        link(pixiObj: PIXI.DisplayObject, display: Display, visible?: boolean): void;
        protected setPixiElement(element: PIXI.DisplayObject, display: Display, visible: boolean): void;
        protected onAppendChild(child: any, level?: number): void;
        protected onRemoveChild(child: any): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dLayers" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
    import { V2dLayers } from 'foundation/editor/view/view2d/V2dLayers';
    import { C2dCanvasContext } from "sk/editor/logic/view/canvas2d/C2dCanvasContext";
    import { C2dLayer } from "sk/editor/logic/view/canvas2d/C2dLayer";
    export class C2dLayers extends V2dLayers {
        context: C2dCanvasContext;
        sceneContainer: V2dGraphicContainer;
        floatContainer: V2dGraphicContainer;
        tools: C2dLayer;
        compass: C2dLayer;
        camera: C2dLayer;
        contentVision: C2dLayer;
        content: C2dLayer;
        bgImage: C2dLayer;
        grid: C2dLayer;
        background: C2dLayer;
        anotation: C2dLayer;
        dimension: C2dLayer;
        protected layerNames: Array<string>;
        protected floatLayerNames: Array<string>;
        constructor();
        setup(): void;
        findIndex(name: string): number;
        find(name: string): C2dLayer;
        private addLayers;
        getScenePointFromCanvas(x: number, y: number): Vector2;
        reset(): void;
        toCenter(): boolean;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dSpatial" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Bound2 } from 'foundation/runtime/math/Bound2';
    import { Rect } from 'foundation/runtime/math/Rect';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataResourceService } from 'foundation/data/common/io/DataResourceService';
    import { DataBlueprintNode } from 'foundation/data/common/model/DataBlueprintNode';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
    import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
    import { V2dHookEvent } from 'foundation/editor/view/view2d/render/V2dHookEvent';
    import { V2dHookManager } from 'foundation/editor/view/view2d/render/V2dHookManager';
    import { ContentController } from 'foundation/editor/view/base/ContentController';
    import { ContentDisplay } from 'foundation/editor/view/base/ContentDisplay';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { V2dCanvas } from 'foundation/editor/view/view2d/V2dCanvas';
    import { V2dLayer } from 'foundation/editor/view/view2d/V2dLayer';
    import { C2dCanvasContext } from "sk/editor/logic/view/canvas2d/C2dCanvasContext";
    import { C2dCanvasEvent } from "sk/editor/logic/view/canvas2d/C2dCanvasEvent";
    export class C2dSpatial extends ContentDisplay {
        context: C2dCanvasContext;
        blueprint: DataBlueprintNode;
        controller: ContentController;
        view: V2dCanvas;
        layer: V2dLayer;
        sceneContainer: V2dGraphicContainer;
        node: V2dGraphicContainer;
        optionContent: boolean;
        optionGraphics: boolean;
        nodeGraphics: V2dGraphicDrawing;
        protected _viewCenter: Vector2;
        protected _viewRect: Rect;
        protected _bound: Bound2;
        protected _dragPoint: Vector2;
        protected _lastPoint: Vector2;
        protected _currentColor: number;
        protected _currentLine: number;
        protected _statusViewChanged: boolean;
        protected _statusViewSizeChanged: boolean;
        protected _statusUnderlay: boolean;
        protected _statusLevelChanged: boolean;
        protected _statusDragging: boolean;
        protected _hookManager: V2dHookManager;
        protected _dataResourceService: DataResourceService;
        protected _selectionService: SelectionService;
        constructor();
        setupLayer(): void;
        setup(): void;
        onViewBoxChanged(sender: ListenerContext, event: C2dCanvasEvent): void;
        onCanvasSizeChange(sender: ListenerContext, event: C2dCanvasEvent): void;
        protected onUnderlayShow(): void;
        protected onUnderlayHide(): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityReload(sender: ListenerContext, event: any): void;
        protected getLevelIndex(): number;
        checkHost(event: any): any;
        protected addContent(index: number): void;
        protected removeContent(): void;
        protected updateBound(): Bound2;
        protected updateTransform(): void;
        protected updateShape(): void;
        protected updateStyleStatus(): void;
        protected updateContentLevel(): void;
        onClick(sender: ListenerContext, event: V2dHookEvent): void;
        onMouseOver(sender: ListenerContext, event: V2dHookEvent): void;
        onMouseOut(sender: ListenerContext, event: V2dHookEvent): void;
        onMouseMove(sender: ListenerContext, event: V2dHookEvent): void;
        onMouseUp(sender: ListenerContext, event: V2dHookEvent): void;
        onDragStart(sender: ListenerContext, event: V2dHookEvent): boolean;
        onDragMove(sender: ListenerContext, event: V2dHookEvent): boolean;
        onDragEnd(sender: ListenerContext, event: V2dHookEvent): void;
        bindEvent(): void;
        canDraw(): boolean;
        createNode(): any;
        protected drawUpdate(context?: DisplayContext): boolean;
        updateShapeCompute(): void;
        drawDisplay(context?: DisplayContext): void;
        show(): void;
        hide(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dContent" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { NodeFieldEvent } from 'cross/runtime/framework/node/NodeFieldEvent';
    import { NodeObjectCollection } from 'cross/runtime/framework/node/NodeObjectCollection';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
    import { V2dGraphicSprite } from 'foundation/editor/view/view2d/render/V2dGraphicSprite';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { DrawingGraphDocumentService } from 'sk/data/family/service/DrawingGraphDocumentService';
    import { C2dSpatial } from "sk/editor/logic/view/canvas2d/C2dSpatial";
    export class C2dContent extends C2dSpatial {
        optionHotArea: boolean;
        optionTopview: boolean;
        nodeImage: V2dGraphicSprite;
        nodeHook: V2dGraphicDrawing;
        topviewUrl: string;
        statusTopview: boolean;
        private _statusTopviewChanged;
        optionDrawingGraph: boolean;
        nodeGraph: V2dGraphicDrawing;
        protected _statusTopviewImageChanged: boolean;
        curves: Curve2dNode[];
        statusGraphChanged: boolean;
        protected _statusGraphImageChanged: boolean;
        protected _drawingGraphDocumentService: DrawingGraphDocumentService;
        constructor();
        get statusTopviewChanged(): boolean;
        set statusTopviewChanged(statusTopviewChanged: boolean);
        onEditOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        testStyleChanged(event: DataNodeFieldEvent): boolean;
        onEntityReload(sender: ListenerContext, event: any): void;
        dirtyShape(): void;
        dirtyTopviewImage(): void;
        protected updateTopviewAsync(): Promise<void>;
        protected update2DTopViewAsync(): Promise<void>;
        getCurvesFromBreps(breps: NodeObjectCollection<DataNode>): Array<Curve2dNode>;
        protected updateGraphAsync(): Promise<void>;
        protected updateShape(): void;
        onLoadCompleted(): void;
        protected drawBoundary(graphics: V2dGraphicDrawing): void;
        protected updateStyleStatus(): void;
        protected updateImage(): void;
        protected updateGraph(): void;
        createNode(): any;
        canDraw(): boolean;
        protected drawUpdate(context?: DisplayContext): boolean;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/renderer/C2dTopviewResource" {
    import { C2dTopviewRenderable } from "sk/editor/logic/view/canvas2d/renderer/C2dTopviewRenderable";
    export class C2dTopviewResource extends PIXI.resources.Resource {
        renderable: C2dTopviewRenderable;
        upload(renderer: PIXI.Renderer, baseTexture: PIXI.BaseTexture, glTexture: PIXI.GLTexture): boolean;
    }
}
declare module "sk/editor/logic/view/canvas2d/renderer/C2dTopviewRenderable" {
    import { Size2 } from 'foundation/runtime/math/Size2';
    import { Size3 } from 'foundation/runtime/math/Size3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { BoundaryBox } from 'foundation/data/common/model/base/BoundaryBox';
    import { Display } from 'foundation/editor/view/base/Display';
    import { Renderable } from 'foundation/editor/view/graphic/Renderable';
    import { C2dRendererManager } from "sk/editor/logic/view/canvas2d/renderer/C2dRendererManager";
    import { C2dTopviewResource } from "sk/editor/logic/view/canvas2d/renderer/C2dTopviewResource";
    export class C2dTopviewRenderable extends Renderable {
        optionFlip: boolean;
        display: Display;
        rendererManager: C2dRendererManager;
        baseTexture: PIXI.BaseTexture;
        texture: PIXI.Texture;
        resource: C2dTopviewResource;
        pictureSize: Size2;
        handleMesh: SkNative.FStageMesh;
        useGeometryBox: boolean;
        meshBox: BoundaryBox;
        protected _size: Size3;
        protected _actualSize: Size3;
        protected _viewAxisUp: Vector3;
        protected _viewDirection: Vector3;
        constructor();
        get size(): Size3;
        get actualSize(): Size3;
        get viewAxisUp(): Vector3;
        get viewDirection(): Vector3;
        private getNearPowerValue;
        build(): void;
        uploadGeometry(geometry: BufferGeometry, meshBox?: BoundaryBox): void;
        protected updateTransform(): void;
        update(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/renderer/C2dRendererManager" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DrawingDevice } from 'cross/core/device/drawing/DrawingDevice';
    import { DrawingDeviceService } from 'cross/core/device/drawing/DrawingDeviceService';
    import { V2dRendererManager } from 'foundation/editor/view/view2d/renderer/V2dRendererManager';
    import { Display } from 'foundation/editor/view/base/Display';
    import { C2dTopview } from "sk/editor/logic/view/canvas2d/renderer/C2dTopview";
    import { C2dTopviewRenderable } from "sk/editor/logic/view/canvas2d/renderer/C2dTopviewRenderable";
    export class C2dRendererManager extends V2dRendererManager {
        canvas2d: DrawingDevice;
        handleParameters: SkNative.SRenderEngineRenderParameters;
        handleEngine: SkNative.FRenderEngine;
        handleView: SkNative.FStageView;
        handleScene: SkNative.FStageScene;
        handleCamera: SkNative.FStageOrthoCamera;
        handleProjection: SkNative.FStageOrthoProjection;
        handleMeshMaterial: SkNative.FStageMeshBasicMaterial;
        _topviews: Dictionary<C2dTopview>;
        _topviewRenderables: Dictionary<C2dTopviewRenderable>;
        protected _drawingDeviceService: DrawingDeviceService;
        setupAsync(): Promise<ResultObject>;
        createTopviewRenderable(display?: Display): C2dTopviewRenderable;
        loadTopviewAsync(resourceId: string): Promise<ResultObject<C2dTopview>>;
        loadTopviewRenderable(key: string, display?: Display): C2dTopviewRenderable;
        removeTopviewRenderable(key: string): void;
        drawRenderable(renderable: C2dTopviewRenderable): void;
    }
}
declare module "sk/editor/logic/view/LogicEditorConstants" {
    export class LogicEditorConstants {
        static ViewFamily: string;
        static ViewScheme: string;
        static ViewSchemeFamily: string;
        static ViewSchemeFamilyOrthogonal: string;
        static ViewExploded: string;
        static ViewArea: string;
        static ViewSurface: string;
        static ViewLevelingFloor: string;
        static ViewLevelingWall: string;
        static ViewDecorateWall: string;
        static ViewLevelingCeiling: string;
        static ViewAssembleCeiling: string;
        static ViewLevelingCompositeCeiling: string;
        static ViewFlatWall: string;
        static ViewPlane: string;
        static Curve: string;
        static ViewResource: string;
        static ViewBathroomLayout: string;
        static ViewBathroomFloor: string;
        static ViewBathroomWall: string;
        static ViewBathroomCeiling: string;
        static ViewIntegCeiling: string;
        static ViewHardwareRule: string;
        static ViewHandleRule: string;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dCameraController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { DisplayController } from 'foundation/editor/view/base/DisplayController';
    import { ObserverViewEntity } from 'foundation/editor/view/entity/ObserverViewEntity';
    import { CameraActionEvent } from "sk/editor/logic/action/camera/CameraActionEvent";
    export class C2dCameraController extends DisplayController {
        entity: ObserverViewEntity;
        onDragStart(sender: ListenerContext, event: CameraActionEvent): void;
        onDragMove(sender: ListenerContext, event: CameraActionEvent): void;
        onDispatchEvent(code: string, event: any): boolean;
        processCameraAction(event: CameraActionEvent): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dCamera" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
    import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
    import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
    import { V2dHookEvent } from 'foundation/editor/view/view2d/render/V2dHookEvent';
    import { V2dHookManager } from 'foundation/editor/view/view2d/render/V2dHookManager';
    import { ActionEvent } from 'foundation/editor/view/action/ActionEvent';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { Observer } from 'foundation/editor/view/base/Observer';
    import { ObserverViewEntity } from 'foundation/editor/view/entity/ObserverViewEntity';
    import { FamilyBlueprintNode } from 'sk/data/family/model/FamilyBlueprintNode';
    import { C2dCameraController } from "sk/editor/logic/view/canvas2d/C2dCameraController";
    import { C2dCanvas } from "sk/editor/logic/view/canvas2d/C2dCanvas";
    import { C2dCanvasContext } from "sk/editor/logic/view/canvas2d/C2dCanvasContext";
    import { C2dCanvasEvent } from "sk/editor/logic/view/canvas2d/C2dCanvasEvent";
    import { C2dLayer } from "sk/editor/logic/view/canvas2d/C2dLayer";
    enum C2dCameraDragModeEnum {
        ModeDragBody = 0,
        ModeDragStart = 1,
        ModeDragEnd = 2
    }
    export class C2dCamera extends Observer {
        context: C2dCanvasContext;
        blueprint: FamilyBlueprintNode;
        entity: ObserverViewEntity;
        view: C2dCanvas;
        layer: C2dLayer;
        controller: C2dCameraController;
        node: V2dGraphicContainer;
        noScaleNode: V2dGraphicContainer;
        scaleNode: V2dGraphicContainer;
        protected _modeCd: C2dCameraDragModeEnum;
        protected _startPoint: Vector2;
        protected _currentPoint: Vector2;
        protected _nodeCameraFan: V2dGraphicDrawing;
        protected _nodeCameraClippingNearLine: V2dGraphicDrawing;
        protected _nodeRenderCameraFan: V2dGraphicDrawing;
        protected _nodeBeginCircle: V2dGraphicDrawing;
        protected _nodeBeginOverCircle: V2dGraphicDrawing;
        protected _nodeEndCircle: V2dGraphicDrawing;
        protected _nodeEndOverCircle: V2dGraphicDrawing;
        protected _nodeSceneContainer: V2dGraphicContainer;
        protected _statusDragging: boolean;
        protected _needRedraw: boolean;
        protected _fanX0: number;
        protected _fanY0: number;
        protected _fanX1: number;
        protected _fanY1: number;
        protected _startAngle: number;
        protected _camAngle: number;
        protected _fanRadius: number;
        protected _fanAngle: number;
        private baseColor;
        protected _hookManager: V2dHookManager;
        private beforCursor;
        private _angleText;
        private _tmpTextPosition;
        constructor();
        setup(): void;
        canDraw(): boolean;
        onActionStarting(sender: ListenerContext, event: ActionEvent): void;
        onActionTerminated(sender: ListenerContext, event: ActionEvent): void;
        onViewBoxChanged(sender: ListenerContext, event: any): void;
        onCanvasSizeChanged(): void;
        onSceneScaleChanged(sender: ListenerContext, event: C2dCanvasEvent): void;
        onCanvasFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        private onDragStart;
        onDragMove(sender: ListenerContext, event: V2dHookEvent): void;
        private snapYaw;
        onDragEnd(sender: ListenerContext, event: V2dHookEvent): void;
        onFanEvent(sender: ListenerContext, event: V2dHookEvent): void;
        onFanBeginEvent(sender: ListenerContext, event: V2dHookEvent): void;
        onFanEndEvent(sender: ListenerContext, event: V2dHookEvent): void;
        switchObserver(entity: ObserverViewEntity): void;
        bindEvent(): void;
        unbindEvent(): void;
        private updateFan;
        private updateField;
        private getRenderCameraData;
        private updateNodeRenderCameraFan;
        private updateNodeCameraClippingNearLine;
        private drawCameraPath;
        private compute;
        private drawEnd;
        updateCamera(radius: number): void;
        private updateCircle;
        private drawText;
        createNode(): void;
        onDraw(displayContext: DisplayContext): void;
        hide(): void;
        show(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dCanvasController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Thread } from 'cross/runtime/module/thread/Thread';
    import { ThreadService } from 'cross/runtime/module/thread/ThreadService';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { BoundaryRect } from 'foundation/data/common/model/base/BoundaryRect';
    import { FrameEvent } from 'foundation/editor/base/core/FrameEvent';
    import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
    import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
    import { V2dHook } from 'foundation/editor/view/view2d/render/V2dHook';
    import { V2dHookEvent } from 'foundation/editor/view/view2d/render/V2dHookEvent';
    import { ActionService } from 'foundation/editor/view/action/ActionService';
    import { CanvasController } from 'foundation/editor/view/base/CanvasController';
    import { ContentController } from 'foundation/editor/view/base/ContentController';
    import { C2dCanvas } from "sk/editor/logic/view/canvas2d/C2dCanvas";
    import { C2dCanvasContext } from "sk/editor/logic/view/canvas2d/C2dCanvasContext";
    export class C2dCanvasController extends CanvasController {
        context: C2dCanvasContext;
        canvas: C2dCanvas;
        protected sceneContainer: V2dGraphicContainer;
        protected backgroundHook: V2dHook;
        protected sceneHook: V2dHook;
        protected _targetPos: Vector2;
        protected _targetScale: number;
        protected wheelSpeed: number;
        protected _scenePoint: Vector2;
        protected _mousePoint: Vector2;
        protected _statusDragging: boolean;
        protected _statusScaling: boolean;
        contentControllerClass: any;
        contentController: ContentController;
        protected _zoomDelayThread: Thread;
        protected _actionService: ActionService;
        protected _threadService: ThreadService;
        constructor();
        setup(): void;
        onFrameEnter(context: ListenerContext, event: FrameEvent): void;
        private onGridMouseDown;
        private onGridClick;
        setGridBackground(graphics: V2dGraphicDrawing): void;
        private onSceneMouseDown;
        private onSceneMouseMove;
        onSceneMouseUp(sender: ListenerContext, event: V2dHookEvent): void;
        onSceneDragStart(sender: ListenerContext, event: V2dHookEvent): void;
        onSceneDragMove(sender: ListenerContext, event: V2dHookEvent): void;
        onZoomDelay(sender: ListenerContext, event: any): void;
        private onMouseWheel;
        setSceneContainer(scene: V2dGraphicContainer): void;
        setScene(mx: number, my: number, scale: number, speed?: number): void;
        updateSceneProcess(scale: Value2): void;
        updateSceneComplete(scale: Value2): void;
        setScale(sx: number, centerX: number, centerY: number, complete?: boolean, fitScreen?: boolean, width?: number, height?: number): void;
        addContent(content: any): void;
        removeContent(content: any): void;
        scaleSceneCenter(scale: number): void;
        fitScreen3D(): void;
        fitScreen(width?: number, height?: number, scaleRatio?: number): void;
        getSceneScale(): number;
        createScreenshot(size: Vector2, callback: any): void;
        createScreenshotFromBoundary(boundary: BoundaryRect, size: Vector2, callback: any): void;
        boundaryFitScreen(boundary: BoundaryRect, currentScale?: number, size?: Vector2): void;
        zoomToAdaptiveSize(params: any, boundaryRect: BoundaryRect): void;
        zoomin(): void;
        zoomout(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/gizmo/C2dGizmoFactory" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { Gizmo } from 'foundation/editor/view/base/gizmo/Gizmo';
    import { GizmoFactory } from 'foundation/editor/view/base/gizmo/GizmoFactory';
    import { C2dCanvas } from "sk/editor/logic/view/canvas2d/C2dCanvas";
    export class C2dGizmoFactory extends GizmoFactory {
        canvas: C2dCanvas;
        setupGizmo(gizmo: Gizmo, entity: DataNode): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/selection/C2dSelectorController" {
    import { V2dSelectorController } from 'foundation/editor/view/view2d/selection/V2dSelectorController';
    export class C2dSelectorController extends V2dSelectorController {
    }
}
declare module "sk/editor/logic/view/canvas2d/selection/C2dSelector" {
    import { V2dSelector } from 'foundation/editor/view/view2d/selection/V2dSelector';
    import { V3dPicker } from 'foundation/editor/view/view3d/selection/V3dPicker';
    import { V3dSelectorEvent } from 'foundation/editor/view/view3d/selection/V3dSelectorEvent';
    import { DisplayEventEnum } from 'foundation/editor/view/base/DisplayEventEnum';
    import { C2dCanvasContext } from "sk/editor/logic/view/canvas2d/C2dCanvasContext";
    import { C2dSelectorController } from "sk/editor/logic/view/canvas2d/selection/C2dSelectorController";
    export class C2dSelector extends V2dSelector {
        context: C2dCanvasContext;
        controller: C2dSelectorController;
        picker: V3dPicker;
        setup(): void;
        processEvent(eventCd: DisplayEventEnum, event: V3dSelectorEvent): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dCanvasOptions" {
    import { CanvasOptions } from 'foundation/editor/view/base/CanvasOptions';
    export class C2dCanvasOptions extends CanvasOptions {
        static FIELD_POSITION_SCALE: string;
        sceneControllerClass: any;
        positionScale: number;
        scaleFactor: number;
        constructor();
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dGrid" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
    import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
    import { Display } from 'foundation/editor/view/base/Display';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { GridEntity } from 'foundation/editor/view/entity/GridEntity';
    import { C2dCanvas } from "sk/editor/logic/view/canvas2d/C2dCanvas";
    import { C2dCanvasContext } from "sk/editor/logic/view/canvas2d/C2dCanvasContext";
    import { C2dCanvasEvent } from "sk/editor/logic/view/canvas2d/C2dCanvasEvent";
    import { C2dLayer } from "sk/editor/logic/view/canvas2d/C2dLayer";
    export class C2dGridLevel {
        graphics: V2dGraphicDrawing;
        step: number;
        widthHalf: number;
        heightHalf: number;
        constructor(graphics: any, step: any, widthHalf: any, heightHalf: any);
        change(visible: boolean, alpha: number, position: boolean, x: number, y: number): void;
    }
    export class C2dGrid extends Display {
        context: C2dCanvasContext;
        entity: GridEntity;
        view: C2dCanvas;
        layer: C2dLayer;
        node: V2dGraphicContainer;
        protected _sceneContainer: V2dGraphicContainer;
        protected _layers: Array<C2dGridLevel>;
        gridSize: number;
        levelSteps: Array<number>;
        levelColors: Array<number>;
        protected _scale: number;
        constructor();
        setup(): void;
        get scale(): number;
        onViewBoxChanged(event: PIXI.interaction.InteractionEvent): void;
        onSceneScaleChanged(sender: ListenerContext, event: C2dCanvasEvent): void;
        onFloorplanFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        createNode(): V2dGraphicContainer;
        onDraw(context?: DisplayContext): void;
        show(): void;
        hide(): void;
        reset(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dCanvas" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DocumentEvent } from 'cross/runtime/framework/document/DocumentEvent';
    import { ViewContext } from 'cross/runtime/framework/view/ViewContext';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { RenderService } from 'foundation/editor/view/base/render/RenderService';
    import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
    import { V2dCanvas } from 'foundation/editor/view/view2d/V2dCanvas';
    import { FamilyBlueprintNode } from 'sk/data/family/model/FamilyBlueprintNode';
    import { PixiBatchMeshManager } from 'sk/editor/render/pixi/PixiBatchMeshManager';
    import { PixiGraphics } from 'sk/editor/render/pixi/PixiGraphics';
    import { C2dCanvasContext } from "sk/editor/logic/view/canvas2d/C2dCanvasContext";
    import { C2dCanvasController } from "sk/editor/logic/view/canvas2d/C2dCanvasController";
    import { C2dCanvasOptions } from "sk/editor/logic/view/canvas2d/C2dCanvasOptions";
    import { C2dGrid } from "sk/editor/logic/view/canvas2d/C2dGrid";
    import { C2dLayers } from "sk/editor/logic/view/canvas2d/C2dLayers";
    export class C2dCanvas extends V2dCanvas {
        options: C2dCanvasOptions;
        context: C2dCanvasContext;
        layers: C2dLayers;
        controller: C2dCanvasController;
        blueprint: FamilyBlueprintNode;
        rootStage: V2dGraphicContainer;
        batchMeshManager: PixiBatchMeshManager;
        grid: C2dGrid;
        maskGraphic: PixiGraphics;
        protected _renderService: RenderService;
        left: number;
        right: number;
        top: number;
        bottom: number;
        protected _width: number;
        protected _height: number;
        private viewArea;
        private _canvasFirstDisplay;
        constructor();
        get width(): number;
        get height(): number;
        get isMainView(): boolean;
        countCanvasSize(): boolean;
        createContext(): C2dCanvasContext;
        onSetupAsync(): Promise<ResultObject>;
        get bgImage(): any;
        setCanvasMask(container: any): void;
        refreshMaskSize(): void;
        getViewAreaRect(isModelSpace?: boolean): any;
        getModelPointFromScreen(screenX: number, screenY: number): Vector2;
        moveCanvas(x: number, y: number): void;
        refreshWindowSize(): void;
        onNewDesign(sender: ListenerContext, event: DocumentEvent): void;
        onOpenDesign(sender: ListenerContext, event: DocumentEvent): void;
        onRefreshDesign(sender: ListenerContext, event: DocumentEvent, dirtyBlueprint?: boolean): void;
        onBlueprintFiledChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        setVisible(visible: boolean): void;
        show(): void;
        private resetSceneScale;
        onResize(): void;
        openBlueprint(blueprint: FamilyBlueprintNode): void;
        closeBlueprint(): void;
        process(viewContext: ViewContext): void;
        reset(): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dCanvasContext" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
    import { ActionService } from 'foundation/editor/view/action/ActionService';
    import { ContentDisplay } from 'foundation/editor/view/base/ContentDisplay';
    import { CursorStatus } from 'foundation/editor/view/base/CursorStatus';
    import { CursorStatusController } from 'foundation/editor/view/base/CursorStatusController';
    import { V2dCanvasContext } from 'foundation/editor/view/view2d/V2dCanvasContext';
    import { PixiBatchMeshManager } from 'sk/editor/render/pixi/PixiBatchMeshManager';
    import { C2dCanvas } from "sk/editor/logic/view/canvas2d/C2dCanvas";
    import { C2dCanvasController } from "sk/editor/logic/view/canvas2d/C2dCanvasController";
    import { C2dCanvasOptions } from "sk/editor/logic/view/canvas2d/C2dCanvasOptions";
    import { C2dLayers } from "sk/editor/logic/view/canvas2d/C2dLayers";
    export class C2dCanvasContext extends V2dCanvasContext {
        options: C2dCanvasOptions;
        canvas: C2dCanvas;
        layers: C2dLayers;
        document: DataDocument;
        rootStage: V2dGraphicContainer;
        contents: Array<ContentDisplay>;
        protected _boundingClientRect: any;
        cursorStatus: CursorStatus;
        cursorStatusCotroller: CursorStatusController;
        canvasController: C2dCanvasController;
        batchMeshManager: PixiBatchMeshManager;
        protected _actionService: ActionService;
        constructor();
        setup(): void;
        getWidth(): number;
        getHeight(): number;
        getScaleSize(): number;
        getContentLevel(display: ContentDisplay): number;
        onMouseEvent(sender: ListenerContext, event: MouseDeviceEvent): void;
        showMessage(message: string, ...parameters: Array<any>): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dUtil" {
    import { Bound2 } from 'foundation/runtime/math/Bound2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
    import { V2dGraphicText } from 'foundation/editor/view/view2d/render/V2dGraphicText';
    import { V2dUtil } from 'foundation/editor/view/view2d/V2dUtil';
    import { C2dCanvasContext } from "sk/editor/logic/view/canvas2d/C2dCanvasContext";
    export class C2dUtil extends V2dUtil {
        static modelToCanvas1(context: C2dCanvasContext, size: number): number;
        static modelToCanvas2(context: C2dCanvasContext, point: Value2, target?: Vector2): Vector2;
        static modelPointToScreen(context: C2dCanvasContext, point: Value2, target?: Vector2): Vector2;
        static modelLengthToScreenLength(context: C2dCanvasContext, length: number): number;
        static canvasPointToScreen(context: C2dCanvasContext, point: Value2, target?: Vector2): Vector2;
        static canvasLengthToScreenLength(context: C2dCanvasContext, length: number): number;
        static screenLengthToCanvasLength(context: C2dCanvasContext, length: number): number;
        static screenLengthToModelLength(context: C2dCanvasContext, length: number): number;
        static screenPointToCanvas(context: C2dCanvasContext, point: Value2, target?: Vector2): Vector2;
        static screenPointToModel(context: C2dCanvasContext, point: Value2, target?: Vector2): Vector2;
        static buildContentBound2(context: C2dCanvasContext, content: ContentNode, bound?: Bound2): Bound2;
        static buildContentBound2_XZ(context: C2dCanvasContext, content: ContentNode, bound?: Bound2): Bound2;
        static buildContentBound2_YZ(context: C2dCanvasContext, content: ContentNode, bound?: Bound2): Bound2;
        protected static getContainerLine(content: ContentNode): Line2;
        static buildContentBound2Matrix(context: C2dCanvasContext, content: ContentNode, matrix: Matrix4, bound?: Bound2): Bound2;
        static setTextFitSize(context: C2dCanvasContext, text: V2dGraphicText, size: number): boolean;
        static contextOffsetFromBody(context: C2dCanvasContext): Vector2;
        static countContainerPosition(con: V2dGraphicContainer, mx: number, my: number, sx: number, sx2: number, target?: Vector2): Vector2;
    }
}
declare module "sk/editor/logic/entity/PipeEntity" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
    import { LineCurve2dElement } from 'sk/data/family/element/brep/geometric/curve2d/LineCurve2dElement';
    import { PipeNode } from 'sk/data/family/database/plumbing/model/PipeNode';
    import { PointElement } from 'sk/data/family/element/brep/geometric/PointElement';
    import { WareElement } from 'sk/data/family/element/instance/WareElement';
    import { WareNode } from 'sk/data/family/model/instance/WareNode';
    export class SegData {
        start: PointData;
        end: PointData;
        elem: LineCurve2dElement;
        constructor();
    }
    export class PointData {
        pos: Vector3;
        elem: PointElement;
        constructor();
    }
    export class InterfaceData {
        static TYPE_PLUGIN: number;
        static TYPE_SOCKET: number;
        type: number;
        pos: Vector3;
        elem: WareElement;
        constructor();
    }
    export class InterfaceList {
        interfaceDataList: any;
        constructor();
        dispose(): void;
    }
    export class PipeEntity extends PipeNode {
        static FIELD_MATERIAL_GUID: string;
        context: any;
        startNode: WareNode;
        endNode: WareNode;
        _segList: Types<SegData>;
        _pointList: Types<PointData>;
        _startInterfaceList: InterfaceList;
        _endInterfaceList: InterfaceList;
        protected socketColor: any;
        protected pluginColor: any;
        protected hlColor: any;
        protected segWidth: any;
        protected lineAlpha: any;
        protected segColor: any;
        protected pointColor: any;
        protected interfaceR: any;
        protected pointLineWidth: any;
        protected pointR: any;
        protected factor: any;
        protected _highLightPointIdx: number;
        protected _highLightSegIdx: number;
        constructor();
        updateData(): void;
        setEditMode(isEditMode: boolean): void;
        updateInterfaceListData(): void;
        protected updateInterfaceData(node: WareNode, interfaceList: InterfaceList): void;
        draw2D(graphics: V2dGraphicDrawing, context: any): void;
        protected drawSegList2D(graphics: V2dGraphicDrawing): void;
        protected drawPointList2D(graphics: V2dGraphicDrawing): void;
        protected drawInterfaceList2D(graphics: V2dGraphicDrawing): void;
        protected drawInterfaceData(graphics: V2dGraphicDrawing, interfaceList: InterfaceList): void;
        hasChildren(): boolean;
        get highLightSegIdx(): number;
        set highLightSegIdx(value: number);
        get highLightPointIdx(): number;
        set highLightPointIdx(value: number);
        addPointData(pointData: PointData): void;
        getPointIndexByPos(x: number, y: number): number;
        findPointDataByPos(pos: Vector3): PointData;
        getSegHasStartPoint(pd: PointData): SegData;
        getSegHasEndPoint(pd: PointData): SegData;
        getStartInterfaceIndexByPos(x: number, y: number): number;
        getEndInterfaceIndexByPos(x: number, y: number): number;
        isStartPoint(pos: Vector3): boolean;
        isEndPoint(pos: Vector3): boolean;
        findPointByPos(pos: Vector3): PointData;
        removePointData(pointData: PointData): void;
        addSegData(segData: SegData): void;
        removeSegData(pointStart: PointData, pointEnd: PointData): void;
        findSegData(pointStart: PointData, pointEnd: PointData): SegData;
        getPointDataFromIndex(index: number): PointData;
        getSegDataFromIndex(index: number): SegData;
        segCount(): number;
        getStartInterfaceFromIndex(index: number): InterfaceData;
        getEndInterfaceFromIndex(index: number): InterfaceData;
        getHighLightSegIndexFromPos(x: number, y: number): number;
        getPointByPos(x: number, y: number): number;
    }
}
declare module "sk/editor/logic/entity/PlaneEntity" {
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    export class PlaneEntity extends PlaneNode {
    }
}
declare module "sk/editor/logic/entity/PointLightEntity" {
    import { PointLightNode } from 'sk/data/scheme/database/light/model/PointLightNode';
    export class PointLightEntity extends PointLightNode {
        constructor();
    }
}
declare module "sk/editor/logic/entity/SphereSolidEntity" {
    import { SphereSolidNode } from 'foundation/data/common/model/brep/geometric/solid/SphereSolidNode';
    export class SphereSolidEntity extends SphereSolidNode {
        setup(): void;
        get geometry(): any;
    }
}
declare module "sk/editor/logic/entity/SpotLightEntity" {
    import { SpotLightNode } from 'sk/data/scheme/database/light/model/SpotLightNode';
    export class SpotLightEntity extends SpotLightNode {
        constructor();
    }
}
declare module "sk/editor/logic/entity/TechnologyCavityEntity" {
    import { TechnologyCavityNode } from 'sk/data/family/database/technology/model/TechnologyCavityNode';
    export class TechnologyCavityEntity extends TechnologyCavityNode {
        constructor();
    }
}
declare module "sk/editor/logic/entity/TechnologyEntity" {
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    export class TechnologyEntity extends TechnologyNode {
        constructor();
    }
}
declare module "sk/editor/logic/entity/TechnologyGrooveEntity" {
    import { TechnologyGrooveNode } from 'sk/data/family/database/technology/model/TechnologyGrooveNode';
    export class TechnologyGrooveEntity extends TechnologyGrooveNode {
        constructor();
    }
}
declare module "sk/editor/logic/entity/TechnologyHoleEntity" {
    import { TechnologyHoleNode } from 'sk/data/family/database/technology/model/TechnologyHoleNode';
    export class TechnologyHoleEntity extends TechnologyHoleNode {
    }
}
declare module "sk/editor/logic/entity/TechnologyMillingEntity" {
    import { TechnologyMillingNode } from 'sk/data/family/database/technology/model/TechnologyMillingNode';
    export class TechnologyMillingEntity extends TechnologyMillingNode {
        constructor();
    }
}
declare module "sk/editor/logic/entity/TechnologyMillingTrackEntity" {
    import { TechnologyMillingTrackNode } from 'sk/data/family/database/technology/model/TechnologyMillingTrackNode';
    export class TechnologyMillingTrackEntity extends TechnologyMillingTrackNode {
        constructor();
    }
}
declare module "sk/editor/logic/entity/VisionBoxSolidEntity" {
    import { BoxGeometry } from 'foundation/runtime/graphics/shape/geometry/BoxGeometry';
    import { VisionBoxSolidNode } from 'foundation/data/common/model/brep/vision/solid/VisionBoxSolidNode';
    export class VisionBoxSolidEntity extends VisionBoxSolidNode {
        protected _geometry: BoxGeometry;
        get geometry(): BoxGeometry;
    }
}
declare module "sk/editor/logic/entity/VisionGridModelEntity" {
    import { VisionGridModelNode } from 'foundation/data/common/model/brep/vision/VisionGridModelNode';
    export class VisionGridModelEntity extends VisionGridModelNode {
    }
}
declare module "sk/editor/logic/entity/VisionLineModelEntity" {
    import { VisionLineModelNode } from 'foundation/data/common/model/brep/vision/VisionLineModelNode';
    export class VisionLineModelEntity extends VisionLineModelNode {
    }
}
declare module "sk/editor/logic/entity/VisionModelEntity" {
    import { VisionModelNode } from 'foundation/data/common/model/brep/vision/VisionModelNode';
    export class VisionModelEntity extends VisionModelNode {
    }
}
declare module "sk/editor/logic/entity/VisionSphereSolidEntity" {
    import { SphereGeometry } from 'foundation/runtime/graphics/shape/geometry/SphereGeometry';
    import { VisionSphereSolidNode } from 'foundation/data/common/model/brep/vision/solid/VisionSphereSolidNode';
    export class VisionSphereSolidEntity extends VisionSphereSolidNode {
        protected _geometry: SphereGeometry;
        get geometry(): SphereGeometry;
    }
}
declare module "sk/editor/logic/service/ActionMessageEvent" {
    export class ActionMessageEvent {
        eventType: string;
        message: string;
    }
}
declare module "sk/editor/logic/service/ActionMessageEventEnum" {
    export class ActionMessageEventEnum {
        static Success: string;
        static Failure: string;
        static Message: string;
        static Warning: string;
        static Loading: string;
    }
}
declare module "sk/editor/logic/service/ActionMessageService" {
    import { Service } from 'cross/runtime/module/Service';
    export class ActionMessageService extends Service {
        constructor();
        successMessage(sender: any, message: string, key?: string, duration?: number): void;
        failMessage(sender: any, message: string, key?: string, duration?: number): void;
        message(sender: any, message: string, key?: string, duration?: number): void;
        warnMessage(sender: any, message: string, key?: string, duration?: number): void;
        loading(sender: any, message: string, key?: string, duration?: number): void;
    }
}
declare module "sk/editor/logic/service/AliveService" {
    import { InvokeThread } from 'cross/runtime/module/thread/InvokeThread';
    import { ThreadService } from 'cross/runtime/module/thread/ThreadService';
    import { Service } from 'cross/runtime/module/Service';
    import { WorkerConnectionService } from 'foundation/core/module/workerconnection/WorkerConnectionService';
    export class AliveService extends Service {
        protected _thread: InvokeThread;
        protected _threadService: ThreadService;
        protected _workerConnectionService: WorkerConnectionService;
        constructor();
        onActive(): void;
        onDeactive(): void;
        pause(): void;
        resume(): void;
        onHeartBeatAsync(): Promise<void>;
        protected sendWorkerHeartBeatMessage(actionCd: string): Promise<void>;
    }
}
declare module "sk/editor/logic/snap/SnapOptions" {
    import { Line3 } from 'foundation/runtime/math/Line3';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { Polygon } from 'foundation/runtime/graphics/shape/brep/Polygon';
    import { CanvasContext } from 'foundation/editor/view/base/CanvasContext';
    export class SnapOptions {
        ignoreSnapOffset: boolean;
        snapOffset: number;
        autoFitEnable: boolean;
        keepZAxis: boolean;
        toWorkFace: boolean;
        vectors: Array<Line3>;
        defaultGround: any;
        mousePoint2d: Vector2;
        localOffset: Vector2;
        polygon: Array<Vector3>;
        polygon2d: Polygon;
        wallSnapEnable: boolean;
        ceilingSnapEnable: boolean;
        contentSnapEnable: boolean;
        floorSnapEnable: boolean;
        contentFaceSnappingEnable: boolean;
        isAxisMove: boolean;
        baseLocalOffset: Vector2;
        surfaceEntity2dPoint: Vector2;
        context: CanvasContext;
    }
}
declare module "sk/editor/logic/snap/SnapConfig" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
    import { SnapOptions } from "sk/editor/logic/snap/SnapOptions";
    export class SnapConfig extends SnapOptions {
        historyResponse: any;
        ctrlKey: boolean;
        altKey: boolean;
        modelToScreen: number;
        localCenterPos: Vector2;
        addToMove: boolean;
        stepName: string;
        info: ISpecificationFamilyInfo;
        host: any;
        threeD: boolean;
    }
}
declare module "sk/editor/logic/snap/strategy/Strategy" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { FloorplanNode } from 'sk/data/scheme/database/floorplan/model/FloorplanNode';
    import { SchemeBlueprintNode } from 'sk/data/scheme/model/SchemeBlueprintNode';
    import { SnapConfig } from "sk/editor/logic/snap/SnapConfig";
    import { SnapOptions } from "sk/editor/logic/snap/SnapOptions";
    export class Strategy extends InstanceObject {
        floorplan: FloorplanNode;
        entity: DataNode;
        snapOffset: number;
        autoFitEnable: boolean;
        blueprint: SchemeBlueprintNode;
        protected _options: SnapConfig;
        constructor(entity: DataNode);
        doSnapping(options: SnapOptions): any;
        protected isFloorplanContent(): boolean;
        isActionSend(): boolean;
        cancelUndoRedo(): boolean;
        onExecute(): void;
        onUndoAsync(): Promise<ResultObject<any>>;
        onRedoAsync(): Promise<ResultObject<any>>;
        setup(options: SnapOptions): void;
        newVersionSetUp(options: SnapConfig): void;
    }
}
declare module "sk/editor/logic/snap/SnapService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Service } from 'cross/runtime/module/Service';
    import { Strategy } from "sk/editor/logic/snap/strategy/Strategy";
    export type SnapDeclareInfo = {
        instanceClass: any;
        strategyClass: any;
    };
    export class SnapService extends Service {
        protected _declares: Types<SnapDeclareInfo>;
        findDeclareByClass(instanceClass: any): SnapDeclareInfo;
        findDeclareByInstance(instance: any): SnapDeclareInfo;
        registerDeclare(instanceClass: any, snapClass: any): void;
        createStrategy(instance: any): Strategy;
    }
}
declare module "sk/editor/logic/snap/SnapDeclare" {
    export function SnapDeclare(instanceClass: any): (target: any) => void;
}
declare module "sk/editor/logic/snap/Snaper" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContentInstanceNode } from 'sk/data/family/model/instance/ContentInstanceNode';
    import { RoomElement } from 'sk/data/scheme/database/floorplan/element/RoomElement';
    import { Strategy } from "sk/editor/logic/snap/strategy/Strategy";
    import { SnapOptions } from "sk/editor/logic/snap/SnapOptions";
    import { SnapService } from "sk/editor/logic/snap/SnapService";
    export class Snaper extends InstanceObject {
        strategies: Array<Strategy>;
        entity: ContentNode;
        options: any;
        protected _snapService: SnapService;
        isCurrentVersion: boolean;
        constructor(entity: ContentNode);
        setup(): Array<Strategy>;
        calOffsetTopBasePos(roomElem: RoomElement, offset: Vector3, entity: ContentInstanceNode, basePos: Vector3, calWorkdis: boolean): Vector3;
        doSnapping(options?: SnapOptions): Array<any>;
        isActionSend(): boolean;
        cancelUndoRedo(): boolean;
        onExecute(): void;
        onUndoAsync(): Promise<ResultObject<any>>;
        onRedoAsync(): Promise<ResultObject<any>>;
        dispose(flag?: boolean): void;
    }
}
declare module "sk/editor/logic/snap/strategy/CompositeStrategy" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { SnapOptions } from "sk/editor/logic/snap/SnapOptions";
    import { Strategy } from "sk/editor/logic/snap/strategy/Strategy";
    export class CompositeStrategy extends Strategy {
        strategies: Array<Strategy>;
        constructor(entity: DataNode, strategies?: Array<Strategy>);
        doSnapping(options: SnapOptions): void;
    }
}
declare module "sk/editor/logic/snap/strategy/NormalStrategy" {
    import { SnapOptions } from "sk/editor/logic/snap/SnapOptions";
    import { CompositeStrategy } from "sk/editor/logic/snap/strategy/CompositeStrategy";
    export class NormalStrategy extends CompositeStrategy {
        doSnapping(options: SnapOptions): Array<any>;
    }
}
declare module "sk/editor/logic/snap/strategy/WholeStrategy" {
    import { SnapOptions } from "sk/editor/logic/snap/SnapOptions";
    import { CompositeStrategy } from "sk/editor/logic/snap/strategy/CompositeStrategy";
    export class WholeStrategy extends CompositeStrategy {
        doSnapping(options: SnapOptions): Array<any>;
    }
}
declare module "sk/editor/logic/ui/base/UiLogicContainer" {
    import { UiContainer, UiContainerProps, UiContainerState } from 'foundation/editor/ui/core/UiContainer';
    export interface UiLogicContainerProps extends UiContainerProps {
        style?: any;
    }
    export interface UiLogicContainerState extends UiContainerState {
    }
    export class UiLogicContainer<P extends UiLogicContainerProps = any, S extends UiLogicContainerState = any> extends UiContainer<P, S> {
    }
}
declare module "sk/editor/logic/ui/base/UiLogicControl" {
    import { UiControl, UiControlProps, UiControlState } from 'foundation/editor/ui/core/UiControl';
    export interface UiLogicControlProps extends UiControlProps {
        style?: any;
    }
    export interface UiLogicControlState extends UiControlState {
    }
    export class UiLogicControl<P extends UiLogicControlProps = any, S extends UiLogicControlState = any> extends UiControl<P, S> {
    }
}
declare module "sk/editor/logic/ui/base/UiSafeLogicContainer" {
    import { UiSafeContainer, UiSafeContainerProps, UiSafeContainerState } from 'foundation/editor/ui/core/UiSafeContainer';
    export interface UiSafeLogicContainerProps extends UiSafeContainerProps {
    }
    export interface UiSafeLogicContainerState extends UiSafeContainerState {
    }
    export class UiSafeLogicContainer<P extends UiSafeLogicContainerProps = any, S extends UiSafeLogicContainerState = any> extends UiSafeContainer<P, S> {
    }
}
declare module "sk/editor/logic/ui/base/UiSafeLogicControl" {
    import { UiSafeControl, UiSafeControlProps, UiSafeControlState } from 'foundation/editor/ui/core/UiSafeControl';
    export interface UiSafeLogicControlProps extends UiSafeControlProps {
        style?: any;
    }
    export interface UiSafeLogicControlState extends UiSafeControlState {
    }
    export class UiSafeLogicControl<P extends UiSafeLogicControlProps = any, S extends UiSafeLogicControlState = any> extends UiSafeControl<P, S> {
    }
}
declare module "sk/editor/logic/ui/component/util/UiFormulaDataUtil" {
    import { ElementNode } from 'foundation/data/common/element/ElementNode';
    import { VariableService } from 'sk/data/family/element/config/variable/VariableService';
    export enum FormulaDataMentionsTypeEnum {
        Features = "features",
        ElementProperty = "elementProperty",
        SystemVariable = "systemVariable",
        GlobalVariable = "globalVariable",
        DataBaseVariable = "dataBaseVariable",
        DocumentVariable = "documentVariable",
        Unknown = "Unknown"
    }
    export class FormulaDataSearchInfo {
        id: string;
        code: string;
        name: string;
        value: string;
        type: string;
    }
    export type FormulaDataSearcResult = Array<FormulaDataSearchInfo>;
    export class UiFormulaDataUtil {
        protected static _systemConfigVariableService: VariableService;
        static dataMasterFeaturesSearchAsync(str: string, selectElement: any, callBack: any): Promise<FormulaDataSearcResult>;
        static dataElementPropertySearch(str: string, ele: ElementNode, callBack: any): FormulaDataSearcResult;
        static dataSystemVariableSearch(str: string, callBack: any): FormulaDataSearcResult;
        static dataCustomVariableSearchAsync(str: string, selectElement: any, callBack: any): Promise<FormulaDataSearcResult>;
        static mentionsDataSearch(str: string, type: FormulaDataMentionsTypeEnum, selectElement?: ElementNode, callBack?: any): FormulaDataSearcResult;
        static checkDataMentionType(str: string): FormulaDataMentionsTypeEnum;
    }
}
declare module "sk/editor/logic/ui/component/util/UiFormulaStringUtil" {
    export const FormulaSplitter: string;
    export class UiFormulaStringUtil {
        static getInputSelectStart(input: any): number;
        static getInputSelectEnd(input: any): number;
        static getInputSelectString(input: any): string;
        static setInputSelectStart(input: any, index: number): void;
        static setInputSelectEnd(input: any, index: number): void;
        static stringInsertValueByIndex(value: string, index: number, insertValue: string): string;
        static pickFormulaTargetString(inputValue: string): string | boolean;
    }
}
declare module "sk/editor/logic/ui/component/UiFormulaInputContentReminder" {
    import * as React from 'react';
    interface UiFormulaInputContentReminderProps {
        title: string;
        info: Array<{
            "insertValue": string;
            "buttonDescription": string;
            "name": string;
            "grammar": string;
            "example": string;
        }>;
        parentHandleButtonClick(string: any): any;
        setButtonDescription(content: JSX.Element): any;
    }
    export class UiFormulaInputContentReminder extends React.Component<UiFormulaInputContentReminderProps> {
        handleButtonClick(clickString: string, e: any): void;
        handleMouseEnter(value: {
            "insertValue": string;
            "buttonDescription": string;
            "name": string;
            "grammar": string;
            "example": string;
        }, e: any): void;
        handleMouseLeave(e: any): void;
        makeButtonArray(array: any, key_i: any): any;
        makeRowArray(info: Array<{
            "insertValue": string;
            "buttonDescription": string;
            "name": string;
            "grammar": string;
            "example": string;
        }>): Array<any>;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/component/UiFormulaInputListContentReminder" {
    import * as React from 'react';
    interface UiFormulaInputListContentReminderProps {
        title: string;
        codeArray: Array<{
            "code": string;
            "value": string;
        }>;
        inserListContent(): any;
        setCurrentContent(string: any): any;
        children?: any;
    }
    export class UiFormulaInputListContentReminder extends React.Component<UiFormulaInputListContentReminderProps> {
        state: {
            currentIndex: number;
        };
        addParameterToTextArea: (insertString: string) => void;
        setCurrentIndex: (index: any, item: {
            "code": string;
            "value": string;
        }, event: any) => void;
        handleListButtonClick(event: any): void;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/component/UiFormulaInputComponent" {
    import * as React from 'react';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { KeyboardDeviceEvent } from 'cross/editor/device/keyboard/KeyboardDeviceEvent';
    import { KeyboardDeviceService } from 'cross/editor/device/keyboard/KeyboardDeviceService';
    import { UiDefineEditControlProps, UiDefineEditControlState, UiDefineEditControl } from 'sk/editor/frame/ui/base/UiDefineEditControl';
    import { FormulaDataMentionsTypeEnum, FormulaDataSearchInfo } from "sk/editor/logic/ui/component/util/UiFormulaDataUtil";
    export interface UiFormulaInputComponentProps extends UiDefineEditControlProps {
    }
    export interface UiFormulaInputComponentState extends UiDefineEditControlState {
        value: string;
        valid: string;
        editorModalVisible: boolean;
        buttonDescription: JSX.Element;
    }
    export class UiFormulaInputComponent<P extends UiFormulaInputComponentProps = any, S extends UiFormulaInputComponentState = any> extends UiDefineEditControl<P, S> {
        state: UiFormulaInputComponentState;
        record: any;
        mentionsType: FormulaDataMentionsTypeEnum;
        mentionsStr: string;
        preOldValue: string;
        nextOldValue: string;
        codeArray: Array<{
            "code": string;
            "value": string;
        }>;
        currentContent: string;
        mentionsData: Array<FormulaDataSearchInfo>;
        isInputMounted: boolean;
        mentionsSelectItem: FormulaDataSearchInfo;
        mentionsContainerHover: boolean;
        canExecuteBlur: boolean;
        canExecuteEnter: boolean;
        protected _keyboardService: KeyboardDeviceService;
        constructor(props?: any, context?: any);
        componentStatusChange(state: any, props: any): void;
        componentDidMount(): void;
        componentWillUnmount(): void;
        protected getDisplayValue(): any;
        protected endsWith(str1: string, str2: string): boolean;
        onInputChange: (event: any) => void;
        onInputPressEnter: (e: any) => void;
        onInputBlur: (e: any) => void;
        onValueConfirm: (e: any) => void;
        resetMentions(): void;
        validate(): boolean;
        buildFormItemOptions(): any;
        private onEditorModalShow;
        dataCustomCallback: (results: Array<FormulaDataSearchInfo>) => void;
        getCursorPos: (domRef: any) => {
            start: number;
            end: number;
        };
        insertAt: (domRef: any, pos: any, str: any) => void;
        setCursorPos: (domRef: any, pos: any) => void;
        parentHandleButtonClick: (clickString: String) => void;
        setButtonDescription: (content: JSX.Element) => void;
        setCurrentContent: (liContent: any) => void;
        inserListContent: () => void;
        private makeEditorModal;
        private onEditorOK;
        private onEditorCancel;
        buildMentionsStyleAuto(): any;
        buildMentionsList(): any;
        buildMentionsItem: (item: any) => React.JSX.Element;
        onKeyDown: (sender: ListenerContext, event: KeyboardDeviceEvent) => void;
        getMentionsPickIndex(): number;
        pickNextMentionsItem(): void;
        resetCursorInSplitEnd: () => void;
        pickPreMentionsItem(): void;
        mentionsItemAutoScroll(): void;
        enterPickMentionsItem(): void;
        onMentionsItemEnter: (item: FormulaDataSearchInfo) => void;
        onMentionsItemLeave: (item: FormulaDataSearchInfo) => void;
        pickMentionsItemValue: (value: any) => void;
        resetMentionsStatus(): void;
        splitInputValue(value: string): void;
        fetchMentionsData(): void;
        fetchMentionsDataCallBack: (results: Array<FormulaDataSearchInfo>) => void;
        checkMentionsType(str: string): FormulaDataMentionsTypeEnum;
        buildEditInput(): any;
    }
}
declare module "sk/editor/logic/ui/component/UiPopoverTitleComponent" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiPopoverTitleComponentProps extends UiLogicControlProps {
        content: any;
        popoverContent: any;
        isShowPopover?: boolean;
        option?: any;
    }
    export interface UiPopoverTitleComponentState extends UiLogicControlState {
        popoverVisble: boolean;
    }
    export class UiPopoverTitleComponent<P extends UiPopoverTitleComponentProps = any, S extends UiPopoverTitleComponentState = any> extends UiLogicControl<P, S> {
        constructor(p?: any, context?: any);
        onOpenChange: () => (visible: boolean) => void;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/control/UiLogicButton" {
    import { UiButton, UiButtonProps, UiButtonState } from 'foundation/editor/ui/form/UiButton';
    export interface UiLogicButtonProps extends UiButtonProps {
        mode?: any;
    }
    export interface UiLogicButtonState extends UiButtonState {
    }
    export class UiLogicButton extends UiButton<UiLogicButtonProps, UiLogicButtonState> {
        get styleClass(): string;
    }
}
declare module "sk/editor/logic/ui/control/UiLogicDrop" {
    import { UiOptionPermissionControl, UiOptionPermissionControlState, UiOptionPermissionControlProps } from 'foundation/editor/ui/core/UiOptionPermissionControl';
    export interface UiLogicDropProps extends UiOptionPermissionControlProps {
        label: string;
    }
    export interface UiLogicDropState extends UiOptionPermissionControlState {
        className: string;
        enable: boolean;
        icon: string;
        label: string;
        title: string;
        showLabel: boolean;
        data: any;
    }
    export class UiLogicDrop extends UiOptionPermissionControl<UiLogicDropProps, UiLogicDropState> {
        state: UiLogicDropState;
        classStr: string;
        clickHandle: any;
        constructor(props?: any, context?: any);
        UNSAFE_componentWillMount(): void;
        UNSAFE_componentWillUpdate(nextProps?: any, nextState?: any): void;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/control/UiLogicFormulaInput" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicFormulaInputProps extends UiLogicControlProps {
    }
    export interface UiLogicFormulaInputState extends UiLogicControlState {
    }
    export class UiLogicFormulaInput<P extends UiLogicFormulaInputProps = any, S extends UiLogicFormulaInputState = any> extends UiLogicControl<P, S> {
        state: UiLogicFormulaInputState;
    }
}
declare module "sk/editor/logic/ui/control/UiLogicMemoInput" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicMemoInputProps extends UiLogicControlProps {
    }
    export interface UiLogicMemoInputState extends UiLogicControlState {
    }
    export class UiLogicMemoInput<P extends UiLogicMemoInputProps = any, S extends UiLogicMemoInputState = any> extends UiLogicControl<P, S> {
        state: UiLogicMemoInputState;
    }
}
declare module "sk/editor/logic/ui/control/UiLogicNumberInput" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicNumberInputProps extends UiLogicControlProps {
        width?: string;
        value?: any;
        addonBefore?: any;
        addonAfter?: any;
        onChanged?: any;
    }
    export interface UiLogicNumberInputState extends UiLogicControlState {
        value: any;
    }
    export class UiLogicNumberInput<P extends UiLogicNumberInputProps = any, S extends UiLogicNumberInputState = any> extends UiLogicControl<P, S> {
        dataValue: any;
        props: UiLogicNumberInputProps;
        state: UiLogicNumberInputState;
        componentPropsChange(nextProps: any, nextContext: any): void;
        handleChange: (event: any) => void;
        handlePressEnter: (event: any) => void;
        handleBlur: (event: any) => void;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/control/UiLogicSearchPanel" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicSearchPanelProps extends UiLogicControlProps {
    }
    export interface UiLogicSearchPanelState extends UiLogicControlState {
    }
    export class UiLogicSearchPanel<P extends UiLogicSearchPanelProps = any, S extends UiLogicSearchPanelState = any> extends UiLogicControl<P, S> {
        state: UiLogicSearchPanelState;
    }
}
declare module "sk/editor/logic/ui/control/UiLogicSelect" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicSelectProps extends UiLogicControlProps {
    }
    export interface UiLogicSelectState extends UiLogicControlState {
    }
    export class UiLogicSelect<P extends UiLogicSelectProps = any, S extends UiLogicSelectState = any> extends UiLogicControl<P, S> {
        state: UiLogicSelectState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/control/UiLogicTextInput" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicTextInputProps extends UiLogicControlProps {
        width?: string;
        value?: any;
        placeholder?: string;
        allowClear?: boolean;
        addonBefore?: any;
        addonAfter?: any;
        onChange?: any;
        onConfirm?: any;
        onCancel?: any;
        isSearch?: boolean;
        onSearch?: any;
    }
    export interface UiLogicTextInputState extends UiLogicControlState {
        value: any;
    }
    export class UiLogicTextInput<P extends UiLogicTextInputProps = any, S extends UiLogicTextInputState = any> extends UiLogicControl<P, S> {
        dataValue: any;
        props: UiLogicTextInputProps;
        state: UiLogicTextInputState;
        constructor(props?: any, context?: any);
        componentPropsChange(nextProps: any, nextContext: any): void;
        handleChange: (event: any) => void;
        handlePressEnter: (event: any) => void;
        handleBlur: (event: any) => void;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/dataset/UiLogicActionEnum" {
    export class UiLogicActionEnum {
        static Insert: string;
        static Update: string;
        static Delete: string;
        static Copy: string;
        static Paste: string;
        static hasAction(actions: any, actionCd: UiLogicActionEnum): boolean;
    }
}
declare module "sk/editor/logic/ui/dataset/UiLogicDataset" {
    import { UiDataDataset } from 'foundation/editor/ui/data/UiDataDataset';
    export class UiLogicDataset extends UiDataDataset {
    }
}
declare module "sk/editor/logic/ui/dataset/UiLogicDatasetEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    export class UiLogicDatasetEvent extends EventObject {
    }
}
declare module "sk/editor/logic/ui/dataset/UiLogicDatasetEventEnum" {
    export class UiLogicDatasetEventEnum {
        static Loaded: string;
    }
}
declare module "sk/editor/logic/ui/dataset/UiLogicMessageEnum" {
    export class UiLogicMessgeEnum {
        static EditingInfo: string;
    }
}
declare module "sk/editor/logic/ui/dataset/UiLogicModeEnum" {
    export class UiLogicModeEnum {
        static Insert: string;
        static Copy: string;
        static Update: string;
        static Delete: string;
    }
}
declare module "sk/editor/logic/ui/header/UiLogicHeader" {
    import { UiSafeContainer, UiSafeContainerProps, UiSafeContainerState } from 'foundation/editor/ui/core/UiSafeContainer';
    export interface UiLogicHeaderProps extends UiSafeContainerProps {
    }
    export interface UiLogicHeaderState extends UiSafeContainerState {
    }
    export class UiLogicHeader extends UiSafeContainer {
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/modal/UiLogicFeaturesEditModal" {
    import { UiSafeContainer, UiSafeContainerProps, UiSafeContainerState } from 'foundation/editor/ui/core/UiSafeContainer';
    import { FrameLogicService } from 'sk/editor/frame/service/frame/FrameLogicService';
    import { UiDataContext } from 'sk/editor/frame/ui/UiDataContext';
    interface UiLogicFeaturesEditModalPorps extends UiSafeContainerProps {
        afterClose?: Function;
        afterSubmit?: (features: any) => {};
        attributeList: any;
        attributeValueList: any;
        dataContext?: UiDataContext;
    }
    interface UiLogicFeaturesEditModalState extends UiSafeContainerState {
        visible: boolean;
        attributeValueList: any;
        title: string;
        dataSource: Array<any>;
        variableId: string;
        textureName: string;
        nameMessage: string;
        materielsCode: string;
        codeMessage: string;
        texturePic: string;
        textureId: string;
        texturePicTip: string;
        picMessage: string;
        linesMessage: string;
        defaultLines: string;
        closeEdge: boolean;
        response: string;
        treeNodeKey: string;
        canSubmit: boolean;
    }
    export class UiLogicFeaturesEditModal<P extends UiLogicFeaturesEditModalPorps, S extends UiLogicFeaturesEditModalState> extends UiSafeContainer<P, S> {
        attributes: Array<any>;
        propData: any;
        frame: any;
        private readonly title;
        protected _frameLogicService: FrameLogicService;
        constructor(props: any, context?: any);
        private columns;
        static getDerivedStateFromProps(nextProps: UiLogicFeaturesEditModalPorps, prevState: UiLogicFeaturesEditModalState): any;
        getAttributeAsync(): Promise<void>;
        makedata(): void;
        createChildTableNodeLoop(tableNode: any, child: any): void;
        onOK: (e: any) => Promise<void>;
        submitAsync(objectAttributes: any): Promise<void>;
        showNormalConfirm: (text: any) => void;
        onCancel: (e: any) => void;
        useTexture: (textureId: any) => void;
        recordChangeAsync: (record: any) => Promise<void>;
        rowChange: (record: any, index: any) => void;
        makedatas(): any;
        private fillDeclareName;
        changeValue: (key: any, value: any) => void;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/modal/UiLogicFeaturesEditButton" {
    import { DataOptions } from 'cross/data/module/dataset/DataOptions';
    import { UiContainer, UiContainerProps, UiContainerState } from 'foundation/editor/ui/core/UiContainer';
    import { UiDataContext } from 'sk/editor/frame/ui/UiDataContext';
    import { UiFrameDataService } from 'sk/editor/frame/ui/UiFrameDataService';
    import { UiFrameService } from 'sk/editor/frame/ui/UiFrameService';
    export interface UiLogicFeaturesEditButtonProps extends UiContainerProps {
        dataUnit: any;
        featureFrameKey: 'sk.platform.logic.module.family.FamilyForm' | 'sk.platform.logic.module.family.CategoryForm';
        controller: any;
        type?: any;
    }
    export interface UiLogicFeaturesEditButtonState extends UiContainerState {
        visible: boolean;
        attributeList: any;
        attributeValueList: any;
        configModalContent: any;
        configModalVisible: boolean;
        dataContext: UiDataContext;
        treeNodeKey: string;
        treeNodeName: string;
        filter: any;
    }
    export class UiLogicFeaturesEditButton<P extends UiLogicFeaturesEditButtonProps = any, S extends UiLogicFeaturesEditButtonState = any> extends UiContainer<P, S> {
        publishModalRef: any;
        props: UiLogicFeaturesEditButtonProps;
        state: UiLogicFeaturesEditButtonState;
        protected _uiFrameService: UiFrameService;
        protected _uiFrameDataService: UiFrameDataService;
        constructor(props: any, context?: any);
        componentStatusChange(state: any, props: any): void;
        protected setupDataOptions(): DataOptions;
        protected setupUiDataContext(): UiDataContext;
        protected buildDataContextAsync(): Promise<any>;
        getAttributeAsync(): Promise<void>;
        showPublishModal: () => Promise<void>;
        showNormalConfirm: (text: any) => void;
        afterSubmit: (features: any) => Promise<void>;
        afterClose: () => void;
        protected makeModal(): JSX.Element;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/selection/UiLogicSelection" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { SelectionEvent } from 'foundation/editor/base/selection/SelectionEvent';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { UiSafeContainer, UiSafeContainerProps, UiSafeContainerState } from 'foundation/editor/ui/core/UiSafeContainer';
    export interface UiLogicSelectionProps extends UiSafeContainerProps {
        nodeClass: any;
    }
    export interface UiLogicSelectionState extends UiSafeContainerState {
    }
    export class UiLogicSelection extends UiSafeContainer<UiLogicSelectionProps, UiLogicSelectionState> {
        protected _selectionService: SelectionService;
        onSelectionChanged(context: ListenerContext, event: SelectionEvent): void;
        componentDidMount(): void;
        componentWillUnmount(): void;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/statusbar/UiLogicLock" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicLockProps extends UiLogicControlProps {
        className?: string;
        onClick?: any;
    }
    export interface UiLogicLockState extends UiLogicControlState {
    }
    export class UiLogicLock<P extends UiLogicLockProps = any, S extends UiLogicLockState = any> extends UiLogicControl<P, S> {
        props: UiLogicLockProps;
        state: UiLogicLockState;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/statusbar/UiLogicStatusBar" {
    import { PluginService } from 'cross/runtime/framework/plugin/PluginService';
    import { UiDesktopService } from 'foundation/editor/ui/desktop/UiDesktopService';
    import { UiMainDesktop } from 'foundation/editor/ui/desktop/UiMainDesktop';
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicStatusbarProps extends UiLogicControlProps {
    }
    export interface UiLogicStatusbarState extends UiLogicControlState {
        bool: boolean;
    }
    export class UiLogicStatusBar<P extends UiLogicStatusbarProps = any, S extends UiLogicStatusbarState = any> extends UiLogicControl<P, S> {
        state: UiLogicStatusbarState;
        desktop: UiMainDesktop;
        protected _desktopService: UiDesktopService;
        protected _pluginService: PluginService;
        classr: string;
        constructor(props: any, context?: any);
        private onPluginMountEvent;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/statusbar/UiLogicStatusButton" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicStatusButtonProps extends UiLogicControlProps {
        label?: string;
        title?: string;
        icon?: string;
        onClick?: any;
    }
    export interface UiLogicStatusButtonState extends UiLogicControlState {
    }
    export class UiLogicStatusButton<P extends UiLogicStatusButtonProps = any, S extends UiLogicStatusButtonState = any> extends UiLogicControl<P, S> {
        props: UiLogicStatusButtonProps;
        state: UiLogicStatusButtonState;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/statusbar/UiLogicStatusContent" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicStatusContentProps extends UiLogicControlProps {
    }
    export interface UiLogicStatusContentState extends UiLogicControlState {
    }
    export class UiLogicStatusContent<P extends UiLogicStatusContentProps = any, S extends UiLogicStatusContentState = any> extends UiLogicControl<P, S> {
        state: UiLogicStatusContentState;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/statusbar/UiLogicStatusDebugButton" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicStatusDebugButtonProps extends UiLogicControlProps {
        item: any;
    }
    export interface UiLogicStatusDebugButtonState extends UiLogicControlState {
        item: any;
    }
    export class UiLogicStatusDebugButton extends UiLogicControl<UiLogicStatusDebugButtonProps, UiLogicStatusDebugButtonState> {
        item: any;
        UNSAFE_componentWillMount(): void;
        UNSAFE_componentWillUpdate(nextProps?: any, nextState?: any): void;
        onClick: (event: any) => void;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/statusbar/UiLogicStatusPopover" {
    import { UiContainer, UiContainerProps, UiContainerState } from 'foundation/editor/ui/core/UiContainer';
    interface UiLogicStatusPopoverProps extends UiContainerProps {
        label: string;
        placement?: string;
        trigger?: string;
        content: any;
        childKey?: string;
        dontUseClose?: boolean;
        onConfirmed?: any;
        onCancel?: any;
        onClick?: any;
    }
    interface UiLogicStatusPopoverState extends UiContainerState {
        visible: boolean;
    }
    export class UiLogicStatusPopover extends UiContainer<UiLogicStatusPopoverProps, UiLogicStatusPopoverState> {
        state: UiLogicStatusPopoverState;
        constructor(props?: any, context?: any);
        private onOpenChange;
        onShowPopover: (event: any) => void;
        private onOk;
        private onClose;
        protected makeButtons(): JSX.Element;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/statusbar/UiLogicStatusSegment" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicStatusSegmentProps extends UiLogicControlProps {
    }
    export interface UiLogicStatusSegmentState extends UiLogicControlState {
    }
    export class UiLogicStatusSegment<P extends UiLogicStatusSegmentProps = any, S extends UiLogicStatusSegmentState = any> extends UiLogicControl<P, S> {
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/statusbar/UiLogicStatusSplitter" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicStatusSplitterProps extends UiLogicControlProps {
    }
    export interface UiLogicStatusSplitterState extends UiLogicControlState {
    }
    export class UiLogicStatusSplitter<P extends UiLogicStatusSplitterProps = any, S extends UiLogicStatusSplitterState = any> extends UiLogicControl<P, S> {
        state: UiLogicStatusSplitterState;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/statusbar/UiLogicStatusText" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicStatusTextProps extends UiLogicControlProps {
        leftSpace: any;
    }
    export interface UiLogicStatusTextState extends UiLogicControlState {
    }
    export class UiLogicStatusText<P extends UiLogicStatusTextProps = any, S extends UiLogicStatusTextState = any> extends UiLogicControl<P, S> {
        state: UiLogicStatusTextState;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTable" {
    import { UiTable, UiTableProps, UiTableState } from 'foundation/editor/ui/table/UiTable';
    import { UiLogicDatasetController } from "sk/editor/logic/ui/dataset/UiLogicDatasetController";
    export interface UiLogicTableProps extends UiTableProps {
        controller?: UiLogicDatasetController;
        selectedRows?: Array<any>;
        joinTableSelect?: boolean;
        onPageChangeAfter?: () => void;
    }
    export interface UiLogicTableState extends UiTableState {
        selectedRows: Array<any>;
    }
    export class UiLogicTable<P extends UiLogicTableProps = any, S extends UiLogicTableState = any> extends UiTable<P, S> {
        props: UiLogicTableProps;
        state: UiLogicTableState;
        controller: UiLogicDatasetController;
        constructor(props?: UiLogicTableProps, context?: any);
        componentPropsChange(nextProps: any, nextContext: any): void;
        get selectedRowKeys(): any;
        set selectedRowKeys(keys: any);
        componentDidMount(): void;
        componentWillUnmount(): void;
        onDatasetLoaded(): void;
        onRowKey: (record: any) => string;
        onRowClick: (event: any, record: any, index: any) => void;
        onRowSelectChange: (selectedKeys: Array<string>, selectedRows: Array<any>) => void;
        clearSelected(): void;
        onPageChange: (page: number, pageSize: number) => void;
        protected onChange: (pagination: any, filters: any, sorter: any) => void;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableButtonCell" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { KeyboardDeviceEvent } from 'cross/editor/device/keyboard/KeyboardDeviceEvent';
    import { KeyboardDeviceService } from 'cross/editor/device/keyboard/KeyboardDeviceService';
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    import { UiLogicDatasetController } from "sk/editor/logic/ui/dataset/UiLogicDatasetController";
    export interface UiLogicTableButtonCellProps extends UiTableCellProps {
        datasetController?: UiLogicDatasetController;
    }
    export interface UiLogicTableButtonCellState extends UiTableCellState {
        saving: boolean;
    }
    export class UiLogicTableButtonCell<P extends UiLogicTableButtonCellProps = any, S extends UiLogicTableButtonCellState = any> extends UiTableCell<P, S> {
        protected _form: any;
        protected datasetController: UiLogicDatasetController;
        protected _input: any;
        protected _keyboardService: KeyboardDeviceService;
        protected _visibleEditoFeatureBtn: boolean;
        protected _disableEditFeatureBtn: boolean;
        constructor(props?: any, context?: any);
        componentDidMount(): void;
        componentWillUnmount(): void;
        onKeyboardDown(sender: ListenerContext, event: KeyboardDeviceEvent): void;
        onInputRef: (value: any) => void;
        onInputFocus: () => void;
        getRowId(): string;
        onEdit: (event: any) => void;
        onExitEdit: () => void;
        private onDelete;
        onSave: (event: any) => void;
        onCancel: (event: any) => Promise<void>;
        protected resetRowCells(): void;
        reset(): void;
        onCheckClick: () => void;
        onEditorClick: () => Promise<void>;
        onCellClick: (event: any) => void;
        onDetail: () => void;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableButtonColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export enum LogicButtonTypeEnum {
        defalut = 0,
        attributeConfig = 1
    }
    export interface UiLogicTableButtonColumnProps extends UiTableColumnProps {
        type?: LogicButtonTypeEnum | null;
        onCheckClick?: any;
        setRowStatus?: any;
        editableStatus?: boolean;
        editorAttribute?: boolean;
        editorAttributeHandle?: any;
        insertResponse?: any;
        editableSaveOrCancel?: boolean;
        editFeature?: boolean;
        detail?: boolean;
        useEditorModal?: boolean;
        hasImgUploadingIcon?: boolean;
    }
    export interface UiLogicTableButtonColumnState extends UiTableColumnState {
    }
    export class UiLogicTableButtonColumn<P extends UiLogicTableButtonColumnProps = any, S extends UiLogicTableButtonColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTableButtonColumnProps;
        state: UiLogicTableButtonColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableAttributeButtonCell" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { KeyboardDeviceEvent } from 'cross/editor/device/keyboard/KeyboardDeviceEvent';
    import { KeyboardDeviceService } from 'cross/editor/device/keyboard/KeyboardDeviceService';
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    import { UiFrameService } from 'sk/editor/frame/ui/UiFrameService';
    import { UiLogicDatasetController } from "sk/editor/logic/ui/dataset/UiLogicDatasetController";
    export interface UiLogicTableAttributeButtonCellProps extends UiTableCellProps {
        datasetController?: UiLogicDatasetController;
    }
    export interface UiLogicTableAttributeButtonCellState extends UiTableCellState {
        saving: boolean;
        configModal: JSX.Element;
    }
    export class UiLogicTableAttributeButtonCell<P extends UiLogicTableAttributeButtonCellProps = any, S extends UiLogicTableAttributeButtonCellState = any> extends UiTableCell<P, S> {
        protected _form: any;
        protected datasetController: UiLogicDatasetController;
        protected _input: any;
        protected _keyboardService: KeyboardDeviceService;
        protected _uiFrameService: UiFrameService;
        constructor(props?: any, context?: any);
        componentDidMount(): void;
        componentWillUnmount(): void;
        onKeyboardDown(sender: ListenerContext, event: KeyboardDeviceEvent): void;
        onInputRef: (value: any) => void;
        onInputFocus: () => void;
        onCancel: (event: any) => Promise<void>;
        protected resetRowCells(): void;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTableColumnProps extends UiTableColumnProps {
    }
    export interface UiLogicTableColumnState extends UiTableColumnState {
    }
    export class UiLogicTableColumn<P extends UiLogicTableColumnProps = any, S extends UiLogicTableColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTableColumnProps;
        state: UiLogicTableColumnState;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableDateTextColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTableTextColumnProps extends UiTableColumnProps {
    }
    export interface UiLogicTableTextColumnState extends UiTableColumnState {
    }
    export class UiLogicTableDateTextColumn<P extends UiLogicTableTextColumnProps = any, S extends UiLogicTableTextColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTableTextColumnProps;
        state: UiLogicTableTextColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableDateTextCell" {
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    export interface UiLogicTableTextCellProps extends UiTableCellProps {
    }
    export interface UiLogicTableTextCellState extends UiTableCellState {
    }
    export class UiLogicTableDateTextCell<P extends UiLogicTableTextCellProps = any, S extends UiLogicTableTextCellState = any> extends UiTableCell<P, S> {
        protected _form: any;
        protected _input: any;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableEffectColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTableEffectColumnProps extends UiTableColumnProps {
        onClick?: any;
    }
    export interface UiLogicTableEffectColumnState extends UiTableColumnState {
    }
    export class UiLogicTableEffectColumn<P extends UiLogicTableEffectColumnProps = any, S extends UiLogicTableEffectColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTableEffectColumnProps;
        state: UiLogicTableEffectColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableEffectCell" {
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    export interface UiLogicTableeEffectCellProps extends UiTableCellProps {
    }
    export interface UiLogicTableeEffectCellState extends UiTableCellState {
        effectName: string;
        effectId: string;
        effectChange: boolean;
    }
    export class UiLogicTableEffectCell<P extends UiLogicTableeEffectCellProps = any, S extends UiLogicTableeEffectCellState = any> extends UiTableCell<P, S> {
        constructor(props?: any, context?: any);
        componentDidMount(): void;
        onPickChange: (pickData?: any) => void;
        onEffectClick: (event: any) => void;
        updateMaterialAsync: () => Promise<void>;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableEnumColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTableEnumColumnProps extends UiTableColumnProps {
        enumType?: any;
    }
    export interface UiLogicTableEnumColumnState extends UiTableColumnState {
    }
    export class UiLogicTableEnumColumn<P extends UiLogicTableEnumColumnProps = any, S extends UiLogicTableEnumColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTableEnumColumnProps;
        state: UiLogicTableEnumColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableEnumCell" {
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    export interface UiLogicTableEnumCellProps extends UiTableCellProps {
    }
    export interface UiLogicTableEnumCellState extends UiTableCellState {
    }
    export class UiLogicTableEnumCell<P extends UiLogicTableEnumCellProps = any, S extends UiLogicTableEnumCellState = any> extends UiTableCell<P, S> {
        protected _form: any;
        protected _input: any;
        onInputRef: (value: any) => void;
        onInputFocus: () => void;
        onToggleEdit: () => void;
        onClick: () => void;
        onChange: (event: any) => void;
        onSave: (event: any) => void;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableIndexCell" {
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    export interface UiLogicTableIndexCellProps extends UiTableCellProps {
    }
    export interface UiLogicTableIndexCellState extends UiTableCellState {
    }
    export class UiLogicTableIndexCell<P extends UiLogicTableIndexCellProps = any, S extends UiLogicTableIndexCellState = any> extends UiTableCell<P, S> {
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableIndexColumn" {
    import { UiTableIndexColumn, UiTableIndexColumnProps, UiTableIndexColumnState } from 'foundation/editor/ui/table/UiTableIndexColumn';
    export interface UiLogicTableColumnIndexProps extends UiTableIndexColumnProps {
    }
    export interface UiLogicTableColumnIndexState extends UiTableIndexColumnState {
    }
    export class UiLogicTableIndexColumn<P extends UiLogicTableColumnIndexProps = any, S extends UiLogicTableColumnIndexState = any> extends UiTableIndexColumn<P, S> {
        static ColumnAlign: string;
        props: UiLogicTableColumnIndexProps;
        state: UiLogicTableColumnIndexState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableSelectCell" {
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    import { UiLogicDatasetController } from "sk/editor/logic/ui/dataset/UiLogicDatasetController";
    import { UiLogicTableSelectColumn } from "sk/editor/logic/ui/table/UiLogicTableSelectColumn";
    export interface UiLogicTableSelectCellProps extends UiTableCellProps {
        column: UiLogicTableSelectColumn;
    }
    export interface UiLogicTableSelectCellState extends UiTableCellState {
    }
    export class UiLogicTableSelectCell<P extends UiLogicTableSelectCellProps = any, S extends UiLogicTableSelectCellState = any> extends UiTableCell<P, S> {
        protected datasetController: UiLogicDatasetController;
        constructor(props?: any, context?: any);
        onSave: (value: any) => void;
        makeOptions(): Array<any>;
        protected onDropdownVisibleChange: (open: boolean) => void;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableSelectColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTableSelectColumnProps extends UiTableColumnProps {
        options: Array<any>;
        onDropdownVisibleChange?: (fileName: string, open: boolean) => void;
    }
    export interface UiLogicTableSelectColumnState extends UiTableColumnState {
    }
    export class UiLogicTableSelectColumn<P extends UiLogicTableSelectColumnProps = any, S extends UiLogicTableSelectColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTableSelectColumnProps;
        state: UiLogicTableSelectColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableMultipleSelectCell" {
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    import { UiLogicDatasetController } from "sk/editor/logic/ui/dataset/UiLogicDatasetController";
    export interface UiLogicTableMultipleSelectCelProps extends UiTableCellProps {
    }
    export interface UiLogicTableMultipleSelectCelState extends UiTableCellState {
    }
    export class UiLogicTableMultipleSelectCel<P extends UiLogicTableMultipleSelectCelProps = any, S extends UiLogicTableMultipleSelectCelState = any> extends UiTableCell<P, S> {
        protected datasetController: UiLogicDatasetController;
        constructor(props?: any, context?: any);
        onSave: (value: any) => void;
        makeOptions(): Array<any>;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableMultipleSelectColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTableMultipleSelectColumnProps extends UiTableColumnProps {
        options: Array<any>;
    }
    export interface UiLogicTableMultipleSelectColumnState extends UiTableColumnState {
    }
    export class UiLogicTableMultipleSelectColumn<P extends UiLogicTableMultipleSelectColumnProps = any, S extends UiLogicTableMultipleSelectColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTableMultipleSelectColumnProps;
        state: UiLogicTableMultipleSelectColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableNumberColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTableNumberColumnProps extends UiTableColumnProps {
        minValue?: number;
    }
    export interface UiLogicTableNumberColumnState extends UiTableColumnState {
    }
    export class UiLogicTableNumberColumn<P extends UiLogicTableNumberColumnProps = any, S extends UiLogicTableNumberColumnState = any> extends UiTableColumn<P, S> {
        static ColumnAlign: string;
        props: UiLogicTableNumberColumnProps;
        state: UiLogicTableNumberColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableNumberCell" {
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    import { UiLogicDatasetController } from "sk/editor/logic/ui/dataset/UiLogicDatasetController";
    export interface UiLogicTableNumberCellProps extends UiTableCellProps {
        minValue?: number;
    }
    export interface UiLogicTableNumberCellState extends UiTableCellState {
    }
    export class UiLogicTableNumberCell<P extends UiLogicTableNumberCellProps = any, S extends UiLogicTableNumberCellState = any> extends UiTableCell<P, S> {
        protected _form: any;
        protected _input: any;
        protected datasetController: UiLogicDatasetController;
        constructor(props?: any, context?: any);
        onInputRef: (value: any) => void;
        onChange: (event: any) => void;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTablePictureColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTablePictureColumnProps extends UiTableColumnProps {
        isModal?: any;
        pictureType: string;
    }
    export interface UiLogicTablePictureColumnState extends UiTableColumnState {
    }
    export class UiLogicTablePictureColumn<P extends UiLogicTablePictureColumnProps = any, S extends UiLogicTablePictureColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTablePictureColumnProps;
        state: UiLogicTablePictureColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTablePictureCell" {
    import { ResourcePictureService } from 'foundation/core/resource/ResourcePictureService';
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    export interface UiLogicTablePictureCellProps extends UiTableCellProps {
    }
    export interface UiLogicTablePictureCellState extends UiTableCellState {
    }
    export class UiLogicTablePictureCell<P extends UiLogicTablePictureCellProps = any, S extends UiLogicTablePictureCellState = any> extends UiTableCell<P, S> {
        props: P;
        state: S;
        protected _resourcePictureService: ResourcePictureService;
        onClick: () => void;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableSliderCell" {
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    import { UiLogicDatasetController } from "sk/editor/logic/ui/dataset/UiLogicDatasetController";
    export interface UiLogicTableSliderCellProps extends UiTableCellProps {
    }
    export interface UiLogicTableSliderCellState extends UiTableCellState {
    }
    export class UiLogicTableSliderCell<P extends UiLogicTableSliderCellProps = any, S extends UiLogicTableSliderCellState = any> extends UiTableCell<P, S> {
        protected datasetController: UiLogicDatasetController;
        constructor(props?: any, context?: any);
        onSave: (value: any) => void;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableSliderColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTableSliderColumnProps extends UiTableColumnProps {
        onClick?: any;
        onDoubleClick?: any;
    }
    export interface UiLogicTableSliderColumnState extends UiTableColumnState {
    }
    export class UiLogicTableSliderColumn<P extends UiLogicTableSliderColumnProps = any, S extends UiLogicTableSliderColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTableSliderColumnProps;
        state: UiLogicTableSliderColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableSwitchColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTableSwitchColumnProps extends UiTableColumnProps {
    }
    export interface UiLogicTableSwitchColumnState extends UiTableColumnState {
    }
    export class UiLogicTableSwitchColumn<P extends UiLogicTableSwitchColumnProps = any, S extends UiLogicTableSwitchColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTableSwitchColumnProps;
        state: UiLogicTableSwitchColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableSwitchCell" {
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    import { UiLogicDatasetController } from "sk/editor/logic/ui/dataset/UiLogicDatasetController";
    export interface UiLogicTableSwitchCellProps extends UiTableCellProps {
    }
    export interface UiLogicTableSwitchCellState extends UiTableCellState {
    }
    export class UiLogicTableSwitchCell<P extends UiLogicTableSwitchCellProps = any, S extends UiLogicTableSwitchCellState = any> extends UiTableCell<P, S> {
        protected datasetController: UiLogicDatasetController;
        constructor(props?: any, context?: any);
        onSave: (value: any) => void;
        oldOnSave: (value: any) => void;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableTextColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTableTextColumnProps extends UiTableColumnProps {
        onClick?: any;
        onDoubleClick?: any;
        maxLangth?: any;
    }
    export interface UiLogicTableTextColumnState extends UiTableColumnState {
    }
    export class UiLogicTableTextColumn<P extends UiLogicTableTextColumnProps = any, S extends UiLogicTableTextColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTableTextColumnProps;
        state: UiLogicTableTextColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableTextCell" {
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    import { UiLogicDatasetController } from "sk/editor/logic/ui/dataset/UiLogicDatasetController";
    export interface UiLogicTableTextCellProps extends UiTableCellProps {
    }
    export interface UiLogicTableTextCellState extends UiTableCellState {
    }
    export class UiLogicTableTextCell<P extends UiLogicTableTextCellProps = any, S extends UiLogicTableTextCellState = any> extends UiTableCell<P, S> {
        protected _form: any;
        protected _input: any;
        protected datasetController: UiLogicDatasetController;
        constructor(props?: any, context?: any);
        onInputRef: (value: any) => void;
        onChange: (event: any) => void;
        onCellClick: (event: any) => void;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableTextSelectColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTableTextSelectColumnProps extends UiTableColumnProps {
        isModal: any;
    }
    export interface UiLogicTableTextSelectColumnState extends UiTableColumnState {
    }
    export class UiLogicTableTextSelectColumn<P extends UiLogicTableTextSelectColumnProps = any, S extends UiLogicTableTextSelectColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTableTextSelectColumnProps;
        state: UiLogicTableTextSelectColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableTextSelectCell" {
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    export interface UiLogicTableTextSelectCellProps extends UiTableCellProps {
    }
    export interface UiLogicTableTextSelectCellState extends UiTableCellState {
    }
    export class UiLogicTableTextSelectCell<P extends UiLogicTableTextSelectCellProps = any, S extends UiLogicTableTextSelectCellState = any> extends UiTableCell<P, S> {
        protected _form: any;
        protected _input: any;
        onInputRef: (value: any) => void;
        onInputFocus: () => void;
        onToggleEdit: () => void;
        onSave: (event: any) => void;
        showNames(text: any): string;
        onClick: () => void;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableUploadColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTableUploadColumnProps extends UiTableColumnProps {
        defauitName?: string;
        fileType?: string;
        updateData?: any;
    }
    export interface UiLogicTableUploadColumnState extends UiTableColumnState {
    }
    export class UiLogicTableUploadColumn<P extends UiLogicTableUploadColumnProps = any, S extends UiLogicTableUploadColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTableUploadColumnProps;
        state: UiLogicTableUploadColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableUploadCell" {
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    import { UiLogicDatasetController } from "sk/editor/logic/ui/dataset/UiLogicDatasetController";
    export interface UiLogicTableUploadCellProps extends UiTableCellProps {
        datasetController?: UiLogicDatasetController;
    }
    export interface UiLogicTableUploadCellState extends UiTableCellState {
        name: string;
        type: string;
    }
    export class UiLogicTableUploadCell<P extends UiLogicTableUploadCellProps = any, S extends UiLogicTableUploadCellState = any> extends UiTableCell<P, S> {
        protected _form: any;
        protected datasetController: UiLogicDatasetController;
        protected _input: any;
        protected file: {};
        constructor(props?: any, context?: any);
        initFileFormat(): void;
        onInputRef: (value: any) => void;
        getRowId(): string;
        protected resetRowCells(): void;
        reset(): void;
        onCellClick: (event: any) => void;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableUploadPictureCell" {
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { ResourcePictureService } from 'foundation/core/resource/ResourcePictureService';
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    import { PictureInputNode } from 'sk/editor/frame/service/frame/node/PictureInputNode';
    import { UiDataContext } from 'sk/editor/frame/ui/UiDataContext';
    export interface UiLogicTableUploadPictureCellProps extends UiTableCellProps {
        data: any;
    }
    export interface UiLogicTableUploadPictureCellState extends UiTableCellState {
        loading: boolean;
        value: any;
    }
    export class UiLogicTableUploadPictureCell<P extends UiLogicTableUploadPictureCellProps = any, S extends UiLogicTableUploadPictureCellState = any> extends UiTableCell<P, S> {
        props: P;
        state: S;
        protected _resourcePictureService: ResourcePictureService;
        declare: PictureInputNode;
        canUpload: boolean;
        protected _environmentService: EnvironmentService;
        data?: UiDataContext;
        constructor(props: any, context?: any);
        private getAccessUrl;
        private makeUploadUrl;
        private makeImg;
        private getResizeImgUrl;
        private getBase64;
        private handleChange;
        private beforeUpload;
        buildEditInput(): JSX.Element;
        buildContent(): JSX.Element;
        validate(): boolean;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/table/UiLogicTableUploadPictureColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTableUploadPictureColumnProps extends UiTableColumnProps {
        data?: any;
    }
    export interface UiLogicTableUploadPictureColumnState extends UiTableColumnState {
    }
    export class UiLogicTableUploadPictureColumn<P extends UiLogicTableUploadPictureColumnProps = any, S extends UiLogicTableUploadPictureColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTableUploadPictureColumnProps;
        state: UiLogicTableUploadPictureColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiPaletteLogicTableTextColumn" {
    import { UiTableColumn, UiTableColumnProps, UiTableColumnState } from 'foundation/editor/ui/table/UiTableColumn';
    export interface UiLogicTableTextColumnProps extends UiTableColumnProps {
        onClick?: any;
        onDoubleClick?: any;
    }
    export interface UiLogicTableTextColumnState extends UiTableColumnState {
    }
    export class UiPaletteLogicTableTextColumn<P extends UiLogicTableTextColumnProps = any, S extends UiLogicTableTextColumnState = any> extends UiTableColumn<P, S> {
        props: UiLogicTableTextColumnProps;
        state: UiLogicTableTextColumnState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/table/UiPaletteLogicTableTextCell" {
    import { UiTableCell, UiTableCellProps, UiTableCellState } from 'foundation/editor/ui/table/UiTableCell';
    import { UiLogicDatasetController } from "sk/editor/logic/ui/dataset/UiLogicDatasetController";
    import { UiPaletteLogicTableTextColumn } from "sk/editor/logic/ui/table/UiPaletteLogicTableTextColumn";
    export interface UiLogicTableTextCellProps extends UiTableCellProps {
        column: UiPaletteLogicTableTextColumn;
    }
    export interface UiLogicTableTextCellState extends UiTableCellState {
    }
    export class UiPaletteLogicTableTextCell<P extends UiLogicTableTextCellProps = any, S extends UiLogicTableTextCellState = any> extends UiTableCell<P, S> {
        protected _form: any;
        protected _input: any;
        protected datasetController: UiLogicDatasetController;
        constructor(props?: any, context?: any);
        onInputRef: (value: any) => void;
        onChange: (event: any) => void;
        private onClick;
        renderContent(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/toolbar/UiLogicToolBar" {
    import { UiSafeLogicControl, UiSafeLogicControlProps, UiSafeLogicControlState } from "sk/editor/logic/ui/base/UiSafeLogicControl";
    export interface UiLogicToolBarProps extends UiSafeLogicControlProps {
    }
    export interface UiLogicToolBarState extends UiSafeLogicControlState {
    }
    export class UiLogicToolBar<P extends UiLogicToolBarProps = any, S extends UiLogicToolBarState = any> extends UiSafeLogicControl<P, S> {
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/toolbar/UiLogicToolButton" {
    import { UiSafeLogicControl, UiSafeLogicControlProps, UiSafeLogicControlState } from "sk/editor/logic/ui/base/UiSafeLogicControl";
    export interface UiLogicToolButtonProps extends UiSafeLogicControlProps {
        mode?: string;
        type?: string;
        buttonClassName?: string;
        icon?: string;
        showLabel?: boolean;
        label?: string;
        select?: boolean;
        accessKey?: string;
        align?: string;
        title?: string;
        timeout?: number;
        onClick?: any;
        onCancel?: any;
    }
    export interface UiLogicToolButtonState extends UiSafeLogicControlState {
        type?: string;
        buttonClassName?: string;
        icon: string;
        showLabel?: boolean;
        label: string;
        select?: boolean;
        accessKey: string;
        align?: string;
        title?: string;
    }
    export class UiLogicToolButton<P extends UiLogicToolButtonProps = any, S extends UiLogicToolButtonState = any> extends UiSafeLogicControl<P, S> {
        get styleClass(): string;
        static getDerivedStateFromProps(nextProps: UiLogicToolButtonProps, prevState: UiLogicToolButtonState): any;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/toolbar/UiLogicToolCheck" {
    import { UiSafeLogicControl, UiSafeLogicControlProps, UiSafeLogicControlState } from "sk/editor/logic/ui/base/UiSafeLogicControl";
    export interface UiLogicToolCheckProps extends UiSafeLogicControlProps {
        label?: string;
        defaultValue?: boolean;
        checked?: boolean;
        onChange?: any;
    }
    export interface UiLogicToolCheckState extends UiSafeLogicControlState {
        label?: string;
        defaultValue?: boolean;
        checked?: boolean;
        onChange?: any;
    }
    export class UiLogicToolCheck<P extends UiLogicToolCheckProps = any, S extends UiLogicToolCheckState = any> extends UiSafeLogicControl<P, S> {
        static defaultProps: any;
        static getDerivedStateFromProps(nextProps: UiLogicToolCheckProps, prevState: UiLogicToolCheckState): any;
        protected onChange: (event: any) => void;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/toolbar/UiLogicToolContent" {
    import { UiSafeLogicControl, UiSafeLogicControlProps, UiSafeLogicControlState } from "sk/editor/logic/ui/base/UiSafeLogicControl";
    export interface UiLogicToolContentProps extends UiSafeLogicControlProps {
    }
    export interface UiLogicToolContentState extends UiSafeLogicControlState {
    }
    export class UiLogicToolContent<P extends UiLogicToolContentProps = any, S extends UiLogicToolContentState = any> extends UiSafeLogicControl<P, S> {
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/toolbar/UiLogicToolDrop" {
    import { UiSafeLogicControl, UiSafeLogicControlProps, UiSafeLogicControlState } from "sk/editor/logic/ui/base/UiSafeLogicControl";
    export interface UiLogicToolDropProps extends UiSafeLogicControlProps {
        mode?: string;
        buttonClassName?: string;
        icon?: string;
        label?: string;
        align?: string;
    }
    export interface UiLogicToolDropState extends UiSafeLogicControlState {
        mode?: string;
        buttonClassName?: string;
        icon?: string;
        label?: string;
        align?: string;
    }
    export class UiLogicToolDrop<P extends UiLogicToolDropProps = any, S extends UiLogicToolDropState = any> extends UiSafeLogicControl<P, S> {
        get styleClass(): string;
        static getDerivedStateFromProps(nextProps: UiLogicToolDropProps, prevState: UiLogicToolDropState): any;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/toolbar/UiLogicToolList" {
    import { UiSafeLogicControl, UiSafeLogicControlProps, UiSafeLogicControlState } from "sk/editor/logic/ui/base/UiSafeLogicControl";
    export interface UiLogicToolListProps extends UiSafeLogicControlProps {
    }
    export interface UiLogicToolListState extends UiSafeLogicControlState {
    }
    export class UiLogicToolList<P extends UiLogicToolListProps = any, S extends UiLogicToolListState = any> extends UiSafeLogicControl<P, S> {
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/toolbar/UiLogicToolListMain" {
    import { UiSafeLogicControl, UiSafeLogicControlProps, UiSafeLogicControlState } from "sk/editor/logic/ui/base/UiSafeLogicControl";
    export interface UiLogicToolListProps extends UiSafeLogicControlProps {
    }
    export interface UiLogicToolListState extends UiSafeLogicControlState {
    }
    export class UiLogicToolListMain<P extends UiLogicToolListProps = any, S extends UiLogicToolListState = any> extends UiSafeLogicControl<P, S> {
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/toolbar/UiLogicToolListVice" {
    import { UiSafeLogicControl, UiSafeLogicControlProps, UiSafeLogicControlState } from "sk/editor/logic/ui/base/UiSafeLogicControl";
    export interface UiLogicToolListProps extends UiSafeLogicControlProps {
    }
    export interface UiLogicToolListState extends UiSafeLogicControlState {
    }
    export class UiLogicToolListVice<P extends UiLogicToolListProps = any, S extends UiLogicToolListState = any> extends UiSafeLogicControl<P, S> {
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/toolbar/UiLogicToolPopover" {
    import { UiSafeLogicControl, UiSafeLogicControlProps, UiSafeLogicControlState } from "sk/editor/logic/ui/base/UiSafeLogicControl";
    export interface UiLogicToolDropProps extends UiSafeLogicControlProps {
        icon?: string;
        label?: string;
        align?: string;
        placement?: any;
        title?: string;
        contentVisiblae?: boolean;
        content?: any;
        onVisibleChange?: any;
    }
    export interface UiLogicToolDropState extends UiSafeLogicControlState {
        icon?: string;
        label?: string;
        align?: string;
        placement?: any;
        title?: string;
        contentVisiblae?: boolean;
        content?: any;
        onVisibleChange?: any;
    }
    export class UiLogicToolPopover<P extends UiLogicToolDropProps = any, S extends UiLogicToolDropState = any> extends UiSafeLogicControl<P, S> {
        static defaultProps: any;
        static getDerivedStateFromProps(nextProps: UiLogicToolDropProps, prevState: UiLogicToolDropState): any;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/toolbar/UiLogicToolSegment" {
    import { UiSafeLogicControl, UiSafeLogicControlProps, UiSafeLogicControlState } from "sk/editor/logic/ui/base/UiSafeLogicControl";
    export interface UiLogicToolSegmentProps extends UiSafeLogicControlProps {
    }
    export interface UiLogicToolSegmentState extends UiSafeLogicControlState {
    }
    export class UiLogicToolSegment<P extends UiLogicToolSegmentProps = any, S extends UiLogicToolSegmentState = any> extends UiSafeLogicControl<P, S> {
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/toolbar/UiLogicToolSplitter" {
    import { UiSafeLogicControl, UiSafeLogicControlProps, UiSafeLogicControlState } from "sk/editor/logic/ui/base/UiSafeLogicControl";
    export interface UiLogicToolSplitterProps extends UiSafeLogicControlProps {
    }
    export interface UiLogicToolSplitterState extends UiSafeLogicControlState {
    }
    export class UiLogicToolSplitter<P extends UiLogicToolSplitterProps = any, S extends UiLogicToolSplitterState = any> extends UiSafeLogicControl<P, S> {
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/tree/UiLogicTreeEventEnum" {
    export class UiLogicTreeEventEnum {
        static Loaded: string;
    }
}
declare module "sk/editor/logic/ui/tree/UiLogicTreeNodeData" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class UiLogicTreeNodeData extends InstanceObject {
        key: string;
        title: any;
        data: any;
        disabled: boolean;
        children: any;
        get(name: string): any;
        static get(node: any, name: string, defaultValue?: any): any;
    }
}
declare module "sk/editor/logic/ui/tree/UiLogicTreeController" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { UiLogicTreeNodeData } from "sk/editor/logic/ui/tree/UiLogicTreeNodeData";
    export enum UiLogicTreeDragType {
        Remove = 0,
        Move = 1,
        Add = 2
    }
    export class UiLogicTreeController extends Dispatcher {
        nodeSorter: any;
        _dataSource: any;
        dataStore: any;
        currentNodeKey: any;
        hoverNodeKey: any;
        selectedKeys: Array<string>;
        selectedNodes: Array<any>;
        rightSelectNode: any;
        statusReady: boolean;
        initSelectKey: string;
        isLeftNode: boolean;
        isShowExpand: string;
        set dataSource(value: any);
        get dataSource(): any;
        get selectedKey(): string;
        get selectedNode(): any;
        makeNodeName(node: UiLogicTreeNodeData): any;
        makeNodeMenu(node: UiLogicTreeNodeData): any;
        makeNodePopover(node: UiLogicTreeNodeData, title: any, menu: any, isHideMenu?: boolean): any;
        makeNodeTitle(node: UiLogicTreeNodeData): any;
        makeTreeNodes(items: Array<any>): Array<UiLogicTreeNodeData>;
        makeTreeRoot(items: Array<any>): Array<UiLogicTreeNodeData>;
        makeEmpty(): any;
        loadAsync(option?: any): Promise<ResultObject>;
        refresh(): void;
        onNodeMenuVisibleChange: (open: boolean) => void;
        onDragNodeAsync(source: any, target: any, dropToGap: boolean): Promise<ResultObject<boolean>>;
        showAddChildMenu(selectedCategory: any): boolean;
    }
}
declare module "sk/editor/logic/ui/tree/UiLogicTree" {
    import { DataNode } from 'antd/lib/tree';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { UiLogicContainer, UiLogicContainerProps, UiLogicContainerState } from "sk/editor/logic/ui/base/UiLogicContainer";
    import { UiLogicTreeController } from "sk/editor/logic/ui/tree/UiLogicTreeController";
    import { UiLogicTreeNodeData } from "sk/editor/logic/ui/tree/UiLogicTreeNodeData";
    export interface UiLogicTreeProps extends UiLogicContainerProps {
        sortAble?: boolean;
        defaultSelectedKeys?: Array<string>;
        expandedKeys?: Array<string>;
        controller?: UiLogicTreeController;
        dataStore?: any;
        onSelect?: any;
        onRightClick?: any;
        onDragEnter?: any;
        onMouseEnter?: any;
        onMouseLeave?: any;
        onDrop?: any;
        readonly?: boolean;
        titleRender?: (node: DataNode) => any;
    }
    export interface UiLogicTreeState extends UiLogicContainerState {
        sortAble: boolean;
        defaultSelectedKeys: Array<string>;
        expandedKeys: Array<string>;
        selectedKeys: Array<string>;
        dataStore: any;
    }
    export class UiLogicTree<P extends UiLogicTreeProps = any, S extends UiLogicTreeState = any> extends UiLogicContainer<P, S> {
        props: UiLogicTreeProps;
        state: UiLogicTreeState;
        nodePosition: Vector2;
        protected _controller: UiLogicTreeController;
        protected _selectedKeys: Array<string>;
        protected _selectedNodes: Array<UiLogicTreeNodeData>;
        constructor(props?: UiLogicTreeProps, context?: any);
        get selectedKey(): string;
        get selectedKeys(): Array<any>;
        get selectedNode(): UiLogicTreeNodeData;
        get selectedNodes(): Array<UiLogicTreeNodeData>;
        UNSAFE_componentWillReceiveProps(nextProps: UiLogicTreeProps, nextContext: any): void;
        componentStatusChange(state: UiLogicTreeState, props: UiLogicTreeProps): void;
        componentDidMount(): void;
        componentWillUnmount(): void;
        hasSelected(): boolean;
        onLoaded(): void;
        protected setDefaultSelectNodes(): void;
        onExpand: (expandedKeys: Array<string>, event: any) => void;
        onSelect: (selectedKeys: Array<string>, event: any) => void;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/tree/UiLogicTreeEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    export class UiLogicTreeEvent extends EventObject {
    }
}
declare module "sk/editor/logic/ui/tree/UiLogicTreeNode" {
    import { UiLogicContainer, UiLogicContainerProps, UiLogicContainerState } from "sk/editor/logic/ui/base/UiLogicContainer";
    export interface UiLogicTreeNodeProps extends UiLogicContainerProps {
    }
    export interface UiLogicTreeNodeState extends UiLogicContainerState {
    }
    export class UiLogicTreeNode<P extends UiLogicTreeNodeProps = any, S extends UiLogicTreeNodeState = any> extends UiLogicContainer<P, S> {
        props: UiLogicTreeNodeProps;
        state: UiLogicTreeNodeState;
        constructor(props?: any, context?: any);
    }
}
declare module "sk/editor/logic/ui/treeview/UiLogicTreeView" {
    import { UiLogicControl, UiLogicControlProps, UiLogicControlState } from "sk/editor/logic/ui/base/UiLogicControl";
    export interface UiLogicTreeViewProps extends UiLogicControlProps {
    }
    export interface UiLogicTreeViewState extends UiLogicControlState {
    }
    export class UiLogicTreeView<P extends UiLogicTreeViewProps = any, S extends UiLogicTreeViewState = any> extends UiLogicControl<P, S> {
        state: UiLogicTreeViewState;
        render(): JSX.Element;
    }
}
declare module "sk/editor/logic/ui/util/ReactComponentUtil" {
    import * as React from 'react';
    export interface UiReference<T> {
        readonly current: T | null;
    }
    export class ReactComponentUtil {
        static navigate: any;
        static location: any;
        static withRouter(clazz: any): React.FunctionComponent;
        static withNavigate(clazz: any): React.FunctionComponent;
        static withLocation(clazz: any): React.FunctionComponent;
    }
}
declare module "sk/editor/logic/view/base/FamilyActionUtil" {
    export class FamilyActionUtil {
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dBackground" {
    import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
    import { Background } from 'foundation/editor/view/base/Background';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { BackgroundEntity } from 'foundation/editor/view/entity/BackgroundEntity';
    import { C2dCanvas } from "sk/editor/logic/view/canvas2d/C2dCanvas";
    import { C2dCanvasContext } from "sk/editor/logic/view/canvas2d/C2dCanvasContext";
    export class C2dBackground extends Background {
        context: C2dCanvasContext;
        view: C2dCanvas;
        entity: BackgroundEntity;
        protected _graphics: V2dGraphicDrawing;
        setup(): void;
        createNode(): void;
        onDraw(context?: DisplayContext): void;
        reset(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dBrep" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { NodeFieldEvent } from 'cross/runtime/framework/node/NodeFieldEvent';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
    import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
    import { V2dHookEvent } from 'foundation/editor/view/view2d/render/V2dHookEvent';
    import { V2dHookManager } from 'foundation/editor/view/view2d/render/V2dHookManager';
    import { BrepDisplay } from 'foundation/editor/view/base/BrepDisplay';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { V2dCanvas } from 'foundation/editor/view/view2d/V2dCanvas';
    import { V2dLayer } from 'foundation/editor/view/view2d/V2dLayer';
    import { C2dCanvasContext } from "sk/editor/logic/view/canvas2d/C2dCanvasContext";
    import { C2dCanvasEvent } from "sk/editor/logic/view/canvas2d/C2dCanvasEvent";
    export class C2dBrep extends BrepDisplay {
        context: C2dCanvasContext;
        view: V2dCanvas;
        layer: V2dLayer;
        sceneContainer: V2dGraphicContainer;
        optionGraphics: boolean;
        nodeGraphics: V2dGraphicDrawing;
        optionViewSizeUpdate: boolean;
        node: V2dGraphicContainer;
        protected _hookManager: V2dHookManager;
        protected _dragPoint: Vector2;
        protected _lastPoint: Vector2;
        protected _statusLevelChanged: boolean;
        protected _statusDragging: boolean;
        protected _selectionService: SelectionService;
        constructor();
        testTransformChanged(event: DataNodeFieldEvent): boolean;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEditOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        setup(): void;
        createNode(): any;
        bindEvent(): void;
        onDragStart(sender: ListenerContext, event: V2dHookEvent): boolean;
        onDragMove(sender: ListenerContext, event: V2dHookEvent): boolean;
        onDragEnd(sender: ListenerContext, event: V2dHookEvent): void;
        unbindEvent(): void;
        onClick(sender: ListenerContext, event: V2dHookEvent): void;
        onMouseDown(sender: ListenerContext, event: V2dHookEvent): void;
        onMouseOver(sender: ListenerContext, event: V2dHookEvent): void;
        onMouseOut(sender: ListenerContext, event: V2dHookEvent): void;
        onMouseMove(sender: ListenerContext, event: V2dHookEvent): void;
        onMouseUp(sender: ListenerContext, event: V2dHookEvent): void;
        onCanvasSizeChanged(sender: ListenerContext, event: C2dCanvasEvent): void;
        bindAction(): void;
        unbindAction(): void;
        protected updateTransform(): void;
        protected updateShape(): void;
        protected updateStyleStatus(): void;
        protected drawUpdate(context?: DisplayContext): boolean;
        drawDisplay(context?: DisplayContext): void;
        show(): void;
        hide(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dContentController" {
    import { C2dCanvas } from "sk/editor/logic/view/canvas2d/C2dCanvas";
    export class C2dContentController {
        canvas: C2dCanvas;
    }
}
declare module "sk/editor/logic/view/canvas2d/C2dVisionModel" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { CanvasEnum } from 'foundation/editor/view/base/CanvasEnum';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { VisionModelEntity } from "sk/editor/logic/entity/VisionModelEntity";
    import { C2dTopview } from "sk/editor/logic/view/canvas2d/renderer/C2dTopview";
    import { C2dTopviewRenderable } from "sk/editor/logic/view/canvas2d/renderer/C2dTopviewRenderable";
    import { C2dContent } from "sk/editor/logic/view/canvas2d/C2dContent";
    export class C2dVisionModel extends C2dContent {
        protected _topview: C2dTopview;
        protected _renderable: C2dTopviewRenderable;
        entity: VisionModelEntity;
        constructor();
        setupLayer(): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        canDraw(): boolean;
        protected updateTopviewAsync(): Promise<void>;
        dispose(): void;
        static testCreateAble(typeCd: CanvasEnum, typeCode: string, entity: FamilyInstanceNode): boolean;
    }
}
declare module "sk/editor/logic/view/canvas2d/gizmo/C2dGizmo" {
    import { Gizmo } from 'foundation/editor/view/base/gizmo/Gizmo';
    import { V2dHookManager } from 'foundation/editor/view/view2d/render/V2dHookManager';
    import { TransactionService } from 'foundation/editor/view/transaction/TransactionService';
    import { FamilyBlueprintNode } from 'sk/data/family/model/FamilyBlueprintNode';
    import { FloorplanNode } from 'sk/data/scheme/database/floorplan/model/FloorplanNode';
    import { C2dCanvas } from "sk/editor/logic/view/canvas2d/C2dCanvas";
    import { C2dCanvasContext } from "sk/editor/logic/view/canvas2d/C2dCanvasContext";
    import { C2dLayer } from "sk/editor/logic/view/canvas2d/C2dLayer";
    export class C2dGizmo extends Gizmo {
        context: C2dCanvasContext;
        view: C2dCanvas;
        layer: C2dLayer;
        document: any;
        blueprint: FamilyBlueprintNode;
        floorplan: FloorplanNode;
        protected _hookManager: V2dHookManager;
        protected _transactionService: TransactionService;
        constructor();
        setup(): void;
        onActivate(): void;
        onDeactivate(): void;
        unbindCommand(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/gizmo/C2dAlignmentLines" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
    import { C2dGizmo } from "sk/editor/logic/view/canvas2d/gizmo/C2dGizmo";
    export class C2dAlignmentLines extends C2dGizmo {
        graphics: V2dGraphicDrawing;
        build(count: number): V2dGraphicDrawing;
        updateData(lines: Types<Line2>, lineWidth?: number): void;
        updateDataInCanvasCoord(lines: Types<Line2>, lineWidth?: number): void;
        hide(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/canvas2d/selection/C2dSelectionManager" {
    import { V3dSelectionManager } from 'foundation/editor/view/view3d/selection/V3dSelectionManager';
    export class C2dSelectionManager extends V3dSelectionManager {
    }
}
declare module "sk/editor/logic/view/canvas2d/util/C2dGraphicUtil" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
    import { C2dCanvasContext } from "sk/editor/logic/view/canvas2d/C2dCanvasContext";
    export class C2dGraphicUtil {
        static drawPolygonGraphic(context: C2dCanvasContext, graphics: V2dGraphicDrawing, polygon: Array<Value2>, holes?: Array<Array<Value2>>): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/gizmo/C3dGizmoManager" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { SelectionEvent } from 'foundation/editor/base/selection/SelectionEvent';
    import { V3dGizmoManager } from 'foundation/editor/view/view3d/gizmo/V3dGizmoManager';
    import { V3dLinearDimension } from 'sk/editor/view/view3d/gizmo/V3dLinearDimension';
    import { C3dGizmoFactory } from "sk/editor/logic/view/webgl3d/gizmo/C3dGizmoFactory";
    export class C3dGizmoManager extends V3dGizmoManager {
        factory: C3dGizmoFactory;
        onSelectionChanged(sender: ListenerContext, event: SelectionEvent): void;
        createLinearDimension(): V3dLinearDimension;
    }
}
declare module "sk/editor/logic/view/webgl3d/selection/C3dSelectionManager" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { V3dSelectionManager } from 'foundation/editor/view/view3d/selection/V3dSelectionManager';
    export class C3dSelectionManager extends V3dSelectionManager {
        _lastEntity: DataNode;
        _lastClickTick: number;
        constructor();
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dLayers" {
    import { V3dLayers } from 'foundation/editor/view/view3d/V3dLayers';
    export class C3dLayers extends V3dLayers {
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dCanvasContext" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ThemeService } from 'foundation/core/module/theme/ThemeService';
    import { V3dGraphicMeshMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { V3dCanvasContext } from 'foundation/editor/view/view3d/V3dCanvasContext';
    import { C3dSelectionManager } from "sk/editor/logic/view/webgl3d/selection/C3dSelectionManager";
    import { C3dCanvas } from "sk/editor/logic/view/webgl3d/C3dCanvas";
    import { C3dCanvasOptions } from "sk/editor/logic/view/webgl3d/C3dCanvasOptions";
    import { C3dLayers } from "sk/editor/logic/view/webgl3d/C3dLayers";
    export class C3dCanvasContext extends V3dCanvasContext {
        canvas: C3dCanvas;
        options: C3dCanvasOptions;
        document: any;
        layers: C3dLayers;
        viewControl: any;
        frozen: boolean;
        halfWallMode: boolean;
        protected _materials: Dictionary<V3dGraphicMeshMaterial>;
        selectionManager: C3dSelectionManager;
        protected _themeService: ThemeService;
        constructor();
    }
}
declare module "sk/editor/logic/view/webgl3d/indicator/C3dIndicatorFactory" {
    import { V3dIndicatorFactory } from 'foundation/editor/view/view3d/indicator/V3dIndicatorFactory';
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    export class C3dIndicatorFactory extends V3dIndicatorFactory {
        context: C3dCanvasContext;
    }
}
declare module "sk/editor/logic/view/webgl3d/indicator/C3dIndicatorManager" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { VertexNode } from 'foundation/data/common/model/brep/VertexNode';
    import { V3dIndicatorManager } from 'foundation/editor/view/view3d/indicator/V3dIndicatorManager';
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    import { C3dIndicatorFactory } from "sk/editor/logic/view/webgl3d/indicator/C3dIndicatorFactory";
    export class C3dIndicatorManager extends V3dIndicatorManager {
        context: C3dCanvasContext;
        factory: C3dIndicatorFactory;
        constructor();
        onEventToolsChanged(sender: ListenerContext, tool: string): void;
        protected showCommonIndicator(selectEntity: DataNode, entities: Types<VertexNode>): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dObserver" {
    import { V3dObserver } from 'foundation/editor/view/view3d/V3dObserver';
    export class C3dObserver extends V3dObserver {
    }
}
declare module "sk/editor/logic/view/webgl3d/selection/C3dSelectorController" {
    import { V3dSelectorController } from 'foundation/editor/view/view3d/selection/V3dSelectorController';
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    import { C3dSelector } from "sk/editor/logic/view/webgl3d/selection/C3dSelector";
    export class C3dSelectorController extends V3dSelectorController {
        context: C3dCanvasContext;
        selector: C3dSelector;
    }
}
declare module "sk/editor/logic/view/webgl3d/selection/C3dSelector" {
    import { V3dPicker } from 'foundation/editor/view/view3d/selection/V3dPicker';
    import { V3dSelector } from 'foundation/editor/view/view3d/selection/V3dSelector';
    import { V3dSelectorEvent } from 'foundation/editor/view/view3d/selection/V3dSelectorEvent';
    import { DisplayEventEnum } from 'foundation/editor/view/base/DisplayEventEnum';
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    import { C3dSelectorController } from "sk/editor/logic/view/webgl3d/selection/C3dSelectorController";
    export class C3dSelector extends V3dSelector {
        context: C3dCanvasContext;
        controller: C3dSelectorController;
        picker: V3dPicker;
        setup(): void;
        processEvent(eventCd: DisplayEventEnum, event: V3dSelectorEvent): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dConstants" {
    import { MeshPhongMaterial } from 'foundation/runtime/graphics/material/MeshPhongMaterial';
    export class C3dConstants {
        static CAMERA_SCREEN_RATE: number;
        static FIRST_PERSON_CAMERA_MOVESPEED_RATE: number;
        static FIRST_PERSON_CAMERA_LOOKSPEED_RATE_HORIZAONTAL: number;
        static FIRST_PERSON_CAMERA_LOOKSPEED_RATE_VERTICAL: number;
        static AERIALVIEW_MOUSEWHEEL_STEP: number;
        static BACKGROUND_COLOR: number;
        static BOUNDARY_POLYON_FACTOR: number;
        static BOUNDARY_POLYON_UNITS: number;
        static BOUNDARY_COLOR_PATTERN_INSTANCE_TECHNOLOGY_INVALID: string;
        static BOUNDARY_OPACITY_PATTERN_INSTANCE_TECHNOLOGY_INVALID: number;
        static BOUNDARY_COLOR_PATTERN_INSTANCE_TECHNOLOGY_MANUAL: string;
        static BOUNDARY_OPACITY_PATTERN_INSTANCE_TECHNOLOGY_MANUAL: number;
        static CONTENT_PRELOADED_BOX_COLOR: number;
        static CONTENT_PRELOADED_BOX_OPACITY: number;
        static CONTENT_PRELOADED_FAILED_BOX_COLOR: number;
        static CONTENT_PRELOADED_FAILED_BOX_OPACITY: number;
        static CONTENT_BOX_EXPAND: number;
        static CONTENT_HOVER_COLOR: number;
        static CONTENT_HOVER_OPACITY: number;
        static CONTENT_SELECT_COLOR: number;
        static CONTENT_SELECT_OPACITY: number;
        static CONTENT_OPERATION_INDICATOR_COLOR: number;
        static CONTENT_OPERATION_INDICATOR_HIGHLIGHT_COLOR: number;
        static CONTENT_OPERATION_INDICATOR_OPACITY: number;
        static CONTENT_OPERATION_INDICATOR_DASHEDLINE_DASHSIZE: number;
        static CONTENT_OPERATION_INDICATOR_DASHEDLINE_GAPSIZE: number;
        static CONTENT_OPERATION_INDICATOR_DASHEDLINE_LINEWIDTH: number;
        static CONTENT_MOVEMENT_INDICATOR_SIZE: number;
        static CONTENT_MOVEMENT_INDICATOR_DIRECTIONAL_OFFSET: number;
        static CONTENT_MOVEMENT_INDICATOR_HEIGHT_OFFSET: number;
        static CONTENT_ROTATION_INDICATOR_SIZE: number;
        static CONTENT_ROTATION_INDICATOR_CIRCLE_SEGMENT: number;
        static CONTENT_ROTATION_INDICATOR_HEIGHT_OFFSET: number;
        static CONTENT_ROTATION_INDICATOR_TRIANGLE_SIZE: number;
        static CONTENT_ROTATION_INDICATOR_TRIANGLE_DISTANCE: number;
        static CONTENT_LIFT_INDICATOR_SCALE: number;
        static CONTENT_LIFT_INDICATOR_HEIGHT_OFFSET: number;
        static CONTENT_LIFT_INDICATOR_PICTURE_ORIGINAL_WIDTH: number;
        static CONTENT_LIFT_INDICATOR_PICTURE_ORIGINAL_HEIGHT: number;
        static CONTENT_LIFT_INDICATOR_OFFSET_INCREMENT: number;
        static DIMESION_PADDING: number;
        static DIMENSION_LINE_COLOR: number;
        static DIMENSION_ARROW_COLOR: number;
        static DIMENSION_TEXT_COLOR: string;
        static DIMENSION_TEXT_AREA_COLOR: string;
        static PLANK_H_COLOR: number;
        static PLANK_V_COLOR: number;
        static PLANK_F_COLOR: number;
        static PLANK_SNAP: number;
        static PLANK_SELECT_OPACITY: number;
        static PLANK_SELECT_COLOR: number;
        static PLANK_SELECT_BORDER_COLOR: number;
        static PLANK_SELECT_DASH_BORDER_COLOR: number;
        static PLANK_DIMENSION_TEXT_COLOR: string;
        static PLANK_DIMENSION_AREA_BORDER_COLOR: string;
        static PLANK_DIMENSION_AREA_GROUND_COLOR: string;
        static MATERIAL_LAYOUT_GAP_COLOR: string;
        static HARDWARE_COLOR: number;
        private static _instance;
        private static instance;
        static getPreloadMaterial(): MeshPhongMaterial;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dGridController" {
    import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
    import { GridEntity } from 'foundation/editor/view/entity/GridEntity';
    import { V3dGridController } from 'foundation/editor/view/view3d/V3dGridController';
    export class C3dGridController extends V3dGridController {
        entity: GridEntity;
        onClick(event: ContentActionEvent): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dGrid" {
    import { GridEntity } from 'foundation/editor/view/entity/GridEntity';
    import { V3dGrid } from 'foundation/editor/view/view3d/V3dGrid';
    import { C3dCanvas } from "sk/editor/logic/view/webgl3d/C3dCanvas";
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    import { C3dGridController } from "sk/editor/logic/view/webgl3d/C3dGridController";
    export class C3dGrid extends V3dGrid {
        view: C3dCanvas;
        context: C3dCanvasContext;
        entity: GridEntity;
        controller: C3dGridController;
        constructor();
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dCanvas" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { ResizeEvent } from 'cross/editor/device/screen/ResizeEvent';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { RenderService } from 'foundation/editor/view/base/render/RenderService';
    import { V3dCanvas } from 'foundation/editor/view/view3d/V3dCanvas';
    import { FamilyObserverEnum } from 'sk/data/family/library/FamilyObserverEnum';
    import { FamilyBlueprintNode } from 'sk/data/family/model/FamilyBlueprintNode';
    import { C3dIndicatorManager } from "sk/editor/logic/view/webgl3d/indicator/C3dIndicatorManager";
    import { C3dSelector } from "sk/editor/logic/view/webgl3d/selection/C3dSelector";
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    import { C3dCanvasOptions } from "sk/editor/logic/view/webgl3d/C3dCanvasOptions";
    import { C3dGrid } from "sk/editor/logic/view/webgl3d/C3dGrid";
    import { C3dLayers } from "sk/editor/logic/view/webgl3d/C3dLayers";
    import { C3dObserver } from "sk/editor/logic/view/webgl3d/C3dObserver";
    export class C3dCanvas extends V3dCanvas {
        options: C3dCanvasOptions;
        context: C3dCanvasContext;
        layers: C3dLayers;
        observer: C3dObserver;
        defaultObserverType: FamilyObserverEnum;
        indicatorManager: C3dIndicatorManager;
        selector: C3dSelector;
        grid: C3dGrid;
        protected _renderService: RenderService;
        constructor();
        onSetupAsync(): Promise<ResultObject>;
        openBlueprint(blueprint: FamilyBlueprintNode, nodes?: [DataNode]): void;
        closeBlueprint(): void;
        onBlueprintFiledChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onMouseEnter(sender: ListenerContext, event: MouseDeviceEvent): void;
        onMouseLeave(sender: ListenerContext, event: MouseDeviceEvent): void;
        onMouseDown(sender: ListenerContext, event: MouseDeviceEvent): void;
        onMouseMove(sender: ListenerContext, event: MouseDeviceEvent): void;
        onMouseUp(sender: ListenerContext, event: MouseDeviceEvent): void;
        onResize(sender?: ListenerContext, event?: ResizeEvent): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/gizmo/C3dGizmoFactory" {
    import { ObjectPool } from 'cross/runtime/lang/ObjectPool';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { Gizmo } from 'foundation/editor/view/base/gizmo/Gizmo';
    import { V3dGizmoFactory } from 'foundation/editor/view/view3d/gizmo/V3dGizmoFactory';
    import { V3dLayer } from 'foundation/editor/view/view3d/V3dLayer';
    import { V3dLinearDimension } from 'sk/editor/view/view3d/gizmo/V3dLinearDimension';
    import { V3dLinearDimensionHelper } from 'sk/editor/view/view3d/helper/V3dLinearDimensionHelper';
    import { C3dCanvas } from "sk/editor/logic/view/webgl3d/C3dCanvas";
    export class C3dGizmoFactory extends V3dGizmoFactory {
        canvas: C3dCanvas;
        layer: V3dLayer;
        manager: any;
        protected _dimensionPool: ObjectPool<V3dLinearDimension>;
        protected _dimensionHelpersPool: ObjectPool<V3dLinearDimensionHelper>;
        constructor();
        setupGizmo(gizmo: Gizmo, entity: DataNode): void;
        createLinearDimension(): V3dLinearDimension;
        createLinearDimensionHelper(): V3dLinearDimensionHelper;
        allocLinearDimension(): V3dLinearDimension;
        allocLinearDimensionHelper(): V3dLinearDimensionHelper;
        freeLinearDimension(helper: V3dLinearDimension): void;
        freeLinearDimensionHelper(helper: V3dLinearDimensionHelper): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dCanvasOptions" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { V3dCanvasOptions } from 'foundation/editor/view/view3d/V3dCanvasOptions';
    export class C3dCanvasOptions extends V3dCanvasOptions {
        static FIELD_DISTANCE_MULTIPLE: string;
        static FIELD_EXPLODED_CENTER: string;
        distanceMultiple: number;
        explodedCenter: Vector3;
        constructor();
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dBrepController" {
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DisplayController } from 'foundation/editor/view/base/DisplayController';
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    export class C3dBrepController extends DisplayController {
        context: C3dCanvasContext;
        entity: BrepNode;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dContentController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
    import { C3dBrepController } from "sk/editor/logic/view/webgl3d/C3dBrepController";
    import { C3dContent } from "sk/editor/logic/view/webgl3d/C3dContent";
    export class C3dContentController extends C3dBrepController {
        entity: ContentNode;
        display: C3dContent;
        constructor();
        setup(): void;
        getEntity(): ContentNode;
        onMouseEnter(sender: ListenerContext, event: ContentActionEvent): void;
        onMouseLeave(sender: ListenerContext, event: ContentActionEvent): void;
        isMultiSelectKey(event: ContentActionEvent): boolean;
        onClick(sender: ListenerContext, event: ContentActionEvent): boolean;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dContent" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { NodeFieldEvent } from 'cross/runtime/framework/node/NodeFieldEvent';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { V3dContent } from 'foundation/editor/view/view3d/V3dContent';
    import { V3dLayer } from 'foundation/editor/view/view3d/V3dLayer';
    import { C3dCanvas } from "sk/editor/logic/view/webgl3d/C3dCanvas";
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    import { C3dContentController } from "sk/editor/logic/view/webgl3d/C3dContentController";
    export class C3dContent extends V3dContent {
        context: C3dCanvasContext;
        view: C3dCanvas;
        controller: C3dContentController;
        optionDrawMode: boolean;
        hoverLayer: V3dLayer;
        constructor();
        setup(): void;
        onCanvasOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        onEditOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        protected isInRoom(room: any, instance: ContentNode): boolean;
        bindAction(): void;
        unbindAction(): void;
        findExplodeReferenceNode(): ContentNode;
        protected updateTransform(): void;
        protected updateStatusHover(): void;
        protected updateStatusError(): void;
        protected updateboundaryStatus(): void;
        protected updateStyle(): void;
        protected canDrawByParentClass(): boolean;
        canDraw(): boolean;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dComposite" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    import { C3dContent } from "sk/editor/logic/view/webgl3d/C3dContent";
    export class C3dComposite extends C3dContent {
        entity: FamilyInstanceNode | PatternInstanceNode;
        statusComposite: boolean;
        protected _statusCompositeDirty: boolean;
        constructor();
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        updateComposite(): void;
        drawDisplay(displayContext?: DisplayContext): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dFamilyInstance" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { C3dComposite } from "sk/editor/logic/view/webgl3d/C3dComposite";
    export class C3dFamilyInstance extends C3dComposite {
        entity: FamilyInstanceNode;
        protected childrenLoadCount: number;
        protected showLoadBox: boolean;
        protected _schemeConfigService: SchemeConfigService;
        constructor();
        setup(): void;
        getInfoByNodeAsync(node: FamilyInstanceNode): Promise<any>;
        addChildDisplayLoadingCount(add: number): void;
        updateComposite(): void;
        updateMoldingEntity(entity: DataNode): void;
        protected updateStyle(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dCompositeContent" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { NodeFieldEvent } from 'cross/runtime/framework/node/NodeFieldEvent';
    import { V3dDynamicMesh } from 'foundation/editor/view/view3d/render/V3dDynamicMesh';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { C3dContent } from "sk/editor/logic/view/webgl3d/C3dContent";
    import { C3dFamilyInstance } from "sk/editor/logic/view/webgl3d/C3dFamilyInstance";
    export class C3dCompositeContent extends C3dContent {
        statusComposite: boolean;
        protected _dynamicMesh: V3dDynamicMesh;
        protected _useMerger: boolean;
        protected _statusMergerDirty: boolean;
        protected firstLoad: boolean;
        constructor();
        onCanvasOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        drawDisplay(displayContext?: DisplayContext): void;
        updateMerger(): void;
        protected getTopFamilyInstanceDisplay(): C3dFamilyInstance;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dPlane" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Lines } from 'foundation/runtime/graphics/data/Lines';
    import { MoldingService } from 'foundation/core/module/molding/MoldingService';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicLines } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLines';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { V3dGraphicMeshInstance } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshInstance';
    import { V3dGraphicMeshMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { RenderService } from 'foundation/editor/view/base/render/RenderService';
    import { V3dBoundaryHelper } from 'foundation/editor/view/view3d/helper/V3dBoundaryHelper';
    import { V3dMoldingBoundaryHelper } from 'foundation/editor/view/view3d/helper/V3dMoldingBoundaryHelper';
    import { V3dDynamicLinesMesh } from 'foundation/editor/view/view3d/render/V3dDynamicLinesMesh';
    import { V3dDynamicMesh } from 'foundation/editor/view/view3d/render/V3dDynamicMesh';
    import { TechnologyNode } from 'sk/data/family/model/component/TechnologyNode';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { SurfaceNode } from 'sk/data/family/model/instance/SurfaceNode';
    import { PlaneGraphic3dStructure } from 'sk/data/family/molding/instance/PlaneGraphic3dStructure';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { C3dCompositeContent } from "sk/editor/logic/view/webgl3d/C3dCompositeContent";
    import { C3dPlaneController } from "sk/editor/logic/view/webgl3d/C3dPlaneController";
    type PlaneLoadMaterialOption = {
        alpha?: number;
        decorate?: boolean;
    };
    export class C3dPlane extends C3dCompositeContent {
        entity: PlaneNode;
        entityShapeIdentity: string;
        viewDepthScale: number;
        viewDepthOffset: number;
        moldingStructure: PlaneGraphic3dStructure;
        controller: C3dPlaneController;
        protected _surfaceMeshs: Dictionary<V3dGraphicMesh>;
        protected _subMeshIndex: number[];
        protected _depthSurfaceMeshes: Dictionary<V3dGraphicMesh>;
        protected _dynamicMeshes: Dictionary<V3dDynamicMesh>;
        protected _surfaceMaterials: Dictionary<V3dGraphicMeshMaterial>;
        protected _statusMaterialChanged: boolean;
        protected _nodeLineMesh: V3dGraphicLines;
        protected _dynamicLineMesh: V3dDynamicLinesMesh;
        protected _lines: Lines;
        protected _colorOption: any;
        protected _holes: Array<TechnologyNode>;
        protected _optionVisionMolding: boolean;
        protected _useDynamicMesh: boolean;
        protected _moldingService: MoldingService;
        protected _schemeConfigService: SchemeConfigService;
        protected _renderService: RenderService;
        protected _surfaceBoundaryHelper: V3dBoundaryHelper | V3dMoldingBoundaryHelper;
        private __oldEdgeCount;
        private __isEditFrontStatus;
        private __isDrawOutline;
        private __depthMehMaterial;
        private __curShowModel;
        private __defaultDepthName;
        private __depthNode;
        constructor();
        bindAction(): void;
        unbindAction(): void;
        makeShapeIdentity(): string;
        getInfoByNodeAsync(node: PlaneNode): Promise<void>;
        private checkNodeOutlinesOption;
        private setColorOption;
        setup(): void;
        onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityEditSurfaceChange(sender: ListenerContext, event: DataNodeFieldEvent): void;
        testShapeChanged(event: DataNodeFieldEvent): boolean;
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        createMesh(id: string, name?: string): V3dGraphicMesh;
        createDepthMesh(name: string): V3dGraphicMesh;
        findMeshById(code: string): V3dGraphicMesh;
        setMeshVisible(visible: boolean): void;
        setDepthMeshVisible(visible: boolean): void;
        setMeshMaterail(useColor: boolean): void;
        setLinesColor(color: number): void;
        createDepthNode(): void;
        createNode(): V3dGraphicContainer;
        protected getDepthMeshMaterial(): V3dGraphicMeshMaterial;
        protected loadSurfaceMaterialBySurfaceAsync(surface: SurfaceNode, option?: PlaneLoadMaterialOption): Promise<ResultObject<V3dGraphicMeshMaterial>>;
        protected loadSurfaceMaterialByIdAsync(materialResourceId: string, alpha?: number): Promise<ResultObject<V3dGraphicMeshMaterial>>;
        protected setMaterailProperty(material: V3dGraphicMeshMaterial): void;
        protected updateTransform(): void;
        protected updateSurfacesMaterialAsync(): Promise<void>;
        protected updateMaterialAsync(): Promise<void>;
        protected createCollisionNode(): V3dGraphicMesh | V3dGraphicMeshInstance;
        protected updateCollisionNode(collisionMesh: V3dGraphicMesh | V3dGraphicMeshInstance): void;
        updateHelper(): void;
        updateShape(): void;
        protected updateMeshData(type: string, data: any): void;
        protected updateStyle(): void;
        protected setBorderModeDepthMehMaterial(): void;
        setLineMeshVisible(visible: boolean): void;
        private isFurniturePlankCupboardTopFamilyType;
        private isBathroomPlankSeamTopFamilyType;
        protected updateSurfaceBoundary(): void;
        protected createSurfaceBoundaryHepler(): void;
        canDraw(): boolean;
        show(): void;
        hide(): void;
        protected updateVisibilityByOption(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dPlaneController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { KeyboardDeviceEvent } from 'cross/editor/device/keyboard/KeyboardDeviceEvent';
    import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { C3dContentController } from "sk/editor/logic/view/webgl3d/C3dContentController";
    import { C3dPlane } from "sk/editor/logic/view/webgl3d/C3dPlane";
    export class C3dPlaneController extends C3dContentController {
        entity: PlaneNode;
        display: C3dPlane;
        private _lastClickTick;
        constructor();
        setup(): void;
        onDragStart(sender: ListenerContext, event: ContentActionEvent): void;
        onDragEnd(sender: ListenerContext, event: ContentActionEvent): void;
        onKeyDown(sender: ListenerContext, event: KeyboardDeviceEvent): void;
        onKeyUp(sender: ListenerContext, event: KeyboardEvent): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dAreaPolygon" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Lines } from 'foundation/runtime/graphics/data/Lines';
    import { MoldingService } from 'foundation/core/module/molding/MoldingService';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicLines } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLines';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { V3dGraphicMeshMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { RenderService } from 'foundation/editor/view/base/render/RenderService';
    import { V3dDynamicLinesMesh } from 'foundation/editor/view/view3d/render/V3dDynamicLinesMesh';
    import { V3dDynamicMesh } from 'foundation/editor/view/view3d/render/V3dDynamicMesh';
    import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
    import { AreaGraphic3dStructure } from 'sk/data/family/molding/instance/AreaGraphic3dStructure';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { C3dCompositeContent } from "sk/editor/logic/view/webgl3d/C3dCompositeContent";
    import { C3dPlaneController } from "sk/editor/logic/view/webgl3d/C3dPlaneController";
    export class C3dAreaPolygon extends C3dCompositeContent {
        entity: AreaPolygonNode;
        viewDepthScale: number;
        viewDepthOffset: number;
        moldingStructure: AreaGraphic3dStructure;
        controller: C3dPlaneController;
        protected _mesh: V3dGraphicMesh;
        protected _dynamicMesh: V3dDynamicMesh;
        protected _material: V3dGraphicMeshMaterial;
        protected _statusMaterialChanged: boolean;
        protected _nodeLineMesh: V3dGraphicLines;
        protected _dynamicLineMesh: V3dDynamicLinesMesh;
        protected _lines: Lines;
        protected _colorOption: any;
        protected _optionVisionMolding: boolean;
        protected _moldingService: MoldingService;
        protected _schemeConfigService: SchemeConfigService;
        protected _renderService: RenderService;
        private oldEdgeCount;
        constructor();
        setup(): void;
        onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        testShapeChanged(event: DataNodeFieldEvent): boolean;
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        setMeshVisible(visible: boolean): void;
        setMeshMaterail(useColor: boolean): void;
        setLinesColor(color: number): void;
        createNode(): V3dGraphicContainer;
        protected loadSurfaceMaterialAsync(materialResourceId: string): Promise<ResultObject<V3dGraphicMeshMaterial>>;
        protected updateTransform(): void;
        protected updateSurfacesMaterialAsync(): Promise<void>;
        protected updateMaterialAsync(): Promise<void>;
        updateHelper(): void;
        updateShape(): void;
        protected updateStyle(): void;
        canDraw(): boolean;
        show(): void;
        hide(): void;
        protected updateVisibilityByOption(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dAreaPolygonController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { KeyboardDeviceEvent } from 'cross/editor/device/keyboard/KeyboardDeviceEvent';
    import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
    import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
    import { C3dAreaPolygon } from "sk/editor/logic/view/webgl3d/C3dAreaPolygon";
    import { C3dContentController } from "sk/editor/logic/view/webgl3d/C3dContentController";
    export class C3dAreaPolygonController extends C3dContentController {
        entity: AreaPolygonNode;
        display: C3dAreaPolygon;
        private _lastClickTick;
        constructor();
        setup(): void;
        onDragStart(sender: ListenerContext, event: ContentActionEvent): void;
        onDragEnd(sender: ListenerContext, event: ContentActionEvent): void;
        onKeyDown(sender: ListenerContext, event: KeyboardDeviceEvent): void;
        onKeyUp(sender: ListenerContext, event: KeyboardEvent): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dBgimage" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { Display } from 'foundation/editor/view/base/Display';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    export class C3dBgImage extends Display {
        context: C3dCanvasContext;
        protected _mesh: V3dGraphicMesh;
        protected _colorOption: any;
        constructor();
        setup(): void;
        createNode(): V3dGraphicContainer;
        protected createMesh(): void;
        setMeshMaterial(useColor: boolean): void;
        updateShape(): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        show(): void;
        hide(): void;
        onDraw(context?: DisplayContext): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dBoxContent" {
    import { Color4 } from 'foundation/runtime/math/Color4';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    import { C3dContent } from "sk/editor/logic/view/webgl3d/C3dContent";
    export class C3dBoxContent extends C3dContent {
        context: C3dCanvasContext;
        entity: ContentNode;
        boxMesh: V3dGraphicMesh;
        color: Color4;
        constructor();
        createNode(): V3dGraphicContainer;
        protected updateShape(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dCountertopController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { KeyboardDeviceEvent } from 'cross/editor/device/keyboard/KeyboardDeviceEvent';
    import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
    import { CountertopNode } from 'sk/data/scheme/database/furniture/model/CountertopNode';
    import { C3dContentController } from "sk/editor/logic/view/webgl3d/C3dContentController";
    import { C3dCountertop } from "sk/editor/logic/view/webgl3d/C3dCountertop";
    export class C3dCountertopController extends C3dContentController {
        entity: CountertopNode;
        display: C3dCountertop;
        private _lastClickTick;
        constructor();
        setup(): void;
        onDragStart(sender: ListenerContext, event: ContentActionEvent): void;
        onDragEnd(sender: ListenerContext, event: ContentActionEvent): void;
        onKeyDown(sender: ListenerContext, event: KeyboardDeviceEvent): void;
        onKeyUp(sender: ListenerContext, event: KeyboardEvent): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dCountertop" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Lines } from 'foundation/runtime/graphics/data/Lines';
    import { MoldingService } from 'foundation/core/module/molding/MoldingService';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicLines } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLines';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { V3dGraphicMeshMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { RenderService } from 'foundation/editor/view/base/render/RenderService';
    import { V3dDynamicLinesMesh } from 'foundation/editor/view/view3d/render/V3dDynamicLinesMesh';
    import { V3dDynamicMesh } from 'foundation/editor/view/view3d/render/V3dDynamicMesh';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { CountertopNode } from 'sk/data/scheme/database/furniture/model/CountertopNode';
    import { CountertopGraphic3dStructure } from 'sk/data/scheme/molding/furniture/CountertopGraphic3dStructure';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { C3dCompositeContent } from "sk/editor/logic/view/webgl3d/C3dCompositeContent";
    import { C3dCountertopController } from "sk/editor/logic/view/webgl3d/C3dCountertopController";
    export class C3dCountertop extends C3dCompositeContent {
        entity: CountertopNode;
        viewDepthScale: number;
        viewDepthOffset: number;
        moldingStructure: CountertopGraphic3dStructure;
        controller: C3dCountertopController;
        protected _surfaceMeshs: Dictionary<V3dGraphicMesh>;
        protected _dynamicMeshes: Dictionary<V3dDynamicMesh>;
        protected _surfaceMaterials: Dictionary<V3dGraphicMeshMaterial>;
        protected _statusMaterialChanged: boolean;
        protected _nodeLineMesh: V3dGraphicLines;
        protected _dynamicLineMesh: V3dDynamicLinesMesh;
        protected _lines: Lines;
        protected _colorOption: any;
        protected _optionVisionMolding: boolean;
        protected _useDynamicMesh: boolean;
        protected _moldingService: MoldingService;
        protected _schemeConfigService: SchemeConfigService;
        protected _renderService: RenderService;
        constructor();
        getInfoByNodeAsync(node: PlaneNode): Promise<void>;
        private setColorOption;
        setup(): void;
        onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        testShapeChanged(event: DataNodeFieldEvent): boolean;
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        updateMerger(): void;
        createMesh(id: string, name?: string): V3dGraphicMesh;
        findMeshById(code: string): V3dGraphicMesh;
        setMeshVisible(visible: boolean): void;
        setMeshMaterail(useColor: boolean): void;
        setLinesColor(color: number): void;
        createNode(): V3dGraphicContainer;
        protected loadSurfaceMaterialAsync(materialResourceId: string): Promise<ResultObject<V3dGraphicMeshMaterial>>;
        protected updateTransform(): void;
        protected updateSurfacesMaterialAsync(): Promise<void>;
        protected updateMaterialAsync(): Promise<void>;
        updateHelper(): void;
        updateShape(): void;
        protected updateStyle(): void;
        canDraw(): boolean;
        show(): void;
        hide(): void;
        protected updateVisibilityByOption(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dGeometricBoxSolid" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
    import { DataResourceService } from 'foundation/data/common/io/DataResourceService';
    import { HoverService } from 'foundation/editor/base/selection/HoverService';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { BoxSolidEntity } from "sk/editor/logic/entity/BoxSolidEntity";
    import { C3dContent } from "sk/editor/logic/view/webgl3d/C3dContent";
    export class C3dGeometricBoxSolid extends C3dContent {
        entity: BoxSolidEntity;
        boxMesh: V3dGraphicMesh;
        protected _resourceService: DataResourceService;
        protected _selectionService: SelectionService;
        protected _hoverService: HoverService;
        constructor();
        createNode(): V3dGraphicContainer;
        protected updateTransform(): void;
        protected updateShape(): void;
        onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dGeometricSphereSolid" {
    import { DataResourceService } from 'foundation/data/common/io/DataResourceService';
    import { HoverService } from 'foundation/editor/base/selection/HoverService';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { V3dSpatial } from 'foundation/editor/view/view3d/V3dSpatial';
    import { SphereSolidEntity } from "sk/editor/logic/entity/SphereSolidEntity";
    export class C3dGeometricSphereSolid extends V3dSpatial {
        entity: SphereSolidEntity;
        node: V3dGraphicContainer;
        mesh: V3dGraphicMesh;
        protected _resourceService: DataResourceService;
        protected _selectionService: SelectionService;
        protected _hoverService: HoverService;
        constructor();
        createNode(): V3dGraphicContainer;
        protected updateTransform(): void;
        freezeWorldMatrix(): void;
        protected updateShape(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dInterface" {
    import { Color } from 'foundation/runtime/math/Color';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { V3dGraphicLines } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLines';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { InterfaceNode } from 'sk/data/family/model/instance/InterfaceNode';
    import { C3dContent } from "sk/editor/logic/view/webgl3d/C3dContent";
    export class C3dInterface extends C3dContent {
        entity: InterfaceNode;
        protected _meshLineZ: V3dGraphicLines;
        protected _meshConeZ: V3dGraphicMesh;
        protected _meshPlaneXY: V3dGraphicMesh;
        protected _color: Color;
        lineLength: number;
        coneHeight: number;
        coneDiameter: number;
        constructor();
        testTransformChanged(event: DataNodeFieldEvent): boolean;
        testShapeChanged(event: DataNodeFieldEvent): boolean;
        protected getPosition(): Vector3;
        protected updateAxisShape(meshConeName: string, meshLineName: string): void;
        protected updatePlaneShape(): void;
        protected updateShape(): void;
        hide(): void;
        show(): void;
        removeMesh(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dLayerTypeEnum" {
    import { V3dLayerTypeEnum } from 'foundation/editor/view/view3d/V3dLayerTypeEnum';
    export class C3dLayerTypeEnum extends V3dLayerTypeEnum {
        static Wall: string;
        static RawWall: string;
        static SpaceShape: string;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dLayout" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { V3dGraphicMeshMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { LayoutNode } from 'sk/data/family/model/instance/LayoutNode';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { C3dContent } from "sk/editor/logic/view/webgl3d/C3dContent";
    export class C3dLayout extends C3dContent {
        entity: LayoutNode;
        protected _gapMesh: V3dGraphicMesh;
        protected _viewDepthScale: number;
        protected _viewDepthOffset: number;
        protected _statusMaterialChanged: boolean;
        protected _schemeConfigService: SchemeConfigService;
        protected _statusLayoutGapStyleChange: boolean;
        private __layoutName;
        private __statusMaterialProperty;
        private _tileMesh;
        constructor();
        setup(): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        canDraw(): boolean;
        createNode(): V3dGraphicContainer;
        createGapMesh(): void;
        createMesh(name: any, parent: any): V3dGraphicMesh;
        protected updateShape(): void;
        protected updateLayoutShape(): void;
        updateMeshMaterialAsync(): Promise<void>;
        protected updateStyle(): void;
        protected updateLayoutGapMaterialAsync(): Promise<void>;
        private updateTileMaterialByMergedMeshAsync;
        protected loadMaterialByIdAsync(materialId: string): Promise<ResultObject<V3dGraphicMeshMaterial>>;
        private getName;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dLightController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { KeyboardDeviceEvent } from 'cross/editor/device/keyboard/KeyboardDeviceEvent';
    import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
    import { LightNode } from 'sk/data/family/model/instance/LightNode';
    import { C3dContentController } from "sk/editor/logic/view/webgl3d/C3dContentController";
    import { C3dLight } from "sk/editor/logic/view/webgl3d/C3dLight";
    export class C3dLightController extends C3dContentController {
        entity: LightNode;
        display: C3dLight;
        private _lastClickTick;
        constructor();
        setup(): void;
        onDragStart(sender: ListenerContext, event: ContentActionEvent): void;
        onDragEnd(sender: ListenerContext, event: ContentActionEvent): void;
        onKeyDown(sender: ListenerContext, event: KeyboardDeviceEvent): void;
        onKeyUp(sender: ListenerContext, event: KeyboardEvent): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dLight" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicLight } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLight';
    import { V3dGraphicLines } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLines';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { V3dGraphicMeshMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { LightNode } from 'sk/data/family/model/instance/LightNode';
    import { PointLightNode } from 'sk/data/scheme/database/light/model/PointLightNode';
    import { SpotLightNode } from 'sk/data/scheme/database/light/model/SpotLightNode';
    import { C3dContent } from "sk/editor/logic/view/webgl3d/C3dContent";
    import { C3dLightController } from "sk/editor/logic/view/webgl3d/C3dLightController";
    export class C3dLight extends C3dContent {
        entity: LightNode;
        controller: C3dLightController;
        protected _mesh: V3dGraphicMesh;
        protected _lineMesh: V3dGraphicLines;
        protected _material: V3dGraphicMeshMaterial;
        protected _colorOption: any;
        protected _light: V3dGraphicLight;
        constructor();
        setup(): void;
        onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        testShapeChanged(event: DataNodeFieldEvent): boolean;
        createMesh(): V3dGraphicMesh;
        createPointLight(): V3dGraphicLight;
        protected createSpotLight(): V3dGraphicLight;
        protected updateLight(): void;
        protected updatePointLight(node: PointLightNode): void;
        protected updateSpotLight(node: SpotLightNode): void;
        createLineMesh(): V3dGraphicLines;
        setMeshVisible(visible: boolean): void;
        setLineMeshVisible(visible: boolean): void;
        setMeshMaterail(useColor: boolean): void;
        setLineMeshMaterail(useColor: boolean): void;
        createNode(): V3dGraphicContainer;
        protected createLightStage(): void;
        protected updateTransform(): void;
        updateShape(): void;
        protected updateStyle(): void;
        show(): void;
        hide(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dLinear" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { DocumentEvent } from 'cross/runtime/framework/document/DocumentEvent';
    import { LoaderEvent } from 'cross/core/module/loader/LoaderEvent';
    import { Lines } from 'foundation/runtime/graphics/data/Lines';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicLines } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLines';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { V3dGraphicMeshMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { V3dBoundaryHelper } from 'foundation/editor/view/view3d/helper/V3dBoundaryHelper';
    import { V3dDynamicMeshMerger } from 'foundation/editor/view/view3d/render/V3dDynamicMeshMerger';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { LinearNode } from 'sk/data/family/model/instance/LinearNode';
    import { LinearGraphic3dStructure } from 'sk/data/family/molding/instance/LinearGraphic3dStructure';
    import { CurveDataDocument } from 'sk/data/resource/curve/model/CurveDataDocument';
    import { C3dContent } from "sk/editor/logic/view/webgl3d/C3dContent";
    export class C3dLinear extends C3dContent {
        entity: LinearNode;
        nodeDisplay: any;
        moldingStructure: LinearGraphic3dStructure;
        optionModel: boolean;
        protected _sidemesh: V3dGraphicMesh;
        protected _beginmesh: V3dGraphicMesh;
        protected _endmesh: V3dGraphicMesh;
        protected _nodeLineMesh: V3dGraphicLines;
        protected _lines: Lines;
        protected _flipZ: boolean;
        protected _material: V3dGraphicMeshMaterial;
        protected _colorOption: any;
        protected _boundaryHelper: V3dBoundaryHelper;
        protected _curvedocument: CurveDataDocument;
        protected _statusMaterialChanged: boolean;
        protected _stateMaterialReady: boolean;
        protected _statePolygonsReady: boolean;
        constructor();
        setup(): void;
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        loadPolygons(guid: string, version: string): void;
        onLoadCurveFailure(sender: ListenerContext, event: DocumentEvent): void;
        onLoadCurveComplete(sender: ListenerContext, event: DocumentEvent): void;
        createNode(): V3dGraphicContainer;
        private isFurnitureLinearFamilyType;
        updateShape(): void;
        protected updateStyle(): void;
        protected meshFlipZ(structure: LinearGraphic3dStructure): void;
        protected getMeshMerger(): V3dDynamicMeshMerger;
        protected translate(structure: LinearGraphic3dStructure): void;
        protected updateStatus(): void;
        protected createMesh(): void;
        protected createNodeLines(): void;
        setMeshVisible(visible: boolean): void;
        setLineMeshVisible(visible: boolean): void;
        setLinesColor(color: number): void;
        setLineMeshMaterail(useColor: boolean, color: number): void;
        setMeshMaterail(useColor: boolean): void;
        onOptionFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEditEntityChanged(sender: ListenerContext, event: any): void;
        onShapeChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEdgeOverrideChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        testShapeChanged(event: DataNodeFieldEvent): boolean;
        canDraw(): boolean;
        protected onDecorateTextureSuccess(sender: ListenerContext, event: LoaderEvent): void;
        protected onDecorateTextureFailure(sender: ListenerContext, event: LoaderEvent): void;
        protected loadMaterialAsync(): Promise<V3dGraphicMeshMaterial>;
        onDraw(context?: DisplayContext): void;
        show(): void;
        hide(): void;
        bindAction(): void;
        unbindAction(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dLogicDisplay" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMeshMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { BrepDisplay } from 'foundation/editor/view/base/BrepDisplay';
    export class C3dLogicDisplay extends BrepDisplay {
        context: any;
        view: any;
        protected _statusMaterialChanged: boolean;
        protected _logicDisplay: SkNative.FLogicDisplay;
        viewDepthScale: number;
        viewDepthOffset: number;
        constructor();
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        createNode(): V3dGraphicContainer;
        onDraw(): void;
        protected updateShape(): void;
        protected updateStyle(): void;
        protected getMaterialByMaterialIdAsync(materialInfoId: string): Promise<V3dGraphicMeshMaterial>;
        private setLayerShow;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dLogicStreamUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ByteStream } from 'cross/runtime/lang/stream/ByteStream';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { UVOptions } from 'foundation/runtime/geometry/UVOptions';
    import { Curve2dStructure } from 'foundation/data/common/structure/geometric/Curve2dStructure';
    export class SkLfPolylineVertex {
        _isLine: boolean;
        _point: Vector3;
        _midPoint: Vector3;
        constructor();
        serializ(stream: ByteStream): void;
    }
    export class SkLfPolyline3d {
        _vertexes: Array<SkLfPolylineVertex>;
        _closed: boolean;
        constructor();
        serializ(stream: ByteStream): void;
        addLineVertex(point: Vector3): void;
        addArcVertex(point: Vector3, midPt: Vector3): void;
        buildFromCurves(curves: Types<Curve2dStructure>, isClosed?: boolean): boolean;
        buildFromPoints(points: Array<Vector3>, isClosed?: boolean): boolean;
    }
    export class SkLfCylinder3d {
        _center: Vector3;
        _radius: number;
        _extrudeDir: Vector3;
        constructor();
        serializ(stream: ByteStream): void;
    }
    export class SkLfPrism3d {
        _outline: SkLfPolyline3d;
        _extrudeDir: Vector3;
        constructor();
        serializ(stream: ByteStream): void;
    }
    export class SkLfPipe3d {
        _outline: SkLfPolyline3d;
        _path: SkLfPolyline3d;
        constructor();
        serializ(stream: ByteStream): void;
    }
    export class PlaneCircleHole extends SkLfCylinder3d {
        serializ(stream: ByteStream): void;
    }
    export class PlanePolygonHole extends SkLfPrism3d {
        serializ(stream: ByteStream): void;
    }
    export class SkLfPlane {
        _outline: SkLfPolyline3d;
        _thick: number;
        _edgeFilletR: number;
        _holeEdgeFilletR: number;
        _holeData: Types<any>;
        _frontSurfaceUVOptions: UVOptions;
        _backSurfaceUVOptions: UVOptions;
        _edgeSurfaceUVOptions: UVOptions;
        constructor();
        serializ(stream: ByteStream): void;
        uvOptionsSerializ(uvOptions: UVOptions, stream: ByteStream): void;
        addCircleHole(center: Vector3, radius: number, extrudeDir: Vector3): void;
        addPolygonHole(outline: SkLfPolyline3d, extrudeDir: Vector3): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dLogicLinear" {
    import { ByteStream } from 'cross/runtime/lang/stream/ByteStream';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { LoaderEvent } from 'cross/core/module/loader/LoaderEvent';
    import { Lines } from 'foundation/runtime/graphics/data/Lines';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicLines } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLines';
    import { V3dGraphicMeshMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { V3dBoundaryHelper } from 'foundation/editor/view/view3d/helper/V3dBoundaryHelper';
    import { V3dDynamicMeshMerger } from 'foundation/editor/view/view3d/render/V3dDynamicMeshMerger';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { LinearNode } from 'sk/data/family/model/instance/LinearNode';
    import { LinearGraphic3dStructure } from 'sk/data/family/molding/instance/LinearGraphic3dStructure';
    import { CurveDataDocument } from 'sk/data/resource/curve/model/CurveDataDocument';
    import { C3dContent } from "sk/editor/logic/view/webgl3d/C3dContent";
    export class C3dLogicLinear extends C3dContent {
        entity: LinearNode;
        nodeDisplay: any;
        moldingStructure: LinearGraphic3dStructure;
        optionModel: boolean;
        protected _nodeLineMesh: V3dGraphicLines;
        protected _lines: Lines;
        protected _flipZ: boolean;
        protected _material: V3dGraphicMeshMaterial;
        protected _colorOption: any;
        protected _boundaryHelper: V3dBoundaryHelper;
        protected _curvedocument: CurveDataDocument;
        protected _statusMaterialChanged: boolean;
        protected _stateMaterialReady: boolean;
        protected _statePolygonsReady: boolean;
        private _linerDisplay;
        private _isDrawOutline;
        constructor();
        get isDrawOutline(): boolean;
        set isDrawOutline(isDrawOutline: boolean);
        setup(): void;
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        createNode(): V3dGraphicContainer;
        private isFurnitureLinearFamilyType;
        buildDisplayByteStream(): ByteStream;
        updateShape(): void;
        protected updateStyle(): void;
        protected meshFlipZ(structure: LinearGraphic3dStructure): void;
        protected getMeshMerger(): V3dDynamicMeshMerger;
        protected translate(structure: LinearGraphic3dStructure): void;
        protected updateStatus(): void;
        protected createNodeLines(): void;
        setMeshVisible(visible: boolean): void;
        setLineMeshVisible(visible: boolean): void;
        setLinesColor(color: number): void;
        setLineMeshMaterail(useColor: boolean, color: number): void;
        setMeshMaterail(useColor: boolean): void;
        onOptionFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEditEntityChanged(sender: ListenerContext, event: any): void;
        onShapeChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEdgeOverrideChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        testShapeChanged(event: DataNodeFieldEvent): boolean;
        canDraw(): boolean;
        protected onDecorateTextureFailure(sender: ListenerContext, event: LoaderEvent): void;
        protected loadMaterialAsync(): Promise<V3dGraphicMeshMaterial>;
        onDraw(context?: DisplayContext): void;
        show(): void;
        hide(): void;
        bindAction(): void;
        unbindAction(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dLogicOpening" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { C3dLogicDisplay } from "sk/editor/logic/view/webgl3d/C3dLogicDisplay";
    export class C3dLogicOpening extends C3dLogicDisplay {
        entity: OpeningNode;
        currentSwing: number;
        needsUpdate: boolean;
        protected _logicDisplay: SkNative.FLogicOpeningDisplay;
        protected _floorplanDispaly: any;
        protected _hostMaterialInfoId: string;
        constructor();
        setup(): void;
        createNode(): V3dGraphicContainer;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        protected updateShape(): void;
        protected updateStyle(): void;
        protected getHostMaterialInfoId(): string;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dLogicPlane" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { NodeFieldEvent } from 'cross/runtime/framework/node/NodeFieldEvent';
    import { MoldingService } from 'foundation/core/module/molding/MoldingService';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
    import { V3dGraphicCamera } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicCamera';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { V3dGraphicMeshInstance } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshInstance';
    import { V3dGraphicMeshMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { RenderService } from 'foundation/editor/view/base/render/RenderService';
    import { V3dAerialViewCamera } from 'foundation/editor/view/view3d/camera/V3dAerialViewCamera';
    import { V3dBoundaryHelper } from 'foundation/editor/view/view3d/helper/V3dBoundaryHelper';
    import { V3dMoldingBoundaryHelper } from 'foundation/editor/view/view3d/helper/V3dMoldingBoundaryHelper';
    import { CanvasEvent } from 'foundation/editor/view/base/CanvasEvent';
    import { EdgeSurfaceNode } from 'sk/data/family/model/instance/EdgeSurfaceNode';
    import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    import { PlaneSurfaceNode } from 'sk/data/family/model/instance/PlaneSurfaceNode';
    import { SurfaceNode } from 'sk/data/family/model/instance/SurfaceNode';
    import { PlaneGraphic3dStructure } from 'sk/data/family/molding/instance/PlaneGraphic3dStructure';
    import { BathroomCeilingNode } from 'sk/data/scheme/database/pattern/node/BathroomCeilingNode';
    import { BathroomWallNode } from 'sk/data/scheme/database/pattern/node/BathroomWallNode';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { C3dCompositeContent } from "sk/editor/logic/view/webgl3d/C3dCompositeContent";
    import { C3dPlaneController } from "sk/editor/logic/view/webgl3d/C3dPlaneController";
    type PlaneLoadMaterialOption = {
        alpha?: number;
    };
    export class C3dLogicPlane extends C3dCompositeContent {
        entity: PlaneNode;
        entityShapeIdentity: string;
        viewDepthScale: number;
        viewDepthOffset: number;
        moldingStructure: PlaneGraphic3dStructure;
        controller: C3dPlaneController;
        protected _surfaceMaterials: Map<any, V3dGraphicMeshMaterial>;
        protected _statusMaterialChanged: boolean;
        protected _colorOption: any;
        protected _optionVisionMolding: boolean;
        protected _moldingService: MoldingService;
        protected _schemeConfigService: SchemeConfigService;
        protected _renderService: RenderService;
        protected _surfaceBoundaryHelper: V3dBoundaryHelper | V3dMoldingBoundaryHelper;
        private _isEditFrontStatus;
        private _planeDisplay;
        private _colorMateiral;
        private _isDrawOutline;
        protected isPlaneFrontSurfaceInCameraView: boolean;
        constructor();
        get isDrawOutline(): boolean;
        set isDrawOutline(isDrawOutline: boolean);
        bindAction(): void;
        unbindAction(): void;
        makeShapeIdentity(): string;
        getInfoByNodeAsync(node: PlaneNode): Promise<void>;
        private checkNodeOutlinesOption;
        private setColorOption;
        setup(): void;
        onEditOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityEditSurfaceChange(sender: ListenerContext, event: DataNodeFieldEvent): void;
        protected onCameraChanged(sender: ListenerContext, event?: CanvasEvent): void;
        protected checkVisibleBathroomPlane(root: PatternInstanceNode, camera: V3dAerialViewCamera): boolean;
        protected checkVisibleBathroomWallPlane(wall: BathroomWallNode, camera: V3dGraphicCamera): boolean;
        protected checkVisibleBathroomCeilingPlane(ceiling: BathroomCeilingNode, camera: V3dGraphicCamera): boolean;
        testShapeChanged(event: DataNodeFieldEvent): boolean;
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        findMeshById(code: string): V3dGraphicMesh;
        setMeshVisible(visible: boolean): void;
        setMeshMaterail(useColor: boolean): void;
        setLinesColor(color: number, isLinesModel?: boolean): void;
        createNode(): V3dGraphicContainer;
        protected loadSurfaceMaterialBySurfaceAsync(surface: SurfaceNode, option?: PlaneLoadMaterialOption): Promise<ResultObject<V3dGraphicMeshMaterial>>;
        protected loadSurfaceMaterialByIdAsync(materialResourceId: string, alpha?: number): Promise<ResultObject<V3dGraphicMeshMaterial>>;
        protected setMaterailProperty(material: V3dGraphicMeshMaterial): void;
        protected updateTransform(): void;
        protected updateSurfaceMaterialAsync(surfaceType: SkNative.PlaneSurfaceTypeEnum, surface: PlaneSurfaceNode | EdgeSurfaceNode, materialResourceId: string, index: number): Promise<void>;
        private getSurfaceMaterialKey;
        protected updateSurfacesMaterialAsync(): Promise<void>;
        protected updateMaterialAsync(): Promise<void>;
        updateHelper(): void;
        protected createCollisionNode(): V3dGraphicMesh | V3dGraphicMeshInstance;
        protected updateCollisionNode(collisionMesh: V3dGraphicMesh | V3dGraphicMeshInstance): void;
        updateShape(): void;
        protected updateBoundaryHelperStyle(): void;
        protected updateStyle(): void;
        setLineMeshVisible(visible: boolean, isLinesMode?: boolean): void;
        private isFurniturePlankCupboardTopFamilyType;
        protected updateSurfaceBoundary(): void;
        protected createSurfaceBoundaryHepler(): void;
        canDraw(): boolean;
        show(): void;
        hide(): void;
        protected updateVisibilityByOption(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dLogicPlaneUtil" {
    import { ByteStream } from 'cross/runtime/lang/stream/ByteStream';
    import { UVOptions } from 'foundation/runtime/geometry/UVOptions';
    import { SurfaceMaterialStructure } from 'foundation/data/common/structure/vision/SurfaceMaterialStructure';
    import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
    export class C3dLogicPlaneUtil {
        static serialize(plane: PlaneNode): ByteStream;
        static setUVOptions(materialInfo: SurfaceMaterialStructure, uvOptions: UVOptions): void;
        static createTestPlaneDataStream(): ByteStream;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dMaterialLayout" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { SectionSurface } from 'foundation/runtime/geometry/surface/SectionSurface';
    import { Single2dSurface, Surface } from 'foundation/runtime/geometry/Surface';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { SurfaceOption } from 'foundation/runtime/graphics/molding/SurfaceMoldingUtil';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { V3dGraphicMeshMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { MaterialLayoutNode } from 'sk/data/family/model/instance/layout/MaterialLayoutNode';
    import { MaterialLayoutTileNode } from 'sk/data/family/model/instance/layout/MaterialLayoutTileNode';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { C3dContent } from "sk/editor/logic/view/webgl3d/C3dContent";
    export class C3dMaterialLayout extends C3dContent {
        entity: MaterialLayoutNode;
        protected _gapMesh: V3dGraphicMesh;
        protected _tileMesh: V3dGraphicMesh;
        protected _tileNodes: Array<MaterialLayoutTileNode>;
        protected _viewDepthScale: number;
        protected _viewDepthOffset: number;
        protected _statusMaterialChanged: boolean;
        protected _createTileMeshFalg: any;
        protected _schemeConfigService: SchemeConfigService;
        protected _statusLayoutGapStyleChange: boolean;
        private __materialLayoutName;
        private __tileMeshName;
        private __isFloorNode;
        private __statusShapeChange;
        private __statusMaterialProperty;
        constructor();
        setup(): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        canDraw(): boolean;
        createNode(): V3dGraphicContainer;
        createGapMeh(): void;
        createMesh(name: any, parent: any): V3dGraphicMesh;
        protected updateShape(): void;
        protected getHoles(): Array<Single2dSurface>;
        protected updateLayoutShape(): void;
        protected updateTileMergeGeometryShape(tiles: MaterialLayoutTileNode[]): void;
        protected getPolygonSurface(points: Vector2[], holes?: any, surfaceOption?: SurfaceOption): BufferGeometry;
        protected createGeomotryBySurface(surface: Surface): BufferGeometry;
        protected updateStyle(): void;
        private updateTileMaterialByMergedMeshAsync;
        protected updateLayoutGapMaterialAsync(): Promise<void>;
        protected testIsFloorNode(): boolean;
        protected loadMaterialByIdAsync(materialId: string): Promise<ResultObject<V3dGraphicMeshMaterial>>;
        private getName;
        createSectionSurfaceByPoints(points: Vector2[]): SectionSurface;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dOpening" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { C3dContent } from "sk/editor/logic/view/webgl3d/C3dContent";
    export class C3dOpening extends C3dContent {
        entity: OpeningNode;
        currentSwing: number;
        needsUpdate: boolean;
        constructor();
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        protected getFlipMatrix(newSwing: number, oldSwing: number): Matrix4;
        onHalfWallModeChanged(): void;
        drawFlippedOpening(): void;
        onActivate(): void;
        onDeactivate(): void;
        draw(displayContext: DisplayContext): void;
        private onChildAdd;
        protected onShapeChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dPatternInstance" {
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { V3dGraphicMeshInstance } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshInstance';
    import { V3dMoldingBoundaryHelper } from 'foundation/editor/view/view3d/helper/V3dMoldingBoundaryHelper';
    import { C3dComposite } from "sk/editor/logic/view/webgl3d/C3dComposite";
    export class C3dPatternInstance extends C3dComposite {
        protected _boundaryHelper: V3dMoldingBoundaryHelper;
        constructor();
        protected createBoundaryHelperNode(): V3dMoldingBoundaryHelper;
        protected updateBoundaryShape(): void;
        protected createCollisionNode(): V3dGraphicMesh | V3dGraphicMeshInstance;
        protected updateCollisionNode(collisionMesh: V3dGraphicMesh | V3dGraphicMeshInstance): void;
        protected updateShape(): void;
        protected updateStyle(): void;
        private setBoundaryStatus;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dPipe" {
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicLines } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLines';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { C3dCanvas } from "sk/editor/logic/view/webgl3d/C3dCanvas";
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    import { C3dLinear } from "sk/editor/logic/view/webgl3d/C3dLinear";
    export class C3dPipe extends C3dLinear {
        view: C3dCanvas;
        context: C3dCanvasContext;
        node: V3dGraphicContainer;
        protected _pipeLines: V3dGraphicLines;
        constructor();
        dispose(): void;
        canDraw(): boolean;
        setup(): void;
        createNode(): any;
        drawDisplay(displayContext?: DisplayContext): void;
        updateShape(): void;
        show(): void;
        hide(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dPlank" {
    import { C3dPlane } from "sk/editor/logic/view/webgl3d/C3dPlane";
    export class C3dPlank extends C3dPlane {
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dSpatialContainer" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { NodeFieldEvent } from 'cross/runtime/framework/node/NodeFieldEvent';
    import { V3dBoundaryHelper } from 'foundation/editor/view/view3d/helper/V3dBoundaryHelper';
    import { V3dMoldingBoundaryHelper } from 'foundation/editor/view/view3d/helper/V3dMoldingBoundaryHelper';
    import { V3dContent } from 'foundation/editor/view/view3d/V3dContent';
    export class C3dSpatialContainer extends V3dContent {
        constructor();
        setup(): void;
        onEditOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        canDraw(): boolean;
        protected createBoundaryHelperNode(): V3dBoundaryHelper | V3dMoldingBoundaryHelper;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dUtil" {
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { Actor } from 'foundation/runtime/graphics/core/Actor';
    import { Geometry } from 'foundation/runtime/graphics/data/Geometry';
    import { BlueprintNode } from 'foundation/data/common/model/base/BlueprintNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { CanvasContext } from 'foundation/editor/view/base/CanvasContext';
    import { V3dUtil } from 'foundation/editor/view/view3d/V3dUtil';
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    export class C3dUtil extends V3dUtil {
        static ConvertMeterFactor: number;
        static screenToCanvas(context: CanvasContext, x: number, y: number, target?: Vector2): Vector2;
        static modelPointToGraphicPoint(point: Value3, target?: Vector3): Vector3;
        static modelPointToGraphicNoScalePoint(point: Value3, target?: Vector3): Vector3;
        static modelPointToScreenPoint(context: C3dCanvasContext, point: Vector3, target?: Vector2): Vector2;
        static modelBox3ToGraphicScaleBox3(box3: Box3, target?: Box3): Box3;
        static modelBox3ToGraphicNoScaleBox3(box3: Box3, target?: Box3): Box3;
        static modelBox3ToScreenBox2(context: C3dCanvasContext, box3: Box3): Box2;
        static modelPointsToScreenLength(context: C3dCanvasContext, point1: Vector3, point2: Vector3): number;
        static modelLengthToScreenLength(context: C3dCanvasContext, size: Vector3): number;
        static screenLengthToModelLength(context: C3dCanvasContext, size: Vector2): Vector2;
        static updateNodeTransform(actor: Actor, matrix: Matrix4, offset?: Vector3): void;
        static updateContentSize(actor: Actor, content: ContentNode): void;
        static testEditing(blueprint: BlueprintNode, content: ContentNode): boolean;
        static convertModelToView(input: Vector3, output?: Vector3): Vector3;
        static convertModelToViewArray(input: Vector3, output: Array<number> | Float32Array, offset?: number): void;
        static convertViewToModel(input: Vector3, output?: Vector3): Vector3;
        static modelSpaceToViewSpace(value: any): any;
        static viewSpaceToModelSpace(value: any): any;
        static getContentCirclePosition(vert: any): Vector3;
        static pickStackMaterials: any;
        static getPickTestMaterial(offset?: any): any;
        static createLineGeometry(start: Value3, end: Value3): Geometry;
        static isRaycastIntersectNotCheckIntersecPoint(intersectResult: Array<any>): boolean;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dVisionBoxSolid" {
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { VisionBoxSolidEntity } from "sk/editor/logic/entity/VisionBoxSolidEntity";
    import { C3dContent } from "sk/editor/logic/view/webgl3d/C3dContent";
    export class C3dVisionBoxSolid extends C3dContent {
        entity: VisionBoxSolidEntity;
        boxMesh: V3dGraphicMesh;
        createNode(): V3dGraphicContainer;
        protected updateShape(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dVisionGridModelController" {
    import { VisionGridModelNode } from 'foundation/data/common/model/brep/vision/VisionGridModelNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { C3dContentController } from "sk/editor/logic/view/webgl3d/C3dContentController";
    export class C3dVisionGridModelController extends C3dContentController {
        entity: VisionGridModelNode;
        getEntity(): ContentNode;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dVisionGridModel" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { QualityService } from 'cross/runtime/framework/quality/QualityService';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMeshInstance } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshInstance';
    import { PlaneSurfaceNode } from 'sk/data/family/model/instance/PlaneSurfaceNode';
    import { VisionGridModelEntity } from "sk/editor/logic/entity/VisionGridModelEntity";
    import { C3dCompositeContent } from "sk/editor/logic/view/webgl3d/C3dCompositeContent";
    export class C3dVisionGridModel extends C3dCompositeContent {
        entity: VisionGridModelEntity;
        protected _mesh: V3dGraphicMeshInstance;
        protected _modelID: string;
        protected _delayTransform: boolean;
        protected _qualityService: QualityService;
        protected _colorOption: any;
        constructor();
        onPlaneSurfaceFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        canDraw(): boolean;
        createNode(): V3dGraphicContainer;
        protected updateShape(): void;
        protected computeMoldingMeshAndUpdateAsync(): Promise<void>;
        protected updateTransform(): void;
        protected findParentPlaneSurface(): PlaneSurfaceNode;
        bindAction(): void;
        unbindAction(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dVisionLineModelController" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { VisionLineModelEntity } from "sk/editor/logic/entity/VisionLineModelEntity";
    import { C3dContentController } from "sk/editor/logic/view/webgl3d/C3dContentController";
    export class C3dVisionLineModelController extends C3dContentController {
        entity: VisionLineModelEntity;
        getEntity(): ContentNode;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dVisionLineModel" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { QualityService } from 'cross/runtime/framework/quality/QualityService';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMeshInstance } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshInstance';
    import { V3dGraphicMeshMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { VisionLineModelEntity } from "sk/editor/logic/entity/VisionLineModelEntity";
    import { C3dCompositeContent } from "sk/editor/logic/view/webgl3d/C3dCompositeContent";
    export class C3dVisionLineModel extends C3dCompositeContent {
        protected _qualityService: QualityService;
        entity: VisionLineModelEntity;
        protected _mergedMesh: V3dGraphicMeshInstance;
        protected _meshMaterial: V3dGraphicMeshMaterial;
        constructor();
        setup(): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        protected loadModelAsync(): Promise<ResultObject>;
        protected computeMoldingMeshAndUpdateAsync(): Promise<void>;
        createNode(): V3dGraphicContainer;
        onDraw(context?: DisplayContext): void;
        protected updateTransform(): void;
        protected updateShape(): void;
        protected updateStyle(): void;
        show(): void;
        setMeshVisible(visible: boolean): void;
        hide(): void;
        freezeWorldMatrix(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dVisionModelController" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { VisionModelEntity } from "sk/editor/logic/entity/VisionModelEntity";
    import { C3dContentController } from "sk/editor/logic/view/webgl3d/C3dContentController";
    export class C3dVisionModelController extends C3dContentController {
        entity: VisionModelEntity;
        getEntity(): ContentNode;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dVisionModel" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataResourceService } from 'foundation/data/common/io/DataResourceService';
    import { HoverService } from 'foundation/editor/base/selection/HoverService';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMeshMaterial } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial';
    import { V3dGraphicModel } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicModel';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
    import { BufferGeometryResource } from 'sk/data/resource/loader/actor/BufferGeometryResource';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { VisionModelEntity } from "sk/editor/logic/entity/VisionModelEntity";
    import { C3dCompositeContent } from "sk/editor/logic/view/webgl3d/C3dCompositeContent";
    import { C3dVisionModelController } from "sk/editor/logic/view/webgl3d/C3dVisionModelController";
    export class C3dVisionModel extends C3dCompositeContent {
        entity: VisionModelEntity;
        parentEntity: FamilyInstanceNode;
        displayAsset: V3dGraphicModel;
        controller: C3dVisionModelController;
        protected _modelResourceId: string;
        protected _statusMaterialChanged: boolean;
        protected _materialResourceId: string;
        protected propertyChanged: boolean;
        protected _colorOption: any;
        protected _bufferGeometry: BufferGeometryResource;
        protected _useDynamicMesh: boolean;
        protected _resourceService: DataResourceService;
        protected _hoverService: HoverService;
        protected _selectionService: SelectionService;
        protected _schemeConfigService: SchemeConfigService;
        constructor();
        setup(): void;
        getInfoByNodeAsync(node: FamilyInstanceNode): Promise<any>;
        private setColorOption;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        private setActor;
        updateMerger(): void;
        protected loadModelAsync(): Promise<ResultObject>;
        protected innerLoadModelAsync(): Promise<ResultObject>;
        protected loadModelMaterialAsync(): Promise<V3dGraphicMeshMaterial>;
        canDraw(): boolean;
        createNode(): V3dGraphicContainer;
        onDraw(context?: DisplayContext): void;
        protected updateTransform(): void;
        protected updateShape(): void;
        protected updateStyle(): void;
        show(): void;
        hide(): void;
        freezeWorldMatrix(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/C3dVisionSphereSolid" {
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { VisionSphereSolidEntity } from "sk/editor/logic/entity/VisionSphereSolidEntity";
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    import { C3dContent } from "sk/editor/logic/view/webgl3d/C3dContent";
    export class C3dVisionSphereSolid extends C3dContent {
        context: C3dCanvasContext;
        entity: VisionSphereSolidEntity;
        mesh: V3dGraphicMesh;
        constructor();
        createNode(): V3dGraphicContainer;
        protected updateShape(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/assistant/C3dAssistant" {
    import { V3dBrep } from 'foundation/editor/view/view3d/V3dBrep';
    export class C3dAssistant extends V3dBrep {
        canDraw(): boolean;
    }
}
declare module "sk/editor/logic/view/webgl3d/assistant/C3dAnchor" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicLines } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLines';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { ObserverChangeEvent } from 'foundation/editor/view/base/ObserverChangeEvent';
    import { V3dCanvasContext } from 'foundation/editor/view/view3d/V3dCanvasContext';
    import { AnchorNode } from 'sk/data/family/model/assistant/AnchorNode';
    import { C3dAssistant } from "sk/editor/logic/view/webgl3d/assistant/C3dAssistant";
    export class C3dAnchor extends C3dAssistant {
        context: V3dCanvasContext;
        entity: AnchorNode;
        protected _meshLineX: V3dGraphicLines;
        protected _meshLineY: V3dGraphicLines;
        protected _meshLineZ: V3dGraphicLines;
        protected _meshConeX: V3dGraphicMesh;
        protected _meshConeY: V3dGraphicMesh;
        protected _meshConeZ: V3dGraphicMesh;
        protected _meshPlaneXY: V3dGraphicMesh;
        protected _statusTransformChanged: boolean;
        lineLength: number;
        coneHeight: number;
        coneDiameter: number;
        constructor();
        setup(): void;
        protected onCameraChanged(sender: ListenerContext, event: ObserverChangeEvent): void;
        protected scale(rs: number): void;
        testTransformChanged(event: DataNodeFieldEvent): boolean;
        testShapeChanged(event: DataNodeFieldEvent): boolean;
        createNode(): V3dGraphicContainer;
        protected getPosition(): Vector3;
        protected updateShape(): void;
        hide(): void;
        show(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/assistant/C3dBoundary" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { NodeFieldEvent } from 'cross/runtime/framework/node/NodeFieldEvent';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
    import { V3dContent } from 'foundation/editor/view/view3d/V3dContent';
    export class C3dBoundary extends V3dContent {
        protected _boudaryMesh: V3dGraphicMesh;
        protected _boudaryDirty: boolean;
        setup(): void;
        onEditOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        canDraw(): boolean;
        createNode(): V3dGraphicContainer;
        protected updateMesh(): void;
        onDraw(context?: DisplayContext): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/assistant/C3dReferenceAxis" {
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { ReferenceAxisNode } from 'sk/data/family/model/assistant/reference/ReferenceAxisNode';
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    import { C3dAssistant } from "sk/editor/logic/view/webgl3d/assistant/C3dAssistant";
    export class C3dReferenceAxis extends C3dAssistant {
        context: C3dCanvasContext;
        entity: ReferenceAxisNode;
        protected nodeMesh: V3dGraphicMesh;
        protected nodeMeshArrow: V3dGraphicMesh;
        testShapeChanged(event: DataNodeFieldEvent): boolean;
        createNode(): V3dGraphicContainer;
        protected updateShape(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/assistant/C3dReferenceLine" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { NodeFieldEvent } from 'cross/runtime/framework/node/NodeFieldEvent';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicLines } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicLines';
    import { ReferenceLineNode } from 'sk/data/family/model/assistant/reference/ReferenceLineNode';
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    import { C3dAssistant } from "sk/editor/logic/view/webgl3d/assistant/C3dAssistant";
    export class C3dReferenceLine extends C3dAssistant {
        context: C3dCanvasContext;
        entity: ReferenceLineNode;
        protected nodeMesh: V3dGraphicLines;
        testTransformChanged(event: DataNodeFieldEvent): boolean;
        createNode(): V3dGraphicContainer;
        protected updateShape(): void;
        onEditOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        canDraw(): boolean;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/assistant/C3dReferencePlane" {
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { V3dGraphicContainer } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicContainer';
    import { V3dGraphicMesh } from 'foundation/editor/view/view3d/render/graphic/V3dGraphicMesh';
    import { ReferencePlaneNode } from 'sk/data/family/model/assistant/reference/ReferencePlaneNode';
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    import { C3dObserver } from "sk/editor/logic/view/webgl3d/C3dObserver";
    import { C3dAssistant } from "sk/editor/logic/view/webgl3d/assistant/C3dAssistant";
    export class C3dReferencePlane extends C3dAssistant {
        context: C3dCanvasContext;
        entity: ReferencePlaneNode;
        protected nodeMesh: V3dGraphicMesh;
        constructor();
        onCameraChanged(observer: C3dObserver, CameraChanged: string, onCameraChanged: any): void;
        testTransformChanged(event: DataNodeFieldEvent): boolean;
        testShapeChanged(event: DataNodeFieldEvent): boolean;
        createNode(): V3dGraphicContainer;
        protected updateShape(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/gizmo/C3dGizmo" {
    import { V3dGizmo } from 'foundation/editor/view/view3d/gizmo/V3dGizmo';
    import { C3dCanvas } from "sk/editor/logic/view/webgl3d/C3dCanvas";
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    import { C3dGizmoManager } from "sk/editor/logic/view/webgl3d/gizmo/C3dGizmoManager";
    export abstract class C3dGizmo extends V3dGizmo {
        context: C3dCanvasContext;
        manager: C3dGizmoManager;
        view: C3dCanvas;
    }
}
declare module "sk/editor/logic/view/webgl3d/gizmo/C3dTemp" {
    import { V3dTemp } from 'foundation/editor/view/view3d/gizmo/V3dTemp';
    import { C3dCanvas } from "sk/editor/logic/view/webgl3d/C3dCanvas";
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    export abstract class C3dTemp extends V3dTemp {
        context: C3dCanvasContext;
        view: C3dCanvas;
    }
}
declare module "sk/editor/logic/view/webgl3d/indicator/C3dContentIndicator" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { EditingService } from 'foundation/editor/base/selection/EditingService';
    import { V3dBoundaryHelper } from 'foundation/editor/view/view3d/helper/V3dBoundaryHelper';
    import { V3dMoldingBoundaryHelper } from 'foundation/editor/view/view3d/helper/V3dMoldingBoundaryHelper';
    import { V3dContentIndicator } from 'foundation/editor/view/view3d/indicator/V3dContentIndicator';
    import { C3dCanvas } from "sk/editor/logic/view/webgl3d/C3dCanvas";
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    export class C3dContentIndicator extends V3dContentIndicator {
        context: C3dCanvasContext;
        view: C3dCanvas;
        positionUpdateSuspended: boolean;
        protected _boundaryHelper: V3dBoundaryHelper | V3dMoldingBoundaryHelper;
        protected _editingService: EditingService;
        constructor();
        setup(): void;
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onCanvasOptionChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        bindAction(): void;
        unbindAction(): void;
        protected getBaseMartrix(matrix: Matrix4): void;
        protected updateTransform(): void;
        onShow(): void;
        onHide(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/indicator/C3dContentIndicatorController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
    import { V3dIndicatorController } from 'foundation/editor/view/view3d/indicator/V3dIndicatorController';
    import { V3dCanvasContext } from 'foundation/editor/view/view3d/V3dCanvasContext';
    export class C3dContentIndicatorController extends V3dIndicatorController {
        context: V3dCanvasContext;
        entity: DataNode;
        direction: Vector3;
        defaultController: any;
        constructor();
        composeDragMoveParam(event: ContentActionEvent): ContentActionEvent;
        onDragStart(event: ContentActionEvent): void;
        onClick(sender: ListenerContext, event: any): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/indicator/C3dOpeningIndicator" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { EditingService } from 'foundation/editor/base/selection/EditingService';
    import { V3dBoundaryHelper } from 'foundation/editor/view/view3d/helper/V3dBoundaryHelper';
    import { V3dOpeningIndicator } from 'foundation/editor/view/view3d/indicator/V3dOpeningIndicator';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { C3dCanvasContext } from "sk/editor/logic/view/webgl3d/C3dCanvasContext";
    export class C3dOpeningIndicator extends V3dOpeningIndicator {
        context: C3dCanvasContext;
        blueprint: any;
        entity: OpeningNode;
        positionUpdateSuspended: boolean;
        protected _statusDirty: boolean;
        protected _statusStyleChanged: boolean;
        protected _boundaryHelper: V3dBoundaryHelper;
        protected _editingService: EditingService;
        constructor();
        onCanvasOptionChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        bindAction(): void;
        unbindAction(): void;
        updateMesh(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/indicator/C3dOpeningIndicatorController" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
    import { V3dIndicatorController } from 'foundation/editor/view/view3d/indicator/V3dIndicatorController';
    import { V3dCanvasContext } from 'foundation/editor/view/view3d/V3dCanvasContext';
    export class C3dOpeningIndicatorController extends V3dIndicatorController {
        context: V3dCanvasContext;
        entity: DataNode;
        direction: Vector3;
        defaultController: any;
        constructor();
        composeDragMoveParam(event: ContentActionEvent): ContentActionEvent;
        onDragStart(event: ContentActionEvent): void;
        onClick(event: ContentActionEvent): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/indicator/C3dPocketIndicator" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { EditingService } from 'foundation/editor/base/selection/EditingService';
    import { V3dBoundaryHelper } from 'foundation/editor/view/view3d/helper/V3dBoundaryHelper';
    import { V3dIndicator } from 'foundation/editor/view/view3d/indicator/V3dIndicator';
    import { V3dCanvasContext } from 'foundation/editor/view/view3d/V3dCanvasContext';
    import { V3dLayer } from 'foundation/editor/view/view3d/V3dLayer';
    export class C3dPocketIndicator extends V3dIndicator {
        context: V3dCanvasContext;
        blueprint: any;
        entity: ContentNode;
        layer: V3dLayer;
        positionUpdateSuspended: boolean;
        protected _statusDirty: boolean;
        protected _statusTransformChanged: boolean;
        protected _statusShapeChanged: boolean;
        protected _statusStyleChanged: boolean;
        protected _boundaryHelper: V3dBoundaryHelper;
        protected _editingService: EditingService;
        constructor();
        setup(): void;
        onCanvasOptionChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        bindAction(): void;
        unbindAction(): void;
        updateMesh(): void;
        dispose(): void;
    }
}
declare module "sk/editor/logic/view/webgl3d/indicator/C3dPocketIndicatorController" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
    import { V3dIndicatorController } from 'foundation/editor/view/view3d/indicator/V3dIndicatorController';
    import { V3dCanvasContext } from 'foundation/editor/view/view3d/V3dCanvasContext';
    export class C3dPocketIndicatorController extends V3dIndicatorController {
        context: V3dCanvasContext;
        entity: DataNode;
        direction: Vector3;
        defaultController: any;
        constructor();
        composeDragMoveParam(event: ContentActionEvent): ContentActionEvent;
        onDragStart(event: ContentActionEvent): void;
        onClick(event: ContentActionEvent): void;
    }
}