/// <reference path="../library/typings/cross-runtime.d.ts" />
/// <reference path="../library/typings/cross-editor.d.ts" />
/// <reference path="../typings/private/foundation-data-common.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/foundation-editor-base.d.ts" />
declare module "copyright" {
    export class FoundationEditorViewCopyright {
        static toString(): string;
    }
}
declare module "foundation/editor/view/IndexSpace" {
    export class IndexSpace {
        static namespaces(): string[];
    }
}
declare module "foundation/editor/view/action/ActionEventEnum" {
    export class ActionEventEnum {
        static Starting: string;
        static Started: string;
        static Suspending: string;
        static Suspended: string;
        static Resuming: string;
        static Resumed: string;
        static Terminating: string;
        static Terminated: string;
        static Completing: string;
        static Complete: string;
        static Finish: string;
        static Restart: string;
    }
}
declare module "foundation/editor/view/action/ActionStateEnum" {
    export enum ActionStateEnum {
        Created = 0,
        Executing = 1,
        Running = 2,
        Suspending = 3,
        Suspended = 4,
        Resuming = 5,
        Terminating = 6,
        Terminated = 7
    }
}
declare module "foundation/editor/view/action/ActionObject" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ActionStateEnum } from "foundation/editor/view/action/ActionStateEnum";
    export class ActionObject extends Dispatcher {
        protected _actionId: string;
        lockCode: string;
        lockTick: number;
        showGizmo: boolean;
        ignoreObserver: boolean;
        event: any;
        element: any;
        entity: any;
        stateCd: ActionStateEnum;
        description: string;
        protected _optionEntityDirty: boolean;
        protected _optionSuspend: boolean;
        protected _optionIndependent: boolean;
        protected _optionUndoRedo: boolean;
        protected _optionRestart: boolean;
        protected _optionMultiPick: boolean;
        protected _optionLogger: boolean;
        protected _statusSetup: boolean;
        protected _oldContent: any;
        protected _newContent: any;
        constructor();
        get actionId(): string;
        get optionRestart(): boolean;
        get optionMultiPick(): boolean;
        get optionLogger(): boolean;
        onSetup(event?: EventObject): void;
        setup(event?: EventObject): void;
        linkEvent(event: EventObject): void;
        canIndependent(): boolean;
        onExecute(event?: any): any;
        execute(event?: any): any;
        canSuspend(): boolean;
        onSuspend(): void;
        suspend(): void;
        onResume(): void;
        resume(): void;
        canUndoRedo(): boolean;
        setCanUndoRedo(canUndoRedo: boolean): void;
        protected onUndoRedo(): void;
        onUndo(): void;
        onUndoAsync(): Promise<ResultObject<any>>;
        undoAsync(): Promise<ResultObject<any>>;
        onRedo(): void;
        onRedoAsync(): Promise<ResultObject<any>>;
        redoAsync(): Promise<ResultObject<any>>;
        canCompleteContinuous(): boolean;
        complete(event?: any): ActionObject;
        commit(): void;
        cancel(event?: any): void;
        onReceive(code: string, event: any): boolean;
        receive(code: string, event: any): boolean;
        willDirtyDataModel(): boolean;
        onProcessFinish(sender: ListenerContext, event: EventObject): void;
        onCleanup(event?: any): void;
    }
}
declare module "foundation/editor/view/script/Script" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class Script extends InstanceObject {
        tick: number;
        text: string;
        code: string;
        parameters: Array<string>;
        parse(text: string): void;
        toScript(): string;
    }
}
declare module "foundation/editor/view/script/ScriptContext" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ContextObject } from 'cross/runtime/lang/ContextObject';
    import { Script } from "foundation/editor/view/script/Script";
    export class ScriptContext extends ContextObject {
        code: string;
        name: string;
        protected _input: Dictionary<any>;
        protected _global: Dictionary<any>;
        protected _session: Dictionary<any>;
        protected _selection: Dictionary<any>;
        protected _local: Dictionary<any>;
        protected _output: Dictionary<any>;
        protected _scripts: Types<Script>;
        constructor();
        get input(): Dictionary<any>;
        get global(): Dictionary<any>;
        get session(): Dictionary<any>;
        get selection(): Dictionary<any>;
        get local(): Dictionary<any>;
        get output(): Dictionary<any>;
        get scripts(): Types<Script>;
        push(script: Script): void;
        toScript(): string;
        convertLocalId(id: string): string;
        convertId(id: string): string;
        parse(text: string): void;
        parseLocalParameter(key: string): any;
        parseSelectionParameter(key: string): any;
        parseParameter(param: string): any;
    }
}
declare module "foundation/editor/view/script/RecordEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { ActionObject } from "foundation/editor/view/action/ActionObject";
    import { Script } from "foundation/editor/view/script/Script";
    import { ScriptContext } from "foundation/editor/view/script/ScriptContext";
    export class RecordEvent extends EventObject {
        document: DataDocument;
        record: ScriptContext;
        script: Script;
        action: ActionObject;
        eventCd: string;
        event: any;
        assign(event: RecordEvent): void;
        free(): void;
    }
}
declare module "foundation/editor/view/script/RecordEventEnum" {
    export class RecordEventEnum {
        static Start: string;
        static Record: string;
        static Stop: string;
        static Play: string;
        static FinishPlay: string;
        static Clear: string;
        static Suspended: string;
        static Resumed: string;
    }
}
declare module "foundation/editor/view/script/ScriptParameters" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class ScriptParameters extends InstanceObject {
        items: Array<any>;
        config: Map<string, any>;
        constructor();
        getConfig(name: string): any;
        loadConfigParameter(parameter: string): boolean;
        get count(): number;
        get(index: number, defaultValue?: any): any;
        getBoolean(index: number, defaultValue?: boolean): boolean;
        getInteger(index: number, defaultValue?: number): number;
        getNumber(index: number, defaultValue?: number): number;
        getString(index: number, defaultValue?: string): string;
    }
}
declare module "foundation/editor/view/script/ScriptCommand" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ActionObject } from "foundation/editor/view/action/ActionObject";
    import { Script } from "foundation/editor/view/script/Script";
    import { ScriptContext } from "foundation/editor/view/script/ScriptContext";
    import { ScriptParameters } from "foundation/editor/view/script/ScriptParameters";
    export class ScriptCommand extends InstanceObject {
        completeDelay: number;
        retryCount: number;
        retryDelay: number;
        constructor();
        convertParameters(context: ScriptContext, script: Script): ScriptParameters;
        convert(context: ScriptContext, action: ActionObject): Script;
        format(context: ScriptContext, source: string): string;
        executeAsync(context: ScriptContext, command: Script, parameters?: ScriptParameters): Promise<ResultObject<ActionObject>>;
    }
}
declare module "foundation/editor/view/script/ScriptService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { ActionObject } from "foundation/editor/view/action/ActionObject";
    import { ScriptCommand } from "foundation/editor/view/script/ScriptCommand";
    import { ScriptContext } from "foundation/editor/view/script/ScriptContext";
    export type ScriptDeclareInfo = {
        name: string;
        type: any;
        clazz: any;
        instance: ScriptCommand;
    };
    export class ScriptService extends Service {
        protected _declares: Types<ScriptDeclareInfo>;
        constructor();
        findDeclareByName(name: string): ScriptDeclareInfo;
        findDeclareByClazz(clazz: any): ScriptDeclareInfo;
        findDeclareByInstance(instance: any): ScriptDeclareInfo;
        registerDeclare(name: string, type: any, clazz?: any): void;
        convertScript(context: ScriptContext, action: any): any;
        private getScriptContentAsync;
        executeScriptAsync(context: ScriptContext, interval?: number): Promise<ResultObject<ActionObject>>;
        executeTextScriptAsync(context: ScriptContext, text: string, interval?: number): Promise<ResultObject<ActionObject>>;
        executeByScriptIdAsync(context: ScriptContext, scriptId: string, interval?: number): Promise<ResultObject<ActionObject>>;
    }
}
declare module "foundation/editor/view/script/RecordService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { ActionObject } from "foundation/editor/view/action/ActionObject";
    import { ScriptContext } from "foundation/editor/view/script/ScriptContext";
    import { ScriptService } from "foundation/editor/view/script/ScriptService";
    enum RecordState {
        NONE = 0,
        RECORDING = 1,
        PAUSING = 2
    }
    export class RecordService extends Service {
        records: Types<ScriptContext>;
        current: ScriptContext;
        recordState: RecordState;
        protected _scriptService: ScriptService;
        constructor();
        actionExecute(action: any, event?: any): void;
        actionReceive(code: string, event: any): void;
        actionComplete(action?: any, event?: any): void;
        actionCancel(action?: any, event?: any): void;
        start(): ScriptContext;
        continue(): ScriptContext;
        stop(): ScriptContext;
        pausing(): ScriptContext;
        playAsync(context: any, scriptContext: ScriptContext, delay?: number): Promise<ResultObject<ActionObject>>;
        executeTextScriptAsync(text: string): Promise<ResultObject<ActionObject>>;
        clear(): void;
    }
}
declare module "foundation/editor/view/transaction/Request" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class Request extends InstanceObject {
        isCommitted: boolean;
        onUndo(): void;
        onUndoAsync(): Promise<ResultObject>;
        undoAsync(): Promise<ResultObject>;
        onRedo(): void;
        onRedoAsync(): Promise<ResultObject>;
        redoAsync(): Promise<ResultObject>;
        onCommit(): void;
        commit(): void;
    }
}
declare module "foundation/editor/view/transaction/common/CompositeRequest" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Request } from "foundation/editor/view/transaction/Request";
    export class CompositeRequest extends Request {
        requests: Types<Request>;
        constructor(requests?: Types<Request>);
        append(request: Request): CompositeRequest;
        onUndoAsync(): Promise<ResultObject>;
        onRedoAsync(): Promise<ResultObject>;
        onCommit(): void;
        static create(request1: Request, request2: Request): CompositeRequest;
    }
}
declare module "foundation/editor/view/transaction/Session" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Request } from "foundation/editor/view/transaction/Request";
    export class Session extends InstanceObject {
        undoStack: Types<Request>;
        redoStack: Types<Request>;
        constructor();
        peekNextUndoRequest(): Request;
        peekNextRedoRequest(): Request;
        canUndo(): boolean;
        undoAsync(): Promise<ResultObject>;
        canRedo(): boolean;
        redoAsync(): Promise<ResultObject>;
        commit(request: Request, flag: boolean): void;
        toRequest(): Request;
        clear(): void;
    }
}
declare module "foundation/editor/view/transaction/TransactionEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    export class TransactionEvent extends EventObject {
        request: any;
        free(): void;
    }
}
declare module "foundation/editor/view/transaction/TransactionEventEnum" {
    export class TransactionEventEnum {
        static Committing: string;
        static Committed: string;
        static StateChanged: string;
        static Undoing: string;
        static Undone: string;
        static Redoing: string;
        static Redone: string;
    }
}
declare module "foundation/editor/view/transaction/TransactionService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Service } from 'cross/runtime/module/Service';
    import { Session } from "foundation/editor/view/transaction/Session";
    export class TransactionService extends Service {
        _activeSession: Session;
        _sessionStack: Types<Session>;
        commit(data: any, flag?: boolean): void;
        startSession(): void;
        endSession(failFunction: any): void;
        canUndo(): boolean;
        undoAsync(): Promise<ResultObject>;
        canRedo(): boolean;
        redoAsync(): Promise<ResultObject>;
        clear(): void;
    }
}
declare module "foundation/editor/view/action/ActionDeclareInfo" {
    export type ActionDeclareInfo = {
        name: string;
        clazz: any;
    };
}
declare module "foundation/editor/view/base/asset/AssetManager" {
    import { Manager } from 'cross/runtime/framework/Manager';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    export class AssetManager extends Manager {
        context: CanvasContext;
    }
}
declare module "foundation/editor/view/base/graphic/GraphicObject" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    export class GraphicObject extends Dispatcher {
        private static UniqueIdCounter;
        context: CanvasContext;
        id: string;
        code: string;
        name: string;
        protected _uniqueId: number;
        protected _tag: any;
        constructor(name?: string);
        get uniqueId(): number;
        get tag(): any;
        initialize(): void;
        setup(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/entity/GroupEntity" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { GroupNode } from 'foundation/data/common/model/brep/GroupNode';
    export class GroupEntity extends GroupNode {
        graphicBox: any;
        assignTo(entity: any): void;
        getHost(): any;
        protected centerTrans(point: Vector3, node: ContentNode): Vector3;
        protected computeBoundaryOnChildChange(): void;
        isCanDestory(): boolean;
        canVisible(): boolean;
    }
    export type GroupEntityMap = {
        [key: string]: GroupEntity;
    };
}
declare module "foundation/editor/view/base/DisplayContext" {
    import { ViewContext } from 'cross/runtime/framework/view/ViewContext';
    export class DisplayContext extends ViewContext {
        force: boolean;
        free(): void;
    }
}
declare module "foundation/editor/view/base/gizmo/GizmoEventEnum" {
    export class GizmoEventEnum {
        static Add: string;
        static Remove: string;
        static MouseDown: string;
        static MouseMove: string;
        static MouseUp: string;
        static CreateWall: string;
        static ValueChanged: string;
        static CreateArea: string;
        static EditArea: string;
        static SplitArea: string;
    }
}
declare module "foundation/editor/view/base/gizmo/GizmoManager" {
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Class } from 'cross/runtime/lang/reflect/Class';
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Timer } from 'cross/runtime/lang/Timer';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { SelectionEvent } from 'foundation/editor/base/selection/SelectionEvent';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    import { ActionService } from "foundation/editor/view/action/ActionService";
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { Gizmo } from "foundation/editor/view/base/gizmo/Gizmo";
    import { GizmoFactory } from "foundation/editor/view/base/gizmo/GizmoFactory";
    export class GizmoManager extends Dispatcher {
        factory: GizmoFactory;
        gizmos: Types<Gizmo>;
        protected _selectionGizmos: TypeMap<number, Types<Gizmo>>;
        protected _actionGizmos: TypeMap<Class, Types<Gizmo>>;
        protected _entityGizmos: TypeMap<number, Types<Gizmo>>;
        protected _beginEntities: Types<DataNode>;
        protected _endEntities: Types<DataNode>;
        timer: Timer;
        protected _selectionService: SelectionService;
        protected _actionService: ActionService;
        constructor();
        get actionGizmos(): TypeMap<Class, Types<Gizmo>>;
        setup(): void;
        setListen(): void;
        removeListen(): void;
        getEntityGizmos(node: DataNode): Types<Gizmo>;
        getEntityGizmo(node: DataNode): Gizmo;
        addGizmo(gizmo: Gizmo): void;
        removeGizmo(gizmo: Gizmo): void;
        private addGizmos;
        private disposeGizmos;
        private dirtyGizmos;
        addEntityGizmo(entity: DataNode): void;
        removeEntityGizmo(entity: DataNode): void;
        redraw(context?: DisplayContext): void;
        beginShowSelectionGizmo(entity: DataNode): void;
        endShowSelectionGizmo(entity: DataNode): void;
        onSelectionChanged(sender: ListenerContext, event: SelectionEvent): void;
        onBeginShowActionGizmo(sender: ListenerContext, event: ActionEvent): void;
        onEndShowActionGizmo(sender: ListenerContext, event: ActionEvent): void;
        refresh(): void;
        clear(): void;
    }
}
declare module "foundation/editor/view/base/gizmo/Gizmo" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Objects } from 'cross/runtime/lang/Objects';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Canvas } from "foundation/editor/view/base/Canvas";
    import { Display } from "foundation/editor/view/base/Display";
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { GizmoFactory } from "foundation/editor/view/base/gizmo/GizmoFactory";
    import { GizmoManager } from "foundation/editor/view/base/gizmo/GizmoManager";
    export class Gizmo extends Display {
        manager: GizmoManager;
        visible: boolean;
        parentGizmo: Gizmo;
        childGizmos: Objects<Gizmo>;
        factory: GizmoFactory;
        dir: Vector2;
        constructor();
        getCanvas(): Canvas;
        addChildGizmo(gizmo: Gizmo): void;
        removeChildGizmo(gizmo: Gizmo): void;
        activate(): void;
        deactivate(): void;
        show(): void;
        hide(): void;
        redraw(context?: DisplayContext): void;
        dispose(): void;
    }
    export type GizmoMap = {
        [key: string]: Types<Gizmo>;
    };
}
declare module "foundation/editor/view/base/gizmo/GizmoDeclareEnum" {
    export class GizmoDeclareEnum {
        static Selection: string;
        static Action: string;
        static Entity: string;
    }
}
declare module "foundation/editor/view/base/CanvasEnum" {
    export class CanvasEnum {
        static Space2d: string;
        static Space3d: string;
        static Surface: string;
        static Cad: string;
        static Profile: string;
    }
}
declare module "foundation/editor/view/base/gizmo/GizmoService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Service } from 'cross/runtime/module/Service';
    import { CanvasEnum } from "foundation/editor/view/base/CanvasEnum";
    import { Gizmo } from "foundation/editor/view/base/gizmo/Gizmo";
    import { GizmoDeclareEnum } from "foundation/editor/view/base/gizmo/GizmoDeclareEnum";
    export type GizmoDeclareInfo = {
        spaceCd: CanvasEnum;
        declareCd: GizmoDeclareEnum;
        value: any;
        clazz: any;
        checkFunc?: Function;
        typeCode?: any;
    };
    export class GizmoService extends Service {
        protected _declares: Types<GizmoDeclareInfo>;
        findDeclareByValue(spaceCd: CanvasEnum, declareCd: GizmoDeclareEnum, value: any, typeCode: any): GizmoDeclareInfo;
        findDeclaresByInstance(spaceCd: CanvasEnum, declareCd: GizmoDeclareEnum, value: any, typeCode?: any): Types<GizmoDeclareInfo>;
        registerDeclare(spaceCd: CanvasEnum, declareCd: GizmoDeclareEnum, value: any, clazz: any, typeCode?: any, checkFunc?: Function): void;
        createGizmos(spaceCd: CanvasEnum, declareCd: GizmoDeclareEnum, value: any, typeCode?: any): Types<Gizmo>;
    }
}
declare module "foundation/editor/view/base/gizmo/GizmoFactory" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { Canvas } from "foundation/editor/view/base/Canvas";
    import { Gizmo } from "foundation/editor/view/base/gizmo/Gizmo";
    import { GizmoService } from "foundation/editor/view/base/gizmo/GizmoService";
    export class GizmoFactory extends InstanceObject {
        canvas: Canvas;
        protected _gizmoService: GizmoService;
        setup(): void;
        setupGizmo(gizmo: Gizmo, node: DataNode): void;
        createSelectionGizmo(node: DataNode): Types<Gizmo>;
        createActionGizmo(action: any): Types<Gizmo>;
        createEntityGizmo(node: DataNode): Types<Gizmo>;
    }
}
declare module "foundation/editor/view/base/selection/SelectionManager" {
    import { Manager } from 'cross/runtime/framework/Manager';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    export class SelectionManager extends Manager {
        context: CanvasContext;
    }
}
declare module "foundation/editor/view/base/CanvasEventEnum" {
    export class CanvasEventEnum {
        static FrameEnter: string;
        static FrameLeave: string;
        static SizeChanged: string;
        static CameraSwitch: string;
        static CameraChanged: string;
        static MouseEnter: string;
        static MouseLeave: string;
        static MouseDown: string;
        static MouseMove: string;
        static MouseUp: string;
        static MouseWheel: string;
        static KeyDown: string;
        static KeyUp: string;
        static TouchStart: string;
        static TouchMove: string;
        static TouchEnd: string;
        static LoadingStatus: string;
        static WebGLContextLost: string;
    }
}
declare module "foundation/editor/view/base/selection/SelectorController" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    import { ActionService } from "foundation/editor/view/action/ActionService";
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { Selector } from "foundation/editor/view/base/selection/Selector";
    export class SelectorController extends Dispatcher {
        context: CanvasContext;
        selector: Selector;
        protected _actionService: ActionService;
        setup(): void;
        onActionRunning(sender: ListenerContext, event: ActionEvent): void;
        onActionStopped(sender: ListenerContext, event: ActionEvent): void;
        onUnselect(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/base/selection/Selector" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { Scenes } from "foundation/editor/view/base/Scenes";
    import { SelectorController } from "foundation/editor/view/base/selection/SelectorController";
    export class Selector extends Dispatcher {
        context: CanvasContext;
        enabled: boolean;
        scenes: Scenes;
        controller: SelectorController;
        optionEnable: boolean;
        optionMulti: boolean;
        constructor();
        setup(): void;
        enable(): void;
        disable(): 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;
        update(): void;
        clear(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/base/style/StyleManager" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    export class StyleManager extends Dispatcher {
        context: CanvasContext;
        setup(): void;
    }
}
declare module "foundation/editor/view/base/selection/SelectorEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { Display } from "foundation/editor/view/base/Display";
    export class SelectorEvent extends EventObject {
        display: Display;
        statusCtrl: boolean;
        statusAlt: boolean;
        statusShift: boolean;
        protected _screenOrigin: Vector2;
        protected _screenPoint: Vector2;
        protected _screenOffset: Vector2;
        protected _point: Vector3;
        protected _offset: Vector3;
        protected _groundPoint: Vector3;
        faceId: number;
        constructor();
        get screenOrigin(): Vector2;
        get screenPoint(): Vector2;
        get screenOffset(): Vector2;
        get point(): Vector3;
        get offset(): Vector3;
        get groundPoint(): Vector3;
        assignEvent(event: MouseDeviceEvent): void;
        free(): void;
    }
}
declare module "foundation/editor/view/base/Controller" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    export class Controller extends Dispatcher {
        setup(): void;
    }
}
declare module "foundation/editor/view/base/DisplayEventEnum" {
    export class DisplayEventEnum {
        static Click: string;
        static MouseEnter: string;
        static MouseEnterChange: string;
        static MouseLeave: string;
        static MouseDown: string;
        static MouseUp: string;
        static MouseMove: string;
        static MouseWheel: string;
        static MouseHoverIn: string;
        static MouseHoverLeave: string;
        static TouchStart: string;
        static TouchEnd: string;
        static TouchMove: string;
        static KeyDown: string;
        static KeyUp: string;
        static DragStart: string;
        static DragMove: string;
        static DragEnd: string;
        static RotateStart: string;
        static Move: string;
        static MoveTo: string;
        static SetYaw: string;
        static MoveAndRot: string;
        static MoveKeepTarget: string;
        static MoveTarget: string;
        static Hotkey: string;
        static Reset: string;
        static EditModeChange: string;
        static constains(name: string): boolean;
        static convertEvent(name: string): DisplayEventEnum;
    }
}
declare module "foundation/editor/view/base/CanvasController" {
    import { SelectorEvent } from "foundation/editor/view/base/selection/SelectorEvent";
    import { Canvas } from "foundation/editor/view/base/Canvas";
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { Controller } from "foundation/editor/view/base/Controller";
    import { DisplayEventEnum } from "foundation/editor/view/base/DisplayEventEnum";
    export class CanvasController extends Controller {
        canvas: Canvas;
        context: CanvasContext;
        processContentEvent(eventCd: DisplayEventEnum, event: SelectorEvent): void;
    }
}
declare module "foundation/editor/view/base/CanvasModeEnum" {
    export class CanvasModeEnum {
        static Master: string;
        static Slave: string;
    }
}
declare module "foundation/editor/view/base/CanvasOptions" {
    import { Node } from 'cross/runtime/framework/node/Node';
    export class CanvasOptions extends Node {
        contextClass: any;
        gizmoFactoryClass: any;
        gizmoManagerClass: any;
        scenesClass: any;
        layersClass: any;
        styleManagerClass: any;
        selectorClass: any;
        selectorControllerClass: any;
        selectionManagerClass: any;
        controllerClass: any;
        contentControllerClass: any;
        htmlContainer: any;
        htmlParent: any;
        htmlView: any;
        htmlRoot: any;
        htmlRootParent: any;
        htmlCanvas: HTMLCanvasElement;
        optionVisible: boolean;
        optionGrid: boolean;
        optionObserver: boolean;
        optionVideo: boolean;
        videoAddress: string;
        optionOutRenderer: boolean;
        engineCode: string;
        constructor();
    }
}
declare module "foundation/editor/view/base/CanvasShadedModeEnum" {
    export class CanvasShadedModeEnum {
        static Consistent: string;
        static Realistic: string;
    }
}
declare module "foundation/editor/view/base/Observer" {
    import { Display } from "foundation/editor/view/base/Display";
    export class Observer extends Display {
        processModeChanged(force?: boolean): void;
    }
}
declare module "foundation/editor/view/base/ViewerAnnotation" {
    import { Annotation } from 'cross/runtime/lang/reflect/Annotation';
    import { CanvasEnum } from "foundation/editor/view/base/CanvasEnum";
    export class ViewerAnnotation extends Annotation {
        typeCd: CanvasEnum;
        typeName: string;
        entityClazzes: any;
        logicCodes: Array<string>;
        check?: Function;
        constructor(typeCd: CanvasEnum, typeName: string, types: Array<Function>, logicCodes?: Array<string>, checkFun?: Function);
        match(typeCd: CanvasEnum, typeName: string, entityType: Function, logicCode: string): boolean;
        newInstance(): any;
    }
}
declare module "foundation/editor/view/base/ViewerControllerAnnotation" {
    import { Annotation } from 'cross/runtime/lang/reflect/Annotation';
    export class ViewerControllerAnnotation extends Annotation {
        displayClasses: Array<Function>;
        nodeClasses: Array<Function>;
        elementClasses: Array<Function>;
        constructor(displayClasses: Array<Function>, nodeClasses?: Array<Function>, elementClasses?: Array<Function>);
        match(display: any, node: any, element: any): boolean;
        newInstance(): any;
    }
}
declare module "foundation/editor/view/base/ViewerDisplay" {
    import { CanvasEnum } from "foundation/editor/view/base/CanvasEnum";
    export interface ViewerDisplay {
        testCreateAble(typeCd: CanvasEnum, typeCode: string, entity: any): boolean;
    }
}
declare module "foundation/editor/view/base/ViewerService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Objects } from 'cross/runtime/lang/Objects';
    import { Service } from 'cross/runtime/module/Service';
    import { CanvasEnum } from "foundation/editor/view/base/CanvasEnum";
    import { ViewerAnnotation } from "foundation/editor/view/base/ViewerAnnotation";
    import { ViewerControllerAnnotation } from "foundation/editor/view/base/ViewerControllerAnnotation";
    type ViewerDecalreInfo = {
        annotation: ViewerAnnotation;
    };
    export class ViewerService extends Service {
        protected _viewerAnnotations: Objects<ViewerAnnotation>;
        protected _viewerControllerAnnotations: Objects<ViewerControllerAnnotation>;
        protected _decalreInfos: Dictionary<ViewerDecalreInfo>;
        registerViewer(annotation: ViewerAnnotation, checkTypeName?: boolean): void;
        findAnnotation(typeCd: CanvasEnum, typeName: string, entityType: Function, logicCode: string, entity: Node): ViewerAnnotation;
        newInstance(typeCd: CanvasEnum, typeName: string, entityType: Function): any;
        createInstance(typeCd: CanvasEnum, typeCode: string, entity: any): any;
        registeViewerController(annotation: ViewerControllerAnnotation): void;
        newControllerInstance(display: any, node: any, element: any): any;
        removeInstance(instance: any): void;
    }
}
declare module "foundation/editor/view/base/Canvas" {
    import { Looper } from 'cross/runtime/lang/collection/Looper';
    import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Class } from 'cross/runtime/lang/reflect/Class';
    import { ClassLinkerFactory } from 'cross/runtime/lang/reflect/ClassLinkerFactory';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Speed } from 'cross/runtime/lang/Speed';
    import { DynamicService } from 'cross/runtime/module/dynamic/DynamicService';
    import { DocumentEvent } from 'cross/runtime/framework/document/DocumentEvent';
    import { NodeChildEvent } from 'cross/runtime/framework/node/NodeChildEvent';
    import { View } from 'cross/runtime/framework/view/View';
    import { ViewContext } from 'cross/runtime/framework/view/ViewContext';
    import { CanvasDeviceService } from 'cross/editor/device/canvas/CanvasDeviceService';
    import { ICanvasDevice } from 'cross/editor/device/canvas/ICanvasDevice';
    import { KeyboardDeviceEvent } from 'cross/editor/device/keyboard/KeyboardDeviceEvent';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { ResizeEvent } from 'cross/editor/device/screen/ResizeEvent';
    import { ScreenDeviceService } from 'cross/editor/device/screen/ScreenDeviceService';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { MainTimeline } from 'foundation/runtime/graphics/timeline/MainTimeline';
    import { ThemeService } from 'foundation/core/module/theme/ThemeService';
    import { DataNode, DataNodeCollection } from 'foundation/data/common/model/base/DataNode';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataBlueprintNode } from 'foundation/data/common/model/DataBlueprintNode';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    import { ActionService } from "foundation/editor/view/action/ActionService";
    import { AssetManager } from "foundation/editor/view/base/asset/AssetManager";
    import { GizmoFactory } from "foundation/editor/view/base/gizmo/GizmoFactory";
    import { GizmoManager } from "foundation/editor/view/base/gizmo/GizmoManager";
    import { SelectionManager } from "foundation/editor/view/base/selection/SelectionManager";
    import { Selector } from "foundation/editor/view/base/selection/Selector";
    import { StyleManager } from "foundation/editor/view/base/style/StyleManager";
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { CanvasController } from "foundation/editor/view/base/CanvasController";
    import { CanvasEnum } from "foundation/editor/view/base/CanvasEnum";
    import { CanvasModeEnum } from "foundation/editor/view/base/CanvasModeEnum";
    import { CanvasOptions } from "foundation/editor/view/base/CanvasOptions";
    import { CanvasShadedModeEnum } from "foundation/editor/view/base/CanvasShadedModeEnum";
    import { Display, DisplayIdMap } from "foundation/editor/view/base/Display";
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { Layers } from "foundation/editor/view/base/Layers";
    import { Observer } from "foundation/editor/view/base/Observer";
    import { ViewerService } from "foundation/editor/view/base/ViewerService";
    export class Canvas extends View {
        optionClass: any;
        options: CanvasOptions;
        canvasId: string;
        context: CanvasContext;
        code: string;
        typeCd: CanvasEnum;
        typeCode: string;
        typeName: string;
        logicCode: string;
        _modeCd: CanvasModeEnum;
        setting: any;
        document: DataDocument;
        blueprint: DataBlueprintNode;
        observer: Observer;
        layers: Layers;
        displays: DisplayIdMap;
        displaysLooper: Looper<Display>;
        controller: CanvasController;
        styleManager: StyleManager;
        assetManager: AssetManager;
        selectionManager: SelectionManager;
        selector: Selector;
        gizmoFactory: GizmoFactory;
        gizmoManager: GizmoManager;
        shadedCd: CanvasShadedModeEnum;
        mainTimeline: MainTimeline;
        statusFreeze: boolean;
        protected _actionDisplays: TypeMap<Class, Display>;
        protected _actionLayerCd: any;
        protected _displayContext: DisplayContext;
        protected _entityFactory: ClassLinkerFactory;
        protected _statusDocumentOpened: boolean;
        protected _processCountLimit: number;
        protected _processTickLimit: number;
        protected _dynamicService: DynamicService;
        protected _viewerService: ViewerService;
        protected _actionService: ActionService;
        protected _themeService: ThemeService;
        frameDisplayCount: number;
        speed: Speed;
        protected _displayAddEntities: Types<DataNode>;
        protected _displayRemoveEntities: Types<DataNode>;
        protected _canvasDevice: ICanvasDevice;
        protected _canvasDeviceService: CanvasDeviceService;
        protected _screenDeviceService: ScreenDeviceService;
        invertedWorldMatrix: Matrix4;
        constructor();
        get canvasDevice(): ICanvasDevice;
        get statusDocumentOpened(): boolean;
        get displayCount(): number;
        createOptions(): CanvasOptions;
        createContext(): CanvasContext;
        get statusInitialized(): boolean;
        get modeCd(): CanvasModeEnum;
        set modeCd(value: CanvasModeEnum);
        onSetupAsync(): Promise<ResultObject>;
        setupAsync(): Promise<ResultObject>;
        setupAfter(): void;
        findDisplayByUniqueId(uniqueId: number): Display;
        findDisplayByEntity(entity: DataNode): Display;
        bindAction(): void;
        unbindAction(): void;
        setParentPanel(hParent: any): void;
        bindDocument(document: DataDocument): void;
        bindDocumentEvent(): void;
        unbindDocumentEvent(): void;
        unbindDocument(): void;
        openBlueprint(blueprint: DataBlueprintNode, nodes?: [DataNode]): void;
        closeBlueprint(): void;
        protected drawEntity(entity: DataNode): void;
        drawBlueprint(blueprint: DataBlueprintNode): void;
        drawNodes(nodes: [DataNode]): void;
        protected drawNode(node: DataNode): void;
        onNewDesign(sender: ListenerContext, event: DocumentEvent): void;
        openDocument(document: DataDocument, nodes?: [DataNode]): void;
        onOpenDesign(sender: ListenerContext, event: DocumentEvent): void;
        onRefreshDesign(sender: ListenerContext, event: DocumentEvent, dirtyBlueprint?: boolean): void;
        onCloseDesign(sender: ListenerContext, event: DocumentEvent): void;
        onBeginingActionDisplay(sender: ListenerContext, event: ActionEvent): void;
        onBeginActionDisplay(sender: ListenerContext, event: ActionEvent): void;
        onEndActionDisplay(sender: ListenerContext, event: ActionEvent): void;
        findActionDisplaysByClass(displayClass: Function): Display;
        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;
        onMouseWheel(sender: ListenerContext, event: WheelEvent): void;
        onKeyDown(sender: ListenerContext, event: KeyboardDeviceEvent): void;
        onKeyUp(sender: ListenerContext, event: KeyboardDeviceEvent): void;
        onTouchStart(sender: ListenerContext, event: TouchEvent): void;
        onTouchMove(sender: ListenerContext, event: TouchEvent): void;
        onTouchEnd(sender: ListenerContext, event: TouchEvent): void;
        createDisplayObject(node: DataNode): Display;
        addDisplayObject(display: Display): void;
        removeDisplayObject(display: Display): void;
        addDisplayEntity(node: DataNode): void;
        removeDisplayEntity(node: DataNode): void;
        onBlueprintFiledChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        protected onChildAdd(sender: ListenerContext, event: NodeChildEvent): void;
        protected onChildRemove(sender: ListenerContext, event: NodeChildEvent): void;
        onResize(sender?: ListenerContext, event?: ResizeEvent): void;
        processBefore(viewContext: ViewContext): void;
        process(viewContext: ViewContext): void;
        processAfter(viewContext: ViewContext): void;
        closeChildren(children: DataNodeCollection): void;
        dirtyAllDisplays(): void;
        clear(): void;
        free(): void;
    }
}
declare module "foundation/editor/view/base/DisplayController" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ActionService } from "foundation/editor/view/action/ActionService";
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { Display } from "foundation/editor/view/base/Display";
    export class DisplayController extends Dispatcher {
        typeName: string;
        context: CanvasContext;
        entity: DataNode;
        display: Display;
        protected _actionService: ActionService;
        setup(): void;
        onDispatchEvent(code: string, event: any): boolean;
        dispatchEvent(code: any, event: any): boolean;
        receiveEvent(code: any, event: any): boolean;
        dispose(): void;
    }
}
declare module "foundation/editor/view/base/DisplayFlagEnum" {
    export class DisplayFlagEnum {
        static OptionView: number;
        static OptionVisible: number;
        static OptionSelect: number;
        static OptionDragable: number;
        static OptionGizmo: number;
        static StatusSetup: number;
        static StatusCreate: number;
        static StatusActive: number;
        static StatusInView: number;
        static StatusValid: number;
        static StatusVisible: number;
        static StatusEditing: number;
        static StatusDirty: number;
    }
}
declare module "foundation/editor/view/base/Display" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ThemeService } from 'foundation/core/module/theme/ThemeService';
    import { BlueprintNode } from 'foundation/data/common/model/base/BlueprintNode';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { DataNodeActionEvent } from 'foundation/data/common/model/base/DataNodeActionEvent';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { ActionObject } from "foundation/editor/view/action/ActionObject";
    import { ActionService } from "foundation/editor/view/action/ActionService";
    import { Canvas } from "foundation/editor/view/base/Canvas";
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { CanvasEnum } from "foundation/editor/view/base/CanvasEnum";
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { DisplayController } from "foundation/editor/view/base/DisplayController";
    import { Layer } from "foundation/editor/view/base/Layer";
    export class Display extends Dispatcher {
        typeName: string;
        code: string;
        name: string;
        context: CanvasContext;
        document: DataDocument;
        blueprint: BlueprintNode;
        entity: DataNode;
        view: Canvas;
        layer: Layer;
        controllerClass: any;
        controller: DisplayController;
        action: ActionObject;
        node: any;
        nodeSelector: any;
        selectorOrder: number;
        protected _statusFlags: number;
        protected _dirtyTick: number;
        protected _dirtyTimeout: number;
        protected _actionService: ActionService;
        protected _themeService: ThemeService;
        constructor();
        get optionView(): boolean;
        set optionView(value: boolean);
        get optionVisible(): boolean;
        set optionVisible(value: boolean);
        get optionSelect(): boolean;
        set optionSelect(value: boolean);
        get optionDragable(): boolean;
        set optionDragable(value: boolean);
        get optionGizmo(): boolean;
        set optionGizmo(value: boolean);
        get statusSetup(): boolean;
        set statusSetup(value: boolean);
        get statusCreate(): boolean;
        set statusCreate(value: boolean);
        get statusActive(): boolean;
        set statusActive(value: boolean);
        get statusInView(): boolean;
        set statusInView(value: boolean);
        get statusValid(): boolean;
        set statusValid(value: boolean);
        get statusVisible(): boolean;
        set statusVisible(value: boolean);
        get statusEditing(): boolean;
        set statusEditing(value: boolean);
        get statusDirty(): boolean;
        set statusDirty(value: boolean);
        get uniqueId(): number;
        setup(): void;
        makeNodeName(name: string): string;
        onEntityMount(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEntityAction(sender: ListenerContext, event: DataNodeActionEvent): void;
        onEntityUnmount(sender: ListenerContext, event: DataNodeFieldEvent): void;
        isDirty(): boolean;
        bindAction(): void;
        unbindAction(): void;
        onAddToView(): void;
        addToView(): void;
        onRemoveFromView(): void;
        removeFromView(): void;
        onActivate(): void;
        activate(): void;
        onDeactivate(): void;
        deactivate(): void;
        canDraw(): boolean;
        createNode(): any;
        onDraw(displayContext?: DisplayContext): void;
        drawDisplay(displayContext?: DisplayContext): void;
        draw(displayContext?: DisplayContext): void;
        redraw(displayContext?: DisplayContext): void;
        show(): void;
        hide(): void;
        update(context?: DisplayContext): void;
        dirty(dirtyTimeout?: number): void;
        nondirty(): void;
        reset(): void;
        dispose(): void;
        static testCreateAble(typeCd: CanvasEnum, typeCode: string, entity: DataNode): boolean;
    }
    export type DisplayIdMap = Map<number, Display>;
    export type DisplayMap = Map<string, Display>;
}
declare module "foundation/editor/view/base/LayerEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { GraphicObject } from "foundation/editor/view/base/graphic/GraphicObject";
    import { Display } from "foundation/editor/view/base/Display";
    import { Layer } from "foundation/editor/view/base/Layer";
    export class LayerEvent extends EventObject {
        layer: Layer;
        display: Display;
        node: GraphicObject;
        appendNode: any;
        free(): void;
    }
}
declare module "foundation/editor/view/base/LayerEventEnum" {
    export class LayerEventEnum {
        static AddNode: string;
        static UpdateNode: string;
        static RemoveNode: string;
    }
}
declare module "foundation/editor/view/base/Scene" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { Layer } from "foundation/editor/view/base/Layer";
    import { LayerGroup } from "foundation/editor/view/base/LayerGroup";
    export class Scene extends Dispatcher {
        context: CanvasContext;
        id: string;
        name: string;
        protected _layerGroups: Types<LayerGroup>;
        protected _layers: Types<Layer>;
        protected _children: Types<any>;
        constructor(name?: string);
        initialize(): void;
        setup(): void;
        addLayerGroup(layerGroup: LayerGroup): void;
        removeLayerGroup(layerGroup: LayerGroup): void;
        addLayer(layer: Layer): void;
        removeLayer(layer: Layer): void;
        get children(): Types<any>;
        addChild(node: any): void;
        removeChild(node: any): void;
    }
}
declare module "foundation/editor/view/base/LayerGroup" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { Layer } from "foundation/editor/view/base/Layer";
    import { Scene } from "foundation/editor/view/base/Scene";
    export class LayerGroup extends Dispatcher {
        context: CanvasContext;
        id: string;
        name: string;
        sceneName: string;
        scene: Scene;
        level: number;
        protected _layers: Types<Layer>;
        constructor(name?: string, sceneName?: string);
        get optionDepthClear(): boolean;
        set optionDepthClear(value: boolean);
        initialize(): void;
        setup(): void;
        hasLayer(layer: Layer): boolean;
        addLayer(layer: Layer): void;
        removeLayer(layer: Layer): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/base/Layer" {
    import { TypeSet } from 'cross/runtime/lang/collection/TypeSet';
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { GraphicObject } from "foundation/editor/view/base/graphic/GraphicObject";
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { Display } from "foundation/editor/view/base/Display";
    import { LayerGroup } from "foundation/editor/view/base/LayerGroup";
    import { Scene } from "foundation/editor/view/base/Scene";
    export class Layer extends Dispatcher {
        context: CanvasContext;
        id: string;
        name: string;
        protected _layerGroup: LayerGroup;
        protected _level: number;
        scene: Scene;
        sceneName: string;
        protected _children: TypeSet<Display>;
        constructor(name?: string, sceneName?: string);
        get children(): TypeSet<Display>;
        initialize(): void;
        setup(): void;
        get levelGroup(): LayerGroup;
        set levelGroup(layerGroup: LayerGroup);
        get level(): number;
        set level(value: number);
        hasChild(child: any): boolean;
        protected onAppendChild(display: any, node?: any): void;
        appendChild(display: any, node?: any): void;
        appendToChildWithNode(child: any, appendNode: any): void;
        appendChildren(children: Array<any>): void;
        appendGroup(children: Array<any>): void;
        updateChild(display: any, node?: any): void;
        protected onRemoveChild(display: any, node?: any): void;
        removeChild(display: any, node?: any): void;
        removeChildren(children: Array<any>): void;
        cleanupChildren(children: Array<any>): void;
        appendDisplay(display: Display, node?: GraphicObject): void;
        removeDisplay(display: Display, node?: GraphicObject): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/base/Layers" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { Layer } from "foundation/editor/view/base/Layer";
    import { LayerGroup } from "foundation/editor/view/base/LayerGroup";
    export class Layers extends InstanceObject {
        context: CanvasContext;
        protected _layerGroups: Dictionary<LayerGroup>;
        protected _children: Dictionary<Layer>;
        get layerGroups(): Dictionary<LayerGroup>;
        get children(): Dictionary<Layer>;
        setup(): void;
        registerLayerGroup(layerGroup: LayerGroup): void;
        register(layer: Layer): Layer;
        find(code: string): Layer;
    }
}
declare module "foundation/editor/view/base/Scenes" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { Layers } from "foundation/editor/view/base/Layers";
    import { Scene } from "foundation/editor/view/base/Scene";
    export class Scenes extends Dispatcher {
        context: CanvasContext;
        children: Dictionary<Scene>;
        setup(): void;
        register(scene: Scene): Scene;
        find(name: string): Scene;
        setupLayers(layers: Layers): void;
    }
}
declare module "foundation/editor/view/base/render/IRenderContext" {
    export interface IRenderContext {
        optionImmediate: boolean;
    }
}
declare module "foundation/editor/view/base/render/RenderDirtyEnum" {
    export class RenderDirtyEnum {
        static Normal: string;
        static Frame: string;
    }
}
declare module "foundation/editor/view/base/render/RendererEventEnum" {
    export class RendererEventEnum {
        static ParentReplaced: string;
        static ChildAdd: string;
        static ChildRemove: string;
        static ChildReplaced: string;
        static FlagChanged: string;
        static FieldChanged: string;
        static GeometryDirty: string;
        static MaterialDirty: string;
        static TextureDirty: string;
        static Dirty: string;
        static Reload: string;
        static Removed: string;
        static Dispose: string;
    }
}
declare module "foundation/editor/view/base/render/RenderOptions" {
    export class RenderOptions {
        renderCode: string;
        engineCode: string;
        width: number;
        height: number;
        alpha: boolean;
        clearColor: number;
        clearOpacity: number;
        shadow: boolean;
        fxaa: boolean;
    }
}
declare module "foundation/editor/view/base/render/RenderParameters" {
    export type RenderParameters = {
        optionImmediate?: boolean;
        optionFlush?: boolean;
    };
}
declare module "foundation/editor/view/base/render/Renderer" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Size2 } from 'foundation/runtime/math/Size2';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { Scenes } from "foundation/editor/view/base/Scenes";
    import { IRenderContext } from "foundation/editor/view/base/render/IRenderContext";
    import { RenderDirtyEnum } from "foundation/editor/view/base/render/RenderDirtyEnum";
    import { RendererEventEnum } from "foundation/editor/view/base/render/RendererEventEnum";
    import { RenderOptions } from "foundation/editor/view/base/render/RenderOptions";
    import { RenderParameters } from "foundation/editor/view/base/render/RenderParameters";
    export class Renderer extends InstanceObject {
        context: CanvasContext;
        options: RenderOptions;
        optionDynamic: boolean;
        scenes: Scenes;
        camera: any;
        protected _statusInitialized: boolean;
        protected _size: Size2;
        get statusInitialized(): boolean;
        setup(): void;
        setupAsync(): Promise<ResultObject>;
        getCanvasSize(): Readonly<Size2>;
        setCanvasSize(width: number, height: number): void;
        setClearColor(color: number, opacity?: number): void;
        renderClear(): void;
        renderBasic(context: IRenderContext, stage?: any, parameters?: RenderParameters): void;
        renderRemained(context: IRenderContext, stage?: any, parameters?: RenderParameters): void;
        renderFinish(): void;
        update(context: IRenderContext): void;
        render(context: IRenderContext, stage?: any, parameters?: RenderParameters): void;
        process(context: IRenderContext): void;
        processEvent(eventCd: RendererEventEnum, parameters?: any): void;
        dirty(dirtyCd?: RenderDirtyEnum): void;
        clear(): void;
    }
}
declare module "foundation/editor/view/base/render/RenderFactoryOptions" {
    export class RenderFactoryOptions {
        renderCode: string;
        engineCode: string;
    }
}
declare module "foundation/editor/view/base/render/RenderFactory" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { Renderer } from "foundation/editor/view/base/render/Renderer";
    import { RenderFactoryOptions } from "foundation/editor/view/base/render/RenderFactoryOptions";
    export class RenderFactory extends InstanceObject {
        context: CanvasContext;
        protected _options: RenderFactoryOptions;
        constructor();
        get options(): RenderFactoryOptions;
        setup(): void;
        createRenderer(options: any): Renderer;
    }
}
declare module "foundation/editor/view/base/CanvasEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { Size2 } from 'foundation/runtime/math/Size2';
    import { Camera } from 'foundation/runtime/graphics/camera/Camera';
    import { Observer } from "foundation/editor/view/base/Observer";
    export class CanvasEvent extends EventObject {
        size: Size2;
        observer: Observer;
        graphicCamera: Camera;
        free(): void;
    }
}
declare module "foundation/editor/view/base/render/DummyRenderer" {
    import { Renderer } from "foundation/editor/view/base/render/Renderer";
    export class DummyRenderer extends Renderer {
    }
}
declare module "foundation/editor/view/base/render/LightManager" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { Scenes } from "foundation/editor/view/base/Scenes";
    export class LightManager extends InstanceObject {
        context: CanvasContext;
        scenes: Scenes;
        setup(): void;
        update(): void;
    }
}
declare module "foundation/editor/view/base/render/RenderModeEnum" {
    export class RenderModeEnum {
        static Normal: string;
        static Fast: string;
    }
}
declare module "foundation/editor/view/base/render/RenderManager" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { CanvasEvent } from "foundation/editor/view/base/CanvasEvent";
    import { Scenes } from "foundation/editor/view/base/Scenes";
    import { IRenderContext } from "foundation/editor/view/base/render/IRenderContext";
    import { LightManager } from "foundation/editor/view/base/render/LightManager";
    import { Renderer } from "foundation/editor/view/base/render/Renderer";
    import { RenderFactory } from "foundation/editor/view/base/render/RenderFactory";
    import { RenderModeEnum } from "foundation/editor/view/base/render/RenderModeEnum";
    import { RenderOptions } from "foundation/editor/view/base/render/RenderOptions";
    import { RenderParameters } from "foundation/editor/view/base/render/RenderParameters";
    export class RenderManager extends Dispatcher {
        context: CanvasContext;
        renderCode: string;
        engineCode: string;
        factory: RenderFactory;
        scenes: Scenes;
        graphicCamera: any;
        lightManager: LightManager;
        rendererClass: any;
        renderer: Renderer;
        modeCd: RenderModeEnum;
        protected _cameraDirty: boolean;
        protected _rendererOptions: RenderOptions;
        protected _fastRenderInterval: number;
        protected _fastRenderStatus: boolean;
        protected _lastRenderTime: number;
        constructor();
        setupAsync(): Promise<ResultObject>;
        onCanvasRectChanged(sender: ListenerContext, event: CanvasEvent): void;
        onCameraChanged(sender: ListenerContext, event: CanvasEvent): void;
        setRenderMode(modeCd: RenderModeEnum): void;
        setEnvironmentColor(color: number, opacity?: number): void;
        createRenderer(): Renderer;
        update(context: any): void;
        render(context: IRenderContext, stage?: any, parameters?: RenderParameters): void;
        process(context: IRenderContext): void;
        refresh(context: CanvasContext): void;
    }
}
declare module "foundation/editor/view/base/CanvasContext" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { Listeners } from 'cross/runtime/lang/Listeners';
    import { QualityEnum } from 'cross/runtime/framework/quality/QualityEnum';
    import { QualityModeEnum } from 'cross/runtime/framework/quality/QualityModeEnum';
    import { ICanvasDevice } from 'cross/editor/device/canvas/ICanvasDevice';
    import { Size2 } from 'foundation/runtime/math/Size2';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { AssetManager } from "foundation/editor/view/base/asset/AssetManager";
    import { Renderer } from "foundation/editor/view/base/render/Renderer";
    import { RenderFactory } from "foundation/editor/view/base/render/RenderFactory";
    import { RenderManager } from "foundation/editor/view/base/render/RenderManager";
    import { SelectionManager } from "foundation/editor/view/base/selection/SelectionManager";
    import { Canvas } from "foundation/editor/view/base/Canvas";
    import { CanvasController } from "foundation/editor/view/base/CanvasController";
    import { CanvasOptions } from "foundation/editor/view/base/CanvasOptions";
    import { Display } from "foundation/editor/view/base/Display";
    export class CanvasContext extends Dispatcher {
        options: CanvasOptions;
        document: DataDocument;
        canvasDevice: ICanvasDevice;
        canvas: Canvas;
        qualityCd: QualityEnum;
        modeCd: QualityModeEnum;
        optionEnable: boolean;
        optionImmediate: boolean;
        size: Size2;
        pixelRatio: number;
        graphicSize: Size2;
        renderer: Renderer;
        renderManager: RenderManager;
        renderFactory: RenderFactory;
        assetManager: AssetManager;
        selectionManager: SelectionManager;
        canvasController: CanvasController;
        enterFrameListeners: Listeners;
        leaveFrameListeners: Listeners;
        protected _dirty: boolean;
        constructor();
        isDirty(): boolean;
        onDataLoad: () => void;
        getClientRect(): any;
        testDisplayDraw(display: Display): boolean;
        resize(): void;
        setSize(width: number, height: number): void;
        dirty(): void;
        reset(): void;
        showMessage(message: string, ...parameters: Array<any>): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/action/ActionEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { KeyboardDeviceEvent } from 'cross/editor/device/keyboard/KeyboardDeviceEvent';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { ActionObject } from "foundation/editor/view/action/ActionObject";
    export class ActionEvent extends EventObject {
        document: DataDocument;
        action: ActionObject;
        eventCd: string;
        keyCode: number;
        keyCtrl: boolean;
        keyAlt: boolean;
        keyShift: boolean;
        context: CanvasContext;
        assign(event: ActionEvent): void;
        assignKeyboard(event: KeyboardDeviceEvent): void;
        free(): void;
    }
}
declare module "foundation/editor/view/action/ActionFilter" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { BaseObject } from 'cross/runtime/lang/BaseObject';
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    import { ActionObject } from "foundation/editor/view/action/ActionObject";
    export class ActionFilter extends BaseObject {
        include: Types<Function>;
        exclude: Types<Function>;
        constructor();
        testRunable(action: ActionObject, event?: ActionEvent): boolean;
    }
}
declare module "foundation/editor/view/action/ActionProcessor" {
    import { BaseObject } from 'cross/runtime/lang/BaseObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    import { ActionObject } from "foundation/editor/view/action/ActionObject";
    export class ActionProcessor extends BaseObject {
        process(action: ActionObject, event?: ActionEvent): ResultObject;
        processAsync(action: ActionObject, event?: ActionEvent): Promise<ResultObject>;
    }
}
declare module "foundation/editor/view/action/ActionProcessorDeclareInfo" {
    export type ActionProcessorDeclareInfo = {
        actionClass: any;
        clazz: any;
        instance?: any;
    };
}
declare module "foundation/editor/view/action/ActionResult" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    export class ActionResult<T = any> extends ResultObject {
    }
}
declare module "foundation/editor/view/action/AsyncActionObject" {
    import { ActionObject } from "foundation/editor/view/action/ActionObject";
    import { ActionResult } from "foundation/editor/view/action/ActionResult";
    export class AsyncActionObject extends ActionObject {
        executeAsync(event?: any): Promise<ActionResult>;
    }
}
declare module "foundation/editor/view/action/ActionService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { DynamicService } from 'cross/runtime/module/dynamic/DynamicService';
    import { LockService } from 'cross/runtime/module/lock/LockService';
    import { Service } from 'cross/runtime/module/Service';
    import { RecordService } from "foundation/editor/view/script/RecordService";
    import { TransactionService } from "foundation/editor/view/transaction/TransactionService";
    import { ActionDeclareInfo } from "foundation/editor/view/action/ActionDeclareInfo";
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    import { ActionFilter } from "foundation/editor/view/action/ActionFilter";
    import { ActionObject } from "foundation/editor/view/action/ActionObject";
    import { ActionProcessor } from "foundation/editor/view/action/ActionProcessor";
    import { ActionProcessorDeclareInfo } from "foundation/editor/view/action/ActionProcessorDeclareInfo";
    import { ActionResult } from "foundation/editor/view/action/ActionResult";
    import { AsyncActionObject } from "foundation/editor/view/action/AsyncActionObject";
    export class ActionService extends Service {
        protected _actionDeclareInfos: Types<ActionDeclareInfo>;
        protected _processorDeclareInfos: Types<ActionProcessorDeclareInfo>;
        actionFilters: Types<ActionFilter>;
        disableActions: Array<Function>;
        protected _filters: Types<Function>;
        current: ActionObject;
        restartAction: ActionObject;
        protected _pendings: Types<ActionObject>;
        protected _lockService: LockService;
        protected _transactionService: TransactionService;
        protected _recordService: RecordService;
        protected _dynamicService: DynamicService;
        constructor();
        get filters(): Types<Function>;
        isAction(...types: Array<Function>): boolean;
        testInFilter(action: ActionObject): boolean;
        testInDisable(action: ActionObject): boolean;
        getRunningActions(): Array<ActionObject>;
        register(declare: ActionDeclareInfo): void;
        registerProcessor(declare: ActionProcessorDeclareInfo): void;
        findProcessors(action: ActionObject): Types<ActionProcessor>;
        createAction(actionClass: Function, event?: ActionEvent): ActionObject;
        createAsyncAction(actionClass: Function, event?: ActionEvent): ActionObject;
        execute(action: ActionObject, event?: ActionEvent): boolean;
        executeAsync(action: AsyncActionObject, event?: any): Promise<ActionResult>;
        receive(code: string, event: any): boolean;
        complete(action?: ActionObject, event?: any): void;
        breforeComplete(action: any): void;
        cancel(action?: ActionObject, event?: any): void;
        restartAsync(): Promise<ResultObject>;
        clearRestart(): void;
        check(action?: ActionObject, event?: any): void;
        addDisable(actionClass: any): void;
        clearDisable(): void;
        addActionFilter(actionFilter: ActionFilter): void;
        clearActionFilter(): void;
        clear(): void;
    }
}
declare module "foundation/editor/view/action/Action" {
    import { ActionObject } from "foundation/editor/view/action/ActionObject";
    import { ActionService } from "foundation/editor/view/action/ActionService";
    export class Action extends ActionObject {
        protected _actionService: ActionService;
    }
}
declare module "foundation/editor/view/action/ActionDeclare" {
    export function ActionDeclare(name: string): (target: any) => void;
}
declare module "foundation/editor/view/action/ActionProcessorDeclare" {
    export function ActionProcessorDeclare(actionClass: any): (target: any) => void;
}
declare module "foundation/editor/view/action/AsyncAction" {
    import { ActionResult } from "foundation/editor/view/action/ActionResult";
    import { ActionService } from "foundation/editor/view/action/ActionService";
    import { AsyncActionObject } from "foundation/editor/view/action/AsyncActionObject";
    export class AsyncAction extends AsyncActionObject {
        protected _actionService: ActionService;
        onExecuteAsync(event?: any): Promise<ActionResult>;
        executeAsync(event?: any): Promise<ActionResult>;
    }
}
declare module "foundation/editor/view/action/AsyncCompositeAction" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ActionObject } from "foundation/editor/view/action/ActionObject";
    import { ActionResult } from "foundation/editor/view/action/ActionResult";
    import { AsyncAction } from "foundation/editor/view/action/AsyncAction";
    export class AsyncCompositeAction extends AsyncAction {
        actions: Types<ActionObject>;
        constructor();
        linkEvent(event: EventObject): void;
        pushAction(action: ActionObject): void;
        onExecute(event?: any): void;
        onExecuteAsync(event?: any): Promise<ActionResult>;
        onReceive(code: string, event?: any): boolean;
        onUndoAsync(): Promise<ResultObject<any>>;
        onRedoAsync(): Promise<ResultObject<any>>;
        onCleanup(event?: any): void;
    }
}
declare module "foundation/editor/view/action/AsyncProcessAction" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ActionService } from "foundation/editor/view/action/ActionService";
    import { AsyncAction } from "foundation/editor/view/action/AsyncAction";
    export class AsyncProcessAction extends AsyncAction {
        protected _actionService: ActionService;
        protected innerProcess(event: any): ResultObject;
        protected innerProcessAsync(event: any): Promise<ResultObject>;
    }
}
declare module "foundation/editor/view/action/CompositeAction" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { Action } from "foundation/editor/view/action/Action";
    export class CompositeAction extends Action {
        actions: Types<Action>;
        constructor();
        linkEvent(event: EventObject): void;
        pushAction(action: Action): void;
        onExecute(event?: any): void;
        onReceive(code: string, event?: any): boolean;
        onUndo(): void;
        onRedo(): void;
        onCleanup(event?: any): void;
    }
}
declare module "foundation/editor/view/action/EntityProcessor" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class EntityProcessor<T> extends InstanceObject {
        workers: Types<T>;
        constructor();
        register(worker: T): void;
        invoke(methodName: string, p1?: any, p2?: any, p3?: any, p4?: any, p5?: any, p6?: any): any;
    }
}
declare module "foundation/editor/view/action/EntityWorker" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class EntityWorker extends InstanceObject {
    }
}
declare module "foundation/editor/view/action/ProcessAsyncAction" {
    import { IContext } from 'cross/runtime/lang/IContext';
    import { ContextService } from 'cross/runtime/module/context/ContextService';
    import { LogicStatisticService } from 'foundation/data/common/logic/LogicStatisticService';
    import { ActionResult } from "foundation/editor/view/action/ActionResult";
    import { ActionService } from "foundation/editor/view/action/ActionService";
    import { AsyncActionObject } from "foundation/editor/view/action/AsyncActionObject";
    export class ProcessAsyncAction extends AsyncActionObject {
        protected _optionStatistics: boolean;
        protected _statisticsCode: string;
        protected _contextService: ContextService;
        protected _statisticService: LogicStatisticService;
        protected _actionService: ActionService;
        onExecuteAsync(context: IContext, event?: any): Promise<ActionResult>;
        executeAsync(event?: any): Promise<ActionResult>;
    }
}
declare module "foundation/editor/view/action/camera/CameraAction" {
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { Action } from "foundation/editor/view/action/Action";
    export class CameraAction extends Action {
        entity: ObserverViewNode;
        protected _selectionService: SelectionService;
    }
}
declare module "foundation/editor/view/action/camera/CameraActionEvent" {
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Size2 } from 'foundation/runtime/math/Size2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { ObserverModeEnum } from 'foundation/data/common/model/brep/ObserverModeEnum';
    import { ObserverTypeEnum } from 'foundation/data/common/model/brep/ObserverTypeEnum';
    import { Canvas } from "foundation/editor/view/base/Canvas";
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    export class CameraActionEvent extends ActionEvent {
        view: Canvas;
        entity: ObserverViewNode;
        typeCd: ObserverTypeEnum;
        modeCd: ObserverModeEnum;
        protected _screenPoint: Vector2;
        protected _screenOffset: Vector2;
        protected _point: Vector3;
        protected _offset: Vector3;
        protected _viewSize: Size2;
        protected _viewPoint: Vector2;
        protected _viewOffset: Vector2;
        viewScale: number;
        protected _movePoint: Vector3;
        protected _moveTarget: Vector3;
        alpha: number;
        beta: number;
        pitch: number;
        yaw: number;
        radius: number;
        zoom: number;
        withTarget: boolean;
        locked: boolean;
        reset: boolean;
        cameraTarget: Vector3;
        cameraPos: Vector3;
        fitBox: Box3;
        canvasWidth: number;
        canvasHeight: number;
        cameraFov: number;
        mouseLeft: boolean;
        mouseMiddle: boolean;
        mouseRight: boolean;
        constructor();
        get screenPoint(): Vector2;
        get screenOffset(): Vector2;
        get point(): Vector3;
        get offset(): Vector3;
        get viewPoint(): Vector2;
        get viewSize(): Size2;
        get viewOffset(): Vector2;
        get movePoint(): Vector3;
        get moveTarget(): Vector3;
        free(): void;
    }
}
declare module "foundation/editor/view/action/camera/CameraAerialViewAction" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { CameraAction } from "foundation/editor/view/action/camera/CameraAction";
    import { CameraActionEvent } from "foundation/editor/view/action/camera/CameraActionEvent";
    export class CameraAerialViewAction extends CameraAction {
        protected _srcPosition: Vector3;
        protected _srcTarget: Vector3;
        protected _curTarget: Vector3;
        protected _curPosition: Vector3;
        protected _lastTarget: Vector3;
        protected _lastOrthoAlpha: number;
        protected _lastOrthoBeta: number;
        protected _lastOrthoRadius: number;
        protected _statusMouseDown: boolean;
        protected _statusDirty: boolean;
        protected _pressedKey: Types<number>;
        protected _oldTarget: Vector3;
        protected _oldOrthoAlpha: number;
        protected _oldOrthoBeta: number;
        constructor();
        isMouseDown(): boolean;
        protected isKeyUp(): boolean;
        protected addPressedKey(keyCode: number): void;
        protected removePressedKey(keyCode: number): void;
        protected processDragMove(event: CameraActionEvent): void;
        protected processZoom(event: CameraActionEvent): void;
        protected moveOffset(offset: Value3): void;
        onExecute(event: CameraActionEvent): void;
        onReceive(code: string, event: any): boolean;
        protected moveTarget(target: Vector3): void;
        protected moveKeepTarget(curPos: Vector3): void;
        protected moveTo(pos: Vector3): void;
        protected cumputerOrthogonalKey(keyCode: number): boolean;
        onUndoAsync(): Promise<ResultObject<any>>;
        onRedoAsync(): Promise<ResultObject<any>>;
    }
}
declare module "foundation/editor/view/action/camera/CameraArcRotationAction" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { CameraAction } from "foundation/editor/view/action/camera/CameraAction";
    import { CameraActionEvent } from "foundation/editor/view/action/camera/CameraActionEvent";
    export class CameraArcRotationAction extends CameraAction {
        protected _lastPosition: Vector3;
        protected _lastTarget: Vector3;
        protected _lastAlpha: number;
        protected _lastBeta: number;
        protected _lastOrthoAlpha: number;
        protected _lastOrthoBeta: number;
        protected _lastViewPoint: Vector2;
        protected _lastOrthoPoint: Vector3;
        protected _lastOrthoTopPoint: Vector3;
        protected _lastOrthoRadius: number;
        protected _statusMouseDown: boolean;
        protected _statusDirty: boolean;
        protected _pressedKey: Types<number>;
        constructor();
        isMouseDown(): boolean;
        protected isKeyUp(): boolean;
        protected addPressedKey(keyCode: number): void;
        protected removePressedKey(keyCode: number): void;
        protected processPerspectiveMove(event: CameraActionEvent): void;
        protected processDragMove(event: CameraActionEvent): void;
        protected processPerspectiveZoom(event: CameraActionEvent): void;
        protected processZoom(event: CameraActionEvent): void;
        protected moveOffset(offset: Value3): void;
        onExecute(event: CameraActionEvent): void;
        onReceive(code: string, event: any): boolean;
    }
}
declare module "foundation/editor/view/action/camera/CameraChangeModeAction" {
    import { ObserverModeEnum } from 'foundation/data/common/model/brep/ObserverModeEnum';
    import { ObserverTypeEnum } from 'foundation/data/common/model/brep/ObserverTypeEnum';
    import { CameraAction } from "foundation/editor/view/action/camera/CameraAction";
    import { CameraActionEvent } from "foundation/editor/view/action/camera/CameraActionEvent";
    export type CameraChangeModeHistory = {
        modeCd: ObserverModeEnum;
        typeCd: ObserverTypeEnum;
    };
    export class CameraChangeModeAction extends CameraAction {
        protected _oldContent: CameraChangeModeHistory;
        protected _newContent: CameraChangeModeHistory;
        constructor();
        private changeCameraMode;
        onExecute(event: CameraActionEvent): void;
        onUndo(): void;
        onRedo(): void;
    }
}
declare module "foundation/editor/view/action/camera/CameraFirstPersonAction" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { CameraAction } from "foundation/editor/view/action/camera/CameraAction";
    import { CameraActionEvent } from "foundation/editor/view/action/camera/CameraActionEvent";
    export class CameraFirstPersonAction extends CameraAction {
        protected _srcPosition: Vector3;
        protected _srcTarget: Vector3;
        protected _lastViewPoint: Vector2;
        protected _lastRadius: number;
        protected _statusMouseDown: boolean;
        protected _statusDirty: boolean;
        protected _pressedKey: Types<number>;
        protected _srcPicth: number;
        protected _srcYaw: number;
        protected _curPicth: number;
        protected _curYaw: number;
        protected _curDir: Vector3;
        protected _curTarget: Vector3;
        protected _curPosition: Vector3;
        private useSnap;
        constructor();
        isMouseDown(): boolean;
        protected isKeyUp(): boolean;
        protected addPressedKey(keyCode: number): void;
        protected removePressedKey(keyCode: number): void;
        protected moveTarget(offset: Value3): void;
        protected movePosition(offset: Value3): void;
        protected moveOffsetLocal(offset: Value3): void;
        protected moveOffset(offset: Value3): void;
        protected processZoom(event: CameraActionEvent): void;
        onExecute(event: CameraActionEvent): void;
        isOverSideByPos(x: number, y: number): boolean;
        isOverSideByOffset(x: number, y: number): boolean;
        protected correntYaw(): void;
        protected calTarget(): void;
        protected someDirCalTarget(): void;
        protected moveTo(pos: Vector3): void;
        protected setYaw(val: number): void;
        protected moveAndRot(pos: Vector3, yaw: number): void;
        protected processDragMove(event: CameraActionEvent): void;
        onReceive(code: string, event: any): boolean;
        setSnap(snap: boolean): void;
        getCurrentPicth(): number;
        getCurrentHeight(): number;
    }
}
declare module "foundation/editor/view/base/CanvasConstants" {
    export class CanvasConstants {
        static SELECTION_MOVE_PIXEL: number;
        static SELECTION_RANGE_PIXEL: number;
        static SELECTION_DOUBLE_TIMEOUT: number;
    }
}
declare module "foundation/editor/view/base/ObserverChangeEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { ObserverModeEnum } from 'foundation/data/common/model/brep/ObserverModeEnum';
    import { Observer } from "foundation/editor/view/base/Observer";
    export class ObserverChangeEvent extends EventObject {
        observer: Observer;
        graphicCamera: any;
        cameraModeCd: ObserverModeEnum;
        free(): void;
    }
}
declare module "foundation/editor/view/base/ObserverEventEnum" {
    export class ObserverEventEnum {
        static GraphicCameraChanged: string;
        static CameraChanged: string;
        static CameraPropertyChanged: string;
        static CameraFit: string;
    }
}
declare module "foundation/editor/view/entity/ObserverViewEntity" {
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    export class ObserverViewEntity extends ObserverViewNode {
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicContentUsageEnum" {
    export class V3dGraphicContentUsageEnum {
        static PickOnly: string;
    }
}
declare module "foundation/editor/view/view3d/asset/material/V3dAssetEffectManager" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AssetVersionType } from 'foundation/data/common/resource/AssetUtil';
    import { EffectDocumentService } from 'sk/data/resource/effect/service/EffectDocumentService';
    import { IGraphicMaterialInfo } from 'sk/data/resource/base/IGraphicMaterialInfo';
    import { MaterialQualityEnum } from 'sk/data/resource/enumeration/MaterialQualityEnum';
    import { AssetManager } from "foundation/editor/view/base/asset/AssetManager";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    export class V3dAssetEffectManager extends AssetManager {
        protected _effectDocumentService: EffectDocumentService;
        protected _effects: Dictionary<IGraphicMaterialInfo>;
        constructor(context: V3dCanvasContext);
        getEffecInfotById(resourceId: string): IGraphicMaterialInfo;
        setEffectInfo(resourceId: string, info: IGraphicMaterialInfo): void;
        loadEffectAsync(resourceId: string, qualityCd: MaterialQualityEnum, resourceVersion?: AssetVersionType): Promise<ResultObject<IGraphicMaterialInfo>>;
    }
}
declare module "foundation/editor/view/graphic/MaterialInfo" {
    import { MaterialConfig } from 'foundation/data/common/config/MaterialConfig';
    export class MaterialInfo extends MaterialConfig {
    }
}
declare module "foundation/editor/view/graphic/MaterialService" {
    import { Service } from 'cross/runtime/module/Service';
    import { MaterialConfigService } from 'foundation/data/common/config/MaterialConfigService';
    import { MaterialInfo } from "foundation/editor/view/graphic/MaterialInfo";
    export class MaterialService extends Service {
        protected _materialConfigService: MaterialConfigService;
        find(name: string): MaterialInfo;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicMaterial" {
    import { V3dGraphicObject } from "foundation/editor/view/view3d/render/graphic/V3dGraphicObject";
    export type V3dGraphicMaterialOptions = {
        vertexColor?: boolean;
    };
    export class V3dGraphicMaterial extends V3dGraphicObject {
        typeName: string;
        handle: any;
        options: V3dGraphicMaterialOptions;
        constructor(name?: string);
        get optionTransparent(): boolean;
        set optionTransparent(value: boolean);
        get optionDepthTest(): boolean;
        set optionDepthTest(value: boolean);
        get optionDepthWrite(): boolean;
        set optionDepthWrite(value: boolean);
        get optionDepthOffset(): boolean;
        set optionDepthOffset(value: boolean);
        get disableDepthWrite(): boolean;
        set disableDepthWrite(value: boolean);
        get sortLevel(): number;
        set sortLevel(value: number);
        get depthBias(): number;
        set depthBias(value: number);
        get depthBiasSlopeScale(): number;
        set depthBiasSlopeScale(value: number);
        get depthBiasSlopeOffset(): number;
        set depthBiasSlopeOffset(value: number);
        get depthBiasClamp(): number;
        set depthBiasClamp(value: number);
        dirty(): void;
        freeze(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicLineMaterial" {
    import { V3dGraphicMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMaterial";
    export type V3dGraphicLineMaterialOptions = {
        transparent?: boolean;
        vertexColor?: boolean;
    };
    export class V3dGraphicLineMaterial extends V3dGraphicMaterial {
        options: V3dGraphicLineMaterialOptions;
        get color(): any;
        setColor(r: number, g: number, b: number): void;
        get alpha(): number;
        set alpha(value: number);
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicTextureWrapEnum" {
    export class V3dGraphicTextureWrapEnum {
        static None: string;
        static Clamp: string;
        static Repeat: string;
        static MirrorRepeat: string;
        static toCode(code: V3dGraphicTextureWrapEnum): string;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicTexture" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { V3dGraphicObject } from "foundation/editor/view/view3d/render/graphic/V3dGraphicObject";
    import { V3dGraphicTextureWrapEnum } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTextureWrapEnum";
    export type V3dGraphicTextureOptions = {
        type?: string;
        mode?: string;
        url?: string;
        load?: boolean;
        invertY?: boolean;
        width?: number;
        height?: number;
        wrapAuCd?: V3dGraphicTextureWrapEnum;
        wrapAvCd?: V3dGraphicTextureWrapEnum;
        wrapAwCd?: V3dGraphicTextureWrapEnum;
        uScale?: number;
        vScale?: number;
    };
    export class V3dGraphicTexture extends V3dGraphicObject {
        type: string;
        url: string;
        handle: any;
        handleOnload: any;
        handleOnerror: any;
        options: V3dGraphicTextureOptions;
        constructor();
        loadImageAsync(url: string, onLoad?: Function): Promise<ResultObject>;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial" {
    import { V3dGraphicMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMaterial";
    import { V3dGraphicTexture } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTexture";
    export type V3dGraphicMeshMaterialOptions = {
        transparent?: boolean;
        vertexColor?: boolean;
    };
    export class V3dGraphicMeshMaterial extends V3dGraphicMaterial {
        options: V3dGraphicMeshMaterialOptions;
        occlusionStrength: number;
        alphaCutOff: number;
        alphaMode: number;
        glossiness: number;
        pointsCloud: boolean;
        wireframe: boolean;
        useParallax: boolean;
        parallaxScaleBias: number;
        indexOfRefraction: number;
        microSurface: number;
        useRoughnessFromMetallicTextureGreen: boolean;
        useMetallnessFromMetallicTextureBlue: boolean;
        useRoughnessFromMetallicTextureAlpha: boolean;
        useAlphaFromAlbedoTexture: boolean;
        useAmbientInGrayScale: boolean;
        sideOrientation: number;
        constructor(name?: string);
        getCode(): string;
        get optionLighting(): boolean;
        set optionLighting(value: boolean);
        get optionFaceFront(): boolean;
        set optionFaceFront(value: boolean);
        get optionFaceBack(): boolean;
        set optionFaceBack(value: boolean);
        get optionReceiveShadows(): boolean;
        set optionReceiveShadows(value: boolean);
        get alpha(): number;
        set alpha(value: number);
        get alphaBase(): number;
        set alphaBase(value: number);
        set metallic(value: number);
        get matallic(): number;
        set roughness(value: number);
        get roughness(): number;
        get ambientColor(): any;
        setAmbientColor(r: number, g: number, b: number): void;
        get baseColor(): any;
        setBaseColor(r: number, g: number, b: number): void;
        get albedoColor(): any;
        setAlbedoColor(r: number, g: number, b: number): void;
        get diffuseColor(): any;
        setDiffuseColor(r: number, g: number, b: number): void;
        get diffuseTexture(): V3dGraphicTexture;
        set diffuseTexture(texture: V3dGraphicTexture);
        get specularColor(): any;
        setSpecularColor(r: number, g: number, b: number): void;
        get specularPower(): number;
        set specularPower(value: number);
        get specularTexture(): V3dGraphicTexture;
        set specularTexture(texture: V3dGraphicTexture);
        get reflectionTexture(): V3dGraphicTexture;
        set reflectionTexture(texture: V3dGraphicTexture);
        get emissiveColor(): any;
        setEmissiveColor(r: number, g: number, b: number): void;
        get backFaceCulling(): boolean;
        set backFaceCulling(value: boolean);
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/V3dConstants" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { MeshPhongMaterial } from 'foundation/runtime/graphics/material/MeshPhongMaterial';
    export class V3dConstantsInstance {
        preloadMeshMaterial: MeshPhongMaterial;
        setup(): void;
    }
    export class V3dConstants {
        static DIRTY_FRAME: number;
        static DIRECTION_LIGHT_DEPTH_MIN: number;
        static DIRECTION_LIGHT_DEPTH_MAX: number;
        static CAMERA_DISTANCE: number;
        static CAMERA_SCREEN_RATE: number;
        static CAMERA_FOV: number;
        static CAMERA_DEPTH_MIN: number;
        static CAMERA_DEPTH_MAX: number;
        static CAMERA_ZOOM_MIN: number;
        static CAMERA_ZOOM_MAX: number;
        static CAMERA_ZOOM_RATE: number;
        static FIRSTPERSON_MOVE_SPEED: number;
        static FIRSTPERSON_LOOK_HORIZAONTAL_SPEED: number;
        static FIRSTPERSON_LOOK_VERTICAL_SPEED: number;
        static AERIALVIEW_MOVE_SPEED: number;
        static AERIALVIEW_LOOK_HORIZAONTAL_SPEED: number;
        static AERIALVIEW_LOOK_VERTICAL_SPEED: number;
        static ARCROTATE_ALPHA_SPEED: number;
        static ARCROTATE_RADIUS_SPEED: number;
        static ARCROTATE_VERTICAL_SPEED: number;
        static SELECTION_DOUBLE_CLICK_SPAN: number;
        static SELECTION_RAY_RANGE: number;
        static LAYER_STRUCTURE_FLOOR_VIEW_LEVEL: number;
        static LAYER_STRUCTURE_WALL_VIEW_LEVEL: number;
        static LAYER_STRUCTURE_CEILING_VIEW_LEVEL: number;
        static LAYER_CONTENT_VIEW_LEVEL: number;
        static LAYER_DIMENSION_VIEW_LEVEL: number;
        static LAYER_ASSISTANT_VIEW_LEVEL: number;
        static MESH_DEPTH_FIX: number;
        static PLANE_DEPTH_FIX: number;
        static BACKGROUND_COLOR: number;
        static GRID_LEVEL1_COLOR: number;
        static GRID_LEVEL2_COLOR: number;
        static GRID_LEVEL3_COLOR: number;
        static GRID_ZOFFSET: number;
        static GRID_POSITION_Z: number;
        static GROUND_ZOFFSET: number;
        static GROUND_POSITION_Z: number;
        static LINER_COLOR: number;
        static LINER_POINT_COLOR: number;
        static MATERIAL_ALPHA_BVOUND: number;
        static MATERIAL_ALPHA_MIN: number;
        static BOUNDARY_POLYON_FACTOR: number;
        static BOUNDARY_POLYON_UNITS: number;
        static INDICATOR_EXPAND: Vector3;
        static INDICATOR_ZOFFSET: 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_EDIT_COLOR: number;
        static CONTENT_EDIT_OPACITY: number;
        static CONTENT_ERROR_COLOR: number;
        static CONTENT_ERROR_OPACITY: number;
        static CONTENT_DIMENSION_COLOR: number;
        static CONTENT_DIMENSION_OPACITY: number;
        static CHEST_DIMENSION_TEXT_COLOR: string;
        static CHEST_DIMENSION_AREA_BORDER_COLOR: string;
        static CHEST_DIMENSION_AREA_GROUND_COLOR: string;
        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 SPACE_DIMENSION_TEXT_COLOR: string;
        static SPACE_DIMENSION_AREA_BORDER_COLOR: string;
        static SPACE_DIMENSION_AREA_GROUND_COLOR: string;
        static SPACE_DIMENSION_MIN_WIDTH: number;
        static SPACE_DIMENSION_MIN_HEIGHT: number;
        static SPACE_DIMENSION_PADDING: number;
        static SPACE_DIMENSION_LAYER: number;
        static DIMENSION_LINE_COLOR: number;
        static DIMENSION_ARROW_COLOR: number;
        static DIMENSION_TEXT_COLOR: string;
        static DIMENSION_TEXT_AREA_COLOR: string;
        static CHEST_DIMENSION_PADDING: number;
        static CHEST_DIMENSION_LAYER: number;
        static DIMESION_PADDING: number;
        static CONTENT_LIFT_INDICATOR_HEIGHT_OFFSET: number;
        static CONTENT_LIFT_INDICATOR_OFFSET_INCREMENT: number;
        static CONTENT_OPERATION_INDICATOR_COLOR: number;
        static CONTENT_OPERATION_INDICATOR_HIGHLIGHT_COLOR: number;
        static CONTENT_OPERATION_INDICATOR_DASHEDLINE_DASHSIZE: number;
        static CONTENT_OPERATION_INDICATOR_DASHEDLINE_GAPSIZE: number;
        static CONTENT_OPERATION_INDICATOR_DASHEDLINE_LINEWIDTH: number;
        static GROUP_COLOR: number;
        static GROUP_SELECT_COLOR: number;
        static GROUP_HOVER_COLOR: number;
        static GROUP_OPACITY: number;
        static MATERIAL_CONTENT_COLLISION: string;
        static MATERIAL_CONTENT_PRELOAD: string;
        private static _instance;
        protected static instance(): V3dConstantsInstance;
        static getPreloadMaterial(): MeshPhongMaterial;
    }
}
declare module "foundation/editor/view/view3d/asset/material/V3dAssetLinesMaterialInfo" {
    export type V3dAssetLinesMaterialInfo = {
        r?: number;
        g?: number;
        b?: number;
        a?: number;
        transparent?: boolean;
        useVertexColor?: boolean;
        depthTest?: boolean;
        depthWrite?: boolean;
        sortLevel?: number;
    };
}
declare module "foundation/editor/view/view3d/asset/material/V3dAssetMaterialLoadOptions" {
    import { V3dGraphicTextureWrapEnum } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTextureWrapEnum";
    export type V3dAssetMaterialLoadOptions = {
        typeCode?: string;
        effectCode?: string;
        qualityCd?: string;
        invertY?: boolean;
        alpha?: number;
        wrapAuCd?: V3dGraphicTextureWrapEnum;
        wrapAvCd?: V3dGraphicTextureWrapEnum;
        wrapAwCd?: V3dGraphicTextureWrapEnum;
        uScale?: number;
        vScale?: number;
        backFaceCulling?: boolean;
        optionDepthOffset?: boolean;
        depthBiasSlopeScale?: number;
        depthBiasSlopeOffset?: number;
    };
}
declare module "foundation/editor/view/view3d/asset/material/V3dAssetMeshMaterialInfo" {
    import { V3dGraphicTextureWrapEnum } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTextureWrapEnum";
    export type V3dAssetMeshMaterialInfo = {
        r?: number;
        red?: number;
        g?: number;
        green?: number;
        b?: number;
        blue?: number;
        a?: number;
        ambientColor?: {
            r: number;
            g: number;
            b: number;
        };
        emissiveColor?: {
            r: number;
            g: number;
            b: number;
        };
        diffuseColor?: {
            r: number;
            g: number;
            b: number;
        };
        specularColor?: {
            r: number;
            g: number;
            b: number;
        };
        alpha?: number;
        lighting?: boolean;
        colorRatio?: number;
        transparent?: boolean;
        useVertexColor?: boolean;
        backFaceCulling?: boolean;
        depthTest?: boolean;
        depthWrite?: boolean;
        sortLevel?: number;
        wrapAuCd?: V3dGraphicTextureWrapEnum;
        wrapAvCd?: V3dGraphicTextureWrapEnum;
        wrapAwCd?: V3dGraphicTextureWrapEnum;
        optionDepthOffset?: boolean;
        depthBiasSlopeScale?: number;
        depthBiasSlopeOffset?: number;
    };
}
declare module "foundation/editor/view/view3d/asset/material/V3dAssetTexturePool" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { V3dGraphicTexture, V3dGraphicTextureOptions } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTexture";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    export class V3dAssetTexturePool extends InstanceObject {
        context: V3dCanvasContext;
        protected _textures: Dictionary<V3dGraphicTexture>;
        setup(): void;
        protected makeTextureName(url: string, options?: V3dGraphicTextureOptions): string;
        loadTexture2d(url: string, options?: V3dGraphicTextureOptions, onLoad?: any, onError?: any): V3dGraphicTexture;
        loadTexture2dAsync(url: string, options?: V3dGraphicTextureOptions, onLoad?: any, onError?: any): Promise<ResultObject<V3dGraphicTexture>>;
        loadTextureHdr(url: string, options?: V3dGraphicTextureOptions, onLoad?: any, onError?: any): V3dGraphicTexture;
        loadTextureAsync(url: string, options?: V3dGraphicTextureOptions, onLoad?: any, onError?: any): Promise<ResultObject<V3dGraphicTexture>>;
    }
}
declare module "foundation/editor/view/view3d/asset/material/V3dAssetMaterialManager" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MultiAsyncProcessor } from 'cross/runtime/feature/multiprocessor/MultiAsyncProcessor';
    import { QualityEnum } from 'cross/runtime/framework/quality/QualityEnum';
    import { QualityService } from 'cross/runtime/framework/quality/QualityService';
    import { Size2 } from 'foundation/runtime/math/Size2';
    import { AssetVersionType } from 'foundation/data/common/resource/AssetUtil';
    import { EffectDocumentService } from 'sk/data/resource/effect/service/EffectDocumentService';
    import { ResourceLoaderService } from 'sk/data/resource/loader/io/ResourceLoaderService';
    import { MaterialOptionStructure } from 'sk/data/resource/material/element/MaterialOptionStructure';
    import { MaterialStructureElement } from 'sk/data/resource/material/element/MaterialStructureElement';
    import { MaterialDocumentService } from 'sk/data/resource/material/service/MaterialDocumentService';
    import { IGraphicMaterialInfo } from 'sk/data/resource/base/IGraphicMaterialInfo';
    import { IGraphicMaterialTextureInfo } from 'sk/data/resource/base/IGraphicMaterialTextureInfo';
    import { MaterialQualityEnum } from 'sk/data/resource/enumeration/MaterialQualityEnum';
    import { MaterialTypeEnum } from 'sk/data/resource/enumeration/MaterialTypeEnum';
    import { AssetManager } from "foundation/editor/view/base/asset/AssetManager";
    import { MaterialService } from "foundation/editor/view/graphic/MaterialService";
    import { V3dGraphicLineMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLineMaterial";
    import { V3dGraphicMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMaterial";
    import { V3dGraphicMeshMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial";
    import { V3dGraphicTexture, V3dGraphicTextureOptions } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTexture";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dAssetLinesMaterialInfo } from "foundation/editor/view/view3d/asset/material/V3dAssetLinesMaterialInfo";
    import { V3dAssetMaterialLoadOptions } from "foundation/editor/view/view3d/asset/material/V3dAssetMaterialLoadOptions";
    import { V3dAssetMeshMaterialInfo } from "foundation/editor/view/view3d/asset/material/V3dAssetMeshMaterialInfo";
    import { V3dAssetTexturePool } from "foundation/editor/view/view3d/asset/material/V3dAssetTexturePool";
    export type AssetMaterialInfo = {
        transparent: boolean;
        alphaBase: number;
        alpha: number;
    };
    export class V3dAssetMaterialManager extends AssetManager {
        context: V3dCanvasContext;
        protected _processor: MultiAsyncProcessor;
        protected _materials: Dictionary<V3dGraphicMeshMaterial>;
        protected _textures: Dictionary<V3dGraphicTexture>;
        protected _texturePool: V3dAssetTexturePool;
        protected _materialDocumentService: MaterialDocumentService;
        protected _effectDocumentService: EffectDocumentService;
        protected _qualityService: QualityService;
        protected _materialService: MaterialService;
        protected _loaderService: ResourceLoaderService;
        protected _qualityElement: MaterialStructureElement;
        constructor(context: V3dCanvasContext);
        setup(): void;
        makeMaterialCode(resourceId: string, resourceVersion?: AssetVersionType, options?: V3dAssetMaterialLoadOptions): string;
        makeMaterialInfo(info: IGraphicMaterialInfo): AssetMaterialInfo;
        protected loadMaterialSyncAsync(asyncInfo: any, code: string, resourceId: string, resourceVersion?: AssetVersionType, options?: V3dAssetMaterialLoadOptions): Promise<void>;
        loadMaterialAsync(resourceId: string, resourceVersion?: AssetVersionType, options?: V3dAssetMaterialLoadOptions): Promise<ResultObject>;
        createMaterial(name: string): any;
        loadCurrentMaterialAsync(resourceId: string): Promise<ResultObject>;
        getMaterial(code: string, setMaterial?: any): any;
        setMaterial(code: string, material: any): void;
        getDefineMaterial(code: string): V3dGraphicMaterial;
        getLinesMeterial(useVertexColor?: boolean): V3dGraphicLineMaterial;
        getImageSize(options: Types<MaterialOptionStructure>, qualityCd: any): Size2;
        getLinesDefineMeterial(name: string, typeName: string, info: V3dAssetLinesMaterialInfo): V3dGraphicLineMaterial;
        getMeshBasicCodeMeterial(name: string, r: number, g: number, b: number, a?: number, back?: boolean, writeDepth?: boolean): V3dGraphicMeshMaterial;
        getMeshDefineMeterial(name: string, typeName: string, info: V3dAssetMeshMaterialInfo): V3dGraphicMeshMaterial;
        createMaterialByInfo(info: IGraphicMaterialInfo, textureOnload: any, material?: V3dGraphicMeshMaterial, force?: boolean, options?: V3dAssetMaterialLoadOptions): V3dGraphicMeshMaterial;
        createMaterialByInfoAsync(info: IGraphicMaterialInfo, textureOnload: any, material?: V3dGraphicMeshMaterial, force?: boolean, options?: V3dAssetMaterialLoadOptions): Promise<ResultObject<V3dGraphicMeshMaterial>>;
        updateMaterialByInfo(material: V3dGraphicMeshMaterial, info: IGraphicMaterialInfo, textureOnload: any, force?: boolean, dirty?: boolean): V3dGraphicMeshMaterial;
        getMaterialInfoAsync(materialInfo: IGraphicMaterialInfo, effectResourceId: string, qualityCd: MaterialQualityEnum, force?: boolean): Promise<IGraphicMaterialInfo>;
        onMaterialReady: () => void;
        private loadStandardMaterial;
        private loadStandardMaterialAsync;
        private loadPbrMaterial;
        private generalPropertiesSet;
        protected setMaterialTexture(materialInfo: IGraphicMaterialInfo, textureInfo: IGraphicMaterialTextureInfo, material: V3dGraphicMeshMaterial, textureName: string, textureOnload: any, options?: V3dAssetMaterialLoadOptions): boolean;
        protected setMaterialTextureAsync(materialInfo: IGraphicMaterialInfo, textureInfo: IGraphicMaterialTextureInfo, material: V3dGraphicMeshMaterial, textureName: string, textureOnload: any, options?: V3dAssetMaterialLoadOptions): Promise<ResultObject>;
        createTexture(url: string, options?: V3dGraphicTextureOptions, onLoad?: () => void, onError?: () => void, useLoader?: boolean): V3dGraphicTexture;
        getTextureUrlByQualityCd(materialTypeCd: MaterialTypeEnum, value: string, qualityCd: QualityEnum): string;
        private resizeImageUrl;
    }
}
declare module "foundation/editor/view/base/LayerTypeEnum" {
    export class LayerTypeEnum {
        static Template: string;
        static Pick: string;
        static Environment: string;
        static Depth: string;
        static Structure: string;
        static ContentBase: string;
        static ContentSurface: string;
        static ContentDecorate: string;
        static ContentLayout: string;
        static Content: string;
        static Indicator: string;
        static Hover: string;
        static Dimension: string;
        static Assistant: string;
        static Reverse: string;
        static TemplateLayer: number;
        static PickLayer: number;
        static EnvironmentLayer: number;
        static DepthLayer: number;
        static StructureLayer: number;
        static ContentBaseLayer: number;
        static ContentSurfaceLayer: number;
        static ContentDecorateLayer: number;
        static ContentLayoutLayer: number;
        static ContentLayer: number;
        static IndicatorLayer: number;
        static HoverLayer: number;
        static AssistantLayer: number;
        static DimensionLayer: number;
        static DimensionLineLayer: number;
        static DimensionTextLayer: number;
        static ReverseLayer: number;
    }
}
declare module "foundation/editor/view/view3d/render/V3dRenderingGroupIdEnum" {
    export enum V3dRenderingGroupIdEnum {
        Zero = 0,
        Dimension = 1,
        FIRST = 2,
        Indicator = 3,
        Boundary = 4,
        Normal
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicLinesInstance" {
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    export class V3dGraphicLinesInstance extends V3dGraphicContent {
        freezeWorldMatrix(withChildren?: boolean, force?: boolean): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicLines" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Polygon } from 'foundation/runtime/graphics/shape/brep/Polygon';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { Lines } from 'foundation/runtime/graphics/data/Lines';
    import { PlaneEnum } from 'foundation/runtime/graphics/shape/PlaneEnum';
    import { V3dRenderingGroupIdEnum } from "foundation/editor/view/view3d/render/V3dRenderingGroupIdEnum";
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    import { V3dGraphicLineMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLineMaterial";
    import { V3dGraphicLinesInstance } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLinesInstance";
    export type V3dGraphicLinesOption = {
        parent?: any;
        vertexColor?: boolean;
        vertexAlpha?: boolean;
    };
    export class V3dGraphicLines extends V3dGraphicContent {
        options: V3dGraphicLinesOption;
        constructor();
        get optionDynamic(): boolean;
        set optionDynamic(value: boolean);
        get optionReserve(): boolean;
        set optionReserve(value: boolean);
        get optionBack(): boolean;
        set optionBack(value: boolean);
        get level(): number;
        set level(value: number);
        get alpha(): number;
        set alpha(value: number);
        get color(): any;
        setColor(red: number, green: number, blue: number): void;
        setColorInteger(value: number): void;
        bakeTransformIntoVertices(transform: Matrix4): V3dGraphicLines;
        setPivotMatrix(matrix: Matrix4): void;
        get material(): V3dGraphicLineMaterial;
        set material(material: V3dGraphicLineMaterial);
        get mergeNumber(): number;
        set mergeNumber(value: number);
        get mergeParent(): V3dGraphicContent;
        set mergeParent(parent: V3dGraphicContent);
        get intersectionThreshold(): number;
        set intersectionThreshold(value: number);
        get renderingGroupId(): V3dRenderingGroupIdEnum;
        set renderingGroupId(value: V3dRenderingGroupIdEnum);
        updateBufferData(data: BufferGeometry): void;
        updateLines(lines: Lines, segmentsMode?: boolean): void;
        updateDashLine(start: Value3, end: Value3, pattern: Array<number>): void;
        updateLinesDash(lines: Lines, pattern: Array<number>, segmentsMode?: boolean): void;
        updatePolygon(polygon: Polygon, planeCd: PlaneEnum, matrix: Matrix4, color?: number): void;
        updatePolygonDash(polygon: Polygon, planeCd: PlaneEnum, matrix: Matrix4, pattern: Array<number>): void;
        setLineMesh(lineMesh: BufferGeometry): void;
        updateAllColor(lineColor: number): void;
        createInstance(name?: string): V3dGraphicLinesInstance;
        freezeWorldMatrix(force?: boolean): void;
        freeze(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshInstance" {
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    export type V3dGraphicMeshInstanceOption = {
        parent?: any;
    };
    export class V3dGraphicMeshInstance extends V3dGraphicContent {
        options: V3dGraphicMeshInstanceOption;
        constructor();
        freezeWorldMatrix(withChildren?: boolean, force?: boolean): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    import { V3dGraphicMeshInstance, V3dGraphicMeshInstanceOption } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshInstance";
    import { V3dGraphicMeshMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial";
    export type V3dGraphicMeshOption = {
        parent?: any;
        optionReference?: boolean;
        optionDynamic?: boolean;
        optionStatic?: boolean;
        optionAddition?: boolean;
        updatable?: boolean;
        type?: string;
        parameters?: any;
        linker?: any;
    };
    export class V3dGraphicMesh extends V3dGraphicContent {
        optionCache: boolean;
        options: V3dGraphicMeshOption;
        pickGroup: number;
        receiveShadows: boolean;
        infiniteDistance: boolean;
        geometryResource: any;
        nativeGeometryResource: any;
        meshNode: any;
        renderingGroupId: number;
        meshs: any;
        constructor();
        get optionBack(): boolean;
        set optionBack(value: boolean);
        get optionParentMatrix(): boolean;
        set optionParentMatrix(value: boolean);
        get material(): V3dGraphicMeshMaterial;
        set material(material: V3dGraphicMeshMaterial);
        bakeTransformIntoVertices(transform: Matrix4): V3dGraphicMesh;
        get mergeNumber(): number;
        set mergeNumber(value: number);
        get mergeParent(): V3dGraphicContent;
        set mergeParent(parent: V3dGraphicContent);
        get layerMask(): number;
        set layerMask(mask: number);
        get optionDynamic(): boolean;
        set optionDynamic(value: boolean);
        get optionReserve(): boolean;
        set optionReserve(value: boolean);
        get level(): number;
        set level(value: number);
        get optionGenerateShadow(): boolean;
        set optionGenerateShadow(value: boolean);
        get optionReceiveShadows(): boolean;
        set optionReceiveShadows(value: boolean);
        getWorldMatrix(): any;
        setPivotMatrix(matrix: Matrix4): void;
        updateBufferData(data: any): void;
        get instanceCount(): number;
        createInstance(name?: string, options?: V3dGraphicMeshInstanceOption): V3dGraphicMeshInstance;
        freezeWorldMatrix(force?: boolean): void;
        computeWorldMatrix(force?: boolean): void;
        freeze(): void;
        dispose(): void;
    }
    export type V3dGraphicMeshMap = {
        [key: string]: V3dGraphicMesh;
    };
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicScene" {
    import { V3dGraphicCamera } from "foundation/editor/view/view3d/render/graphic/V3dGraphicCamera";
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    export type V3dGraphicSceneOptions = {
        parent?: any;
        linker?: boolean;
    };
    export class V3dGraphicScene extends V3dGraphicContent {
        camera: V3dGraphicCamera;
        options: V3dGraphicSceneOptions;
        constructor();
        setMainCamera(camera: V3dGraphicCamera): void;
        setSecondCamera(camera: V3dGraphicCamera): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicLayerGroup" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    import { V3dGraphicLayer } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLayer";
    import { V3dGraphicScene } from "foundation/editor/view/view3d/render/graphic/V3dGraphicScene";
    export type V3dGraphicLayerGroupOptions = {
        parent?: V3dGraphicScene;
    };
    export class V3dGraphicLayerGroup extends V3dGraphicContent {
        options: V3dGraphicLayerGroupOptions;
        sceneName: string;
        protected _level: number;
        protected _layers: Types<V3dGraphicLayer>;
        constructor();
        get level(): number;
        set level(value: number);
        get optionDepthClear(): boolean;
        set optionDepthClear(value: boolean);
        hasLayer(layer: V3dGraphicLayer): boolean;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicLayer" {
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    import { V3dGraphicLayerGroup } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLayerGroup";
    export type V3dGraphicLayerOptions = {
        parent?: any;
        linker?: boolean;
    };
    export class V3dGraphicLayer extends V3dGraphicContent {
        protected _level: number;
        options: V3dGraphicLayerOptions;
        constructor();
        get levelGroup(): V3dGraphicLayerGroup;
        set levelGroup(layerGroup: V3dGraphicLayerGroup);
        get level(): number;
        set level(value: number);
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/V3dLayerGroup" {
    import { LayerGroup } from "foundation/editor/view/base/LayerGroup";
    import { V3dGraphicLayerGroup } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLayerGroup";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    export class V3dLayerGroup extends LayerGroup {
        context: V3dCanvasContext;
        graphic: V3dGraphicLayerGroup;
        get optionDepthClear(): boolean;
        set optionDepthClear(value: boolean);
    }
}
declare module "foundation/editor/view/view3d/V3dLayer" {
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { Display } from "foundation/editor/view/base/Display";
    import { Layer } from "foundation/editor/view/base/Layer";
    import { V3dGraphicLayer } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLayer";
    import { V3dGraphicNode } from "foundation/editor/view/view3d/render/graphic/V3dGraphicNode";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayerGroup } from "foundation/editor/view/view3d/V3dLayerGroup";
    export type V3dLayerOptions = {
        parent?: any;
    };
    export class V3dLayer extends Layer {
        context: V3dCanvasContext;
        graphic: V3dGraphicLayer;
        protected _position: Vector3;
        protected _rotation: Vector3;
        protected _scale: Vector3;
        set levelGroup(layerGroup: V3dLayerGroup);
        set level(value: number);
        get position(): Readonly<Value3>;
        setPosition(x: number, y: number, z: number): void;
        get rotation(): Readonly<Value3>;
        setRotation(x: number, y: number, z: number): void;
        get scale(): Readonly<Value3>;
        setScale(x: number, y: number, z: number): void;
        appendNode(node: V3dGraphicNode): void;
        removeNode(node: V3dGraphicNode): void;
        protected onAppendChild(child: Display, node?: any): void;
        protected onRemoveChild(child: Display, node?: any): void;
        computeWorldMatrix(force?: boolean): void;
        freezeWorldMatrix(force?: boolean): void;
        freeze(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicContainer" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    export type V3dGraphicContainerOptions = {
        parent?: any;
        linker?: boolean;
    };
    export class V3dGraphicContainer extends V3dGraphicContent {
        handle: any;
        options: V3dGraphicContainerOptions;
        constructor();
        setPivotMatrix(matrix: Matrix4): void;
        getWorldMatrix(): Matrix4;
        freezeWorldMatrix(force?: boolean): void;
        computeWorldMatrix(force?: boolean): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicDynamicLines" {
    import { V3dGraphicLines } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLines";
    export class V3dGraphicDynamicLines extends V3dGraphicLines {
        constructor();
        updateMerge(): void;
        reset(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicDynamicMesh" {
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    export class V3dGraphicDynamicMesh extends V3dGraphicMesh {
        updateMerge(): void;
        reset(): void;
    }
}
declare module "foundation/editor/view/view3d/render/V3dDynamicLinesMesh" {
    import { Lines } from 'foundation/runtime/graphics/data/Lines';
    import { V3dGraphicMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMaterial";
    import { V3dDynamicMesh } from "foundation/editor/view/view3d/render/V3dDynamicMesh";
    export class V3dDynamicLinesMesh extends V3dDynamicMesh {
        lines: Lines;
        alpha: number;
        isDash: boolean;
        material: V3dGraphicMaterial;
        constructor(name?: string);
        isValid(): boolean;
        dispose(): void;
    }
    export type V3dDynamicLinesMeshMap = {
        [key: string]: V3dDynamicLinesMesh;
    };
}
declare module "foundation/editor/view/view3d/render/V3dDynamicMeshMerger" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    import { V3dGraphicContainer } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContainer";
    import { V3dGraphicDynamicLines } from "foundation/editor/view/view3d/render/graphic/V3dGraphicDynamicLines";
    import { V3dGraphicDynamicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicDynamicMesh";
    import { V3dGraphicObject } from "foundation/editor/view/view3d/render/graphic/V3dGraphicObject";
    import { V3dDynamicLinesMesh } from "foundation/editor/view/view3d/render/V3dDynamicLinesMesh";
    import { V3dDynamicMesh } from "foundation/editor/view/view3d/render/V3dDynamicMesh";
    export class V3dDynamicMeshMerger extends Dispatcher {
        context: V3dCanvasContext;
        name: string;
        viewLevel: number;
        layer: V3dLayer;
        meshs: Types<V3dDynamicMesh>;
        linesMeshs: Types<V3dDynamicLinesMesh>;
        node: V3dGraphicObject;
        nodeParent: V3dGraphicContainer;
        optionPickable: boolean;
        isLighting: boolean;
        needShadow: boolean;
        needMirror: boolean;
        receiveShadows: boolean;
        protected _displays: Dictionary<V3dGraphicDynamicMesh>;
        protected _linesDisplays: Dictionary<V3dGraphicDynamicLines>;
        protected _diry: boolean;
        protected _tranformDiry: boolean;
        constructor(name?: string);
        setup(): void;
        get displays(): Dictionary<V3dGraphicDynamicMesh>;
        add(mesh: V3dDynamicMesh | V3dDynamicLinesMesh): void;
        remove(mesh: V3dDynamicMesh | V3dDynamicLinesMesh): void;
        dirty(): void;
        dirtyTransform(): void;
        private getMaterialCode;
        getMeshDisplay(mesh: V3dDynamicMesh): V3dGraphicDynamicMesh;
        getLinesDisplay(mesh: V3dDynamicLinesMesh): V3dGraphicDynamicLines;
        removeDisplay(display: V3dGraphicDynamicMesh | V3dGraphicDynamicLines): void;
        updateMeshes(isLinesMesh: boolean): void;
        update(): void;
        updateDisplayTranform(isLinesMesh: boolean): void;
        updateTranform(): void;
        process(): void;
        clear(): void;
        dispose(): void;
    }
    export type V3dDynamicMeshMergerMap = {
        [key: string]: V3dDynamicMeshMerger;
    };
}
declare module "foundation/editor/view/view3d/render/V3dDynamicMesh" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { V3dDynamicMeshMerger } from "foundation/editor/view/view3d/render/V3dDynamicMeshMerger";
    export class V3dDynamicMesh extends InstanceObject {
        name: string;
        matrix: Matrix4;
        protected _matrixParentNode: any;
        protected _matrixNode: any;
        merger: V3dDynamicMeshMerger;
        geometry: BufferGeometry;
        material: any;
        renderingGroupId: number;
        protected _optionVisible: boolean;
        constructor(name?: string);
        get matrixParentNode(): any;
        set matrixParentNode(value: any);
        get matrixNode(): any;
        set matrixNode(value: any);
        get optionVisible(): boolean;
        set optionVisible(visible: boolean);
        dirty(): void;
        isValid(): boolean;
        dispose(): void;
    }
    export type V3dDynamicMeshMap = {
        [key: string]: V3dDynamicMesh;
    };
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicModel" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ModelNode } from 'sk/data/resource/model/model/ModelNode';
    import { ModelResource } from 'sk/data/resource/model/resource/ModelResource';
    import { V3dDynamicMesh } from "foundation/editor/view/view3d/render/V3dDynamicMesh";
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dGraphicNode } from "foundation/editor/view/view3d/render/graphic/V3dGraphicNode";
    export class V3dGraphicModel extends V3dGraphicNode {
        version: string;
        resource: ModelResource;
        modelNode: ModelNode;
        meshs: Types<V3dGraphicMesh>;
        pushMesh(mesh: V3dGraphicMesh): void;
        setContentTransform(content: ContentNode): void;
        freezeWorldMatrix(): void;
        setVisible(visible: boolean): void;
        show(): void;
        hide(): void;
        setSelectable(value: boolean): void;
        upadteDynamicMesh(dynamicMesh: V3dDynamicMesh, parentNode: any): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicTextureHdr" {
    import { V3dGraphicTexture, V3dGraphicTextureOptions } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTexture";
    export class V3dGraphicTextureHdr extends V3dGraphicTexture {
        options: V3dGraphicTextureOptions;
        constructor();
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/asset/V3dAssetDefineCodeEnum" {
    export class V3dAssetDefineCodeEnum {
        static Collision: string;
        static Preload: string;
    }
}
declare module "foundation/editor/view/view3d/asset/V3dAssetDefineTypeEnum" {
    export class V3dAssetDefineTypeEnum {
        static UnitBoxLines: string;
        static UnitBoxMesh: string;
    }
}
declare module "foundation/editor/view/view3d/asset/model/V3dAssetGridModelParameters" {
    import { VisionGridModelNode } from 'foundation/data/common/model/brep/vision/VisionGridModelNode';
    export class V3dAssetGridModelParameters {
        modelResourceId: string;
        modelResourceVersion: string;
        positiveXLength: number;
        negativeXLength: number;
        positiveYLength: number;
        negativeYLength: number;
        positiveZLength: number;
        negativeZLength: number;
        totalLengthX: number;
        totalLengthY: number;
        totalLengthZ: number;
        tileRotation: number;
        _content: VisionGridModelNode;
        isValid(): boolean;
        toHashString(): string;
        toJsonObject(): any;
        toSimpleString(): string;
    }
}
declare module "foundation/editor/view/base/asset/AssetPool" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    export class AssetPool extends InstanceObject {
        context: CanvasContext;
        setup(): void;
    }
}
declare module "foundation/editor/view/view3d/V3dScene" {
    import { Scene } from "foundation/editor/view/base/Scene";
    import { V3dGraphicCamera } from "foundation/editor/view/view3d/render/graphic/V3dGraphicCamera";
    import { V3dGraphicScene } from "foundation/editor/view/view3d/render/graphic/V3dGraphicScene";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    export class V3dScene extends Scene {
        context: V3dCanvasContext;
        graphic: V3dGraphicScene;
        setMainCamera(camera: V3dGraphicCamera): void;
        setSecondCamera(camera: V3dGraphicCamera): void;
        appendNode(node: any): void;
        removeNode(node: any): void;
        addLayer(layer: V3dLayer): void;
        removeLayer(layer: V3dLayer): void;
    }
}
declare module "foundation/editor/view/view3d/asset/model/V3dAssetLineModelParameters" {
    import { VisionLineModelNode } from 'foundation/data/common/model/brep/vision/VisionLineModelNode';
    export class V3dAssetLineModelParameters {
        beginModelResourceId: string;
        beginModelResourceVersion: string;
        middleModelResourceId: string;
        middleModelResourceVersion: string;
        endModelResourceId: string;
        endModelResourceVersion: string;
        beginLength: number;
        middleLength: number;
        endLength: number;
        totalLengthX: number;
        totalLengthY: number;
        totalLengthZ: number;
        _content: VisionLineModelNode;
        isValid(): boolean;
        toHashString(): string;
        toJsonObject(): any;
        toSimpleString(): string;
    }
}
declare module "foundation/editor/view/view3d/asset/model/V3dAssetModelResource" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ModelDocument } from 'sk/data/resource/model/model/ModelDocument';
    import { ModelMeshNode } from 'sk/data/resource/model/model/ModelMeshNode';
    import { ModelNode } from 'sk/data/resource/model/model/ModelNode';
    import { ModelResource } from 'sk/data/resource/model/resource/ModelResource';
    export class V3dAssetModelResource {
        optionValid: boolean;
        geometries: any;
        meshNodes: Types<ModelMeshNode>;
        resource: ModelResource;
        document: ModelDocument;
        modelNode: ModelNode;
    }
}
declare module "foundation/editor/view/view3d/asset/V3dAssetManager" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { MultiAsyncProcessor } from 'cross/runtime/feature/multiprocessor/MultiAsyncProcessor';
    import { AssetVersionType } from 'foundation/data/common/resource/AssetUtil';
    import { EffectDocumentService } from 'sk/data/resource/effect/service/EffectDocumentService';
    import { IGraphicMaterialInfo } from 'sk/data/resource/base/IGraphicMaterialInfo';
    import { MaterialQualityEnum } from 'sk/data/resource/enumeration/MaterialQualityEnum';
    import { AssetManager } from "foundation/editor/view/base/asset/AssetManager";
    import { V3dGraphicLineMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLineMaterial";
    import { V3dGraphicLinesInstance } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLinesInstance";
    import { V3dGraphicMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMaterial";
    import { V3dGraphicMeshInstance } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshInstance";
    import { V3dGraphicMeshMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial";
    import { V3dGraphicModel } from "foundation/editor/view/view3d/render/graphic/V3dGraphicModel";
    import { V3dGraphicTexture, V3dGraphicTextureOptions } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTexture";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dScene } from "foundation/editor/view/view3d/V3dScene";
    import { V3dAssetEffectManager } from "foundation/editor/view/view3d/asset/material/V3dAssetEffectManager";
    import { V3dAssetLinesMaterialInfo } from "foundation/editor/view/view3d/asset/material/V3dAssetLinesMaterialInfo";
    import { V3dAssetMaterialLoadOptions } from "foundation/editor/view/view3d/asset/material/V3dAssetMaterialLoadOptions";
    import { V3dAssetMaterialManager } from "foundation/editor/view/view3d/asset/material/V3dAssetMaterialManager";
    import { V3dAssetMeshMaterialInfo } from "foundation/editor/view/view3d/asset/material/V3dAssetMeshMaterialInfo";
    import { V3AssetdModelManager } from "foundation/editor/view/view3d/asset/model/V3AssetdModelManager";
    import { V3dAssetGridModelParameters } from "foundation/editor/view/view3d/asset/model/V3dAssetGridModelParameters";
    import { V3dAssetLineModelParameters } from "foundation/editor/view/view3d/asset/model/V3dAssetLineModelParameters";
    import { V3dAssetModelResource } from "foundation/editor/view/view3d/asset/model/V3dAssetModelResource";
    import { V3dAssetDefineCodeEnum } from "foundation/editor/view/view3d/asset/V3dAssetDefineCodeEnum";
    import { V3dAssetDefineTypeEnum } from "foundation/editor/view/view3d/asset/V3dAssetDefineTypeEnum";
    export class V3dAssetManager extends AssetManager {
        context: V3dCanvasContext;
        materialManager: V3dAssetMaterialManager;
        effectManager: V3dAssetEffectManager;
        modelManager: V3AssetdModelManager;
        contentScene: V3dScene;
        protected _processor: MultiAsyncProcessor;
        protected _effectDocumentService: EffectDocumentService;
        constructor(context: V3dCanvasContext);
        setup(): void;
        setupAfter(): void;
        createMaterial(name: string): any;
        getLinesMeterial(useVertexColor?: boolean): V3dGraphicLineMaterial;
        createMaterialByInfo(info: IGraphicMaterialInfo, textureOnload: any, material?: V3dGraphicMeshMaterial, force?: boolean, options?: V3dAssetMaterialLoadOptions): V3dGraphicMeshMaterial;
        getLinesBasicMeterial(name: string, r: number, g: number, b: number, a?: number, options?: V3dAssetLinesMaterialInfo): V3dGraphicLineMaterial;
        onMaterialReady: () => void;
        getMeshDepthMeterial(name: string, options?: V3dAssetMeshMaterialInfo): V3dGraphicMeshMaterial;
        getMeshBasicCodeMeterial(name: string, r: number, g: number, b: number, a?: number, back?: boolean, writeDepth?: boolean): V3dGraphicMeshMaterial;
        getMeshBasicMeterial(name: string, r: number, g: number, b: number, a?: number, options?: V3dAssetMeshMaterialInfo): V3dGraphicMeshMaterial;
        getMesBasicMeterial(name: string, options?: V3dAssetMeshMaterialInfo): V3dGraphicMeshMaterial;
        getMeshDefineMeterial(name: string, typeName: string, options?: V3dAssetMeshMaterialInfo): V3dGraphicMeshMaterial;
        getDefineMaterial(code: string): V3dGraphicMaterial;
        getMaterial(code: string, setMaterial?: any): any;
        setMaterial(code: string, material: any): void;
        loadMaterialAsync(resourceId: string, resourceVersion?: AssetVersionType, options?: V3dAssetMaterialLoadOptions): Promise<ResultObject>;
        allocModelAsync(resourceId: string, materialResourceId?: string): Promise<ResultObject<V3dGraphicModel>>;
        allocLineModelAsync(modelResourceParameters: V3dAssetLineModelParameters, materialResourceId?: string): Promise<ResultObject<V3dGraphicMeshInstance>>;
        allocGridModelAsync(modelResourceParameters: V3dAssetGridModelParameters, materialResourceId?: string): Promise<ResultObject<V3dGraphicMeshInstance>>;
        allocModelResourceAsync(resourceId: string, resourceVersion?: AssetVersionType): Promise<ResultObject<V3dAssetModelResource>>;
        createTexture(url: string, options?: V3dGraphicTextureOptions, onLoad?: () => void, onError?: () => void, useLoader?: boolean): V3dGraphicTexture;
        allocCurrentModelAsync(resourceId: string, materialResourceId?: string): Promise<ResultObject<V3dGraphicModel>>;
        loadCurrentMaterialAsync(resourceId: string): Promise<ResultObject>;
        createDefineMeshInstance(typeCd: V3dAssetDefineTypeEnum, code: V3dAssetDefineCodeEnum, name: string, parameters?: any): V3dGraphicLinesInstance | V3dGraphicMeshInstance;
        updateMaterialByInfo(material: V3dGraphicMeshMaterial, info: IGraphicMaterialInfo, textureOnload: any, force?: boolean, dirty?: boolean): V3dGraphicMeshMaterial;
        getMaterialInfoAsync(materialInfo: IGraphicMaterialInfo, effectResourceId: string, qualityCd: MaterialQualityEnum, force?: boolean): Promise<any>;
    }
}
declare module "foundation/editor/view/view3d/asset/model/V3dAssetGridModelPool" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AsyncInfo } from 'cross/runtime/feature/multiprocessor/AsyncInfo';
    import { MultiAsyncProcessor } from 'cross/runtime/feature/multiprocessor/MultiAsyncProcessor';
    import { QualityService } from 'cross/runtime/framework/quality/QualityService';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { MoldingService } from 'foundation/core/module/molding/MoldingService';
    import { AssetPool } from "foundation/editor/view/base/asset/AssetPool";
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dAssetManager } from "foundation/editor/view/view3d/asset/V3dAssetManager";
    import { V3dAssetGridModelParameters } from "foundation/editor/view/view3d/asset/model/V3dAssetGridModelParameters";
    export class V3dGridModelBufferGeometryCache {
        geometry: BufferGeometry;
    }
    export class V3dGridModelMeshCache {
        cache: V3dGridModelBufferGeometryCache;
        mesh: V3dGraphicMesh;
        constructor();
    }
    export class V3dAssetGridModelPool extends AssetPool {
        assetManager: V3dAssetManager;
        protected _processor: MultiAsyncProcessor;
        protected _modelCaches: Dictionary<V3dGridModelBufferGeometryCache>;
        protected _modelInstanceCaches: Dictionary<V3dGridModelMeshCache>;
        protected _qualityService: QualityService;
        protected _moldingService: MoldingService;
        loadModelResourceSyncAsync(asyncInfo: AsyncInfo, code: string, modelParameters: V3dAssetGridModelParameters): Promise<void>;
        loadModelResourceAsync(modelParameters: V3dAssetGridModelParameters): Promise<ResultObject<V3dGridModelBufferGeometryCache>>;
        loadModelSyncAsync(asyncInfo: AsyncInfo, code: string, context: V3dCanvasContext, modelParameters: V3dAssetGridModelParameters, materialResourceId?: string): Promise<void>;
        loadModelAsync(context: V3dCanvasContext, modelParameters: V3dAssetGridModelParameters, materialResourceId?: string): Promise<ResultObject<V3dGridModelMeshCache>>;
    }
}
declare module "foundation/editor/view/view3d/asset/model/V3dAssetLineModelPool" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AsyncInfo } from 'cross/runtime/feature/multiprocessor/AsyncInfo';
    import { MultiAsyncProcessor } from 'cross/runtime/feature/multiprocessor/MultiAsyncProcessor';
    import { QualityService } from 'cross/runtime/framework/quality/QualityService';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { MoldingService } from 'foundation/core/module/molding/MoldingService';
    import { AssetPool } from "foundation/editor/view/base/asset/AssetPool";
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dAssetManager } from "foundation/editor/view/view3d/asset/V3dAssetManager";
    import { V3dAssetLineModelParameters } from "foundation/editor/view/view3d/asset/model/V3dAssetLineModelParameters";
    class V3dLineModelBufferGeometryCache {
        geometry: BufferGeometry;
    }
    class V3dLineModelMeshCache {
        cache: V3dLineModelBufferGeometryCache;
        mesh: V3dGraphicMesh;
        constructor();
    }
    export class V3dAssetLineModelPool extends AssetPool {
        protected _modelCaches: Dictionary<V3dLineModelBufferGeometryCache>;
        protected _modelInstanceCaches: Dictionary<V3dLineModelMeshCache>;
        assetManager: V3dAssetManager;
        protected _processor: MultiAsyncProcessor;
        protected _qualityService: QualityService;
        protected _moldingService: MoldingService;
        loadModelResourceSyncAsync(asyncInfo: AsyncInfo, code: string, modelParameters: V3dAssetLineModelParameters): Promise<void>;
        loadModelResourceAsync(modelParameters: V3dAssetLineModelParameters): Promise<ResultObject<V3dLineModelBufferGeometryCache>>;
        loadModelSyncAsync(asyncInfo: AsyncInfo, code: string, context: V3dCanvasContext, modelParameters: V3dAssetLineModelParameters, materialResourceId?: string): Promise<void>;
        loadModelAsync(context: V3dCanvasContext, modelParameters: V3dAssetLineModelParameters, materialResourceId?: string): Promise<ResultObject<V3dLineModelMeshCache>>;
    }
}
declare module "foundation/editor/view/view3d/asset/model/V3dAssetModelPool" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AsyncInfo } from 'cross/runtime/feature/multiprocessor/AsyncInfo';
    import { MultiAsyncProcessor } from 'cross/runtime/feature/multiprocessor/MultiAsyncProcessor';
    import { QualityService } from 'cross/runtime/framework/quality/QualityService';
    import { AssetVersionType } from 'foundation/data/common/resource/AssetUtil';
    import { ResourceLoaderService } from 'sk/data/resource/loader/io/ResourceLoaderService';
    import { ModelDocument } from 'sk/data/resource/model/model/ModelDocument';
    import { ModelMeshNode } from 'sk/data/resource/model/model/ModelMeshNode';
    import { ModelNode } from 'sk/data/resource/model/model/ModelNode';
    import { ModelResource } from 'sk/data/resource/model/resource/ModelResource';
    import { ModelDocumentService } from 'sk/data/resource/model/service/ModelDocumentService';
    import { AssetPool } from "foundation/editor/view/base/asset/AssetPool";
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dGraphicTextureHdr } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTextureHdr";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dAssetManager } from "foundation/editor/view/view3d/asset/V3dAssetManager";
    import { V3dAssetModelResource } from "foundation/editor/view/view3d/asset/model/V3dAssetModelResource";
    class V3dAssetModelInstanceCache {
        cache: V3dAssetModelResource;
        optionValid: boolean;
        geometries: any;
        meshNodes: Types<ModelMeshNode>;
        optionCreate: boolean;
        meshs: Types<V3dGraphicMesh>;
        resource: ModelResource;
        document: ModelDocument;
        modelNode: ModelNode;
    }
    export class V3dAssetModelPool extends AssetPool {
        static SIMPLIFY_OPTIONS: any;
        context: V3dCanvasContext;
        assetManager: V3dAssetManager;
        environmentTexture: V3dGraphicTextureHdr;
        protected _processor: MultiAsyncProcessor;
        protected _modelCaches: Dictionary<V3dAssetModelResource>;
        protected _modelInstanceCaches: Dictionary<V3dAssetModelInstanceCache>;
        protected _qualityService: QualityService;
        protected _modelDocumentService: ModelDocumentService;
        protected _loaderService: ResourceLoaderService;
        setup(): void;
        protected loadModelResourceSyncAsync(asyncInfo: AsyncInfo, code: string, resourceId: string, resourceVersion?: AssetVersionType): Promise<void>;
        loadModelResourceAsync(resourceId: string, resourceVersion?: AssetVersionType): Promise<ResultObject<V3dAssetModelResource>>;
        protected loadModelSyncAsync(asyncInfo: AsyncInfo, code: string, context: V3dCanvasContext, resourceId: string, materialResourceId?: string): Promise<void>;
        loadModelAsync(context: V3dCanvasContext, resourceId: string, materialResourceId?: string): Promise<ResultObject<V3dAssetModelInstanceCache>>;
    }
}
declare module "foundation/editor/view/view3d/asset/model/V3AssetdModelManager" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { AssetVersionType } from 'foundation/data/common/resource/AssetUtil';
    import { AssetManager } from "foundation/editor/view/base/asset/AssetManager";
    import { V3dGraphicLines } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLines";
    import { V3dGraphicLinesInstance } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLinesInstance";
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dGraphicMeshInstance } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshInstance";
    import { V3dGraphicModel } from "foundation/editor/view/view3d/render/graphic/V3dGraphicModel";
    import { V3dGraphicTextureHdr } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTextureHdr";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dAssetDefineCodeEnum } from "foundation/editor/view/view3d/asset/V3dAssetDefineCodeEnum";
    import { V3dAssetDefineTypeEnum } from "foundation/editor/view/view3d/asset/V3dAssetDefineTypeEnum";
    import { V3dAssetGridModelParameters } from "foundation/editor/view/view3d/asset/model/V3dAssetGridModelParameters";
    import { V3dAssetGridModelPool } from "foundation/editor/view/view3d/asset/model/V3dAssetGridModelPool";
    import { V3dAssetLineModelParameters } from "foundation/editor/view/view3d/asset/model/V3dAssetLineModelParameters";
    import { V3dAssetLineModelPool } from "foundation/editor/view/view3d/asset/model/V3dAssetLineModelPool";
    import { V3dAssetModelPool } from "foundation/editor/view/view3d/asset/model/V3dAssetModelPool";
    import { V3dAssetModelResource } from "foundation/editor/view/view3d/asset/model/V3dAssetModelResource";
    export class V3AssetdModelManager extends AssetManager {
        context: V3dCanvasContext;
        unitBox: V3dGraphicMesh;
        protected _defineMeshs: Dictionary<V3dGraphicLines | V3dGraphicMesh>;
        protected _modelInstancePool: V3dAssetModelPool;
        protected _lineModelInstancePool: V3dAssetLineModelPool;
        protected _gridModelInstancePool: V3dAssetGridModelPool;
        constructor(context: V3dCanvasContext);
        setup(): void;
        setupAfter(): void;
        allocModelAsync(resourceId: string, materialResourceId?: string): Promise<ResultObject<V3dGraphicModel>>;
        getDefineMesh(typeCd: V3dAssetDefineTypeEnum, code: V3dAssetDefineCodeEnum, parameters?: any): V3dGraphicLines | V3dGraphicMesh;
        allocModelResourceAsync(resourceId: string, resourceVersion?: AssetVersionType): Promise<ResultObject<V3dAssetModelResource>>;
        allocLineModelAsync(modelParameters: V3dAssetLineModelParameters, materialResourceId?: string): Promise<ResultObject<V3dGraphicMeshInstance>>;
        allocGridModelAsync(modelParameters: V3dAssetGridModelParameters, materialResourceId?: string): Promise<ResultObject<V3dGraphicMeshInstance>>;
        createDefineMeshInstance(typeCd: V3dAssetDefineTypeEnum, code: V3dAssetDefineCodeEnum, name: string, parameters?: any): V3dGraphicLinesInstance | V3dGraphicMeshInstance;
        get environmentTexture(): V3dGraphicTextureHdr;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicTexture2d" {
    import { V3dGraphicTexture } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTexture";
    import { V3dGraphicTextureWrapEnum } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTextureWrapEnum";
    export class V3dGraphicTexture2d extends V3dGraphicTexture {
        get optionInvertY(): boolean;
        set optionInvertY(value: boolean);
        get wrapAuCd(): V3dGraphicTextureWrapEnum;
        set wrapAuCd(value: V3dGraphicTextureWrapEnum);
        get wrapAvCd(): V3dGraphicTextureWrapEnum;
        set wrapAvCd(value: V3dGraphicTextureWrapEnum);
        get wrapAwCd(): V3dGraphicTextureWrapEnum;
        set wrapAwCd(value: V3dGraphicTextureWrapEnum);
        get uScale(): number;
        get vScale(): number;
        setScale(uScale: number, vScale: number): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicLightManager" {
    import { QualityEnum } from 'cross/runtime/framework/quality/QualityEnum';
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    import { V3dGraphicObject } from "foundation/editor/view/view3d/render/graphic/V3dGraphicObject";
    import { V3dGraphicTexture2d } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTexture2d";
    export class V3dGraphicLightManager extends V3dGraphicObject {
        qualityCd: QualityEnum;
        mirrowTexture: V3dGraphicTexture2d;
        addShadow(mesh: V3dGraphicContent): void;
        removeShadow(mesh: V3dGraphicContent): void;
        addMirrow(mesh: V3dGraphicContent): void;
        removeMirrow(mesh: V3dGraphicContent): void;
        addLightExcluded(mesh: V3dGraphicContent): void;
        removeLightExcluded(mesh: V3dGraphicContent): void;
    }
}
declare module "foundation/editor/view/view3d/selection/V3dPickerItem" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { Display } from "foundation/editor/view/base/Display";
    export class V3dPickerItem {
        dataNode: ContentNode;
        display: Display;
        point: Vector3;
        coord: Vector2;
        distance: number;
        node: any;
        normal: Vector3;
        faceId: number;
        drawableId: number;
        constructor();
        assign(info: any): void;
        reset(): void;
    }
}
declare module "foundation/editor/view/view3d/selection/V3dPicker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { Display } from "foundation/editor/view/base/Display";
    import { Layer } from "foundation/editor/view/base/Layer";
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dPickerItem } from "foundation/editor/view/view3d/selection/V3dPickerItem";
    export class V3dPicker extends InstanceObject {
        context: V3dCanvasContext;
        constructor(context?: V3dCanvasContext);
        setup(): void;
        enable(): void;
        disable(): void;
        setTrackingMesh(layer: Layer, display: Display, mesh: any, isTrack: boolean): void;
        addTrackingMesh(layer: Layer, display: Display, node: V3dGraphicMesh): void;
        removeTrackingMesh(layer: Layer, display: Display, node: V3dGraphicMesh): void;
        getTriangleFunc(): (point1: any, point2: any, point3: any, ray: any) => boolean;
        getPredicateFunc(): (mesh: any) => boolean;
        getPickSorter(): (source: any, target: any) => number;
        pickSingle(x: number, y: number, layers: Types<any>, skipEntity?: ContentNode, force?: boolean): V3dPickerItem;
        pick(x: number, y: number, layers: Types<any>, multiPicking: boolean): Array<V3dPickerItem>;
        screenToGroundPoint(x: number, y: number, contentHeight: number, scene: any): any;
        canvasToXZPlanePoint(x: number, y: number, contentHeight: number, i?: any): any;
        clear(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicDynamicTexture" {
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    export type V3dGraphicDynamicTextureOption = {
        width?: number;
        height?: number;
    };
    export class V3dGraphicDynamicTexture extends V3dGraphicContent {
        optionCache: boolean;
        options: V3dGraphicDynamicTextureOption;
        handle: any;
        constructor();
        get value(): number;
        set value(v: number);
        updateTextValue(value?: number): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicLight" {
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    export class V3dGraphicLight extends V3dGraphicContent {
        type: string;
        setPosition(x: number, y: number, z: number): void;
        setDirection(x: number, y: number, z: number): void;
        setIntensity(value: number): void;
        setTarget(x: number, y: number, z: number): void;
        lookAt(x: number, y: number, z: number): void;
        setShadowDistance(minValue: number, maxValue: number): void;
        setCaseLight(value: boolean): void;
        setFalloff(value: number): void;
        setConeInnerAngle(value: number): void;
        setConeOuterAngle(value: number): void;
        setDiffuseColor(r: number, g: number, b: number): void;
        setSpecularColor(r: number, g: number, b: number): void;
        set optionShadow(value: boolean);
        get optionShadow(): boolean;
        reset(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicSprite" {
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    export type MouseEnterCallback = () => void;
    export type V3dGraphicSpriteOption = {
        parent?: any;
        updatable?: boolean;
        type?: string;
        parameters?: any;
        width?: number;
        height?: number;
        mouseEnterCallback?: MouseEnterCallback;
        spriteManager?: any;
        linker?: any;
    };
    export class V3dGraphicSprite extends V3dGraphicContent {
        optionCache: boolean;
        options: V3dGraphicSpriteOption;
        _value: number;
        constructor();
        get optionLockSize(): boolean;
        set optionLockSize(value: boolean);
        get width(): number;
        set width(value: number);
        get height(): number;
        set height(value: number);
        get layerMask(): number;
        set layerMask(value: number);
        show(): void;
        hide(): void;
        get value(): number;
        set value(value: number);
        updateTextValue(value: number): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicSpriteManager" {
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    export type V3dGraphicSpriteManagerOption = {
        parent?: any;
        updatable?: boolean;
        type?: string;
        parameters?: any;
        width?: number;
        height?: number;
        textTexture?: any;
    };
    export class V3dGraphicSpriteManager extends V3dGraphicContent {
        optionCache: boolean;
        options: V3dGraphicSpriteManagerOption;
        handle: any;
        constructor();
        get parent(): V3dGraphicContent;
        set parent(parent: V3dGraphicContent);
        get optionPickable(): boolean;
        set optionPickable(value: boolean);
        setPosition(x: number, y: number, z: number): void;
        setRotation(x: number, y: number, z: number): void;
        setScale(x: number, y: number, z: number): void;
        get layerMask(): number;
        set layerMask(value: number);
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicSpriteMaterial" {
    import { V3dGraphicMaterial, V3dGraphicMaterialOptions } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMaterial";
    export class V3dGraphicSpriteMaterial extends V3dGraphicMaterial {
        optionCache: boolean;
        options: V3dGraphicMaterialOptions;
        constructor(name?: string);
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicTextureCube" {
    import { V3dGraphicTexture, V3dGraphicTextureOptions } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTexture";
    export class V3dGraphicTextureCube extends V3dGraphicTexture {
        options: V3dGraphicTextureOptions;
        coordinatesMode: number;
        constructor();
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicRenderFactory" {
    import { RenderFactory } from "foundation/editor/view/base/render/RenderFactory";
    import { V3dPicker } from "foundation/editor/view/view3d/selection/V3dPicker";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dGraphicCamera } from "foundation/editor/view/view3d/render/graphic/V3dGraphicCamera";
    import { V3dGraphicContainer, V3dGraphicContainerOptions } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContainer";
    import { V3dGraphicDynamicLines } from "foundation/editor/view/view3d/render/graphic/V3dGraphicDynamicLines";
    import { V3dGraphicDynamicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicDynamicMesh";
    import { V3dGraphicDynamicTexture, V3dGraphicDynamicTextureOption } from "foundation/editor/view/view3d/render/graphic/V3dGraphicDynamicTexture";
    import { V3dGraphicLayer, V3dGraphicLayerOptions } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLayer";
    import { V3dGraphicLayerGroup, V3dGraphicLayerGroupOptions } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLayerGroup";
    import { V3dGraphicLight } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLight";
    import { V3dGraphicLineMaterial, V3dGraphicLineMaterialOptions } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLineMaterial";
    import { V3dGraphicLines, V3dGraphicLinesOption } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLines";
    import { V3dGraphicMaterialOptions } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMaterial";
    import { V3dGraphicMesh, V3dGraphicMeshOption } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dGraphicMeshMaterial, V3dGraphicMeshMaterialOptions } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial";
    import { V3dGraphicModel } from "foundation/editor/view/view3d/render/graphic/V3dGraphicModel";
    import { V3dGraphicScene, V3dGraphicSceneOptions } from "foundation/editor/view/view3d/render/graphic/V3dGraphicScene";
    import { V3dGraphicSprite, V3dGraphicSpriteOption } from "foundation/editor/view/view3d/render/graphic/V3dGraphicSprite";
    import { V3dGraphicSpriteManager, V3dGraphicSpriteManagerOption } from "foundation/editor/view/view3d/render/graphic/V3dGraphicSpriteManager";
    import { V3dGraphicSpriteMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicSpriteMaterial";
    import { V3dGraphicTextureOptions } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTexture";
    import { V3dGraphicTexture2d } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTexture2d";
    import { V3dGraphicTextureCube } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTextureCube";
    import { V3dGraphicTextureHdr } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTextureHdr";
    export class V3dGraphicRenderFactory extends RenderFactory {
        context: V3dCanvasContext;
        createScene(name?: string, options?: V3dGraphicSceneOptions): V3dGraphicScene;
        createLayerGroup(name?: string, options?: V3dGraphicLayerGroupOptions): V3dGraphicLayerGroup;
        createLayer(name?: string, options?: V3dGraphicLayerOptions): V3dGraphicLayer;
        createCamera(name?: string, type?: string): V3dGraphicCamera;
        createPicker(name?: string): V3dPicker;
        createLight(name?: string, type?: string): V3dGraphicLight;
        createContainer(name?: string, options?: V3dGraphicContainerOptions): V3dGraphicContainer;
        createModel(name?: string): V3dGraphicModel;
        createLineMaterial(name?: string, typeName?: string, options?: V3dGraphicLineMaterialOptions): V3dGraphicLineMaterial;
        createLines(name?: string, options?: V3dGraphicLinesOption): V3dGraphicLines;
        createDynamicLines(name?: string, options?: V3dGraphicLinesOption): V3dGraphicDynamicLines;
        createMeshMaterial(name?: string, typeName?: string, options?: V3dGraphicMeshMaterialOptions): V3dGraphicMeshMaterial;
        createMesh(name?: string, options?: V3dGraphicMeshOption): V3dGraphicMesh;
        createDynamicTexture(name?: string, options?: V3dGraphicDynamicTextureOption): V3dGraphicDynamicTexture;
        createSprite(name?: string, options?: V3dGraphicSpriteOption): V3dGraphicSprite;
        createSpriteMaterial(name?: string, options?: V3dGraphicMaterialOptions): V3dGraphicSpriteMaterial;
        createSpriteManager(name?: string, options?: V3dGraphicSpriteManagerOption): V3dGraphicSpriteManager;
        createDynamicMesh(name?: string, options?: V3dGraphicMeshOption): V3dGraphicDynamicMesh;
        createTexture2d(name?: string, options?: V3dGraphicTextureOptions, onload?: any, onerror?: any): V3dGraphicTexture2d;
        createTetureHdr(name?: string, options?: V3dGraphicTextureOptions, onload?: any, onerror?: any): V3dGraphicTextureHdr;
        createTetureCube(name?: string, options?: V3dGraphicTextureOptions, onload?: any, onerror?: any): V3dGraphicTextureCube;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicRenderer" {
    import { Renderer } from "foundation/editor/view/base/render/Renderer";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dGraphicLightManager } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLightManager";
    import { V3dGraphicRenderFactory } from "foundation/editor/view/view3d/render/graphic/V3dGraphicRenderFactory";
    export class V3dGraphicRenderer extends Renderer {
        context: V3dCanvasContext;
        factory: V3dGraphicRenderFactory;
        get lightManager(): V3dGraphicLightManager;
        connect(): void;
        disconnect(): void;
    }
}
declare module "foundation/editor/view/view3d/light/V3dLightManager" {
    import { QualityService } from 'cross/runtime/framework/quality/QualityService';
    import { ViewContext } from 'cross/runtime/framework/view/ViewContext';
    import { LightManager } from "foundation/editor/view/base/render/LightManager";
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    import { V3dGraphicTexture } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTexture";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dObserver } from "foundation/editor/view/view3d/V3dObserver";
    export class V3dLightManager extends LightManager {
        context: V3dCanvasContext;
        protected _lastTick: number;
        protected _qualityService: QualityService;
        get mirrowTexture(): V3dGraphicTexture;
        addShadow(content: V3dGraphicContent): void;
        removeShadow(content: V3dGraphicContent): void;
        addMirrow(content: V3dGraphicContent): void;
        removeMirrow(content: V3dGraphicContent): void;
        addLightExcluded(content: V3dGraphicContent): void;
        removeLightExcluded(content: V3dGraphicContent): void;
        show(): void;
        reset(Observer: V3dObserver): void;
        dirty(): void;
        process(viewContext: ViewContext): void;
    }
}
declare module "foundation/editor/view/view3d/V3dLayerTypeEnum" {
    import { LayerTypeEnum } from "foundation/editor/view/base/LayerTypeEnum";
    export class V3dLayerTypeEnum extends LayerTypeEnum {
        static Floor: string;
    }
}
declare module "foundation/editor/view/base/helper/Helper" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    export class Helper extends Dispatcher {
        typeName: string;
        name: string;
        context: CanvasContext;
        node: any;
        statusVisible: boolean;
        constructor();
        setup(): void;
        makeNodeName(name: string): string;
        show(): void;
        hide(): void;
        setVisible(visible: boolean): void;
        update(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dHelper" {
    import { Value3 } from 'cross/runtime/math/Value3';
    import { Vector3 } from 'cross/runtime/math/Vector3';
    import { Helper } from "foundation/editor/view/base/helper/Helper";
    import { V3dGraphicContainer } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContainer";
    import { V3dGraphicNode } from "foundation/editor/view/view3d/render/graphic/V3dGraphicNode";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    export class V3dHelper extends Helper {
        context: V3dCanvasContext;
        node: V3dGraphicContainer;
        protected _position: Vector3;
        protected _rotation: Vector3;
        protected _nodeParent: V3dGraphicNode;
        setup(): void;
        get nodeParent(): V3dGraphicNode;
        set nodeParent(parent: V3dGraphicNode);
        get position(): Readonly<Value3>;
        setPosition(x: number, y: number, z: number): void;
        get rotation(): Readonly<Value3>;
        setRotation(x: number, y: number, z: number): void;
        show(): void;
        hide(): void;
        freezeWorldMatrix(force?: boolean): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dHelperUtil" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { Lines } from 'foundation/runtime/graphics/data/Lines';
    export class V3dHelperUtil {
        static createDashLinePosList(start: Vector3, end: Vector3, pattern: Array<number>, positions?: Array<number>): Array<number>;
        static toBabylonSpace(vec: Vector3): Vector3;
        static isDashPatternValid(pattern: Array<number>): boolean;
        static getLinesFromBox(box: BoxSolid, lineColor?: number): Lines;
        static getDashLinesFromBox(box: BoxSolid, dashPattern: any, lineColor?: number): Lines;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dBoundaryHelper" {
    import { Color } from 'foundation/runtime/math/Color';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { Lines } from 'foundation/runtime/graphics/data/Lines';
    import { MoldingVisionEnum } from 'foundation/data/common/enumeration/MoldingVisionEnum';
    import { V3dGraphicLines } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLines";
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dHelper } from "foundation/editor/view/view3d/helper/V3dHelper";
    export class V3dBoundaryHelper extends V3dHelper {
        optionBorder: boolean;
        optionDash: boolean;
        borderPattern: Array<number>;
        borderColor: Color;
        borderOpacity: number;
        optionBorderBack: boolean;
        optionDashBack: boolean;
        borderBackPattern: Array<number>;
        borderBackColor: Color;
        borderBackOpacity: number;
        borderBackSolid: number;
        borderBackBreak: number;
        optionFace: boolean;
        faceColor: Color;
        faceOpacity: number;
        adjustSize: number;
        optionEdge: boolean;
        optionAlpha: boolean;
        edgeColor: Color;
        zOffset: number;
        renderingGroupId: number;
        protected _box: BoxSolid;
        protected _cubeMesh: V3dGraphicMesh;
        protected _cubeFrontLines: V3dGraphicLines;
        protected _cubeBackLines: V3dGraphicLines;
        constructor();
        setup(): void;
        private getCubeMaterial;
        private createNodeCube;
        private createBoundaryLine;
        updateStyle(): void;
        updateSize(size: Vector3): void;
        updateMatrix(matrix: Matrix4): void;
        updateTransform(): void;
        protected getBoxLine(box: BoxSolid, lineColor: number): Lines;
        updateBox(box: BoxSolid): void;
        updateBoundaryBox(box: BoxSolid): void;
        showHover(): void;
        showSelect(): void;
        showError(): void;
        showMode(mode: MoldingVisionEnum, colorOption: any): void;
        update(): void;
        freezeWorldMatrix(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/V3dLines" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Polygon } from 'foundation/runtime/graphics/shape/brep/Polygon';
    import { LinesActor } from 'foundation/runtime/graphics/actor/LinesActor';
    import { LineSegments } from 'foundation/runtime/graphics/actor/LineSegments';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { LineBasicMaterial } from 'foundation/runtime/graphics/material/LineBasicMaterial';
    import { PlaneEnum } from 'foundation/runtime/graphics/shape/PlaneEnum';
    export class V3dLines extends LineSegments {
        actor: LinesActor;
        material: LineBasicMaterial;
        geometry: BufferGeometry;
        constructor(actor?: LinesActor);
        update(actor: LinesActor): void;
        updatePolygon(polygon: Polygon, planeCd: PlaneEnum, matrix: Matrix4): void;
        static makeBufferGeometry(vertexCount: number, useVertexColor: boolean, positionData: Array<number>, colorData: Array<number>, indexData: Array<number>): BufferGeometry;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dBoundingBox" {
    import { Color3 } from 'foundation/runtime/math/Color3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { V3dGraphicLines } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLines";
    import { V3dGraphicNode } from "foundation/editor/view/view3d/render/graphic/V3dGraphicNode";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    export class V3dBoundingBox {
        protected _context: V3dCanvasContext;
        protected _min: Vector3;
        protected _max: Vector3;
        protected _mesh: V3dGraphicLines;
        protected _color: Color3;
        protected _parent: V3dGraphicNode;
        constructor(context: V3dCanvasContext);
        show(bShow: boolean): void;
        setColor(r: number, g: number, b: number): void;
        set(min: Vector3, max: Vector3): void;
        bindToNode(node: V3dGraphicNode): void;
        removeMesh(): void;
        protected updateMesh(): void;
    }
}
declare module "foundation/editor/view/view3d/selection/V3dSelectionManager" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { SelectionEvent } from 'foundation/editor/base/selection/SelectionEvent';
    import { SelectionManager } from "foundation/editor/view/base/selection/SelectionManager";
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    import { V3dBoundaryHelper } from "foundation/editor/view/view3d/helper/V3dBoundaryHelper";
    import { V3dBoundingBox } from "foundation/editor/view/view3d/helper/V3dBoundingBox";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    import { V3dScene } from "foundation/editor/view/view3d/V3dScene";
    export class V3dSelectionManager extends SelectionManager {
        context: V3dCanvasContext;
        selectionScene: V3dScene;
        selectionLayer: V3dLayer;
        protected _editingHelper: V3dBoundaryHelper;
        protected _HLightNodeList: Array<DataNode>;
        protected _boundingBoxList: Array<V3dBoundingBox>;
        constructor();
        setup(): void;
        isMultiSelectKey(event: ActionEvent): boolean;
        hasOnlySelected(node: DataNode): boolean;
        canMultiSelect(node: DataNode): boolean;
        onSelectChanged(sender: ListenerContext, event: SelectionEvent): void;
        addHover(mesh: any): void;
        removeHover(mesh: any): void;
        addHSelected(entity: DataNode, meshNode: any): void;
        removeHSelected(entity: DataNode): void;
        protected showBoundary(box: BoxSolid): void;
        protected hideBoundary(): void;
        processMouseUp(event?: MouseDeviceEvent): void;
    }
}
declare module "foundation/editor/view/view3d/vision/V3dVisionManager" {
    import { Manager } from 'cross/runtime/framework/Manager';
    export class V3dVisionManager extends Manager {
    }
}
declare module "foundation/editor/view/base/render/RenderEnum" {
    export class RenderEnum {
        static Svg: string;
        static Render2d: string;
        static RenderHigh2d: string;
        static Render3d: string;
        static RenderHigh3d: string;
    }
}
declare module "foundation/editor/view/view3d/gizmo/V3dGizmoFactory" {
    import { GizmoFactory } from "foundation/editor/view/base/gizmo/GizmoFactory";
    export class V3dGizmoFactory extends GizmoFactory {
    }
}
declare module "foundation/editor/view/view3d/gizmo/V3dGizmoManager" {
    import { GizmoManager } from "foundation/editor/view/base/gizmo/GizmoManager";
    import { V3dGizmoFactory } from "foundation/editor/view/view3d/gizmo/V3dGizmoFactory";
    export class V3dGizmoManager extends GizmoManager {
        factory: V3dGizmoFactory;
    }
}
declare module "foundation/editor/view/view3d/gizmo/V3dGizmo" {
    import { Gizmo } from "foundation/editor/view/base/gizmo/Gizmo";
    import { V3dGraphicContainer } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContainer";
    import { V3dCanvas } from "foundation/editor/view/view3d/V3dCanvas";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    import { V3dGizmoManager } from "foundation/editor/view/view3d/gizmo/V3dGizmoManager";
    export abstract class V3dGizmo extends Gizmo {
        context: V3dCanvasContext;
        manager: V3dGizmoManager;
        view: V3dCanvas;
        layer: V3dLayer;
        node: V3dGraphicContainer;
        constructor();
        onActivate(): void;
        onDeactivate(): void;
        show(): void;
        hide(): void;
    }
}
declare module "foundation/editor/view/base/indicator/Indicator" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Display } from "foundation/editor/view/base/Display";
    import { ObserverChangeEvent } from "foundation/editor/view/base/ObserverChangeEvent";
    import { IndicatorManager } from "foundation/editor/view/base/indicator/IndicatorManager";
    export class Indicator extends Display {
        statusSuspend: boolean;
        indicatorManager: IndicatorManager;
        constructor();
        onObserverChanged(sender: ListenerContext, event: ObserverChangeEvent): void;
        onShow(): void;
        show(): void;
        pause(): void;
        resume(): void;
        onHide(): void;
        hide(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/base/indicator/IndicatorDeclareService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Service } from 'cross/runtime/module/Service';
    export type IndicatorDeclareInfo = {
        name: string;
        entityClass: any;
        displayClass: any;
        indicatorClass: any;
    };
    export class IndicatorDeclareService extends Service {
        protected _declares: Types<IndicatorDeclareInfo>;
        findDeclareByEntityInstance(entity: any): IndicatorDeclareInfo;
        registerDeclare(declare: IndicatorDeclareInfo): void;
        createEntityIndicator(entity: any): any;
    }
}
declare module "foundation/editor/view/base/indicator/IndicatorFactory" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { Layer } from "foundation/editor/view/base/Layer";
    import { Indicator } from "foundation/editor/view/base/indicator/Indicator";
    import { IndicatorDeclareService } from "foundation/editor/view/base/indicator/IndicatorDeclareService";
    export class IndicatorFactory extends InstanceObject {
        context: CanvasContext;
        protected _indicatorDeclareService: IndicatorDeclareService;
        setup(): void;
        createEntityIndicator(layer: Layer, entity: DataNode): Indicator;
    }
}
declare module "foundation/editor/view/base/indicator/IndicatorManager" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    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 { HoverService } from 'foundation/editor/base/selection/HoverService';
    import { SelectionEvent } from 'foundation/editor/base/selection/SelectionEvent';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    import { ActionService } from "foundation/editor/view/action/ActionService";
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { Indicator } from "foundation/editor/view/base/indicator/Indicator";
    import { IndicatorFactory } from "foundation/editor/view/base/indicator/IndicatorFactory";
    export class IndicatorManager extends Dispatcher {
        context: CanvasContext;
        factoryClass: any;
        factory: IndicatorFactory;
        protected _entities: Types<VertexNode>;
        protected _indicators: Types<Indicator>;
        protected _actionService: ActionService;
        protected _hoverService: HoverService;
        protected _selectionService: SelectionService;
        constructor();
        get indicatorCount(): number;
        setup(): void;
        showContentIndicators(selectEntity: DataNode, entities: Types<VertexNode>): void;
        onActionRunning(sender: ListenerContext, event: ActionEvent): void;
        onActionStopped(sender: ListenerContext, event: ActionEvent): void;
        onSelectionHover(sender: ListenerContext, event: SelectionEvent): void;
        onSelectionUnhover(sender: ListenerContext, event: SelectionEvent): void;
        onSelectionChanged(sender: ListenerContext, event: SelectionEvent): void;
        hookEvents(): void;
        unhookEvents(): void;
        pauseIndicators(): void;
        resumeIndicators(): void;
        showIndicator(indicator: Indicator): void;
        hideIndicators(): void;
        redraw(context?: DisplayContext): void;
        clear(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/base/indicator/IndicatorTypeEnum" {
    export class IndicatorTypeEnum {
        static Axis_X: string;
        static Axis_Y: string;
        static Axis_Z: string;
        static Local: string;
        static World: string;
        static IndicatorSelect: string;
        static IndicatorMove: string;
        static IndicatorRotation: string;
        static IndicatorScale: string;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorCoordEnum" {
    export class V3dIndicatorCoordEnum {
        static Local: string;
        static World: string;
    }
}
declare module "foundation/editor/view/view3d/render/V3dGroupEnum" {
    export enum V3dGroupEnum {
        Backgroun = 0,
        Structure = 1,
        Content = 2,
        Assistant = 3
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicator" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { VertexNode } from 'foundation/data/common/model/brep/VertexNode';
    import { Indicator } from "foundation/editor/view/base/indicator/Indicator";
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { ObserverChangeEvent } from "foundation/editor/view/base/ObserverChangeEvent";
    import { V3dGraphicContainer } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContainer";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    export class V3dIndicator extends Indicator {
        context: V3dCanvasContext;
        layer: V3dLayer;
        node: V3dGraphicContainer;
        protected _nodeDisplay: V3dGraphicContainer;
        protected _scaler: number;
        protected _scalerFactor: number;
        setup(): void;
        onObserverChanged(sender: ListenerContext, event: ObserverChangeEvent): void;
        getPosition(entity?: VertexNode): Vector3;
        protected updateScaleFactor(): void;
        draw(context?: DisplayContext): void;
        onShow(): void;
        onHide(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/action/selection/SelectPickerItem" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { Display } from "foundation/editor/view/base/Display";
    export class SelectPickerItem {
        dataNode: ContentNode;
        display: Display;
        point: Vector3;
        coord: Vector2;
        distance: number;
        node: any;
        normal: Vector3;
        faceId: number;
        drawableId: number;
        constructor();
        assign(info: any): void;
        reset(): void;
    }
}
declare module "foundation/editor/view/action/content/ContentActionEvent" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ElementNode } from 'foundation/data/common/element/ElementNode';
    import { SelectPickerItem } from "foundation/editor/view/action/selection/SelectPickerItem";
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    export class ContentActionEvent extends ActionEvent {
        container: ElementNode;
        element: ElementNode;
        entity: DataNode;
        threeD: boolean;
        host: DataNode;
        alignMode: string;
        arrangeMode: string;
        visible: boolean;
        valid: boolean;
        ignoreSnapOffset: boolean;
        defaultGround: boolean;
        displayHover: any;
        modelToScreen: number;
        anchorX: number;
        anchorY: number;
        meshId: any;
        mesh: any;
        snapType: string;
        indicatorMatrix: Matrix4;
        indicatorRotation: number;
        isIndicatorMove: boolean;
        protected _entities: Types<DataNode>;
        protected _normal: Vector3;
        protected _point: Vector3;
        protected _offset: Vector3;
        protected _rotation: Vector3;
        protected _size: Vector3;
        protected _scale: Vector3;
        protected _screenOrigin: Vector2;
        protected _screenPoint: Vector2;
        protected _screenOffset: Vector2;
        protected _indicatorSrcPos: Vector3;
        protected _indicatorSrcRot: Vector3;
        protected _groundPos: Vector3;
        protected _selects: Types<any>;
        protected _rotationAxis: Vector3;
        selectItem: SelectPickerItem;
        isSnap: boolean;
        faceId: number;
        constructor();
        get entities(): Types<DataNode>;
        get normal(): Vector3;
        get point(): Vector3;
        get offset(): Vector3;
        get size(): Vector3;
        get rotation(): Vector3;
        get scale(): Vector3;
        get screenOrigin(): Vector2;
        get screenPoint(): Vector2;
        get screenOffset(): Vector2;
        get indicatorSrcPos(): Vector3;
        get indicatorSrcRot(): Vector3;
        get groundPos(): Vector3;
        get selects(): Types<any>;
        get rotationAxis(): Vector3;
        addSelect(obj: any): void;
        assign(event: ContentActionEvent): void;
        free(): void;
    }
}
declare module "foundation/editor/view/view3d/V3dUtil" {
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoxGeometry } from 'foundation/runtime/graphics/shape/geometry/BoxGeometry';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { Geometry } from 'foundation/runtime/graphics/data/Geometry';
    import { MeshLambertMaterial } from 'foundation/runtime/graphics/material/MeshLambertMaterial';
    import { MeshPhongMaterial } from 'foundation/runtime/graphics/material/MeshPhongMaterial';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ModelMeshNode } from 'sk/data/resource/model/model/ModelMeshNode';
    import { V3dGraphicContainer } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContainer";
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    export class V3dUtil {
        static TempMatrix0: Matrix4;
        static TempMatrix1: Matrix4;
        protected static _meshLoadingMaterial: MeshLambertMaterial;
        protected static _meshFailureMaterial: MeshPhongMaterial;
        protected static _unitBoxGeometry: BoxGeometry;
        static browserSupport(htmlPanel: any): boolean;
        static elementToScreen(context: V3dCanvasContext, x: number, y: number, target?: Vector2): Vector2;
        static getMeshLoadingMaterial(): MeshLambertMaterial;
        static getMeshFailureMaterial(): MeshPhongMaterial;
        static getUnitBoxGeometry(): Geometry;
        static viewSpaceToModelSpace(value: Value3, target?: Vector3): Vector3;
        static modelSpaceToViewSpace(value: Value2 | Value3, target?: Vector3): Vector3;
        static cleanupGeometries(geometries: Array<Geometry | BufferGeometry>): void;
        static updateContentFromDataMatrixWithMultiple(content: ContentNode, mesh: any, center: Value3, multiple: number): Matrix3d;
        static updateContentFromDataMatrixWithMultiple2(worldPos: Vector3, center: Value3, multiple: number, factor?: number): Matrix3d;
        static updateMeshMatrix(matrix: Matrix3d, mesh: V3dGraphicMesh, zoom?: boolean): void;
        static updateContentMeshMatrix(content: ModelMeshNode, mesh: V3dGraphicContainer): void;
        static v3dModelPointToScreenPoint(context: V3dCanvasContext, point: Vector3, scale?: number, target?: Vector2): Vector2;
        static v3dModelPointsToScreenLength(context: V3dCanvasContext, point1: Vector3, point2: Vector3, scale?: number): number;
        static projectPositionToScreenPoint(context: V3dCanvasContext, projectionPoint: Vector3, target?: Vector2): Vector2;
        static getCameraProjectMatrix(context: V3dCanvasContext): Matrix4;
        static babylonPointToScreenPoint(context: V3dCanvasContext, matrix: Matrix4, point: Vector3, screenPoint?: Vector2): Vector2;
        static babylonPointsToScreenLength(context: V3dCanvasContext, point1: Vector3, point2: Vector3): number;
        static modelPointToScreen(context: V3dCanvasContext, point: Vector3, screenPoint?: Vector2): Vector2;
        static modelPointsToScreenLength(context: V3dCanvasContext, point1: Vector3, point2: Vector3): number;
        static freezeWorldMatrix(node: V3dGraphicMesh | V3dGraphicContainer): void;
        static disposeMesh(mesh: V3dGraphicMesh): any;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorController" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DisplayController } from "foundation/editor/view/base/DisplayController";
    import { V3dIndicator } from "foundation/editor/view/view3d/indicator/V3dIndicator";
    export class V3dIndicatorController extends DisplayController {
        display: V3dIndicator;
        protected _pickPosSrc: Vector3;
        protected _pickPosCur: Vector3;
        protected _axisX: Vector3;
        protected _axisY: Vector3;
        protected _axisZ: Vector3;
        protected _pickScreenPosSrc: Vector2;
        protected _pickScreenPosCur: Vector2;
        protected _isDraging: boolean;
        constructor();
        setAxisX(x: number, y: number, z: number): void;
        setAxisY(x: number, y: number, z: number): void;
        setAxisZ(x: number, y: number, z: number): void;
        dispatchToDisplay(code: any, event: any): void;
        dispatchEvent(code: any, event: any): boolean;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorCommonController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentActionEvent } from "foundation/editor/view/action/content/ContentActionEvent";
    import { V3dIndicatorCommon } from "foundation/editor/view/view3d/indicator/V3dIndicatorCommon";
    import { V3dIndicatorController } from "foundation/editor/view/view3d/indicator/V3dIndicatorController";
    export class V3dIndicatorCommonController extends V3dIndicatorController {
        display: V3dIndicatorCommon;
        protected _screenFactor: number;
        protected _startPoint: Vector3;
        protected _moveDir: Vector3;
        protected _screenDir: Vector2;
        protected _rotationAnchorPoint: Vector2;
        protected _rotationStartRad: number;
        private _indicatorMatrix;
        private info;
        onMouseEnter(sender: ListenerContext, event: any): void;
        onMouseEnterChange(sender: ListenerContext, event: any): void;
        onMouseLeave(sender: ListenerContext, event: any): void;
        onDragStart(sender: ListenerContext, event: any): boolean;
        onDragMove(sender: ListenerContext, event: ContentActionEvent): boolean;
        protected computeTempLocalMatrix(): Matrix3d;
        private onMoveStart;
        private onMove;
        private onRotateStart;
        private onRotate;
        onDragEnd(sender: ListenerContext, event: ContentActionEvent): boolean;
        dispatchToDisplay(code: any, event: any): void;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorCommon" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { ObserverModeEnum } from 'foundation/data/common/model/brep/ObserverModeEnum';
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dIndicator } from "foundation/editor/view/view3d/indicator/V3dIndicator";
    import { V3dIndicatorCommonController } from "foundation/editor/view/view3d/indicator/V3dIndicatorCommonController";
    export class V3dIndicatorCommon extends V3dIndicator {
        context: V3dCanvasContext;
        controller: V3dIndicatorCommonController;
        anchor: Vector3;
        normal: Vector3;
        hasHost: boolean;
        localMatrix: Matrix3d;
        nodeMatrix: Matrix3d;
        worldMatrix: Matrix3d;
        meshInfos: any;
        protected _statusLocalMatrixChanged: boolean;
        protected _intersectionThreshold: number;
        constructor();
        setup(): void;
        private getLocalMatrixByAxisData;
        bindAction(): void;
        unbindAction(): void;
        protected onCameraChanged(owner: any, event: any): void;
        protected updateAxisByCameraModeCd(mode: ObserverModeEnum): void;
        setLocalMatrix(): void;
        private createMesh;
        private createCylinderSolidMesh;
        private createLine;
        private createCircle;
        private createCircleZ;
        private createCircleX;
        private createCircleY;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onDraw(context?: DisplayContext): void;
        protected computeTempMatrix(): Matrix3d;
        private updateTransform;
        highLight(name: string, bool: boolean): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorMoveArrowController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentActionEvent } from "foundation/editor/view/action/content/ContentActionEvent";
    import { V3dIndicatorController } from "foundation/editor/view/view3d/indicator/V3dIndicatorController";
    import { V3dIndicatorMoveArrow } from "foundation/editor/view/view3d/indicator/V3dIndicatorMoveArrow";
    export class V3dIndicatorMoveArrowController extends V3dIndicatorController {
        display: V3dIndicatorMoveArrow;
        protected _modelToScreen: number;
        protected _startPoint: Vector3;
        protected _screenDir: Vector2;
        onMouseEnter(sender: ListenerContext, event: ContentActionEvent): void;
        onMouseLeave(sender: ListenerContext, event: ContentActionEvent): void;
        onDragStart(sender: ListenerContext, event: ContentActionEvent): boolean;
        onDragMove(sender: ListenerContext, event: ContentActionEvent): boolean;
        onDragEnd(sender: ListenerContext, event: ContentActionEvent): boolean;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorMoveArrow" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Color4 } from 'foundation/runtime/math/Color4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { V3dGraphicMeshMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dIndicator } from "foundation/editor/view/view3d/indicator/V3dIndicator";
    import { V3dIndicatorMoveArrowController } from "foundation/editor/view/view3d/indicator/V3dIndicatorMoveArrowController";
    export class V3dIndicatorMoveArrow extends V3dIndicator {
        context: V3dCanvasContext;
        controller: V3dIndicatorMoveArrowController;
        rotation: number;
        private meshCone;
        private meshLine;
        nodeMaterial: V3dGraphicMeshMaterial;
        protected color: Color4;
        protected highlightColor: Color4;
        protected _axis: String;
        constructor(axis: String);
        get axis(): String;
        setup(): void;
        getPosition(): Vector3;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onDraw(context?: DisplayContext): void;
        highLight(bHightLight: boolean): void;
        onShow(): void;
        onHide(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorRotationController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentActionEvent } from "foundation/editor/view/action/content/ContentActionEvent";
    import { V3dIndicatorController } from "foundation/editor/view/view3d/indicator/V3dIndicatorController";
    import { V3dIndicatorRotation } from "foundation/editor/view/view3d/indicator/V3dIndicatorRotation";
    export class V3dIndicatorRotationController extends V3dIndicatorController {
        display: V3dIndicatorRotation;
        protected _factor: number;
        protected _lastScreenPoint: Vector2;
        protected _startPoint: Vector3;
        protected _screenDir: Vector2;
        constructor();
        onMouseEnter(sender: ListenerContext, event: ContentActionEvent): void;
        onMouseLeave(sender: ListenerContext, event: ContentActionEvent): void;
        onDragStart(sender: ListenerContext, event: ContentActionEvent): boolean;
        onDragMove(sender: ListenerContext, event: ContentActionEvent): boolean;
        onDragEnd(sender: ListenerContext, event: ContentActionEvent): boolean;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorRotation" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Color } from 'foundation/runtime/math/Color';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { V3dGraphicMeshMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dIndicator } from "foundation/editor/view/view3d/indicator/V3dIndicator";
    import { V3dIndicatorRotationController } from "foundation/editor/view/view3d/indicator/V3dIndicatorRotationController";
    export class V3dIndicatorRotation extends V3dIndicator {
        context: V3dCanvasContext;
        controller: V3dIndicatorRotationController;
        rotation: number;
        private meshRing;
        nodeMaterial: V3dGraphicMeshMaterial;
        protected _axisName: String;
        protected color: Color;
        protected highlightColor: Color;
        protected collisonMesh: any;
        protected collisonMateiral: any;
        constructor(axis: String);
        get axisName(): String;
        setup(): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        highLight(bHightLight: boolean): void;
        getPosition(): Vector3;
        onDraw(context?: DisplayContext): void;
        onShow(): void;
        onHide(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorScaleBarController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ContentActionEvent } from "foundation/editor/view/action/content/ContentActionEvent";
    import { V3dIndicatorController } from "foundation/editor/view/view3d/indicator/V3dIndicatorController";
    import { V3dIndicatorScaleBar } from "foundation/editor/view/view3d/indicator/V3dIndicatorScaleBar";
    export class V3dIndicatorScaleBarController extends V3dIndicatorController {
        display: V3dIndicatorScaleBar;
        onMouseEnter(sender: ListenerContext, event: ContentActionEvent): void;
        onMouseLeave(sender: ListenerContext, event: ContentActionEvent): void;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorScaleBar" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Color } from 'foundation/runtime/math/Color';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { V3dGraphicMeshMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dIndicator } from "foundation/editor/view/view3d/indicator/V3dIndicator";
    import { V3dIndicatorScaleBarController } from "foundation/editor/view/view3d/indicator/V3dIndicatorScaleBarController";
    export class V3dIndicatorScaleBar extends V3dIndicator {
        context: V3dCanvasContext;
        entity: ContentNode;
        controller: V3dIndicatorScaleBarController;
        rotation: number;
        private meshBox;
        private meshLine;
        nodeMaterial: V3dGraphicMeshMaterial;
        protected _axis: String;
        protected color: Color;
        protected highlightColor: Color;
        constructor(axis: String);
        get axis(): String;
        setup(): void;
        highLight(bHightLight: boolean): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onDraw(context?: DisplayContext): void;
        onShow(): void;
        onHide(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorScaleXYZController" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { V3dIndicatorController } from "foundation/editor/view/view3d/indicator/V3dIndicatorController";
    import { V3dIndicatorScaleXYZ } from "foundation/editor/view/view3d/indicator/V3dIndicatorScaleXYZ";
    export class V3dIndicatorScaleXYZController extends V3dIndicatorController {
        display: V3dIndicatorScaleXYZ;
        direction: Vector3;
        constructor();
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorScaleXYZ" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Color } from 'foundation/runtime/math/Color';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { V3dGraphicMeshMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dIndicator } from "foundation/editor/view/view3d/indicator/V3dIndicator";
    import { V3dIndicatorScaleXYZController } from "foundation/editor/view/view3d/indicator/V3dIndicatorScaleXYZController";
    export class V3dIndicatorScaleXYZ extends V3dIndicator {
        context: V3dCanvasContext;
        entity: ContentNode;
        controller: V3dIndicatorScaleXYZController;
        rotation: number;
        private meshBox;
        nodeMaterial: V3dGraphicMeshMaterial;
        protected color: Color;
        protected highlightColor: Color;
        constructor();
        setup(): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onDraw(context?: DisplayContext): void;
        onShow(): void;
        onHide(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorFactory" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { IndicatorFactory } from "foundation/editor/view/base/indicator/IndicatorFactory";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    import { V3dIndicatorCommon } from "foundation/editor/view/view3d/indicator/V3dIndicatorCommon";
    import { V3dIndicatorMoveArrow } from "foundation/editor/view/view3d/indicator/V3dIndicatorMoveArrow";
    import { V3dIndicatorRotation } from "foundation/editor/view/view3d/indicator/V3dIndicatorRotation";
    import { V3dIndicatorScaleBar } from "foundation/editor/view/view3d/indicator/V3dIndicatorScaleBar";
    import { V3dIndicatorScaleXYZ } from "foundation/editor/view/view3d/indicator/V3dIndicatorScaleXYZ";
    export class V3dIndicatorFactory extends IndicatorFactory {
        context: V3dCanvasContext;
        createCommonIndicator(layer: V3dLayer, entity: DataNode, hasHost?: boolean): V3dIndicatorCommon;
        createIndicatorMoveArrow(layer: V3dLayer, axis: String, entity: DataNode): V3dIndicatorMoveArrow;
        createIndicatorScaleBar(layer: V3dLayer, axis: String, entity: ContentNode): V3dIndicatorScaleBar;
        createIndicatorRotation(layer: V3dLayer, axis: String, entity: ContentNode): V3dIndicatorRotation;
        createIndicatorScaleXYZ(layer: V3dLayer, entity: ContentNode): V3dIndicatorScaleXYZ;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorManager" {
    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 { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { VertexNode } from 'foundation/data/common/model/brep/VertexNode';
    import { IndicatorManager } from "foundation/editor/view/base/indicator/IndicatorManager";
    import { IndicatorTypeEnum } from "foundation/editor/view/base/indicator/IndicatorTypeEnum";
    import { ObserverChangeEvent } from "foundation/editor/view/base/ObserverChangeEvent";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    import { V3dIndicatorCoordEnum } from "foundation/editor/view/view3d/indicator/V3dIndicatorCoordEnum";
    import { V3dIndicatorFactory } from "foundation/editor/view/view3d/indicator/V3dIndicatorFactory";
    export class V3dIndicatorManager extends IndicatorManager {
        context: V3dCanvasContext;
        factory: V3dIndicatorFactory;
        selectEntity: DataNode;
        cameraLayer: V3dLayer;
        contentLayer: V3dLayer;
        protected _coordCd: V3dIndicatorCoordEnum;
        protected _typeCd: IndicatorTypeEnum;
        constructor();
        onObserverPropertyChanged(sender: ListenerContext, event: ObserverChangeEvent): void;
        hookEvents(): void;
        unhookEvents(): void;
        protected calculatePosition(entitys: Types<VertexNode>): void;
        protected showIndicatorsMove(entity: DataNode): void;
        protected showIndicatorsRotation(entity: ContentNode): void;
        protected showIndicatorsScale(entity: ContentNode): void;
        protected showIndicatorByType(typeCd: IndicatorTypeEnum, entity: DataNode): void;
        protected showCommonIndicator(selectEntity: DataNode, entities: Types<VertexNode>): void;
        private checkSnapHost;
        showContentIndicator(entity: DataNode): void;
        showContentIndicators(selectEntity: DataNode, entities: Types<VertexNode>): void;
        changeIndicatorType(typeCd: IndicatorTypeEnum, entity: DataNode): boolean;
        dispose(): void;
    }
}
declare module "foundation/editor/view/base/selection/SelectorOptions" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    export class SelectorOptions {
        entity: DataNode;
        layers: Types<any>;
        multiPicking: boolean;
    }
}
declare module "foundation/editor/view/base/SceneEnum" {
    export class SceneEnum {
        static Background: string;
        static Content: string;
        static Picker: string;
    }
}
declare module "foundation/editor/view/view3d/V3dScenes" {
    import { Scenes } from "foundation/editor/view/base/Scenes";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dScene } from "foundation/editor/view/view3d/V3dScene";
    export class V3dScenes extends Scenes {
        context: V3dCanvasContext;
        protected _content: V3dScene;
        protected _picker: V3dScene;
        get content(): V3dScene;
        get picker(): V3dScene;
        setup(): void;
    }
}
declare module "foundation/editor/view/view3d/selection/V3dSelectorController" {
    import { SelectorController } from "foundation/editor/view/base/selection/SelectorController";
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dSelector } from "foundation/editor/view/view3d/selection/V3dSelector";
    export class V3dSelectorController extends SelectorController {
        context: V3dCanvasContext;
        selector: V3dSelector;
        onActionStopped(sender: any, event: ActionEvent): void;
    }
}
declare module "foundation/editor/view/view3d/selection/V3dSelectorEvent" {
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SelectorEvent } from "foundation/editor/view/base/selection/SelectorEvent";
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dPickerItem } from "foundation/editor/view/view3d/selection/V3dPickerItem";
    export class V3dSelectorEvent extends SelectorEvent {
        htmlEvent: MouseEvent;
        host: any;
        mesh: V3dGraphicMesh;
        normal: Vector3;
        selectItem: V3dPickerItem;
        selectItems: Array<V3dPickerItem>;
        constructor();
        assignEvent(event: MouseDeviceEvent): void;
        free(): void;
    }
}
declare module "foundation/editor/view/view3d/selection/V3dSelector" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { Selector } from "foundation/editor/view/base/selection/Selector";
    import { SelectorOptions } from "foundation/editor/view/base/selection/SelectorOptions";
    import { ActionService } from "foundation/editor/view/action/ActionService";
    import { Display } from "foundation/editor/view/base/Display";
    import { DisplayEventEnum } from "foundation/editor/view/base/DisplayEventEnum";
    import { LayerEvent } from "foundation/editor/view/base/LayerEvent";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    import { V3dScenes } from "foundation/editor/view/view3d/V3dScenes";
    import { V3dPicker } from "foundation/editor/view/view3d/selection/V3dPicker";
    import { V3dPickerItem } from "foundation/editor/view/view3d/selection/V3dPickerItem";
    import { V3dSelectorController } from "foundation/editor/view/view3d/selection/V3dSelectorController";
    import { V3dSelectorEvent } from "foundation/editor/view/view3d/selection/V3dSelectorEvent";
    export class V3dSelector extends Selector {
        context: V3dCanvasContext;
        scenes: V3dScenes;
        controller: V3dSelectorController;
        picker: V3dPicker;
        protected _draggingFlag: boolean;
        protected _draggingDisplay: Display;
        protected _hoverDisplay: Display;
        protected _hoverNode: any;
        protected _dispatchDisplay: Display;
        protected _originScreenPoint: Vector2;
        protected _originWorldPoint: Vector3;
        protected _preselectableLayers: Types<any>;
        protected _selectableLayers: Types<any>;
        protected _selectableLayersOverride: Types<any>;
        protected _statusMouseDown: boolean;
        protected _actionService: ActionService;
        constructor();
        setup(picker?: V3dPicker): void;
        get preselectableLayers(): Types<any>;
        get selectableLayers(): Types<any>;
        setSelectOptions(options: SelectorOptions): void;
        processEvent(eventCd: DisplayEventEnum, event: V3dSelectorEvent): void;
        private setTrackingMesh;
        onLayerAddChild(sender: ListenerContext, event: LayerEvent): void;
        onLayerUpdateChild(sender: ListenerContext, event: LayerEvent): void;
        onLayerRemoveChild(sender: ListenerContext, event: LayerEvent): void;
        private isSameSelectParent;
        onDisplayEnter(select: V3dPickerItem, event?: any): void;
        onDisplayLeave(): void;
        private assignSelectorEvent;
        onClick(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragStart(sender: ListenerContext, event: MouseDeviceEvent): void;
        onNonDragMove(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragMove(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragEnd(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;
        onSelectByPoint(point: Vector2): void;
        watchLayer(layer: V3dLayer, selectable: boolean, preselectable: boolean): void;
        enable(): void;
        disable(): void;
        update(): void;
        clear(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/V3dCanvas" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Speed } from 'cross/runtime/lang/Speed';
    import { ViewContext } from 'cross/runtime/framework/view/ViewContext';
    import { ResizeEvent } from 'cross/editor/device/screen/ResizeEvent';
    import { ScreenDeviceService } from 'cross/editor/device/screen/ScreenDeviceService';
    import { ScreenEventHook } from 'cross/editor/device/screen/ScreenEventHook';
    import { RenderEnum } from "foundation/editor/view/base/render/RenderEnum";
    import { RenderManager } from "foundation/editor/view/base/render/RenderManager";
    import { Canvas } from "foundation/editor/view/base/Canvas";
    import { V3dAssetManager } from "foundation/editor/view/view3d/asset/V3dAssetManager";
    import { V3dGizmo } from "foundation/editor/view/view3d/gizmo/V3dGizmo";
    import { V3dGizmoManager } from "foundation/editor/view/view3d/gizmo/V3dGizmoManager";
    import { V3dIndicatorManager } from "foundation/editor/view/view3d/indicator/V3dIndicatorManager";
    import { V3dLightManager } from "foundation/editor/view/view3d/light/V3dLightManager";
    import { V3dSelectionManager } from "foundation/editor/view/view3d/selection/V3dSelectionManager";
    import { V3dSelector } from "foundation/editor/view/view3d/selection/V3dSelector";
    import { V3dVisionManager } from "foundation/editor/view/view3d/vision/V3dVisionManager";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dScenes } from "foundation/editor/view/view3d/V3dScenes";
    export class V3dCanvas extends Canvas {
        htmlContainer: HTMLElement;
        htmlCanvas: HTMLCanvasElement;
        context: V3dCanvasContext;
        engineCode: string;
        renderCd: RenderEnum;
        renderManager: RenderManager;
        assetManager: V3dAssetManager;
        lightManager: V3dLightManager;
        visionManager: V3dVisionManager;
        selectionManager: V3dSelectionManager;
        gizmoManager: V3dGizmoManager;
        indicatorManager: V3dIndicatorManager;
        selector: V3dSelector;
        scenes: V3dScenes;
        clipCallback: any;
        protected _htmlCurrentContainer: HTMLElement;
        protected _eventHook: ScreenEventHook;
        protected _speed: Speed;
        statusFreezeStructure: boolean;
        protected _screenService: ScreenDeviceService;
        constructor();
        get statusInitialized(): boolean;
        createContext(): V3dCanvasContext;
        onSetupAsync(): Promise<ResultObject>;
        setupAsync(): Promise<ResultObject>;
        onActive(): void;
        onDeactive(): void;
        addNodeToLayer(gizmo: V3dGizmo): void;
        removeNodeFromLayer(gizmo: V3dGizmo): void;
        onResize(sender?: ListenerContext, event?: ResizeEvent): void;
        process(viewContext: ViewContext): void;
        show(): void;
        getImageData(width?: number, height?: number): Blob;
        adjustCamera(): void;
        doClip(func: any): void;
        clear(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/base/LayerGroupTypeEnum" {
    export class LayerGroupTypeEnum {
        static Background: string;
        static Structure: string;
        static Content: string;
        static Assistant: string;
    }
}
declare module "foundation/editor/view/view3d/V3dLayers" {
    import { Layers } from "foundation/editor/view/base/Layers";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    import { V3dLayerGroup } from "foundation/editor/view/view3d/V3dLayerGroup";
    import { V3dScene } from "foundation/editor/view/view3d/V3dScene";
    export class V3dLayers extends Layers {
        context: V3dCanvasContext;
        backgroundLayerGroup: V3dLayerGroup;
        depthLayerGroup: V3dLayerGroup;
        contentLayerGroup: V3dLayerGroup;
        assistantLayerGroup: V3dLayerGroup;
        template: V3dLayer;
        pick: V3dLayer;
        environment: V3dLayer;
        depth: V3dLayer;
        structure: V3dLayer;
        contentBase: V3dLayer;
        contentSurface: V3dLayer;
        contentDecorate: V3dLayer;
        contentLayout: V3dLayer;
        content: V3dLayer;
        dimension: V3dLayer;
        hover: V3dLayer;
        assistant: V3dLayer;
        indicator: V3dLayer;
        wall: V3dLayer;
        createLayerGroup(name: string, level: number, scene?: V3dScene): V3dLayerGroup;
        createLayer(name: string, scene?: V3dScene): V3dLayer;
        setup(): void;
    }
}
declare module "foundation/editor/view/view3d/V3dCanvasContext" {
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { V3dAssetEffectManager } from "foundation/editor/view/view3d/asset/material/V3dAssetEffectManager";
    import { V3dAssetMaterialManager } from "foundation/editor/view/view3d/asset/material/V3dAssetMaterialManager";
    import { V3AssetdModelManager } from "foundation/editor/view/view3d/asset/model/V3AssetdModelManager";
    import { V3dGraphicLayer } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLayer";
    import { V3dGraphicRenderer } from "foundation/editor/view/view3d/render/graphic/V3dGraphicRenderer";
    import { V3dGraphicRenderFactory } from "foundation/editor/view/view3d/render/graphic/V3dGraphicRenderFactory";
    import { V3dGraphicScene } from "foundation/editor/view/view3d/render/graphic/V3dGraphicScene";
    import { V3dAssetManager } from "foundation/editor/view/view3d/asset/V3dAssetManager";
    import { V3dLightManager } from "foundation/editor/view/view3d/light/V3dLightManager";
    import { V3dSelectionManager } from "foundation/editor/view/view3d/selection/V3dSelectionManager";
    import { V3dVisionManager } from "foundation/editor/view/view3d/vision/V3dVisionManager";
    import { V3dCanvas } from "foundation/editor/view/view3d/V3dCanvas";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    import { V3dLayers } from "foundation/editor/view/view3d/V3dLayers";
    import { V3dScenes } from "foundation/editor/view/view3d/V3dScenes";
    export class V3dCanvasContext extends CanvasContext {
        optionPhysics: boolean;
        canvas: V3dCanvas;
        htmlCanvas: HTMLCanvasElement;
        scenes: V3dScenes;
        layers: V3dLayers;
        optionMaster: boolean;
        renderFactory: V3dGraphicRenderFactory;
        renderer: V3dGraphicRenderer;
        assetManager: V3dAssetManager;
        modelManager: V3AssetdModelManager;
        materialManager: V3dAssetMaterialManager;
        lightManager: V3dLightManager;
        visionManager: V3dVisionManager;
        selectionManager: V3dSelectionManager;
        effectManager: V3dAssetEffectManager;
        graphicEngine: any;
        graphicView: any;
        graphicScene: V3dGraphicScene;
        graphicTestScene: any;
        graphicCamera: any;
        forground: boolean;
        protected _dirtyFrame: boolean;
        protected _dirtyFrameCount: number;
        constructor();
        get templateLayer(): V3dLayer;
        get templateNode(): V3dGraphicLayer;
        get pickLayer(): V3dLayer;
        get pickNode(): V3dGraphicLayer;
        isDirtyFrame(): boolean;
        onDataLoad: () => void;
        dirtyFrame(count?: number): void;
        reset(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicObject" {
    import { GraphicObject } from "foundation/editor/view/base/graphic/GraphicObject";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dGraphicRenderFactory } from "foundation/editor/view/view3d/render/graphic/V3dGraphicRenderFactory";
    export class V3dGraphicObject extends GraphicObject {
        context: V3dCanvasContext;
        factory: V3dGraphicRenderFactory;
        setup(): void;
        update(): void;
        dirty(): void;
        freeze(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicNode" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { V3dGraphicObject } from "foundation/editor/view/view3d/render/graphic/V3dGraphicObject";
    export class V3dGraphicNode extends V3dGraphicObject {
        handle: any;
        protected _children: Types<V3dGraphicNode>;
        get className(): string;
        get optionEnabled(): boolean;
        set optionEnabled(value: boolean);
        get parent(): V3dGraphicNode;
        set parent(parent: V3dGraphicNode);
        get children(): Types<V3dGraphicNode>;
        addChild(node: V3dGraphicNode): void;
        removeChild(node: V3dGraphicNode): void;
        disposeChildren(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicContent" {
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { V3dGraphicContentUsageEnum } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContentUsageEnum";
    import { V3dGraphicNode } from "foundation/editor/view/view3d/render/graphic/V3dGraphicNode";
    export class V3dGraphicContent extends V3dGraphicNode {
        protected _useageCd: V3dGraphicContentUsageEnum;
        protected _position: Vector3;
        protected _rotation: Vector3;
        protected _scale: Vector3;
        get optionCulling(): boolean;
        set optionCulling(value: boolean);
        get optionVisible(): boolean;
        set optionVisible(visible: boolean);
        get isVisible(): boolean;
        set isVisible(value: boolean);
        get optionPickable(): boolean;
        set optionPickable(value: boolean);
        get isPickable(): boolean;
        set isPickable(value: boolean);
        get optionStatic(): boolean;
        set optionStatic(value: boolean);
        get optionStaticTransform(): boolean;
        set optionStaticTransform(value: boolean);
        get optionBoundary(): boolean;
        set optionBoundary(value: boolean);
        get optionBoundaryDepth(): boolean;
        set optionBoundaryDepth(value: boolean);
        get groupLevel(): number;
        set groupLevel(value: number);
        get layerLevel(): number;
        set layerLevel(value: number);
        get pickLevel(): number;
        set pickLevel(value: number);
        get useageCd(): V3dGraphicContentUsageEnum;
        setUseageCd(useageCd: V3dGraphicContentUsageEnum): void;
        get position(): Readonly<Value3>;
        setPosition(x: number, y: number, z: number): void;
        get rotation(): Readonly<Value3>;
        setRotation(x: number, y: number, z: number): void;
        get scale(): Readonly<Value3>;
        setScale(x: number, y: number, z: number): void;
        freezeWorldMatrix(force?: boolean): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicCamera" {
    import { CoordinateEnum } from 'foundation/runtime/math/CoordinateEnum';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    export class V3dGraphicCamera extends V3dGraphicContent {
        coordinateCd: CoordinateEnum;
        handle: any;
        type: string;
        protected _upAxis: Vector3;
        constructor();
        set mode(value: any);
        get upVector(): any;
        setUpAxis(x: any, y: number, z: number): void;
        get target(): any;
        setTarget(x: any, y: number, z: number): void;
        getViewMatrix(): Matrix4;
        getProjectionMatrix(): Matrix4;
        set inertia(value: any);
        set wheelPrecision(value: any);
        set upperBetaLimit(value: any);
        set lowerRadiusLimit(value: any);
        set upperRadiusLimit(value: any);
        set allowUpsideDown(value: any);
        set lowerBetaLimit(value: any);
        set alpha(value: any);
        set beta(value: any);
        set radius(value: any);
        set orthoLeft(value: any);
        set orthoTop(value: any);
        set orthoRight(value: any);
        set orthoBottom(value: any);
        get minZ(): number;
        set minZ(value: number);
        get maxZ(): number;
        set maxZ(value: number);
        get fov(): number;
        set fov(value: number);
        computeWorldMatrix(): void;
    }
}
declare module "foundation/editor/view/action/camera/CameraOrthogonalAction" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { CameraAction } from "foundation/editor/view/action/camera/CameraAction";
    import { CameraActionEvent } from "foundation/editor/view/action/camera/CameraActionEvent";
    export class CameraOrthogonalAction extends CameraAction {
        protected _lastPosition: Vector3;
        protected _lastTarget: Vector3;
        protected _lastAlpha: number;
        protected _lastBeta: number;
        protected _lastViewPoint: Vector2;
        protected _lastRadius: number;
        protected _statusMouseDown: boolean;
        protected _statusDirty: boolean;
        protected _pressedKey: Types<number>;
        protected _selectionService: SelectionService;
        constructor();
        isMouseDown(): boolean;
        protected isKeyUp(): boolean;
        protected addPressedKey(keyCode: number): void;
        protected removePressedKey(keyCode: number): void;
        protected moveTarget(offset: Value3): void;
        protected movePosition(offset: Value3): void;
        protected moveOffset(offset: Value3): void;
        protected processZoom(event: CameraActionEvent): void;
        onExecute(event: CameraActionEvent): void;
        onReceive(code: string, event: any): boolean;
    }
}
declare module "foundation/editor/view/action/camera/CameraRenderAction" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { CameraAction } from "foundation/editor/view/action/camera/CameraAction";
    import { CameraActionEvent } from "foundation/editor/view/action/camera/CameraActionEvent";
    export class CameraRenderAction extends CameraAction {
        protected _srcPosition: Vector3;
        protected _srcTarget: Vector3;
        protected _lastViewPoint: Vector2;
        protected _lastRadius: number;
        protected _statusMouseDown: boolean;
        protected _statusDirty: boolean;
        protected _pressedKey: Types<number>;
        protected _srcPicth: number;
        protected _srcYaw: number;
        protected _curPicth: number;
        protected _curYaw: number;
        protected _curDir: Vector3;
        protected _curTarget: Vector3;
        protected _curPosition: Vector3;
        private useSnap;
        constructor();
        isMouseDown(): boolean;
        protected isKeyUp(): boolean;
        protected addPressedKey(keyCode: number): void;
        protected removePressedKey(keyCode: number): void;
        protected moveTarget(offset: Value3): void;
        protected movePosition(offset: Value3): void;
        protected moveOffsetLocal(offset: Value3): void;
        protected moveOffset(offset: Value3): void;
        protected processZoom(event: CameraActionEvent): void;
        onExecute(event: CameraActionEvent): void;
        protected correntYaw(): void;
        protected radius(camera: ObserverViewNode): number;
        isOverSideByPos(x: number, y: number): boolean;
        isOverSideByOffset(x: number, y: number): boolean;
        protected calTarget(): void;
        protected someDirCalTarget(): void;
        protected moveTo(pos: Vector3): void;
        protected setYaw(val: number): void;
        protected moveAndRot(pos: Vector3, yaw: number): void;
        protected processDragMove(event: CameraActionEvent): void;
        onReceive(code: string, event: any): boolean;
        setSnap(snap: boolean): void;
        getCurrentPicth(): number;
        getCurrentHeight(): number;
    }
}
declare module "foundation/editor/view/action/dimension/DimensionActionEvent" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    export class DimensionActionEvent extends ActionEvent {
        entity: DataNode;
        visible: boolean;
        protected _entities: Types<DataNode>;
        constructor();
        get entities(): Types<DataNode>;
        free(): void;
    }
}
declare module "foundation/editor/view/action/dimension/DimensionDisplayAction" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { Action } from "foundation/editor/view/action/Action";
    import { DimensionActionEvent } from "foundation/editor/view/action/dimension/DimensionActionEvent";
    export class DimensionDisplayAction extends Action {
        constructor();
        protected switchFlag(entity: DataNode, visible: boolean, deep: boolean): void;
        onExecute(event: DimensionActionEvent): boolean;
    }
}
declare module "foundation/editor/view/base/ObserverController" {
    import { ObserverNode } from 'foundation/data/common/model/brep/ObserverNode';
    import { DisplayController } from "foundation/editor/view/base/DisplayController";
    export class ObserverController extends DisplayController {
        entity: ObserverNode;
    }
}
declare module "foundation/editor/view/view3d/V3dObserverController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { CameraActionEvent } from "foundation/editor/view/action/camera/CameraActionEvent";
    import { ObserverController } from "foundation/editor/view/base/ObserverController";
    export class V3dObserverController extends ObserverController {
        processCameraAction(event: CameraActionEvent): void;
        processDimensionAction(visible: boolean): void;
        onDispatchEvent(code: string, event: any): boolean;
        onDragStart(sender: ListenerContext, event: CameraActionEvent): void;
        onDragMove(sender: ListenerContext, event: CameraActionEvent): void;
        onMouseWheel(sender: ListenerContext, event: CameraActionEvent): void;
        onKeyDown(sender: ListenerContext, event: CameraActionEvent): void;
        protected onCameraFit(event: CameraActionEvent): void;
    }
}
declare module "foundation/editor/view/view3d/camera/CameraTypeEnum" {
    export class CameraTypeEnum {
        static FreeCamera: string;
        static ArcRotateCamera: string;
    }
}
declare module "foundation/editor/view/base/camera/Camera" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { KeyboardDeviceEvent } from 'cross/editor/device/keyboard/KeyboardDeviceEvent';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { WheelDeviceEvent } from 'cross/editor/device/mouse/WheelDeviceEvent';
    import { ObserverNode } from 'foundation/data/common/model/brep/ObserverNode';
    import { FrameEvent } from 'foundation/editor/base/core/FrameEvent';
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    import { ActionService } from "foundation/editor/view/action/ActionService";
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { ObserverController } from "foundation/editor/view/base/ObserverController";
    export class Camera extends Dispatcher {
        context: CanvasContext;
        entity: ObserverNode;
        enabled: boolean;
        controller: ObserverController;
        statusActive: boolean;
        protected _actionService: ActionService;
        constructor();
        setup(): void;
        onFrameEnter(sender: ListenerContext, event: FrameEvent): void;
        onFrameLeave(sender: ListenerContext, event: FrameEvent): void;
        onActionBegin(sender: ListenerContext, event: ActionEvent): void;
        onActionEnd(sender: ListenerContext, event: ActionEvent): void;
        onMouseEnter(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragStart(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragMove(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragEnd(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;
        onMouseWheel(sender: ListenerContext, event: WheelDeviceEvent): void;
        onKeyDown(sender: ListenerContext, event: KeyboardDeviceEvent): void;
        onKeyUp(sender: ListenerContext, event: KeyboardDeviceEvent): void;
        protected onEnable(): void;
        enable(force?: boolean): boolean;
        protected onDisable(): void;
        disable(force?: boolean): boolean;
        active(enable?: boolean): void;
        deactive(): void;
        update(): void;
        reset(observer?: ObserverNode): void;
        fit(parameter?: any): void;
    }
}
declare module "foundation/editor/view/view3d/camera/V3dCamera" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { WheelDeviceEvent } from 'cross/editor/device/mouse/WheelDeviceEvent';
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { Camera } from "foundation/editor/view/base/camera/Camera";
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    import { V3dGraphicCamera } from "foundation/editor/view/view3d/render/graphic/V3dGraphicCamera";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dObserverController } from "foundation/editor/view/view3d/V3dObserverController";
    export class V3dCamera extends Camera {
        context: V3dCanvasContext;
        entity: ObserverViewNode;
        controller: V3dObserverController;
        statusLocked: boolean;
        graphicCamera: V3dGraphicCamera;
        onActionEnd(context: ListenerContext, event: ActionEvent): void;
        onMouseLeave(sender: ListenerContext, event: MouseDeviceEvent): void;
        onMouseWheel(sender: ListenerContext, event: WheelDeviceEvent): void;
    }
}
declare module "foundation/editor/view/view3d/camera/V3dMoveCamera" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { KeyboardDeviceEvent } from 'cross/editor/device/keyboard/KeyboardDeviceEvent';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ObserverViewEntity } from "foundation/editor/view/entity/ObserverViewEntity";
    import { V3dCamera } from "foundation/editor/view/view3d/camera/V3dCamera";
    export class V3dMoveCamera extends V3dCamera {
        entity: ObserverViewEntity;
        protected _draggingFlag: boolean;
        protected _moveForward: boolean;
        protected _moveBackward: boolean;
        protected _moveLeft: boolean;
        protected _moveRight: boolean;
        protected _moveDown: boolean;
        protected _moveUp: boolean;
        protected _shift: boolean;
        protected _draggingOriginPoint: Vector2;
        protected _draggingOriginDirection: Vector3;
        protected _draggingOriginPitch: number;
        protected _draggingOriginLength: number;
        constructor();
        onMouseUp(sender: ListenerContext, event: MouseDeviceEvent): void;
        protected setMouseStyle(open: boolean): void;
        onDragStart(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragEnd(sender: ListenerContext, event: MouseDeviceEvent): void;
        onKeyDown(sender: ListenerContext, event: KeyboardDeviceEvent): void;
        onKeyUp(sender: ListenerContext, event: KeyboardDeviceEvent): void;
    }
}
declare module "foundation/editor/view/view3d/camera/V3dAerialViewCamera" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { QualityService } from 'cross/runtime/framework/quality/QualityService';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ObserverNode } from 'foundation/data/common/model/brep/ObserverNode';
    import { FrameEvent } from 'foundation/editor/base/core/FrameEvent';
    import { V3dMoveCamera } from "foundation/editor/view/view3d/camera/V3dMoveCamera";
    export class V3dAerialViewCamera extends V3dMoveCamera {
        protected _moveOffset: Vector3;
        protected _frameOffset: Vector3;
        protected _draggingMovePoint: Vector2;
        protected _draggingOrthoPoint: Vector2;
        protected _viewPosition: Vector3;
        protected _viewTarget: Vector3;
        protected _qualityService: QualityService;
        constructor();
        setup(): void;
        processMove(direction: Vector3, rate: number): void;
        onFrameEnter(context: ListenerContext, event: FrameEvent): void;
        onMouseDown(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragStart(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragMove(sender: ListenerContext, event: MouseDeviceEvent): void;
        update(): void;
        reset(observer?: ObserverNode): void;
        fit(box: Box3): void;
    }
}
declare module "foundation/editor/view/view3d/camera/V3dArcRotateCamera" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { QualityService } from 'cross/runtime/framework/quality/QualityService';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ObserverNode } from 'foundation/data/common/model/brep/ObserverNode';
    import { FrameEvent } from 'foundation/editor/base/core/FrameEvent';
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    import { V3dMoveCamera } from "foundation/editor/view/view3d/camera/V3dMoveCamera";
    export class V3dArcRotateCamera extends V3dMoveCamera {
        protected _moveOffset: Vector3;
        protected _frameOffset: Vector3;
        protected _draggingMovePoint: Vector2;
        protected _draggingOrthoPoint: Vector2;
        protected _qualityService: QualityService;
        constructor();
        setup(): void;
        processMove(offset: Vector3, rate: number): void;
        onFrameEnter(context: ListenerContext, event: FrameEvent): void;
        onActionBegin(context: ListenerContext, event: ActionEvent): void;
        onMouseDown(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragStart(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragMove(sender: ListenerContext, event: MouseDeviceEvent): void;
        switchToPerspective(): void;
        switchToOrthographic(): void;
        update(): void;
        reset(observer?: ObserverNode): void;
        protected getBlueprintBox(observer: ObserverNode): Box3;
        fit(box: Box3): void;
    }
}
declare module "foundation/editor/view/view3d/camera/V3dFirstPersonCamera" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { WheelDeviceEvent } from 'cross/editor/device/mouse/WheelDeviceEvent';
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ObserverNode } from 'foundation/data/common/model/brep/ObserverNode';
    import { FrameEvent } from 'foundation/editor/base/core/FrameEvent';
    import { V3dMoveCamera } from "foundation/editor/view/view3d/camera/V3dMoveCamera";
    export class V3dFirstPersonCamera extends V3dMoveCamera {
        protected _cameraOriginPitch: number;
        protected _minPitch: number;
        protected _maxPitch: number;
        protected _moveOffset: Vector3;
        protected _frameOffset: Vector3;
        protected _touchLocation: any;
        protected _originDirection: Vector3;
        protected _currentZoom: number;
        protected _targetZoom: number;
        protected _targetWheelDelta: number;
        protected _curWheelDelta: number;
        constructor();
        setup(): void;
        processMove(direction: Vector3, rate: number): void;
        resetZoom(): void;
        onFrameEnter(context: ListenerContext, event: FrameEvent): void;
        onDragStart(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragMove(sender: ListenerContext, event: MouseDeviceEvent): void;
        onMouseDown(sender: ListenerContext, event: MouseDeviceEvent): void;
        update(): void;
        fit(box: Box3): void;
        reset(observer?: ObserverNode): void;
        onMouseWheel(sender: ListenerContext, event: WheelDeviceEvent): void;
    }
}
declare module "foundation/editor/view/view3d/camera/V3dOrthogonalCamera" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { WheelDeviceEvent } from 'cross/editor/device/mouse/WheelDeviceEvent';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ObserverModeEnum } from 'foundation/data/common/model/brep/ObserverModeEnum';
    import { ObserverNode } from 'foundation/data/common/model/brep/ObserverNode';
    import { FrameEvent } from 'foundation/editor/base/core/FrameEvent';
    import { V3dGraphicCamera } from "foundation/editor/view/view3d/render/graphic/V3dGraphicCamera";
    import { V3dMoveCamera } from "foundation/editor/view/view3d/camera/V3dMoveCamera";
    export class V3dOrthogonalCamera extends V3dMoveCamera {
        graphicCamera: V3dGraphicCamera;
        protected _cameraOriginPitch: number;
        protected _minPitch: number;
        protected _maxPitch: number;
        protected _moveOffset: Vector3;
        protected _frameOffset: Vector3;
        protected _touchLocation: any;
        protected _originDirection: Vector3;
        protected _viewAxis: Vector3;
        protected _targetPoint: Vector3;
        protected _cameraDirection: Vector2;
        protected _distCurToOri: number;
        protected _lastDraggingPoint: Vector2;
        protected _moveFactor: number;
        protected _maxZoomFactor: number;
        constructor();
        setup(): void;
        set modeCd(modeCd: ObserverModeEnum);
        get modeCd(): ObserverModeEnum;
        processMove(direction: Vector3, rate: number): void;
        processMouseMove(moveOffset: Vector3): void;
        onFrameEnter(context: ListenerContext, event: FrameEvent): void;
        onMouseDown(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragStart(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragMove(sender: ListenerContext, event: MouseDeviceEvent): void;
        onMouseWheel(sender: ListenerContext, event: WheelDeviceEvent): void;
        update(): void;
        reset(observer?: ObserverNode): void;
        updateMode(): void;
        focusPoint(position: Vector3, target: Vector3): void;
        onCanvasSizeChanged(): void;
    }
}
declare module "foundation/editor/view/view3d/camera/V3dRenderCamera" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { WheelDeviceEvent } from 'cross/editor/device/mouse/WheelDeviceEvent';
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ObserverNode } from 'foundation/data/common/model/brep/ObserverNode';
    import { FrameEvent } from 'foundation/editor/base/core/FrameEvent';
    import { V3dMoveCamera } from "foundation/editor/view/view3d/camera/V3dMoveCamera";
    export class V3dRenderCamera extends V3dMoveCamera {
        protected _cameraOriginPitch: number;
        protected _minPitch: number;
        protected _maxPitch: number;
        protected _moveOffset: Vector3;
        protected _frameOffset: Vector3;
        protected _touchLocation: any;
        protected _originDirection: Vector3;
        protected _currentZoom: number;
        protected _targetZoom: number;
        protected _targetWheelDelta: number;
        protected _curWheelDelta: number;
        constructor();
        setup(): void;
        processMove(direction: Vector3, rate: number): void;
        resetZoom(): void;
        onFrameEnter(context: ListenerContext, event: FrameEvent): void;
        onDragStart(sender: ListenerContext, event: MouseDeviceEvent): void;
        onDragMove(sender: ListenerContext, event: MouseDeviceEvent): void;
        onMouseDown(sender: ListenerContext, event: MouseDeviceEvent): void;
        update(): void;
        fit(box: Box3): void;
        reset(observer?: ObserverNode): void;
        onMouseWheel(sender: ListenerContext, event: WheelDeviceEvent): void;
    }
}
declare module "foundation/editor/view/view3d/V3dObserver" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { KeyboardDeviceEvent } from 'cross/editor/device/keyboard/KeyboardDeviceEvent';
    import { MouseDeviceEvent } from 'cross/editor/device/mouse/MouseDeviceEvent';
    import { WheelDeviceEvent } from 'cross/editor/device/mouse/WheelDeviceEvent';
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { ObserverNode } from 'foundation/data/common/model/brep/ObserverNode';
    import { FrameEvent } from 'foundation/editor/base/core/FrameEvent';
    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 { V3dGraphicCamera } from "foundation/editor/view/view3d/render/graphic/V3dGraphicCamera";
    import { V3dAerialViewCamera } from "foundation/editor/view/view3d/camera/V3dAerialViewCamera";
    import { V3dArcRotateCamera } from "foundation/editor/view/view3d/camera/V3dArcRotateCamera";
    import { V3dCamera } from "foundation/editor/view/view3d/camera/V3dCamera";
    import { V3dFirstPersonCamera } from "foundation/editor/view/view3d/camera/V3dFirstPersonCamera";
    import { V3dOrthogonalCamera } from "foundation/editor/view/view3d/camera/V3dOrthogonalCamera";
    import { V3dRenderCamera } from "foundation/editor/view/view3d/camera/V3dRenderCamera";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dObserverController } from "foundation/editor/view/view3d/V3dObserverController";
    export class V3dObserver extends Observer {
        context: V3dCanvasContext;
        entity: ObserverNode;
        controller: V3dObserverController;
        firstPersonCamera: V3dFirstPersonCamera;
        aerialViewCamera: V3dAerialViewCamera;
        renderCamera: V3dRenderCamera;
        arcRotateCamera: V3dArcRotateCamera;
        orthogonalCamera: V3dOrthogonalCamera;
        activeCamera: V3dCamera;
        protected _canvasSizeChanged: boolean;
        protected _statusFieldChanged: boolean;
        protected _cameraDirection: Vector2;
        protected _cameraTarget: Vector3;
        protected _statusTypeChanged: boolean;
        protected _modeFlag: any;
        protected _draggingFlag: boolean;
        protected _statusMouseDown: boolean;
        protected _mouseDownPoint: Vector2;
        constructor();
        setup(): void;
        get activeGraphicCamera(): any;
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        setMainCamera(camera: V3dGraphicCamera): void;
        setViewCamera(camera: V3dGraphicCamera): void;
        processModeChanged(force?: boolean): void;
        processCameraChanged(): void;
        onFrameEnter(sender: ListenerContext, event: FrameEvent): void;
        onFrameLeave(sender: ListenerContext, event: FrameEvent): void;
        onActionBegin(sender: ListenerContext, event: ActionEvent): void;
        onActionEnd(sender: ListenerContext, event: ActionEvent): 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;
        onMouseWheel(sender: ListenerContext, event: WheelDeviceEvent): void;
        onKeyDown(sender: ListenerContext, event: KeyboardDeviceEvent): void;
        onKeyUp(sender: ListenerContext, event: KeyboardDeviceEvent): void;
        onActivate(): void;
        onDeactivate(): void;
        onCanvasSizeChanged(sender: any, event: any): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        draw(displayContext: DisplayContext): void;
        reset(): void;
        switchObserver(newObserver: ObserverViewEntity): void;
        fit(box: Box3): void;
        lock(flag: boolean): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/action/camera/CameraFitAction" {
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { V3dObserver } from "foundation/editor/view/view3d/V3dObserver";
    import { CameraAction } from "foundation/editor/view/action/camera/CameraAction";
    import { CameraActionEvent } from "foundation/editor/view/action/camera/CameraActionEvent";
    export class CameraFitAction extends CameraAction {
        protected _observer: V3dObserver;
        protected _observerNode: ObserverViewNode;
        constructor();
        onExecute(event: CameraActionEvent): void;
        onUndo(): void;
        onRedo(): void;
    }
}
declare module "foundation/editor/view/action/camera/CameraFitRotationAction" {
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { V3dObserver } from "foundation/editor/view/view3d/V3dObserver";
    import { CameraAction } from "foundation/editor/view/action/camera/CameraAction";
    import { CameraActionEvent } from "foundation/editor/view/action/camera/CameraActionEvent";
    export class CameraFitRotationAction extends CameraAction {
        protected _observer: V3dObserver;
        protected _observerNode: ObserverViewNode;
        constructor();
        onExecute(event: CameraActionEvent): void;
        onUndo(): void;
        onRedo(): void;
    }
}
declare module "foundation/editor/view/action/camera/CameraResetEvent" {
    import { Size2 } from 'foundation/runtime/math/Size2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { ObserverModeEnum } from 'foundation/data/common/model/brep/ObserverModeEnum';
    import { ObserverTypeEnum } from 'foundation/data/common/model/brep/ObserverTypeEnum';
    import { Canvas } from "foundation/editor/view/base/Canvas";
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    export class CameraResetEvent extends ActionEvent {
        view: Canvas;
        entity: ObserverViewNode;
        typeCd: ObserverTypeEnum;
        modeCd: ObserverModeEnum;
        protected _screenPoint: Vector2;
        protected _screenOffset: Vector2;
        protected _point: Vector3;
        protected _offset: Vector3;
        protected _viewSize: Size2;
        protected _viewPoint: Vector2;
        protected _viewOffset: Vector2;
        viewScale: number;
        protected _movePoint: Vector3;
        protected _moveTarget: Vector3;
        alpha: number;
        beta: number;
        pitch: number;
        yaw: number;
        radius: number;
        zoom: number;
        withTarget: boolean;
        locked: boolean;
        reset: boolean;
        cameraTarget: Vector3;
        cameraPos: Vector3;
        box: BoxSolid;
        canvasWidth: number;
        canvasHeight: number;
        cameraFov: number;
        oldOrthPos: Vector3;
        newOrthPos: Vector3;
        oldOrthZoom: Number;
        newOrthZoom: number;
        constructor();
        get screenPoint(): Vector2;
        get screenOffset(): Vector2;
        get point(): Vector3;
        get offset(): Vector3;
        get viewPoint(): Vector2;
        get viewSize(): Size2;
        get viewOffset(): Vector2;
        get movePoint(): Vector3;
        get moveTarget(): Vector3;
        free(): void;
    }
}
declare module "foundation/editor/view/action/camera/CameraResetAction" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { V3dObserver } from "foundation/editor/view/view3d/V3dObserver";
    import { CameraAction } from "foundation/editor/view/action/camera/CameraAction";
    import { CameraResetEvent } from "foundation/editor/view/action/camera/CameraResetEvent";
    export class CameraResetAction extends CameraAction {
        protected _observer: V3dObserver;
        protected _observerNode: ObserverViewNode;
        oldOrthPos: Vector3;
        newOrthPos: Vector3;
        oldOrthZoom: number;
        newOrthZoom: number;
        constructor();
        onExecute(event: CameraResetEvent): void;
        onUndo(): void;
        onRedo(): void;
    }
}
declare module "foundation/editor/view/action/camera/CameraSwitchEvent" {
    import { Size2 } from 'foundation/runtime/math/Size2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { ObserverModeEnum } from 'foundation/data/common/model/brep/ObserverModeEnum';
    import { ObserverTypeEnum } from 'foundation/data/common/model/brep/ObserverTypeEnum';
    import { Canvas } from "foundation/editor/view/base/Canvas";
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    export class CameraSwitchEvent extends ActionEvent {
        view: Canvas;
        entity: ObserverViewNode;
        typeCd: ObserverTypeEnum;
        modeCd: ObserverModeEnum;
        protected _screenPoint: Vector2;
        protected _screenOffset: Vector2;
        protected _point: Vector3;
        protected _offset: Vector3;
        protected _viewSize: Size2;
        protected _viewPoint: Vector2;
        protected _viewOffset: Vector2;
        viewScale: number;
        protected _movePoint: Vector3;
        protected _moveTarget: Vector3;
        alpha: number;
        beta: number;
        pitch: number;
        yaw: number;
        radius: number;
        zoom: number;
        withTarget: boolean;
        locked: boolean;
        reset: boolean;
        cameraTarget: Vector3;
        cameraPos: Vector3;
        box: BoxSolid;
        canvasWidth: number;
        canvasHeight: number;
        cameraFov: number;
        oldOrthPos: Vector3;
        newOrthPos: Vector3;
        oldOrthZoom: Number;
        newOrthZoom: number;
        constructor();
        get screenPoint(): Vector2;
        get screenOffset(): Vector2;
        get point(): Vector3;
        get offset(): Vector3;
        get viewPoint(): Vector2;
        get viewSize(): Size2;
        get viewOffset(): Vector2;
        get movePoint(): Vector3;
        get moveTarget(): Vector3;
        free(): void;
    }
}
declare module "foundation/editor/view/action/camera/CameraSwitchAction" {
    import { Size2 } from 'foundation/runtime/math/Size2';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    import { ObserverModeEnum } from 'foundation/data/common/model/brep/ObserverModeEnum';
    import { ObserverTypeEnum } from 'foundation/data/common/model/brep/ObserverTypeEnum';
    import { CameraAction } from "foundation/editor/view/action/camera/CameraAction";
    import { CameraSwitchEvent } from "foundation/editor/view/action/camera/CameraSwitchEvent";
    export type CameraSwitchHistory = {
        modeCd: ObserverModeEnum;
        typeCd: ObserverTypeEnum;
    };
    export class CameraSwitchAction extends CameraAction {
        protected _oldContent: CameraSwitchHistory;
        protected _newContent: CameraSwitchHistory;
        protected _box: BoxSolid;
        protected _viewPort: Size2;
        protected _observerNode: ObserverViewNode;
        constructor();
        private changeCameraMode;
        onExecute(event: CameraSwitchEvent): void;
        onUndo(): void;
        onRedo(): void;
    }
}
declare module "foundation/editor/view/action/canvas/CanvasOptionEvent" {
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    export class CanvasOptionEvent extends ActionEvent {
        eventName: string;
        constructor();
        free(): void;
    }
}
declare module "foundation/editor/view/action/clip/ClipActionEvent" {
    import { ElementNode } from 'foundation/data/common/element/ElementNode';
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    export class ClipActionEvent extends ActionEvent {
        parent: ElementNode;
        content: any;
        type: any;
        params: any;
        callback: any;
        assign(event: ClipActionEvent): void;
        free(): void;
    }
}
declare module "foundation/editor/view/action/clip/ClipCopyAction" {
    import { EditorClipService } from 'foundation/editor/base/service/clip/EditorClipService';
    import { Action } from "foundation/editor/view/action/Action";
    import { ClipActionEvent } from "foundation/editor/view/action/clip/ClipActionEvent";
    export class ClipCopyAction extends Action {
        content: any;
        protected _editorClipService: EditorClipService;
        constructor();
        onExecute(event: ClipActionEvent): void;
        onUndo(): void;
        onRedo(): void;
    }
}
declare module "foundation/editor/view/action/clip/ClipPasteAction" {
    import { ElementNode } from 'foundation/data/common/element/ElementNode';
    import { EditorClipService } from 'foundation/editor/base/service/clip/EditorClipService';
    import { ActionResult } from "foundation/editor/view/action/ActionResult";
    import { AsyncAction } from "foundation/editor/view/action/AsyncAction";
    import { ClipActionEvent } from "foundation/editor/view/action/clip/ClipActionEvent";
    export class ClipPasteAction extends AsyncAction {
        type: any;
        parent: ElementNode;
        callback: any;
        protected _editorClipService: EditorClipService;
        constructor();
        onExecuteAsync(event: ClipActionEvent): Promise<ActionResult>;
    }
}
declare module "foundation/editor/view/action/clip/command/AffiliatedHardwareRuleCopyClipCommand" {
    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';
    import { RuleItemElement } from 'sk/data/family/rule/element/instance/RuleItemElement';
    import { Element } from 'sk/data/family/element/base/Element';
    export class AffiliatedHardwareRuleCopyClipCommand extends EditorClipCommand {
        copyToData(context: EditorClipContext, content: Element): EditorClipData;
        pasteToContent(context: EditorClipContext, data: EditorClipData): RuleItemElement;
    }
}
declare module "foundation/editor/view/action/clip/command/ComponentInstanceElementClipCommand" {
    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';
    import { ComponentInstanceElement } from 'sk/data/family/element/component/ComponentInstanceElement';
    export class ComponentInstanceElementClipCommand extends EditorClipCommand {
        copyToData(context: EditorClipContext, content: ComponentInstanceElement): EditorClipData;
        pasteToContent(context: EditorClipContext, data: EditorClipData): ComponentInstanceElement;
    }
}
declare module "foundation/editor/view/action/clip/command/DefaultElementClipCommand" {
    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';
    import { Element } from 'sk/data/family/element/base/Element';
    export class DefaultElementClipCommand extends EditorClipCommand {
        copyToData(context: EditorClipContext, content: Element): EditorClipData;
        pasteToContent(context: EditorClipContext, data: EditorClipData): Element;
    }
}
declare module "foundation/editor/view/action/clip/command/DefaultElementMultiClipCommand" {
    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 DefaultElementMultiClipCommand extends EditorClipCommand {
        copyToData(context: EditorClipContext, content: any): EditorClipData;
        pasteToContent(context: EditorClipContext, data: EditorClipData): any;
    }
}
declare module "foundation/editor/view/action/clip/command/DoorConfigClipCommand" {
    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 DoorConfigClipCommand extends EditorClipCommand {
        copyToData(context: EditorClipContext, content: any): EditorClipData;
        pasteToContent(context: EditorClipContext, data: EditorClipData): void;
        findChildById(source: Array<any>, id: string): any;
    }
}
declare module "foundation/editor/view/action/clip/command/DoorPlankCopyClipCommand" {
    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 enum DoorPlankCopyClipEnum {
        capDefaults = "CapDefaults",
        capCustoms = "CapCustoms",
        driftRate = "DriftRate",
        handShandle = "HandShandle"
    }
    export class DoorPlankCopyClipCommand extends EditorClipCommand {
        copyToData(context: EditorClipContext, content: any): EditorClipData;
        pasteToContent(context: EditorClipContext, data: EditorClipData): void;
        private copyCapDefaults;
        private pasteCapDefaults;
        private copyCapCustoms;
        private pasteCapCustoms;
        private copyDriftRate;
        private pasteDriftRate;
        private copyHandShandle;
        private pasteHandShandle;
    }
}
declare module "foundation/editor/view/action/clip/command/MillingClipCopyCommand" {
    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';
    import { Element } from 'sk/data/family/element/base/Element';
    export class MillingClipCopyCommand extends EditorClipCommand {
        copyToData(context: EditorClipContext, content: any): EditorClipData;
        pasteToContent(context: EditorClipContext, data: EditorClipData): Element;
    }
}
declare module "foundation/editor/view/action/clip/command/PathElementPasteClipCommand" {
    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 PathElementPasteClipCommand extends EditorClipCommand {
        copyToData(context: EditorClipContext, content: any): EditorClipData;
        pasteToContent(context: EditorClipContext, data: EditorClipData): any;
    }
}
declare module "foundation/editor/view/action/clip/command/VariableMultiClipCommand" {
    import { EditorClipCommand } from 'foundation/editor/base/service/clip/EditorClipCommand';
    export class VariableMultiClipCommand extends EditorClipCommand {
    }
}
declare module "foundation/editor/view/action/content/ContentAddAction" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ElementNode } from 'foundation/data/common/element/ElementNode';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { Action } from "foundation/editor/view/action/Action";
    import { ContentActionEvent } from "foundation/editor/view/action/content/ContentActionEvent";
    export class ContentAddAction extends Action {
        document: DataDocument;
        container: ElementNode;
        host: DataNode;
        entity: ContentNode;
        element: ContentElement;
        protected _position: Vector3;
        protected _saveData: any;
        protected _selectionService: SelectionService;
        constructor();
        onExecute(event: ContentActionEvent): void;
        onUndo(): boolean;
        onRedo(): boolean;
    }
}
declare module "foundation/editor/view/action/content/ContentMoveEvent" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { InstanceElement } from 'sk/data/family/element/base/InstanceElement';
    export class ContentMoveEvent {
        static BeginMove: string;
        static UpdateMove: string;
        static EndMove: string;
        eventType: string;
        space: string;
        srcPos: Vector3;
        curPos: Vector3;
        elems: Types<InstanceElement>;
        constructor();
    }
}
declare module "foundation/editor/view/action/dimension/DimensionAccuracyActionEvent" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { DimensionAccuracyEnum } from 'sk/data/family/enumeration/frame/dimension/DimensionAccuracyEnum';
    import { Canvas } from "foundation/editor/view/base/Canvas";
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    export class DimensionAccuracyActionEvent extends ActionEvent {
        view: Canvas;
        entity: DataNode;
        accuracy: DimensionAccuracyEnum;
        free(): void;
    }
}
declare module "foundation/editor/view/action/dimension/DimensionAccuracyAction" {
    import { Action } from "foundation/editor/view/action/Action";
    import { DimensionAccuracyActionEvent } from "foundation/editor/view/action/dimension/DimensionAccuracyActionEvent";
    export class DimensionAccuracyAction extends Action {
        constructor();
        onExecute(event: DimensionAccuracyActionEvent): boolean;
    }
}
declare module "foundation/editor/view/action/group/AssemblyAddAction" {
    import { CompositeAction } from "foundation/editor/view/action/CompositeAction";
    export class AssemblyAddAction extends CompositeAction {
    }
}
declare module "foundation/editor/view/action/group/GroupActionEvent" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    export class GroupActionEvent {
        entity: DataNode;
    }
}
declare module "foundation/editor/view/action/group/GroupAddAction" {
    import { CompositeAction } from "foundation/editor/view/action/CompositeAction";
    export class GroupAddAction extends CompositeAction {
    }
}
declare module "foundation/editor/view/action/group/GroupDeleteAction" {
    import { CompositeAction } from "foundation/editor/view/action/CompositeAction";
    export class GroupDeleteAction extends CompositeAction {
    }
}
declare module "foundation/editor/view/action/group/GroupOperationAction" {
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { GroupEntity } from "foundation/editor/view/entity/GroupEntity";
    import { Action } from "foundation/editor/view/action/Action";
    import { GroupActionEvent } from "foundation/editor/view/action/group/GroupActionEvent";
    export class GroupOperationAction extends Action {
        protected _selectionService: SelectionService;
        entity: GroupEntity;
        private _members;
        private _isCreat;
        onExecute(event?: GroupActionEvent): void;
        private createGroup;
        private destoryGroup;
        onUndo(): boolean;
        onRedo(): boolean;
    }
}
declare module "foundation/editor/view/action/group/GroupRemoveAction" {
    import { Action } from "foundation/editor/view/action/Action";
    export class GroupRemoveAction extends Action {
    }
}
declare module "foundation/editor/view/action/group/MemberExcludeAction" {
    import { Action } from "foundation/editor/view/action/Action";
    export class MemberExcludeAction extends Action {
    }
}
declare module "foundation/editor/view/action/group/MemberIncludeAction" {
    import { Action } from "foundation/editor/view/action/Action";
    export class MemberIncludeAction extends Action {
    }
}
declare module "foundation/editor/view/action/selection/SelectActionAnnotation" {
    import { Annotation } from 'cross/runtime/lang/reflect/Annotation';
    export class SelectActionAnnotation extends Annotation {
        static AnnotationName: string;
        actionClass: any;
        constructor(name: string, actionClass: any);
    }
}
declare module "foundation/editor/view/action/selection/SelectActionEvent" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    export class SelectActionEvent extends ActionEvent {
        entity: DataNode;
        meshId: any;
        drawableId: number;
        multiSelect: boolean;
        addMode: boolean;
        subMode: boolean;
        statusHover: boolean;
        protected _normal: Vector3;
        protected _point: Vector3;
        faceId: number;
        constructor();
        setPoint(point: Vector3): void;
        get normal(): Vector3;
        get point(): Vector3;
        assign(event: ActionEvent): void;
        clone(): SelectActionEvent;
        free(): void;
    }
}
declare module "foundation/editor/view/action/selection/SelectActionEventEnum" {
    export class SelectActionEventEnum {
        static Point: string;
    }
}
declare module "foundation/editor/view/action/selection/SelectActionService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Service } from 'cross/runtime/module/Service';
    import { SelectActionAnnotation } from "foundation/editor/view/action/selection/SelectActionAnnotation";
    import { SelectActionEvent } from "foundation/editor/view/action/selection/SelectActionEvent";
    import { SelectActionEventEnum } from "foundation/editor/view/action/selection/SelectActionEventEnum";
    export class SelectActionService extends Service {
        protected _actions: Dictionary<any>;
        register(annotation: SelectActionAnnotation): void;
        process(actionType: SelectActionEventEnum, event: SelectActionEvent): void;
    }
}
declare module "foundation/editor/view/action/selection/SelectActionDeclare" {
    export function SelectActionDeclare(name: string): (target: any) => void;
}
declare module "foundation/editor/view/action/selection/SelectHoverAction" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { HoverService } from 'foundation/editor/base/selection/HoverService';
    import { Action } from "foundation/editor/view/action/Action";
    import { SelectActionEvent } from "foundation/editor/view/action/selection/SelectActionEvent";
    export class SelectHoverAction extends Action {
        entity: DataNode;
        multiSelect: boolean;
        protected _hoverService: HoverService;
        constructor();
        onExecute(event: SelectActionEvent): any;
    }
}
declare module "foundation/editor/view/action/selection/SelectPointAction" {
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { Action } from "foundation/editor/view/action/Action";
    import { SelectActionEvent } from "foundation/editor/view/action/selection/SelectActionEvent";
    export class SelectPointAction extends Action {
        entity: DataNode;
        multiSelect: boolean;
        protected _selectionService: SelectionService;
        constructor();
        onExecute(event: SelectActionEvent): void;
    }
}
declare module "foundation/editor/view/action/spatial/SpatialActionEvent" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { SpatialNode } from 'foundation/data/common/model/brep/SpatialNode';
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    export class SpatialActionEvent extends ActionEvent {
        container: DataNode;
        host: DataNode;
        entity: SpatialNode;
        visible: boolean;
        alignMode: string;
        protected _rotation: Vector3;
        shapeEntity: SpatialNode;
        shapeType: any;
        protected _entities: Types<DataNode>;
        constructor();
        get rotation(): Vector3;
        get entities(): Types<DataNode>;
        free(): void;
    }
}
declare module "foundation/editor/view/action/spatial/SpatialWorker" {
    import { EntityWorker } from "foundation/editor/view/action/EntityWorker";
    export class SpatialWorker extends EntityWorker {
        create(info: any): any;
    }
}
declare module "foundation/editor/view/action/spatial/SpatialActionService" {
    import { Service } from 'cross/runtime/module/Service';
    import { SpatialNode } from 'foundation/data/common/model/brep/SpatialNode';
    import { SpatialWorker } from "foundation/editor/view/action/spatial/SpatialWorker";
    export class SpatialActionService extends Service {
        private static _logger;
        constructor();
        register(worker: SpatialWorker): void;
        createSpatialInstance(info: SpatialNode): any;
    }
}
declare module "foundation/editor/view/action/spatial/SpatialActionWorker" {
    export class SpatialActionWorker {
    }
}
declare module "foundation/editor/view/action/spatial/SpatialAddAction" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { SpatialNode } from 'foundation/data/common/model/brep/SpatialNode';
    import { DataDocument } from 'foundation/data/common/model/DataDocument';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { SpatialElement } from 'sk/data/family/element/brep/SpatialElement';
    import { Action } from "foundation/editor/view/action/Action";
    import { SpatialActionEvent } from "foundation/editor/view/action/spatial/SpatialActionEvent";
    import { SpatialActionService } from "foundation/editor/view/action/spatial/SpatialActionService";
    export class SpatialAddAction extends Action {
        document: DataDocument;
        container: DataNode;
        host: DataNode;
        entity: SpatialNode;
        element: SpatialElement;
        protected _position: Vector3;
        protected _saveData: any;
        protected _selectionService: SelectionService;
        protected _spatialActionService: SpatialActionService;
        constructor();
        onExecute(event: SpatialActionEvent): void;
        onUndo(): boolean;
        onRedo(): boolean;
    }
}
declare module "foundation/editor/view/action/spatial/SpatialAlignAction" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { SpatialNode } from 'foundation/data/common/model/brep/SpatialNode';
    import { Action } from "foundation/editor/view/action/Action";
    import { SpatialActionEvent } from "foundation/editor/view/action/spatial/SpatialActionEvent";
    export class SpatialAlignAction extends Action {
        entities: Types<SpatialNode>;
        constructor();
        setPosition(entities: any, value: any, align: string): void;
        onExecute(event: SpatialActionEvent): void;
    }
}
declare module "foundation/editor/view/action/spatial/SpatialProcessor" {
    import { SpatialNode } from 'foundation/data/common/model/brep/SpatialNode';
    import { EntityProcessor } from "foundation/editor/view/action/EntityProcessor";
    import { SpatialWorker } from "foundation/editor/view/action/spatial/SpatialWorker";
    export class SpatialProcessor extends EntityProcessor<SpatialWorker> {
        create(info: SpatialNode): any;
    }
}
declare module "foundation/editor/view/base/Background" {
    import { Display } from "foundation/editor/view/base/Display";
    export class Background extends Display {
        createGeometry(): void;
    }
}
declare module "foundation/editor/view/entity/EditModeEnum" {
    export class EditModeEnum {
        static Normal: string;
        static Scheme: string;
        static Floorplan: string;
        static Conceale: string;
        static Room: string;
        static Structure: string;
        static Area: string;
        static Surface: string;
        static Component: string;
        static Space_Modify: string;
        static Smart_Match: string;
        static Render: string;
    }
}
declare module "foundation/editor/view/entity/EditEventEnum" {
    export class EditEventEnum {
        static EditEntityChanged: string;
        static EditToolsChanged: string;
    }
}
declare module "foundation/editor/view/entity/EditToolsEnum" {
    export class EditToolsEnum {
        static EditToolsSelect: string;
        static EditToolsMove: string;
        static EditToolsRotation: string;
        static EditToolsScale: string;
    }
}
declare module "foundation/editor/view/entity/EditOptions" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Node } from 'cross/runtime/framework/node/Node';
    import { BuildStructureTypeEnum } from 'sk/data/family/enumeration/BuildStructureTypeEnum';
    import { Canvas } from "foundation/editor/view/base/Canvas";
    import { EditModeEnum } from "foundation/editor/view/entity/EditModeEnum";
    import { EditToolsEnum } from "foundation/editor/view/entity/EditToolsEnum";
    export class EditOptions extends Node {
        static FIELD_MODE_CD: string;
        static FIELD_HOVER_ENTITY: string;
        static FIELD_ACTIVE_ENTITY: string;
        static FIELD_SELECT_ENTITY: string;
        static FIELD_DISPLAY_LENGTH_UINT_CD: string;
        static FIELD_DISPLAY_LENGTH_PRECISION_DIGITS: string;
        static FIELD_DISPLAY_AREA_UINT_CD: string;
        static FIELD_DISPLAY_AREA_PRECISION_DIGITS: string;
        modeCd: EditModeEnum;
        activeEntity: any;
        hoverEntity: any;
        selectEntity: any;
        selectRoom: any;
        masterViews: Types<Canvas>;
        slaveView: Canvas;
        editTools: EditToolsEnum;
        distanceMultiple: number;
        buildStructureCd: BuildStructureTypeEnum;
        constructor();
        isMasterView(view: Canvas): boolean;
        isSlaveView(view: Canvas): boolean;
        setMasterView(view: Canvas): void;
        setEditTools(tool: EditToolsEnum): void;
        reset(): void;
    }
}
declare module "foundation/editor/view/stack/EditorStack" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepElement } from 'sk/data/family/element/brep/BrepElement';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    export class EditorStack extends InstanceObject {
        document: FamilyDocument;
        code: string;
        name: string;
        activeElements: BrepElement;
        elements: Array<BrepElement>;
        nodes: Array<DataNode>;
        optionTestVisible: boolean;
        data: any;
        originalData: any;
        statusDirty: boolean;
        constructor();
        onPush(): void;
        onPop(): void;
        onReveal(): void;
        protected saveOriginalData(): void;
        protected revertOriginalDataAsync(): Promise<void>;
    }
}
declare module "foundation/editor/view/stack/EditorStackEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { EditorStack } from "foundation/editor/view/stack/EditorStack";
    export class EditorStackEvent extends EventObject {
        stack: EditorStack;
        assign(event: EditorStackEvent): void;
        free(): void;
    }
}
declare module "foundation/editor/view/stack/EditorStackEventEnum" {
    export class EditorStackEventEnum {
        static Starting: string;
        static Started: string;
        static Terminating: string;
        static Terminated: string;
        static Changed: string;
    }
}
declare module "foundation/editor/view/stack/EditorStackService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Service } from 'cross/runtime/module/Service';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { EditorStack } from "foundation/editor/view/stack/EditorStack";
    export type EditorStackDeclareInfo = {
        name: string;
        stackClass: any;
    };
    export class EditorStackService extends Service {
        protected _currentStack: EditorStack;
        protected _stacks: Types<EditorStack>;
        protected _declares: Types<EditorStackDeclareInfo>;
        protected _selectionService: SelectionService;
        stackPersistentMap: Map<any, any>;
        findDeclareByName(name: string): EditorStackDeclareInfo;
        registerDeclare(declare: EditorStackDeclareInfo): void;
        setup(): void;
        get currentStack(): EditorStack;
        get stacks(): Types<EditorStack>;
        isEmpty(): boolean;
        testVisible(entity: BrepNode): boolean;
        isCurrentChild(entity: BrepNode, deep?: boolean): boolean;
        private isGroupMembersChild;
        private isEntityHasParent;
        openByCode(code: string, selects?: DataNode | DataNode[], params?: any): EditorStack;
        push(stack: EditorStack): void;
        pop(): EditorStack;
        popAllSame(code?: string): void;
        popAll(): void;
    }
}
declare module "foundation/editor/view/base/BrepDisplay" {
    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 { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
    import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
    import { DataBlueprintNode } from 'foundation/data/common/model/DataBlueprintNode';
    import { EditOptions } from "foundation/editor/view/entity/EditOptions";
    import { EditorStackService } from "foundation/editor/view/stack/EditorStackService";
    import { Display } from "foundation/editor/view/base/Display";
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    export class BrepDisplay extends Display {
        optionHover: boolean;
        optionReady: boolean;
        blueprint: DataBlueprintNode;
        entity: BrepNode;
        editOptions: EditOptions;
        actionEventClass: any;
        protected _statusReadyChanged: boolean;
        protected _statusTransformChanged: boolean;
        protected _statusShapeChanged: boolean;
        protected _statusStyleChanged: boolean;
        protected _statusShowInvalid: boolean;
        protected _statusHover: boolean;
        protected _statusSelect: boolean;
        protected _stackService: EditorStackService;
        constructor();
        setup(): void;
        testTransformChanged(event: DataNodeFieldEvent): boolean;
        testStyleChanged(event: DataNodeFieldEvent): boolean;
        testShapeChanged(event: DataNodeFieldEvent): boolean;
        testMaterialChanged(code: string): boolean;
        onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEditorOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        bindAction(): void;
        unbindAction(): void;
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        protected onMouseEnter(sender: ListenerContext, event: any): void;
        protected onMouseLeave(sender: ListenerContext, event: any): void;
        canDraw(): boolean;
        createNode(): any;
        updateReady(): void;
        draw(displayContext: DisplayContext): void;
        dirtyTransform(): void;
        dirtyShape(): void;
        dirtyStyle(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/base/CanvasService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ObjectPools } from 'cross/runtime/lang/ObjectPools';
    import { Service } from 'cross/runtime/module/Service';
    import { Canvas } from "foundation/editor/view/base/Canvas";
    export type CanvasDeclareInfo = {
        typeName: string;
        canvasClass: any;
    };
    export class CanvasService extends Service {
        protected _declares: Types<CanvasDeclareInfo>;
        protected _pools: ObjectPools<any>;
        protected _canvases: Types<Canvas>;
        get canvases(): Types<Canvas>;
        findDeclare(typeName: string): CanvasDeclareInfo;
        registerDeclare(typeName: string, canvasClass: any): void;
        createCanvasAsync(typeName: string): Promise<Canvas>;
        allocCanvasAsync(typeName: string, beforeActive?: Function): Promise<Canvas>;
        freeCanvas(canvas: Canvas): void;
    }
}
declare module "foundation/editor/view/base/CanvasDeclare" {
    export function CanvasDeclare(typeName: string): (target: any) => void;
}
declare module "foundation/editor/view/base/CanvasEventTypeEnum" {
    export class CanvasEventTypeEnum {
        static ShadedModeChanged: string;
        static LoadingStatusChanged: string;
        static ModeChanged: string;
        static ZoomBegin: string;
        static ZoomEnd: string;
        static ZoomChanged: string;
        static ZoomChangedDelay: string;
        static ViewBoxChanged: string;
        static CanvasSizeChanging: string;
        static CanvasSizeChanged: string;
        static UnderlayChanged: string;
        static UnderlayShow: string;
        static UnderlayHide: string;
    }
}
declare module "foundation/editor/view/base/ContentController" {
    import { DisplayController } from "foundation/editor/view/base/DisplayController";
    export class ContentController extends DisplayController {
    }
}
declare module "foundation/editor/view/base/SpatialDisplay" {
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { SpatialNode } from 'foundation/data/common/model/brep/SpatialNode';
    import { BrepDisplay } from "foundation/editor/view/base/BrepDisplay";
    export class SpatialDisplay extends BrepDisplay {
        optionPreloaded: boolean;
        optionBoundary: boolean;
        entity: SpatialNode;
        testTransformChanged(event: DataNodeFieldEvent): boolean;
    }
}
declare module "foundation/editor/view/base/ContentDisplay" {
    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 { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { SpatialDisplay } from "foundation/editor/view/base/SpatialDisplay";
    export class ContentDisplay extends SpatialDisplay {
        optionBoundary: boolean;
        optionCollision: boolean;
        entity: ContentNode;
        testTransformChanged(event: DataNodeFieldEvent): boolean;
        testShapeChanged(event: DataNodeFieldEvent): boolean;
        onEditOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        canDraw(): boolean;
        bindAction(): void;
        unbindAction(): void;
    }
}
declare module "foundation/editor/view/base/CursorEnum" {
    export class CursorEnum {
        static grab: string;
        static grabbing: string;
        static none: string;
        static move: string;
        static default: string;
        static crosshair: string;
        static nsResize: string;
        static ewResize: string;
        static seResize: string;
        static neResize: string;
        static rotation: string;
        static brush: string;
        static pointer: string;
        static notallowed: string;
    }
}
declare module "foundation/editor/view/base/CursorStatus" {
    export class CursorStatus {
        _owner: any;
        _locked: boolean;
        _holdingStatus: string;
        _cursorStatus: string;
        constructor(dataAndEvents: any);
        innerSetStatus(data: any): void;
        innerReplaceItemOfStyle(obj: any, headerValue: any, chunk: any): void;
        lock(): void;
        unlock(): void;
        holdingStatus(obj: any): void;
        releaseStatus(): void;
        setCurrentStatus(status: any): void;
        calWallCursorStatus(y: any): string;
    }
}
declare module "foundation/editor/view/base/CursorStatusController" {
    export class CursorStatusController {
        cursorMgr: any;
        _CursorStatusByCmyType: any;
        constructor(exports: any, dataAndEvents: any);
        onCleanup(): void;
        onActionRunning(options: any): void;
        onActionStopped(ev: any): void;
        onRestoreCursorStatus(): void;
    }
}
declare module "foundation/editor/view/base/DataDisplay" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    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 { DataBlueprintNode } from 'foundation/data/common/model/DataBlueprintNode';
    import { Display } from "foundation/editor/view/base/Display";
    export class DataDisplay extends Display {
        blueprint: DataBlueprintNode;
        optionPreloaded: boolean;
        optionHover: boolean;
        optionBoundary: boolean;
        protected _statusTransformChanged: boolean;
        protected _statusShapeChanged: boolean;
        protected _statusStyleChanged: boolean;
        protected _statusHover: boolean;
        protected _shapeFields: Types<string>;
        protected _transformFields: Types<string>;
        protected _materialFields: Types<string>;
        constructor();
        setup(): void;
        onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        onEntityDirty(sender: ListenerContext, event: DataNodeFieldEvent): void;
        protected onMouseEnter(sender: ListenerContext, event: any): void;
        protected onMouseLeave(sender: ListenerContext, event: any): void;
        canDraw(): boolean;
        createNode(): any;
        dispose(): void;
    }
}
declare module "foundation/editor/view/base/DisplayClassMapItem" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ClassLinkerFactory } from 'cross/runtime/lang/reflect/ClassLinkerFactory';
    export class DisplayClassMapItem {
        displayClassMaps: Types<DisplayClassMap>;
        name: string;
        typeCd: string;
        constructor(name: string, typeCd: string);
        push(displayClass: Function, nodeClass: Function): void;
        registerToFactory(factory: ClassLinkerFactory): void;
    }
    export class DisplayClassMap {
        displayClass: Function;
        nodeClass: Function;
        constructor(displayClass: Function, nodeClass: Function);
    }
}
declare module "foundation/editor/view/base/DisplayClassMapService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ClassLinkerFactory } from 'cross/runtime/lang/reflect/ClassLinkerFactory';
    import { Service } from 'cross/runtime/module/Service';
    import { DisplayClassMapItem } from "foundation/editor/view/base/DisplayClassMapItem";
    export class DisplayClassMapService extends Service {
        protected _items: Types<DisplayClassMapItem>;
        constructor();
        get items(): Types<DisplayClassMapItem>;
        count(): number;
        register(name: string, typeCd: string, displayClass: Function, nodeClass: Function): void;
        unregister(name: string, typeCd: string): void;
        findItem(name: string, typeCd: string): DisplayClassMapItem;
        registerToFactory(typeCd: string, factory: ClassLinkerFactory): void;
    }
}
declare module "foundation/editor/view/base/DisplayDeclare" {
    import { CanvasEnum } from "foundation/editor/view/base/CanvasEnum";
    export function DisplayDeclare(typeCd: CanvasEnum, typeCode: string, modelClazzes: Function | Array<Function>, logicCodes?: string | Array<string>, checkFun?: Function): (target: any) => any;
}
declare module "foundation/editor/view/base/DisplayTimeoutEnum" {
    export class DisplayTimeoutEnum {
        static WallSurface: number;
    }
}
declare module "foundation/editor/view/base/SpatialController" {
    import { SpatialNode } from 'foundation/data/common/model/brep/SpatialNode';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { SpatialActionEvent } from "foundation/editor/view/action/spatial/SpatialActionEvent";
    import { DisplayController } from "foundation/editor/view/base/DisplayController";
    export class SpatialController extends DisplayController {
        entity: SpatialNode;
        protected _selectionService: SelectionService;
        onClick(event: SpatialActionEvent): void;
        onDragStart(event: SpatialActionEvent): void;
    }
}
declare module "foundation/editor/view/base/ViewEnum" {
    export class ViewEnum {
        static Svg: string;
        static View: string;
        static ViewMain: string;
        static ViewSlave: string;
        static ViewSlave1: string;
        static ViewSlave2: string;
    }
}
declare module "foundation/editor/view/base/Viewer" {
    import { CanvasEnum } from "foundation/editor/view/base/CanvasEnum";
    export function Viewer(typeCd: CanvasEnum, ...modelClazzes: Function[]): (target: any) => any;
}
declare module "foundation/editor/view/base/ViewerController" {
    export function ViewerController(displayClasses: Array<Function>, nodeClasses?: Array<Function>, elementClasses?: Array<Function>): (target: Function) => any;
}
declare module "foundation/editor/view/base/gizmo/GizmoDeclare" {
    import { CanvasEnum } from "foundation/editor/view/base/CanvasEnum";
    import { GizmoDeclareEnum } from "foundation/editor/view/base/gizmo/GizmoDeclareEnum";
    export function GizmoDeclare(spaceCd: CanvasEnum, declareCd: GizmoDeclareEnum, types: any, typeCode?: any, checkFunc?: Function): (target: any) => void;
}
declare module "foundation/editor/view/base/gizmo/GizmoEvent" {
    import { FreeObject } from 'cross/runtime/lang/FreeObject';
    export class GizmoEvent extends FreeObject {
        gizmo: any;
        state: any;
        oldState: any;
        changeReazon: any;
        free(): void;
        dispose(flag?: boolean): void;
    }
}
declare module "foundation/editor/view/base/gizmo/Temp" {
    import { Display } from "foundation/editor/view/base/Display";
    export class Temp extends Display {
        createGeometry(): void;
        addToView(): void;
        removeFromView(): void;
    }
}
declare module "foundation/editor/view/base/indicator/IndicatorDeclare" {
    export function IndicatorDeclare(entityClass: any, displayClass?: any): (target: any) => void;
}
declare module "foundation/editor/view/base/indicator/IndicatorEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    export class IndicatorEvent extends EventObject {
    }
}
declare module "foundation/editor/view/base/indicator/IndicatorEventEnum" {
    export class IndicatorEventEnum {
        static EventName: string;
        static DragBegin: string;
        static DragEnd: string;
        static DragMove: string;
        static UpdatePos: string;
        static IndicatorMoveBegin: string;
        static IndicatorMoveUpdate: string;
        static IndicatorMoveEnd: string;
        static IndicatorRotBegin: string;
        static IndicatorRotUpdate: string;
        static IndicatorRotEnd: string;
        static IndicatorScaleBegin: string;
        static IndicatorScaleUpdate: string;
        static IndicatorScaleEnd: string;
    }
}
declare module "foundation/editor/view/base/indicator/IndicatorEventProcessor" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { VertexNode } from 'foundation/data/common/model/brep/VertexNode';
    import { IndicatorEvent } from "foundation/editor/view/base/indicator/IndicatorEvent";
    export class IndicatorEventProcessor {
        protected _entitys: Types<VertexNode>;
        constructor();
        updateEntitys(elist: Types<VertexNode>): void;
        processEvent(evt: IndicatorEvent): void;
    }
}
declare module "foundation/editor/view/base/indicator/InheranceNodeUtil" {
    import { IndicatorDeclareInfo } from "foundation/editor/view/base/indicator/IndicatorDeclareService";
    class InherianceNode {
        childrenNodes: Array<InherianceNode>;
        parentNode: InherianceNode;
        entityClass: any;
        info: IndicatorDeclareInfo;
        addChild(child: InherianceNode): void;
        removeChild(child: InherianceNode): void;
        static fromDelcare(declare: IndicatorDeclareInfo): InherianceNode;
        get isLeaf(): boolean;
        static isSameClass(declare1: InherianceNode, declare2: InherianceNode): boolean;
        static isChildClass(declare1: InherianceNode, declare2: InherianceNode): boolean;
        static isParentClass(declare1: InherianceNode, declare2: InherianceNode): boolean;
    }
    class InherianceTree {
        addNew(toAddNode: InherianceNode): boolean;
        insertAsParent(toAddNode: InherianceNode, target: InherianceNode): void;
        insertAsChild(toAddNode: InherianceNode, target: InherianceNode): void;
        getLeafs(): Array<InherianceNode>;
        getNodes(startNode?: InherianceNode): Array<InherianceNode>;
        get rootNode(): InherianceNode;
        protected _rootNode: InherianceNode;
    }
    class InherianceForest {
        clear(): void;
        addNew(toAddNode: InherianceNode): boolean;
        getNodes(): Array<InherianceNode>;
        protected trees: Array<InherianceTree>;
    }
    export class InherianceNodeUtil {
        static reset(): void;
        static addNew(declare: IndicatorDeclareInfo): void;
        static getSortedDeclares(): Array<IndicatorDeclareInfo>;
        protected static forest: InherianceForest;
    }
}
declare module "foundation/editor/view/base/loading/LoadingStatusEnum" {
    export class LoadingStatusEnum {
        static NotStarted: string;
        static Progress: string;
        static Completed: string;
        static Failed: string;
        static Canceled: string;
    }
}
declare module "foundation/editor/view/base/loading/LoadingTask" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { LoadingStatusEnum } from "foundation/editor/view/base/loading/LoadingStatusEnum";
    export class LoadingTask extends InstanceObject {
        taskCd: string;
        statusCd: LoadingStatusEnum;
        url: string;
        options: any;
        constructor();
    }
}
declare module "foundation/editor/view/base/loading/LoadingTaskEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    export class LoadingTaskEvent extends EventObject {
        entity: any;
        statusCd: any;
        tasks: any;
        options: any;
        free(): void;
    }
}
declare module "foundation/editor/view/base/loading/LoadingTasks" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { View } from 'cross/runtime/framework/view/View';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { LoadingTask } from "foundation/editor/view/base/loading/LoadingTask";
    export class LoadingTasks extends Dispatcher {
        view: View;
        entity: DataNode;
        protected _tasks: Dictionary<LoadingTask>;
        addTask(taskCd: any): LoadingTask;
        onLoadingTaskBegin(taskCd: any, url: string, options?: any): void;
        protected onLoadingTaskFinished(): void;
        onLoadingTaskCompleted(taskCd: any, options?: any): void;
        onLoadingTaskFailed(taskCd: any, options?: any): void;
    }
}
declare module "foundation/editor/view/base/message/EditorMessageCodeEnum" {
    export class EditorMessageCodeEnum {
        static Save: string;
        static validate: string;
    }
}
declare module "foundation/editor/view/base/message/EditorMessageTypeEnum" {
    export class EditorMessageTypeEnum {
        static Notification: string;
        static PopconfirmAdd: string;
        static PopconfirmRemove: string;
    }
}
declare module "foundation/editor/view/base/message/EditorMessageService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Service } from 'cross/runtime/module/Service';
    import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
    import { ActionService } from "foundation/editor/view/action/ActionService";
    export type EditorMessageInfo = {
        id: string;
        code: string;
        content: any;
        message: string;
        description: string;
        duration: number;
        isUpdate: boolean;
    };
    export class EditorMessageService extends Service {
        protected _actionService: ActionService;
        protected _selectionService: SelectionService;
        protected _popconfirmMap: Dictionary<EditorMessageInfo>;
        get popconfirmMap(): Dictionary<EditorMessageInfo>;
        sendNotification(editorMessageInfo: EditorMessageInfo): void;
        addPopconfirm(editorMessageInfo: EditorMessageInfo): void;
        removePopconfirm(code: string): void;
        getPopconfirmMessageByCode(code: string): EditorMessageInfo;
    }
}
declare module "foundation/editor/view/base/render/RenderCodeEnum" {
    export class RenderCodeEnum {
        static Webgl: string;
        static Webgpu: string;
        static Filament: string;
        static Unreal: string;
    }
}
declare module "foundation/editor/view/base/render/RenderService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Service } from 'cross/runtime/module/Service';
    import { StorageDeviceService } from 'cross/core/device/storage/StorageDeviceService';
    import { RenderFactory } from "foundation/editor/view/base/render/RenderFactory";
    export type RenderDeclareInfo = {
        typeCd: string;
        type: any;
        factory: any;
    };
    export type ViewConfigInfo = {
        render: string;
        engine: string;
        worker: boolean;
    };
    export class RenderService extends Service {
        static MULTI_THREAD: string;
        static GPU_MODE: string;
        static DEFAULT_MODE: string;
        protected _infos: Types<RenderDeclareInfo>;
        protected _configView2d: ViewConfigInfo;
        protected _configView3d: ViewConfigInfo;
        protected _storageService: StorageDeviceService;
        get configView2d(): ViewConfigInfo;
        get configView3d(): ViewConfigInfo;
        initializeConfig(jconfig: any): void;
        findInfo(typeCd: string): RenderDeclareInfo;
        create(renderCode: string, engineCode?: string): RenderFactory;
        register(info: RenderDeclareInfo): void;
        unregister(typeCd: string): void;
    }
}
declare module "foundation/editor/view/base/render/RendererDeclare" {
    export function RendererDeclare(typeCd: string): (target: any) => void;
}
declare module "foundation/editor/view/base/selection/SelectorStatusEnum" {
    export class SelectorStatusEnum {
        static Enable: string;
        static Disable: string;
    }
}
declare module "foundation/editor/view/base/selection/SelectorItem" {
    import { Selector } from "foundation/editor/view/base/selection/Selector";
    export class SelectorItem {
        selector: Selector;
        protected status: string;
        name: string;
        typeCd: string;
        constructor(name: string, typeCd: string, selector: Selector);
        isEnable(): boolean;
        isDisable(): boolean;
        enable(): void;
        disable(): void;
    }
}
declare module "foundation/editor/view/entity/ArrayContainerEntity" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ArrayContainerNode } from 'sk/data/family/model/instance/ArrayContainerNode';
    export class ArrayContainerEntity extends ArrayContainerNode {
        graphicBox: any;
        assignTo(entity: any): void;
        getHost(): any;
        protected centerTrans(point: Vector3, node: ContentNode): Vector3;
        protected computeBoundaryOnChildChange(): void;
        isCanDestory(): boolean;
        canVisible(): boolean;
    }
    export type ArrayContainerEntityMap = {
        [key: string]: ArrayContainerEntity;
    };
}
declare module "foundation/editor/view/entity/BackgroundEntity" {
    import { BackgroundNode } from 'sk/data/family/model/assistant/BackgroundNode';
    export class BackgroundEntity extends BackgroundNode {
    }
}
declare module "foundation/editor/view/entity/EntityConstants" {
    export class EntityConstants {
        static SCENE_SIZE: number;
        static GRID_SPACING: number;
        static GRID_MAJOR_LINE_SPACE: number;
        static FIRSTPERSON_CAMERA_HEIGHT: number;
        static FIRSTPERSON_CAMERA_TARGET_X: number;
        static FIRSTPERSON_CAMERA_TARGET_Y: number;
        static FIRSTPERSON_CAMERA_TARGET_Z: number;
        static FIRSTPERSON_CAMERA_FOV: number;
        static FIRSTPERSON_CAMERA_PITCH: number;
        static FIRSTPERSON_CAMERA_HORIZONTAL_FOV_MIN: number;
        static FIRSTPERSON_CAMERA_HORIZONTAL_FOV_MAX: number;
        static AERIALVIEW_CAMERA_ALPHA: number;
        static AERIALVIEW_CAMERA_BELTA: number;
        static AERIALVIEW_CAMERA_RADIUS: number;
        static AERIALVIEW_CAMERA_X: number;
        static AERIALVIEW_CAMERA_Y: number;
        static AERIALVIEW_CAMERA_Z: number;
        static AERIALVIEW_CAMERA_TARGET_X: number;
        static AERIALVIEW_CAMERA_TARGET_Y: number;
        static AERIALVIEW_CAMERA_TARGET_Z: number;
        static AERIALVIEW_CAMERA_LENGTH: number;
        static AERIALVIEW_CAMERA_FOV: number;
        static AERIALVIEW_CAMERA_PITCH: number;
        static AERIALVIEW_CAMERA_HORIZONTAL_FOV_MIN: number;
        static AERIALVIEW_CAMERA_HORIZONTAL_FOV_MAX: number;
        static AERIALVIEW_CAMERA_DISTANCE: number;
        static AERIALVIEW_CAMERA_MAX_DISTANCE: number;
        static AERIALVIEW_CAMERA_MIN_DISTANCE: number;
        static ORTHOGANOL_CAMERA_HEIGHT: number;
        static ORTHOGANOL_CAMERA_TARGET_X: number;
        static ORTHOGANOL_CAMERA_TARGET_Y: number;
        static ORTHOGANOL_CAMERA_TARGET_Z: number;
        static RENDER_CAMERA_HEIGHT: number;
        static RENDER_CAMERA_TARGET_X: number;
        static RENDER_CAMERA_TARGET_Y: number;
        static RENDER_CAMERA_TARGET_Z: number;
        static RENDER_CAMERA_FOV: number;
        static RENDER_CAMERA_PITCH: number;
        static RENDER_CAMERA_HORIZONTAL_FOV_MIN: number;
        static RENDER_CAMERA_HORIZONTAL_FOV_MAX: number;
    }
}
declare module "foundation/editor/view/entity/GridEntity" {
    import { GridNode } from 'sk/data/family/model/assistant/GridNode';
    export class GridEntity extends GridNode {
        lineSpace: number;
        lineMajorSpace: number;
        constructor();
        canSelect(): boolean;
    }
}
declare module "foundation/editor/view/entity/BlueprintEntity" {
    import { SchemeBlueprintNode } from 'sk/data/scheme/model/SchemeBlueprintNode';
    import { EditOptions } from "foundation/editor/view/entity/EditOptions";
    import { GridEntity } from "foundation/editor/view/entity/GridEntity";
    import { ObserverViewEntity } from "foundation/editor/view/entity/ObserverViewEntity";
    export class BlueprintEntity extends SchemeBlueprintNode {
        activeObserver: ObserverViewEntity;
        grid: GridEntity;
        editOptions: EditOptions;
        constructor();
        getOptions(code?: string): any;
        reset(): void;
    }
}
declare module "foundation/editor/view/entity/BoundaryEntity" {
    import { BoundaryNode } from 'sk/data/family/model/assistant/BoundaryNode';
    export class BoundaryEntity extends BoundaryNode {
    }
}
declare module "foundation/editor/view/entity/CompassEntity" {
    import { CompassNode } from 'sk/data/family/model/assistant/CompassNode';
    export class CompassEntity extends CompassNode {
    }
}
declare module "foundation/editor/view/entity/EditEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { EditModeEnum } from "foundation/editor/view/entity/EditModeEnum";
    export class EditEvent extends EventObject {
        modeCd: EditModeEnum;
        entity: any;
        free(): void;
    }
}
declare module "foundation/editor/view/entity/EntityPersistentFactory" {
    import { PersistentFactory } from 'cross/runtime/module/persistent/PersistentFactory';
    export class EntityPersistentFactory extends PersistentFactory {
        constructor();
    }
}
declare module "foundation/editor/view/entity/EntityService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { PersistentContext } from 'cross/runtime/module/persistent/PersistentContext';
    import { Service } from 'cross/runtime/module/Service';
    export type EntityInfo = {
        nodeClass: any;
        entityClass: any;
        className: any;
        groupName: any;
    };
    export class EntityService extends Service {
        infos: Types<EntityInfo>;
        registerClass(nodeClass: any, entityClass: any, className?: string, groupName?: string): void;
        factoryRegisterEntities(factory: PersistentContext): void;
    }
}
declare module "foundation/editor/view/entity/ObserverBirdRenderEntity" {
    import { ObserverBirdRenderNode } from 'foundation/data/common/model/brep/observer/ObserverBirdRenderNode';
    export class ObserverBirdRenderEntity extends ObserverBirdRenderNode {
        constructor();
        reset(): void;
    }
}
declare module "foundation/editor/view/entity/ObserverNormalRenderEntity" {
    import { ObserverNormalRenderNode } from 'foundation/data/common/model/brep/observer/ObserverNormalRenderNode';
    export class ObserverNormalRenderEntity extends ObserverNormalRenderNode {
    }
}
declare module "foundation/editor/view/entity/ObserverPanoRenderEntity" {
    import { ObserverPanoRenderNode } from 'foundation/data/common/model/brep/observer/ObserverPanoRenderNode';
    export class ObserverPanoRenderEntity extends ObserverPanoRenderNode {
        constructor();
        reset(): void;
    }
}
declare module "foundation/editor/view/entity/SpatialContainerEntity" {
    import { SpatialContainerNode } from 'sk/data/family/model/instance/SpatialContainerNode';
    export class SpatialContainerEntity extends SpatialContainerNode {
    }
}
declare module "foundation/editor/view/entity/UnderlayEntity" {
    import { UnderlayNode } from 'sk/data/family/model/assistant/UnderlayNode';
    export class UnderlayEntity extends UnderlayNode {
        lock: boolean;
        isValid(): boolean;
        hideUnderlay(): void;
        showUnderlay(): void;
        loadUnderlay(url: string, factor: any, w: number, h: number): void;
    }
}
declare module "foundation/editor/view/entity/UnderlayEvent" {
    export class UnderlayActionEvent {
        oldValue: any;
        newValue: any;
    }
}
declare module "foundation/editor/view/graphic/Constants" {
    export class Constants {
        static BOUNDARY_POLYON_FACTOR: number;
        static BOUNDARY_POLYON_UNITS: number;
        static DIMENSION_LINE_COLOR: number;
        static DIMENSION_ARROW_COLOR: number;
        static DIMENSION_COLOR_2: number;
        static DIMENSION_COLOR_1: number;
        static DIMENSION_TEXT_COLOR: string;
        static DIMENSION_TEXT_AREA_COLOR: string;
        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 DIMENSION_LINE_LEVEL1: number;
        static DIMENSION_LINE_LEVEL2: number;
        static DIMENSION_MAX_DISTANCE: number;
    }
}
declare module "foundation/editor/view/graphic/Renderable" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    export class Renderable extends InstanceObject {
        protected _pivotMatrix: Matrix4;
        protected _position: Vector3;
        protected _rotation: Vector3;
        protected _scaling: Vector3;
        protected _worldMatrix: Matrix4;
        constructor();
        get pivotMatrix(): Matrix4;
        get position(): Vector3;
        get rotation(): Vector3;
        get scaling(): Vector3;
        get worldMatrix(): Matrix4;
        setup(): void;
        dispose(): void;
    }
    export type RenderableMap = {
        [key: string]: Renderable;
    };
}
declare module "foundation/editor/view/graphic/helper/AlignmentLineType" {
    export class AlignmentLineType {
        static X: string;
        static Y: string;
        static Z: string;
    }
}
declare module "foundation/editor/view/graphic/helper/AlignmentLine" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { AlignmentLineType } from "foundation/editor/view/graphic/helper/AlignmentLineType";
    export class AlignmentLine extends InstanceObject {
        typeCd: AlignmentLineType;
        position: Vector3;
        color: number;
        constructor();
        writeData(points: Types<number>, colors: Types<number>): void;
    }
}
declare module "foundation/editor/view/graphic/helper/AlignmentLineHelper" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { LineSegments } from 'foundation/runtime/graphics/actor/LineSegments';
    import { Actor } from 'foundation/runtime/graphics/core/Actor';
    import { AlignmentLine } from "foundation/editor/view/graphic/helper/AlignmentLine";
    export class AlignmentLineHelper extends Actor {
        lines: Types<AlignmentLine>;
        lineActor: LineSegments;
        protected _positions: Types<number>;
        protected _colors: Types<number>;
        constructor();
        setup(): void;
        pushLine(line: AlignmentLine): void;
        update(): void;
        clear(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/graphic/helper/BoundaryHelper" {
    import { Actor } from 'foundation/runtime/graphics/core/Actor';
    export class BoundaryHelper extends Actor {
    }
}
declare module "foundation/editor/view/graphic/helper/DataCanvas" {
    import { DrawingDeviceService } from 'cross/core/device/drawing/DrawingDeviceService';
    import { IDrawingDevice } from 'cross/core/device/drawing/IDrawingDevice';
    import { Size2 } from 'foundation/runtime/math/Size2';
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Mesh } from 'foundation/runtime/graphics/actor/Mesh';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { MeshBasicMaterial } from 'foundation/runtime/graphics/material/MeshBasicMaterial';
    import { Texture } from 'foundation/runtime/graphics/texture/Texture';
    export class DataCanvas extends Mesh {
        size: Size2;
        sizeFactor: number;
        geometry: BufferGeometry;
        material: MeshBasicMaterial;
        texture: Texture;
        canvas: IDrawingDevice;
        protected _drawingService: DrawingDeviceService;
        constructor();
        setup(): void;
        resize(width: number, heigh: number): void;
        updatePositions(p1: Value3, p2: Value3, p3: Value3, p4: Value3): void;
        updateTexture(): void;
    }
}
declare module "foundation/editor/view/graphic/helper/DimensionHelper" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { LineSegments } from 'foundation/runtime/graphics/actor/LineSegments';
    import { Mesh } from 'foundation/runtime/graphics/actor/Mesh';
    import { Actor } from 'foundation/runtime/graphics/core/Actor';
    import { DataCanvas } from "foundation/editor/view/graphic/helper/DataCanvas";
    export class DimensionHelperOptions {
        optionExtension: boolean;
        optionText: boolean;
        begin: Vector3;
        beginArrow: number;
        beginArrowColor: number;
        beginLine: number;
        beginLineColor: number;
        end: Vector3;
        endArrow: number;
        endArrowColor: number;
        endLine: number;
        endLineColor: number;
        arrowLength: number;
        arrowWidth: number;
        arrowColor: number;
        extensionWidth: number;
        lineStyle: number;
        lineColor: number;
        areaWidth: number;
        areaHeight: number;
        areaCorner: number;
        text: string;
        textWidth: number;
        textHeight: number;
        textFactor: number;
        textColor: string;
        textFont: string;
        textFontHeight: number;
        textBaseline: string;
        textAreaColor: string;
        textAreaBorderColor: string;
        direction: Vector3;
        constructor();
    }
    export class DimensionHelper extends Actor {
        options: DimensionHelperOptions;
        protected _lineActor: LineSegments;
        protected _arrowActor: Mesh;
        protected _priorText: string;
        protected _textActor: DataCanvas;
        protected _arrowBegin: Vector3;
        protected _arrowEnd: Vector3;
        protected _areaWidth: number;
        protected _textAreaWidth: number;
        protected _textAreaHeight: number;
        protected _textWidth: number;
        protected _textHeight: number;
        protected _textBeginPoint: Vector3;
        protected _textEndPoint: Vector3;
        constructor();
        setup(): void;
        setTextAreaSize(width?: number, height?: number): void;
        updateText(): void;
        updateArrow(): void;
        updateLines(): void;
        update(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/script/ScriptDeclare" {
    export function ScriptDeclare(name: string | string[], clazz?: any): (target: any) => void;
}
declare module "foundation/editor/view/snap/helper/SnapHelper" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class SnapHelper extends InstanceObject {
        reset(): void;
    }
}
declare module "foundation/editor/view/snap/helper/SnapNumberHelper" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { SnapHelper } from "foundation/editor/view/snap/helper/SnapHelper";
    export class SnapNumberHelper extends SnapHelper {
        offset: number;
        values: Types<number>;
        constructor();
        addValue(value: number): void;
        addValues(values: Array<number>): void;
        process(value: number, fixValue?: number): number;
        reset(): void;
    }
}
declare module "foundation/editor/view/stack/EditorStackDeclare" {
    export function EditorStackDeclare(stackType: string): (target: any) => void;
}
declare module "foundation/editor/view/transaction/IconCameraConverter" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
    import { ObserverViewEntity } from "foundation/editor/view/entity/ObserverViewEntity";
    export class IconCameraConverter {
        private _width;
        private _height;
        private _sizeScale;
        converteIconCamera(iconNode: ContainerNode, camera: ObserverViewEntity): void;
        viewPortLHToRef(w: number, h: number, result: Matrix4): void;
        viewPortRHToRef(w: number, h: number, result: Matrix4): void;
        perspectiveFovLHToRef(fov: number, aspect: number, znear: number, zfar: number, result: Matrix4, isVerticalFovFixed?: boolean): void;
        perspectiveFovRHToRef(fov: number, aspect: number, znear: number, zfar: number, result: Matrix4, isVerticalFovFixed?: boolean): void;
        lookAtLHToRef(eye: Vector3, target: Vector3, up: Vector3, result: Matrix4): void;
        static lookAtRHToRef(eye: Vector3, target: Vector3, up: Vector3, result: Matrix4): void;
        protected fovDataToVray(fov: number, width?: number, height?: number): number;
        protected fovVrayToData(fov: number, width?: number, height?: number): number;
    }
}
declare module "foundation/editor/view/transaction/common/DataRequest" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { Request } from "foundation/editor/view/transaction/Request";
    export class DataRequest extends Request {
        before: any;
        after: any;
        setter: any;
        setterScope: any;
        constructor(before: any, after: any, setter: any, setterScope: any);
        onUndoAsync(): Promise<ResultObject>;
        onRedoAsync(): Promise<ResultObject>;
        onCommit(): void;
        static create(before: any, after: any, setter: any, setterScope: any): DataRequest;
    }
}
declare module "foundation/editor/view/validator/EditorValidator" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class EditorValidator extends InstanceObject {
        process(parameters: any): void;
    }
}
declare module "foundation/editor/view/validator/EditorValidatorInfo" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { EditorValidator } from "foundation/editor/view/validator/EditorValidator";
    export class EditorValidatorInfo extends InstanceObject {
        canvasCd: string;
        name: string;
        type: any;
        instance: EditorValidator;
    }
}
declare module "foundation/editor/view/validator/EditorValidatorService" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Thread } from 'cross/runtime/module/thread/Thread';
    import { ThreadService } from 'cross/runtime/module/thread/ThreadService';
    import { Service } from 'cross/runtime/module/Service';
    import { ValidateService } from 'foundation/core/module/validate/ValidateService';
    import { ActionEvent } from "foundation/editor/view/action/ActionEvent";
    import { ActionObject } from "foundation/editor/view/action/ActionObject";
    import { ActionService } from "foundation/editor/view/action/ActionService";
    import { TransactionEvent } from "foundation/editor/view/transaction/TransactionEvent";
    import { TransactionService } from "foundation/editor/view/transaction/TransactionService";
    import { EditorValidatorInfo } from "foundation/editor/view/validator/EditorValidatorInfo";
    export enum EditorValidatorEventEnum {
        Processed = 1
    }
    export class EditorValidatorService extends Service {
        protected _filters: Types<Function>;
        parameters: any;
        protected _declares: Dictionary<EditorValidatorInfo>;
        protected _thread: Thread;
        protected _statusDirty: boolean;
        protected _actionService: ActionService;
        protected _transactionService: TransactionService;
        protected _threadService: ThreadService;
        protected _validateService: ValidateService;
        constructor();
        get filters(): Types<Function>;
        registerDeclare(info: EditorValidatorInfo): void;
        testInFilter(action: ActionObject): boolean;
        onThreadProcess(sender: ListenerContext, event: ActionEvent): void;
        onActionBegin(sender: ListenerContext, event: ActionEvent): void;
        onActionEnd(sender: ListenerContext, event: ActionEvent): void;
        onTransactionChanged(sender: ListenerContext, evet: TransactionEvent): void;
        protected startThread(): void;
        onEditOptionsChanged(sender: ListenerContext, event: any): void;
        startup(parameters: any): void;
        shutdown(): void;
    }
}
declare module "foundation/editor/view/validator/EditorValidatorDeclare" {
    export function EditorValidatorDeclare(name?: string): (type: any) => void;
}
declare module "foundation/editor/view/view2d/V2dScene" {
    import { Scene } from "foundation/editor/view/base/Scene";
    export class V2dScene extends Scene {
        handle: any;
    }
}
declare module "foundation/editor/view/view2d/V2dScenes" {
    import { Scenes } from "foundation/editor/view/base/Scenes";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    import { V2dScene } from "foundation/editor/view/view2d/V2dScene";
    export class V2dScenes extends Scenes {
        context: V2dCanvasContext;
        background: V2dScene;
        content: V2dScene;
        indicator: V2dScene;
        dimension: V2dScene;
        assistant: V2dScene;
        pickTest: V2dScene;
        picker: V2dScene;
        setup(): void;
    }
}
declare module "foundation/editor/view/view2d/asset/V2dTexture" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class V2dTexture extends InstanceObject {
        handle: any;
        url: string;
        loadUrl(url: string, onLoaded?: any): void;
    }
}
declare module "foundation/editor/view/view2d/render/V2dGraphicDrawing" {
    import { Rect } from 'foundation/runtime/math/Rect';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Curve2dNode } from 'foundation/data/common/model/brep/geometric/Curve2dNode';
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    import { V2dGraphicContent } from "foundation/editor/view/view2d/render/V2dGraphicContent";
    export class V2dGraphicDrawing extends V2dGraphicContent {
        nativeLines: boolean;
        set interactive(value: any);
        set alpha(value: number);
        set cursor(value: any);
        toGlobal(point: any, side?: any): any;
        lineStyle(lineWidth?: number, color?: number, alpha?: number, alignment?: number, native?: boolean): void;
        beginFill(color: number, alpha?: number): void;
        beginHole(): void;
        endHole(): void;
        endFill(): void;
        moveTo(x: number, y: number): void;
        lineTo(x: number, y: number): void;
        closePath(): void;
        arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, clockwise?: boolean): void;
        drawRect(x: number, y: number, width: number, height: number): void;
        drawTriangle(x: number, y: number, width: number, height: number): void;
        drawCross(x: number, y: number, width: number, height: number, Angle: number): void;
        drawRoundedRect(x: number, y: number, width: number, height: number, radius: number): void;
        drawGraph(context: V2dCanvasContext, nodes: Curve2dNode[]): void;
        drawCircle(x: any, y: any, radius: any): void;
        drawPolygon(points: any): void;
        drawDottedLine(start: Value2, end: Value2, scale?: number, segmentLength?: number, rect?: Rect): void;
        addChild(content: any): void;
        removeChild(content: any): void;
        clear(): void;
    }
}
declare module "foundation/editor/view/view2d/render/V2dGraphicMesh" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { V2dGraphicContent } from "foundation/editor/view/view2d/render/V2dGraphicContent";
    export class V2dGraphicMesh extends V2dGraphicContent {
        get drawMode(): number;
        set drawMode(value: number);
        get texture(): any;
        set texture(value: any);
        updateFillMeshGeometry(geometry: Vector2[], uvLen?: number, canvasPoint?: boolean): void;
        updateFillMeshImg(imgUrl: string): void;
    }
}
declare module "foundation/editor/view/view2d/render/V2dGraphicSprite" {
    import { V2dGraphicContent } from "foundation/editor/view/view2d/render/V2dGraphicContent";
    export class V2dGraphicSprite extends V2dGraphicContent {
        handle: any;
        set anchor(value: any);
        get texture(): any;
        set texture(value: any);
    }
}
declare module "foundation/editor/view/view2d/render/V2dGraphicText" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { V2dGraphicContent } from "foundation/editor/view/view2d/render/V2dGraphicContent";
    export class V2dGraphicText extends V2dGraphicContent {
        get style(): any;
        set style(value: any);
        get text(): string;
        set text(value: string);
        get anchor(): Readonly<Value2>;
        setAnchor(x: number, y: number): void;
    }
}
declare module "foundation/editor/view/view2d/render/V2dGraphicTextStyle" {
    import { V2dGraphicObject } from "foundation/editor/view/view2d/render/V2dGraphicObject";
    export class V2dGraphicTextStyle extends V2dGraphicObject {
    }
}
declare module "foundation/editor/view/view2d/V2dGraphic" {
    import { IDrawingGraphic } from 'cross/core/device/drawing/IDrawingGraphic';
    import { Display } from "foundation/editor/view/base/Display";
    export class V2dGraphic extends Display {
        paint(graphicContext: IDrawingGraphic): void;
    }
}
declare module "foundation/editor/view/view2d/render/V2dHookEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { MouseButtonEnum } from 'cross/editor/device/mouse/MouseButtonEnum';
    import { MouseEventEnum } from 'cross/editor/device/mouse/MouseEventEnum';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { V2dGraphicContainer } from "foundation/editor/view/view2d/render/V2dGraphicContainer";
    export class V2dHookEvent extends EventObject {
        typeCd: MouseEventEnum;
        buttonCd: MouseButtonEnum;
        target: any;
        nativeEvent: any;
        protected _point: Vector2;
        protected _offset: Vector2;
        protected _mousePoint: Vector2;
        ctrlKey: boolean;
        altKey: boolean;
        constructor();
        get point(): Vector2;
        get offset(): Vector2;
        get mousePoint(): Vector2;
        attachButton(button: number): void;
        attachEvent(event: any): void;
        getLocalPosition(container: V2dGraphicContainer): Vector2;
        stopPropagation(): void;
        free(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view2d/render/V2dHook" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { V2dGraphic } from "foundation/editor/view/view2d/V2dGraphic";
    import { V2dHookEvent } from "foundation/editor/view/view2d/render/V2dHookEvent";
    export class V2dHook extends InstanceObject {
        owner: any;
        click: any;
        mouseOver: any;
        mouseOut: any;
        mouseDown: any;
        mouseMove: any;
        mouseUp: any;
        dragStart: any;
        dragMove: any;
        dragEnd: any;
        torlerance: number;
        htmlElement: any;
        nodePlane: V2dGraphic;
        protected _statusDown: boolean;
        protected _statusDragging: boolean;
        protected _dragButton: number;
        protected _lastX: number;
        protected _lastY: number;
        protected _isLastDragging: boolean;
        protected _event: V2dHookEvent;
        protected infoClick: boolean;
        protected infoMouseOver: boolean;
        protected infoMouseOut: boolean;
        protected infoMouseDown: boolean;
        protected infoMouseMove: boolean;
        protected infoMouseUp: boolean;
        protected constructor();
        setup(): void;
        testTargetElement(event: any): boolean;
        active(): void;
        deactive(): void;
        onClick(event: any): void;
        onMouseOver(event: any): void;
        onMouseOut(event: any): void;
        onMouseDown(event: any): void;
        onMouseMove(event: any): void;
        onMouseUp(event: any): void;
        onDragStart(event: any): void;
        onDragMove(event: any): void;
        onDragEnd(event: any): void;
        clear(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view2d/render/V2dPickerItem" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { Display } from "foundation/editor/view/base/Display";
    export class V2dPickerItem {
        dataNode: ContentNode;
        display: Display;
        point: Vector3;
        coord: Vector2;
        distance: number;
        node: any;
        normal: Vector3;
        faceId: number;
        constructor();
        assign(info: any): void;
        reset(): void;
    }
}
declare module "foundation/editor/view/view2d/render/V2dPicker" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { Display } from "foundation/editor/view/base/Display";
    import { Layer } from "foundation/editor/view/base/Layer";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    import { V2dPickerItem } from "foundation/editor/view/view2d/render/V2dPickerItem";
    export class V2dPicker extends InstanceObject {
        context: V2dCanvasContext;
        constructor(context?: V2dCanvasContext);
        setup(): void;
        enable(): void;
        disable(): void;
        get resolution(): any;
        pointerClick(event: any): any;
        setTrackingMesh(layer: Layer, display: Display, mesh: any, isTrack: boolean): void;
        addTrackingMesh(layer: Layer, display: Display, node: any): void;
        removeTrackingMesh(layer: Layer, display: Display, node: any): void;
        getTriangleFunc(): (point1: any, point2: any, point3: any, ray: any) => boolean;
        getPredicateFunc(): (mesh: any) => boolean;
        getPickSorter(): (source: any, target: any) => number;
        pickSingle(x: number, y: number, layers: Types<any>, skipEntity?: ContentNode, force?: boolean): V2dPickerItem;
        pick(x: number, y: number, layers: Types<any>, multiPicking: boolean): Array<V2dPickerItem>;
        clear(): void;
    }
}
declare module "foundation/editor/view/view2d/render/V2dGraphicRenderFactory" {
    import { RenderFactory } from "foundation/editor/view/base/render/RenderFactory";
    import { V2dTexture } from "foundation/editor/view/view2d/asset/V2dTexture";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    import { V2dGraphicContainer } from "foundation/editor/view/view2d/render/V2dGraphicContainer";
    import { V2dGraphicDrawing } from "foundation/editor/view/view2d/render/V2dGraphicDrawing";
    import { V2dGraphicMesh } from "foundation/editor/view/view2d/render/V2dGraphicMesh";
    import { V2dGraphicSprite } from "foundation/editor/view/view2d/render/V2dGraphicSprite";
    import { V2dGraphicText } from "foundation/editor/view/view2d/render/V2dGraphicText";
    import { V2dGraphicTextStyle } from "foundation/editor/view/view2d/render/V2dGraphicTextStyle";
    import { V2dHook } from "foundation/editor/view/view2d/render/V2dHook";
    import { V2dPicker } from "foundation/editor/view/view2d/render/V2dPicker";
    export class V2dGraphicRenderFactory extends RenderFactory {
        context: V2dCanvasContext;
        createScene(name?: string): any;
        createPicker(name?: string): V2dPicker;
        createLayer(name?: string): any;
        createContainer(name?: string): V2dGraphicContainer;
        createGraphics(name?: string): V2dGraphicDrawing;
        createSprite(name?: string): V2dGraphicSprite;
        createTexture(name?: string): V2dTexture;
        createMesh(name?: string): V2dGraphicMesh;
        createText(name?: string, text?: string, options?: any, style?: any): V2dGraphicText;
        createTextStyle(name?: string, options?: any): V2dGraphicTextStyle;
        createHook(name?: string, owner?: any, element?: any, torlerance?: number): V2dHook;
    }
}
declare module "foundation/editor/view/view2d/render/V2dGraphicObject" {
    import { GraphicObject } from "foundation/editor/view/base/graphic/GraphicObject";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    import { V2dGraphicRenderFactory } from "foundation/editor/view/view2d/render/V2dGraphicRenderFactory";
    export class V2dGraphicObject extends GraphicObject {
        context: V2dCanvasContext;
        factory: V2dGraphicRenderFactory;
        statusBatch: boolean;
        setup(): void;
        beginBatch(): void;
        endBatch(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view2d/render/V2dGraphicContent" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { V2dGraphicObject } from "foundation/editor/view/view2d/render/V2dGraphicObject";
    export type V2dGraphicContentParemetersType = {
        x?: number;
        y?: number;
        width?: number;
        height?: number;
    };
    export class V2dGraphicContent extends V2dGraphicObject {
        set parent(value: any);
        get visible(): boolean;
        set visible(value: boolean);
        get x(): number;
        get y(): number;
        setLocation(x: number, y: number): void;
        get rotation(): number;
        set rotation(value: number);
        get width(): number;
        get height(): number;
        setSize(width: number, height: number): void;
        get scale(): Readonly<Value2>;
        setScale(x: number, y: number): void;
        setScaleAll(scale: number): void;
        get alpha(): number;
        set alpha(value: number);
        on(code: string, method: any, owner: any): void;
        off(code: string, method: any, owner?: any): void;
        set(parameters: V2dGraphicContentParemetersType): void;
    }
}
declare module "foundation/editor/view/view2d/render/V2dGraphicContainer" {
    import { V2dGraphicContent } from "foundation/editor/view/view2d/render/V2dGraphicContent";
    export class V2dGraphicContainer extends V2dGraphicContent {
        handle: any;
        get interactive(): boolean;
        set interactive(value: boolean);
        get interactiveChildren(): boolean;
        set interactiveChildren(value: boolean);
        hitTest(method: any): void;
        setHitReactangle(x: number, y: number, width: number, height: number): void;
        toGlobal(point: any, side?: any): any;
        addChild(content: any): void;
        addChildAt(content: any, index: number): void;
        setChildIndex(content: any, index: number): void;
        removeChild(content: any): void;
        getChildrenCount(): number;
    }
}
declare module "foundation/editor/view/view2d/render/V2dGraphicRenderer" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { IRenderContext } from "foundation/editor/view/base/render/IRenderContext";
    import { Renderer } from "foundation/editor/view/base/render/Renderer";
    import { RenderParameters } from "foundation/editor/view/base/render/RenderParameters";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    import { V2dScenes } from "foundation/editor/view/view2d/V2dScenes";
    import { V2dGraphicContainer } from "foundation/editor/view/view2d/render/V2dGraphicContainer";
    import { V2dGraphicRenderFactory } from "foundation/editor/view/view2d/render/V2dGraphicRenderFactory";
    export class V2dGraphicRenderer extends Renderer {
        context: V2dCanvasContext;
        factory: V2dGraphicRenderFactory;
        scenes: V2dScenes;
        camera: any;
        handle: any;
        handleRenderer: any;
        handleView: any;
        setClearColor(color: number, opacity?: number): void;
        hitTest(color: Value2, container: V2dGraphicContainer): void;
        render(context: IRenderContext, stage?: any, parameters?: RenderParameters): void;
    }
}
declare module "foundation/editor/view/view2d/renderer/V2dRendererManager" {
    import { RenderManager } from "foundation/editor/view/base/render/RenderManager";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    export class V2dRendererManager extends RenderManager {
        context: V2dCanvasContext;
    }
}
declare module "foundation/editor/view/view2d/V2dLayer" {
    import { Layer } from "foundation/editor/view/base/Layer";
    import { V2dGraphicContainer } from "foundation/editor/view/view2d/render/V2dGraphicContainer";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    export class V2dLayer extends Layer {
        context: V2dCanvasContext;
        container: V2dGraphicContainer;
        constructor(context: V2dCanvasContext, name: string, sceneName?: string);
        appendNode(node: any): void;
        removeNode(node: any): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view2d/V2dLayers" {
    import { Layers } from "foundation/editor/view/base/Layers";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    import { V2dLayer } from "foundation/editor/view/view2d/V2dLayer";
    export class V2dLayers extends Layers {
        context: V2dCanvasContext;
        content: V2dLayer;
        temp: V2dLayer;
    }
}
declare module "foundation/editor/view/view2d/V2dCanvasContext" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { CanvasContext } from "foundation/editor/view/base/CanvasContext";
    import { V2dAssetManager } from "foundation/editor/view/view2d/asset/V2dAssetManager";
    import { V2dGraphicRenderer } from "foundation/editor/view/view2d/render/V2dGraphicRenderer";
    import { V2dGraphicRenderFactory } from "foundation/editor/view/view2d/render/V2dGraphicRenderFactory";
    import { V2dRendererManager } from "foundation/editor/view/view2d/renderer/V2dRendererManager";
    import { V2dCanvas } from "foundation/editor/view/view2d/V2dCanvas";
    import { V2dLayers } from "foundation/editor/view/view2d/V2dLayers";
    import { V2dScenes } from "foundation/editor/view/view2d/V2dScenes";
    export class V2dCanvasContext extends CanvasContext {
        htmlCanvas: HTMLCanvasElement;
        htmlRenderCanvas: HTMLCanvasElement;
        canvas: V2dCanvas;
        renderer: V2dGraphicRenderer;
        renderFactory: V2dGraphicRenderFactory;
        assetManager: V2dAssetManager;
        rendererManager: V2dRendererManager;
        scenes: V2dScenes;
        layers: V2dLayers;
        lastMoveDelta: Vector2;
        constructor();
        dispose(): void;
    }
}
declare module "foundation/editor/view/view2d/asset/V2dTopview" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class V2dTopview extends InstanceObject {
    }
}
declare module "foundation/editor/view/view2d/asset/V2dAssetManager" {
    import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
    import { AssetManager } from "foundation/editor/view/base/asset/AssetManager";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    import { V2dTexture } from "foundation/editor/view/view2d/asset/V2dTexture";
    import { V2dTopview } from "foundation/editor/view/view2d/asset/V2dTopview";
    export class V2dAssetManager extends AssetManager {
        context: V2dCanvasContext;
        textures: Dictionary<V2dTexture>;
        topviews: Dictionary<V2dTopview>;
        loadTextureByUrl(url: string): V2dTexture;
        freeTexture(texture: V2dTexture): any;
    }
}
declare module "foundation/editor/view/view2d/V2dCanvas" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { ScreenDeviceService } from 'cross/editor/device/screen/ScreenDeviceService';
    import { ScreenEventHook } from 'cross/editor/device/screen/ScreenEventHook';
    import { RenderEnum } from "foundation/editor/view/base/render/RenderEnum";
    import { RenderManager } from "foundation/editor/view/base/render/RenderManager";
    import { Canvas } from "foundation/editor/view/base/Canvas";
    import { V2dAssetManager } from "foundation/editor/view/view2d/asset/V2dAssetManager";
    import { V2dPicker } from "foundation/editor/view/view2d/render/V2dPicker";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    import { V2dScenes } from "foundation/editor/view/view2d/V2dScenes";
    export class V2dCanvas extends Canvas {
        context: V2dCanvasContext;
        htmlCanvas: HTMLCanvasElement;
        htmlRenderCanvas: HTMLCanvasElement;
        assetManager: V2dAssetManager;
        renderCd: RenderEnum;
        renderManager: RenderManager;
        scenes: V2dScenes;
        picker: V2dPicker;
        protected _eventHook: ScreenEventHook;
        protected _screenService: ScreenDeviceService;
        constructor();
        setupAsync(): Promise<ResultObject>;
        getImageData(): Blob;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view2d/V2dCanvasEvent" {
    import { EventObject } from 'cross/runtime/lang/EventObject';
    import { Rect } from 'foundation/runtime/math/Rect';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class V2dCanvasEvent extends EventObject {
        x: number;
        y: number;
        scale: Vector2;
        viewRect: Rect;
        constructor();
        free(): void;
    }
}
declare module "foundation/editor/view/view2d/V2dConstants" {
    export class V2dConstants {
        static SCENE_SIZE: number;
        static MODEL_TO_CANVAS_FACTOR: number;
        static CANVAS_TO_MODEL_FACTOR: number;
        static DimensionTextHeight: number;
        static DimensionTextColor: string;
        static DimensionLineColor: string;
        static DimensionBorderLength: number;
        static DimensionsDistance: number;
        static FirstDimensionDistance: number;
    }
}
declare module "foundation/editor/view/view2d/V2dDisplay" {
    import { Display } from "foundation/editor/view/base/Display";
    export class V2dDisplay extends Display {
        show(): void;
        hide(): void;
    }
}
declare module "foundation/editor/view/view2d/V2dDrawingGraphUtil" {
    import { NodeObjectCollection } from 'cross/runtime/framework/node/NodeObjectCollection';
    import { Box2 } from 'foundation/runtime/math/Box2';
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { PointNode } from 'foundation/data/common/model/brep/geometric/PointNode';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    export class V2dDrawingGraphUtil {
        static modelToCanvas1(context: any, size: number): number;
        static modelToCanvas2(context: any, point: Value2, target?: Vector2): Vector2;
        static computeGraphBound(nodes: NodeObjectCollection<DataNode>): Box2;
        static appendBoundaryRectByNode(dataNode: DataNode, target: Box2): Box2;
        static appendBoundaryRectByRectAngle(x: number, y: number, w: number, h: number, angle: number, target: Box2): Box2;
        static appendBoundaryRect(point: PointNode, target: Box2): Box2;
        static appendBoundaryRectValues(x: number, y: number, target: Box2): Box2;
    }
}
declare module "foundation/editor/view/view2d/V2dObserver" {
    import { ObserverNode } from 'foundation/data/common/model/brep/ObserverNode';
    import { Observer } from "foundation/editor/view/base/Observer";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    export class V2dObserver extends Observer {
        context: V2dCanvasContext;
        entity: ObserverNode;
        reset(observer?: ObserverNode): void;
    }
}
declare module "foundation/editor/view/view2d/V2dObserverController" {
    import { ObserverController } from "foundation/editor/view/base/ObserverController";
    export class V2dObserverController extends ObserverController {
    }
}
declare module "foundation/editor/view/view2d/V2dSceneTypeEnum" {
    export class V2dSceneTypeEnum {
        static Background: string;
        static Content: string;
        static Indicator: string;
        static Dimension: string;
        static Assistant: string;
        static PickTest: string;
    }
}
declare module "foundation/editor/view/view2d/render/V2dHookManager" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { V2dHook } from "foundation/editor/view/view2d/render/V2dHook";
    export class V2dHookManager extends InstanceObject {
        protected _hooks: Types<V2dHook>;
        constructor();
        push(hook: V2dHook): void;
        active(): void;
        deactive(): void;
        clear(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view2d/V2dUtil" {
    import { Value2 } from 'foundation/runtime/math/Value2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class V2dUtil {
        static browserSupport(htmlPanel: any): boolean;
        static oldModelToCanvas1(size: number): number;
        static oldModelToCanvas2(point: Value2, target?: Vector2): Vector2;
        static canvasToModel1(size: number): number;
        static canvasToModel2(point: Value2, target?: Vector2): Vector2;
        static disposeDisplay(display: any): any;
    }
}
declare module "foundation/editor/view/view2d/V2dTemp" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Temp } from "foundation/editor/view/base/gizmo/Temp";
    import { GridEntity } from "foundation/editor/view/entity/GridEntity";
    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 { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    import { V2dLayer } from "foundation/editor/view/view2d/V2dLayer";
    import { V2dLayers } from "foundation/editor/view/view2d/V2dLayers";
    export class V2dTemp extends Temp {
        context: V2dCanvasContext;
        container: V2dGraphicContainer;
        layer: V2dLayer;
        layers: V2dLayers;
        protected maskGraphics: V2dGraphicDrawing;
        protected _hookManager: V2dHookManager;
        optionCanvasMove: boolean;
        protected _canMoveCanvas: boolean;
        protected _movingCanvas: boolean;
        gridEntity: GridEntity;
        constructor();
        setup(): void;
        onScaleChanged(sender: ListenerContext, event: any): void;
        onMouseDown(sender: ListenerContext, event: V2dHookEvent): void;
        onMouseMove(sender: ListenerContext, event: V2dHookEvent): void;
        onMouseUp(sender: ListenerContext, event: V2dHookEvent): void;
        onMouseClick(sender: ListenerContext, event: V2dHookEvent): void;
        onElementMouseDown(sender: ListenerContext, event: V2dHookEvent): void;
        onElementMouseMove(sender: ListenerContext, event: V2dHookEvent): void;
        onElementMouseUp(sender: ListenerContext, event: V2dHookEvent): void;
        onElementClick(sender: ListenerContext, event: V2dHookEvent): void;
        onElementDragStart(sender: ListenerContext, event: V2dHookEvent): void;
        onElementDragMove(sender: ListenerContext, event: V2dHookEvent): boolean;
        onElementDragEnd(sender: ListenerContext, event: V2dHookEvent): void;
        bindCommand(): void;
        unbindCommand(): void;
        onActivate(): void;
        onDeactivate(): void;
        onRemoveFromView(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view2d/camera/V2dCamera" {
    import { Camera } from "foundation/editor/view/base/camera/Camera";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    import { V2dObserverController } from "foundation/editor/view/view2d/V2dObserverController";
    export class V2dCamera extends Camera {
        context: V2dCanvasContext;
        controller: V2dObserverController;
    }
}
declare module "foundation/editor/view/view2d/helper/V2dHelper" {
    import { Helper } from "foundation/editor/view/base/helper/Helper";
    import { V2dGraphicContainer } from "foundation/editor/view/view2d/render/V2dGraphicContainer";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    export class V2dHelper extends Helper {
        context: V2dCanvasContext;
        container: V2dGraphicContainer;
        set visiable(value: boolean);
        setup(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view2d/helper/V2dAlignmentLinesHelper" {
    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 { V2dHelper } from "foundation/editor/view/view2d/helper/V2dHelper";
    export class V2dAlignmentLinesHelper extends V2dHelper {
        graphics: V2dGraphicDrawing;
        build(count: number): V2dGraphicDrawing;
        updateData(lines: Types<Line2>, lineWidth?: number): void;
        hide(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view2d/helper/V2dArrowHelper" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { V2dGraphicDrawing } from "foundation/editor/view/view2d/render/V2dGraphicDrawing";
    import { V2dHelper } from "foundation/editor/view/view2d/helper/V2dHelper";
    export class V2dArrowHelper extends V2dHelper {
        static ArrowStyle1: string;
        static ArrowStyle2: string;
        static ArrowStyle3: string;
        static ArrowStyle4: string;
        static ArrowStyle5: string;
        static ArrowStyle6: string;
        static ArrowStyle7: string;
        protected _graphics: V2dGraphicDrawing;
        protected _begin: Vector2;
        protected _end: Vector2;
        protected _lineWidth: number;
        protected _lineColor: number;
        protected _arrowColor: number;
        protected _showArrowBegin: boolean;
        protected _showArrowEnd: boolean;
        protected _arrowStyle: string;
        protected _arrowWidth: number;
        protected _arrowLen: number;
        protected _arrowTriangleLen: number;
        protected _dashPattern: Array<number>;
        protected _screenSizeMode: boolean;
        constructor();
        setup(): void;
        set lineWidth(value: number);
        set screenSizeMode(value: boolean);
        get screenSizeMode(): boolean;
        set lineColor(value: number);
        set arrowColor(value: number);
        set showArrowBegin(value: boolean);
        set showArrowEnd(value: boolean);
        set arrowWidth(value: number);
        set arrowLength(value: number);
        set arrowTriangleLen(value: number);
        set dashPattern(p: Array<number>);
        set arrowStyle(s: string);
        setBeginEnd(begin: Vector2, end: Vector2): void;
        protected drawLine(begin: Vector2, end: Vector2): void;
        draw(): void;
        protected drawDirArrow(): void;
        protected convertArrowSizeLen(size: number): number;
        protected computeBeginLinePoints(): number[];
        protected computeBeginArrowPoints(): number[];
        protected computeEndLinePoints(): number[];
        protected computeEndArrowPoints(): number[];
        dispose(): void;
    }
}
declare module "foundation/editor/view/view2d/helper/V2dBoundaryHelper" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { V2dGraphicDrawing } from "foundation/editor/view/view2d/render/V2dGraphicDrawing";
    import { V2dHelper } from "foundation/editor/view/view2d/helper/V2dHelper";
    export class V2dBoundaryHelper extends V2dHelper {
        protected _graphics: V2dGraphicDrawing;
        protected _position: Vector2;
        protected _width: number;
        protected _height: number;
        protected _color: number;
        protected _colorBorder: number;
        protected _colorPoint: number;
        protected _borderWidth: number;
        protected _alpha: number;
        protected _pointWidth: number;
        protected _drawBorder: boolean;
        protected _drawPoint: boolean;
        constructor();
        setup(): void;
        dispose(): void;
        draw(): void;
        set color(c: number);
        set colorBorder(c: number);
        set colorPoint(c: number);
        set borderWidth(w: number);
        set position(p: Vector2);
        set size(s: Vector2);
        set drawBorder(b: boolean);
        set drawPoint(b: boolean);
    }
}
declare module "foundation/editor/view/view2d/helper/V2dLineDimensionHelper" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { V2dGraphicDrawing } from "foundation/editor/view/view2d/render/V2dGraphicDrawing";
    import { V2dGraphicText } from "foundation/editor/view/view2d/render/V2dGraphicText";
    import { V2dArrowHelper } from "foundation/editor/view/view2d/helper/V2dArrowHelper";
    import { V2dHelper } from "foundation/editor/view/view2d/helper/V2dHelper";
    export class V2dLineDimensionHelper extends V2dHelper {
        protected _showText: boolean;
        protected _textColor: string;
        protected _textStrokeColor: string;
        protected _fontSize: number;
        protected _arrowLength: number;
        protected _arrowWidth: number;
        protected _arrowTriangleLen: number;
        protected _screenSizeMode: boolean;
        protected _text: string;
        protected _lineWidth: number;
        protected _lineColor: number;
        protected _arrowColor: number;
        protected _showArrowBegin: boolean;
        protected _showArrowEnd: boolean;
        protected _arrowStyle: string;
        protected _alpha: number;
        protected _begin: Vector2;
        protected _end: Vector2;
        protected _textSprite: V2dGraphicText;
        protected _arrowBegin: V2dArrowHelper;
        protected _arrowEnd: V2dArrowHelper;
        protected _graphics: V2dGraphicDrawing;
        protected _changeSizeDir: boolean;
        protected _displayDirArrowFlag: boolean;
        protected _displayNoArrowFlag: boolean;
        protected _textRotation: number;
        constructor();
        set textRotation(value: number);
        set showArrow(value: boolean);
        setup(): void;
        setArrowDir(flag: boolean): void;
        set text(value: string);
        set textColor(value: string);
        set textStrokeColor(value: string);
        set fontSize(value: number);
        set lineWidth(value: number);
        set arrowLength(value: number);
        set arrowWidth(value: number);
        set arrowTriangleLen(value: number);
        set screenSizeMode(value: boolean);
        set lineColor(value: number);
        set arrowColor(value: number);
        set arrowStyle(value: string);
        set showText(value: boolean);
        setBeginEnd(begin: Vector2, end: Vector2): void;
        get textSprite(): V2dGraphicText;
        draw(): void;
        displayNoArrow(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view2d/helper/V2dPreloadedHelper" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { V2dGraphicDrawing } from "foundation/editor/view/view2d/render/V2dGraphicDrawing";
    import { V2dHelper } from "foundation/editor/view/view2d/helper/V2dHelper";
    export class V2dPreloadedHelper extends V2dHelper {
        static Vertical: string;
        static Horizontal: string;
        protected _graphics: V2dGraphicDrawing;
        protected _position: Vector2;
        protected _width: number;
        protected _height: number;
        protected _colorBack: number;
        protected _colorFront: number;
        protected _alpha: number;
        protected _mode: string;
        protected _preloaded: number;
        constructor();
        set width(w: number);
        set height(h: number);
        set colorFront(c: number);
        set colorBack(c: number);
        set position(p: Vector2);
        get preloaded(): number;
        set preloaded(p: number);
        set alpha(p: number);
        setup(): void;
        dispose(): void;
        draw(): void;
    }
}
declare module "foundation/editor/view/view2d/indicator/V2dIndicator" {
    import { Indicator } from "foundation/editor/view/base/indicator/Indicator";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    export class V2dIndicator extends Indicator {
        context: V2dCanvasContext;
    }
}
declare module "foundation/editor/view/view2d/selection/V2dSelectorController" {
    import { SelectorController } from "foundation/editor/view/base/selection/SelectorController";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    import { V2dSelector } from "foundation/editor/view/view2d/selection/V2dSelector";
    export class V2dSelectorController extends SelectorController {
        context: V2dCanvasContext;
        selector: V2dSelector;
    }
}
declare module "foundation/editor/view/view2d/selection/V2dSelector" {
    import { Selector } from "foundation/editor/view/base/selection/Selector";
    import { V2dCanvasContext } from "foundation/editor/view/view2d/V2dCanvasContext";
    import { V2dSelectorController } from "foundation/editor/view/view2d/selection/V2dSelectorController";
    export class V2dSelector extends Selector {
        context: V2dCanvasContext;
        controller: V2dSelectorController;
    }
}
declare module "foundation/editor/view/view2d/selection/V2dSelectorEvent" {
    import { SelectorEvent } from "foundation/editor/view/base/selection/SelectorEvent";
    export class V2dSelectorEvent extends SelectorEvent {
    }
}
declare module "foundation/editor/view/view3d/V3dActorEventEnum" {
    export class V3dActorEventEnum {
        static ModelLoaded: string;
        static TextureLoaded: string;
    }
}
declare module "foundation/editor/view/view3d/V3dActor" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { LoaderEvent } from 'cross/core/module/loader/LoaderEvent';
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Actor } from 'foundation/runtime/graphics/core/Actor';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { MeshPhongMaterial } from 'foundation/runtime/graphics/material/MeshPhongMaterial';
    import { V3dGraphicContainer } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContainer";
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    export class V3dActor extends Actor {
        context: V3dCanvasContext;
        node: V3dGraphicContainer;
        modelUrl: string;
        modelTextureUrl: string;
        originMatrix: Matrix4;
        localMatrix: Matrix4;
        boundingBox: Box3;
        protected _meshes: Array<V3dGraphicMesh>;
        protected _texture: any;
        constructor();
        setup(): void;
        createMaterial(): MeshPhongMaterial;
        protected applyModel(content: Array<BufferGeometry>): void;
        protected applyTexture(): void;
        loadTextureAsync(): Promise<ResultObject>;
        protected onLoadModelFailure(sender: ListenerContext, event: LoaderEvent): void;
        loadModelAsync(): Promise<ResultObject>;
        load(): void;
        dirty(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/V3dBrep" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { NodeFieldEvent } from 'cross/runtime/framework/node/NodeFieldEvent';
    import { BrepDisplay } from "foundation/editor/view/base/BrepDisplay";
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { V3dGraphicContainer } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContainer";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    export class V3dBrep extends BrepDisplay {
        context: V3dCanvasContext;
        layer: V3dLayer;
        node: V3dGraphicContainer;
        nodeSelector: any;
        protected _statusReady: boolean;
        constructor();
        setup(): void;
        createNode(): V3dGraphicContainer;
        protected updateTransform(): void;
        protected updateShape(): void;
        drawDisplay(displayContext?: DisplayContext): void;
        show(): void;
        hide(): void;
        addToView(): void;
        removeFromView(): void;
        onEditOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        bindAction(): void;
        unbindAction(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/V3dCanvasQualityModeEnum" {
    export class V3dCanvasQualityModeEnum {
        static Low: string;
        static Middle: string;
        static High: string;
    }
}
declare module "foundation/editor/view/view3d/V3dCanvasOptions" {
    import { MoldingVisionEnum } from 'foundation/data/common/enumeration/MoldingVisionEnum';
    import { IndicatorTypeEnum } from "foundation/editor/view/base/indicator/IndicatorTypeEnum";
    import { CanvasOptions } from "foundation/editor/view/base/CanvasOptions";
    import { V3dCanvasQualityModeEnum } from "foundation/editor/view/view3d/V3dCanvasQualityModeEnum";
    export class V3dCanvasOptions extends CanvasOptions {
        static FIELD_QUALITY_MODE_CD: string;
        static FIELD_DRAW_MODE_CD: string;
        static FIELD_INDICATOR_TYPE_CD: string;
        qualityModeCd: V3dCanvasQualityModeEnum;
        drawModeCd: MoldingVisionEnum;
        indicatorTypeCd: IndicatorTypeEnum;
        indicatorManagerClass: any;
        constructor();
    }
}
declare module "foundation/editor/view/view3d/helper/V3dMoldingBoundaryHelper" {
    import { Color } from 'foundation/runtime/math/Color';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { GeometricNode } from 'foundation/data/common/model/brep/GeometricNode';
    import { MoldingVisionEnum } from 'foundation/data/common/enumeration/MoldingVisionEnum';
    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 { V3dGraphicNode } from "foundation/editor/view/view3d/render/graphic/V3dGraphicNode";
    import { V3dDynamicMesh } from "foundation/editor/view/view3d/render/V3dDynamicMesh";
    import { V3dDynamicMeshMerger } from "foundation/editor/view/view3d/render/V3dDynamicMeshMerger";
    import { V3dHelper } from "foundation/editor/view/view3d/helper/V3dHelper";
    export class V3dMoldingBoundaryHelper extends V3dHelper {
        optionBorder: boolean;
        borderColor: Color;
        borderOpacity: number;
        optionBorderBack: boolean;
        borderBackPattern: Array<number>;
        borderBackColor: Color;
        borderBackOpacity: number;
        optionFace: boolean;
        faceColor: Color;
        faceOpacity: number;
        protected _nodeMesh: V3dGraphicMesh;
        protected _dynamicMesh: V3dDynamicMesh;
        protected _nodeLineMesh: V3dGraphicLines;
        protected _nodeLineMeshBack: V3dGraphicLines;
        private _dynamicLineMesh;
        private _dynamicLineMeshBack;
        protected _material: V3dGraphicMeshMaterial;
        protected _useDynamicMesh: boolean;
        constructor();
        setup(): void;
        protected getMeshMerger(): V3dDynamicMeshMerger;
        private getSurfaceMaterial;
        get nodeParent(): V3dGraphicNode;
        set nodeParent(node: V3dGraphicNode);
        updateStyle(): void;
        updateShapeByNodeMolding(node: GeometricNode): void;
        updateTransformByMatrix(matrix: Matrix4): void;
        showHover(): void;
        showError(): void;
        showSelect(): void;
        showMode(mode: MoldingVisionEnum, colorOption: any): void;
        hide(): void;
        show(): void;
        update(): void;
        freezeWorldMatrix(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/V3dContent" {
    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 { ContentDisplay } from "foundation/editor/view/base/ContentDisplay";
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    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 { V3dBoundaryHelper } from "foundation/editor/view/view3d/helper/V3dBoundaryHelper";
    import { V3dMoldingBoundaryHelper } from "foundation/editor/view/view3d/helper/V3dMoldingBoundaryHelper";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    export class V3dContent extends ContentDisplay {
        context: V3dCanvasContext;
        layer: V3dLayer;
        node: V3dGraphicContainer;
        nodeSelector: any;
        nodeDisplay: any;
        protected _nodePreload: V3dGraphicMeshInstance;
        protected _boundaryHelper: V3dBoundaryHelper | V3dMoldingBoundaryHelper;
        protected _statusReady: boolean;
        protected _isDynamicShow: boolean;
        protected _collisionMesh: V3dGraphicMesh | V3dGraphicMeshInstance;
        constructor();
        setup(): void;
        onEditOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        createPreloadedBox(): V3dGraphicMeshInstance;
        showPreloadedBox(): void;
        hidePreloadedBox(): void;
        protected createBoundaryHelperNode(): V3dBoundaryHelper | V3dMoldingBoundaryHelper;
        protected createCollisionNode(): V3dGraphicMesh | V3dGraphicMeshInstance;
        protected updateCollisionNode(collisionMesh: V3dGraphicMesh | V3dGraphicMeshInstance): void;
        protected updateBoundaryShape(): void;
        canDraw(): boolean;
        createNode(linker?: boolean): V3dGraphicContainer;
        protected updateTransform(): void;
        protected onLoadCompleted(): void;
        protected updateShape(): void;
        protected updateStyle(): void;
        updateMerger(): void;
        drawDisplay(displayContext?: DisplayContext): void;
        showDynamic(): void;
        hideDynamic(): void;
        show(): void;
        hide(): void;
        addToView(): void;
        removeFromView(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/V3dDisplay" {
    import { QualityService } from 'cross/runtime/framework/quality/QualityService';
    import { Display } from "foundation/editor/view/base/Display";
    import { V3dGraphicContent } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContent";
    import { V3dCanvas } from "foundation/editor/view/view3d/V3dCanvas";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    export class V3dDisplay extends Display {
        context: V3dCanvasContext;
        view: V3dCanvas;
        node: V3dGraphicContent;
        protected _qualityService: QualityService;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/V3dDynamicMeshEnum" {
    export class V3dDynamicMeshEnum {
        static Dimension: string;
        static PreloadedBox: string;
        static BoundaryBox: string;
        static Technology: string;
        static FloorplanFloor: string;
        static FloorplanCeiling: string;
        static FloorplanWall: string;
        static FloorplanLinear: string;
    }
}
declare module "foundation/editor/view/view3d/V3dFloatingLayer" {
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    export class V3dFloatingLayer extends V3dLayer {
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicLevelEnum" {
    export class V3dGraphicLevelEnum {
        static Frame: number;
        static Lines: number;
        static GroundGrid: number;
        static Sprite: number;
        static Content: number;
        static Structure: number;
        static GroundPlane: number;
        static Sky: number;
    }
}
declare module "foundation/editor/view/view3d/V3dGridController" {
    import { GridNode } from 'sk/data/family/model/assistant/GridNode';
    import { DisplayController } from "foundation/editor/view/base/DisplayController";
    export class V3dGridController extends DisplayController {
        entity: GridNode;
    }
}
declare module "foundation/editor/view/view3d/V3dGrid" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { NodeFieldEvent } from 'cross/runtime/framework/node/NodeFieldEvent';
    import { GridNode } from 'sk/data/family/model/assistant/GridNode';
    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 { V3dGraphicTextureCube } from "foundation/editor/view/view3d/render/graphic/V3dGraphicTextureCube";
    import { V3dDisplay } from "foundation/editor/view/view3d/V3dDisplay";
    import { V3dGridController } from "foundation/editor/view/view3d/V3dGridController";
    export class V3dGrid extends V3dDisplay {
        entity: GridNode;
        controller: V3dGridController;
        optionSky: boolean;
        skyUri: string;
        optionCoordinate: boolean;
        optionGrid: boolean;
        optionGround: boolean;
        node: V3dGraphicContainer;
        skyTexture: V3dGraphicTextureCube;
        skyMaterial: V3dGraphicMeshMaterial;
        skyMesh: V3dGraphicMesh;
        groundTextureUri: string;
        groundSpecularTextureUri: string;
        groundMaterial: V3dGraphicMeshMaterial;
        gridSize: number;
        gridUnit: number;
        gridMesh: V3dGraphicLines;
        groundMesh: V3dGraphicMesh;
        constructor();
        setup(): void;
        onSettingsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        canDraw(): boolean;
        createNode(): V3dGraphicContainer;
        show(): void;
        hide(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/V3dShape" {
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { ContentDisplay } from "foundation/editor/view/base/ContentDisplay";
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { V3dGraphicContainer } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContainer";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    export class V3dShape extends ContentDisplay {
        context: V3dCanvasContext;
        layer: V3dLayer;
        entity: ContentNode;
        node: V3dGraphicContainer;
        constructor();
        setup(): void;
        createNode(): any;
        protected updateStatusHover(): void;
        protected updateStatus(): void;
        protected updateShape(): void;
        protected updateTransform(): void;
        drawDisplay(displayContext?: DisplayContext): void;
        show(): void;
        hide(): void;
        addToView(): void;
        removeFromView(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/V3dSpatial" {
    import { Box3 } from 'foundation/runtime/math/Box3';
    import { SpatialNode } from 'foundation/data/common/model/brep/SpatialNode';
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { SpatialDisplay } from "foundation/editor/view/base/SpatialDisplay";
    import { V3dGraphicContainer } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContainer";
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dBoundaryHelper } from "foundation/editor/view/view3d/helper/V3dBoundaryHelper";
    import { V3dDynamicMesh } from "foundation/editor/view/view3d/render/V3dDynamicMesh";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    export class V3dSpatial extends SpatialDisplay {
        context: V3dCanvasContext;
        layer: V3dLayer;
        entity: SpatialNode;
        node: V3dGraphicContainer;
        nodeSelector: any;
        nodeDisplay: V3dGraphicMesh;
        protected _nodePreload: V3dGraphicMesh;
        protected _dynamicNodePreload: V3dDynamicMesh;
        protected _boundingBox: Box3;
        protected _boundaryHelper: V3dBoundaryHelper;
        protected _statusReady: boolean;
        protected _isDynamicShow: boolean;
        constructor();
        setup(): void;
        createNode(): V3dGraphicContainer;
        protected updateShape(): void;
        protected updateTransform(): void;
        protected updateStatusHover(): void;
        protected updateStatus(): void;
        drawDisplay(displayContext?: DisplayContext): void;
        showDynamic(): void;
        hideDynamic(): void;
        show(): void;
        hide(): void;
        addToView(): void;
        removeFromView(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/asset/V3dAssetMesh" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    export class V3dAssetMesh extends Dispatcher {
    }
}
declare module "foundation/editor/view/view3d/asset/V3dAssetModel" {
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    export class V3dAssetModel extends Dispatcher {
    }
}
declare module "foundation/editor/view/view3d/camera/CameraModeEnum" {
    export class CameraModeEnum {
        static Perspective: number;
        static Front: number;
        static Left: number;
        static Back: number;
        static Right: number;
        static Top: number;
        static Bottom: number;
    }
}
declare module "foundation/editor/view/view3d/camera/V3dArcRotateCameraHelper" {
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    export class V3dArcRotateCameraHelper {
        alpha: number;
        beta: number;
        radius: number;
        lowerBetaLimit: number;
        upperBetaLimit: number;
        lowerAlphaLimit: number;
        upperAlphaLimit: number;
        lowerRadiusLimit: number;
        upperRadiusLimit: number;
        allowUpsideDown: boolean;
        private _position;
        private _target;
        private _upVector;
        get target(): Vector3;
        set target(value: Vector3);
        get position(): Vector3;
        set position(value: Vector3);
        get upVector(): Vector3;
        set upVector(value: Vector3);
        private _computationVector;
        private _upToYMatrix;
        private _YToUpMatrix;
        private _newPosition;
        private _viewMatrix;
        private _worldMatrix;
        private _cache;
        constructor(name?: string, alpha?: number, beta?: number, radius?: number, target?: Vector3, upVector?: Vector3);
        setTarget(x: number, y: number, z: number): void;
        setPosition(x: number, y: number, z: number): void;
        setUpAxis(x: number, y: number, z: number): void;
        getWorldMatrix(): Matrix4;
        getViewMatrix(force?: boolean): Matrix4;
        computeWorldMatrix(): void;
        private innerGetViewMatrix;
        private _rebuildAnglesAndRadius;
        private _setMatUp;
        private innerCheckLimits;
        private updateCache;
        private isSynchronizedViewMatrix;
    }
}
declare module "foundation/editor/view/view3d/camera/V3dCameraUtil" {
    import { ObserverViewNode } from 'foundation/data/common/model/brep/observer/ObserverViewNode';
    export class V3dCameraUtil {
        static autoFix(observer: ObserverViewNode, sizeX: number, sizeY: number, sizeZ: number, scale?: number): void;
    }
}
declare module "foundation/editor/view/view3d/gizmo/V3dLinearDimensionCommitTypeEnum" {
    export class V3dLinearDimensionCommitTypeEnum {
        static Enter: string;
        static Click: string;
    }
}
declare module "foundation/editor/view/view3d/gizmo/V3dLinearDimensionStateEnum" {
    export class V3dLinearDimensionStateEnum {
        static Disabled: number;
        static Editable: number;
        static Focus: number;
        static Invalid: number;
    }
}
declare module "foundation/editor/view/view3d/gizmo/V3dTemp" {
    import { Temp } from "foundation/editor/view/base/gizmo/Temp";
    import { V3dCanvas } from "foundation/editor/view/view3d/V3dCanvas";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    export class V3dTemp extends Temp {
        view: V3dCanvas;
        context: V3dCanvasContext;
        drawing: any;
        protected _canMoveCanvas: boolean;
        protected _movingCanvas: boolean;
        optionCanvasMove: boolean;
        onMouseDown(event: MouseEvent, x: number, y: number): void;
        onMouseMove(event: MouseEvent, x: number, y: number): void;
        onMouseUp(event: MouseEvent, x: number, y: number): void;
        onMouseClick(event: MouseEvent, x: number, y: number): void;
        onKeyDown(event: any): void;
        onKeyUp(event: any): void;
        onElementMouseDown(event: MouseEvent, x: number, y: number): void;
        onElementMouseMove(event: MouseEvent, x: number, y: number): void;
        onElementMouseUp(event: MouseEvent, x: number, y: number): void;
        onElementClick(event: MouseEvent, x: number, y: number): void;
        onElementDragStart(event: MouseEvent, x: number, y: number): void;
        onElementDragMove(event: MouseEvent, cx: number, cy: number, x: number, y: number): void;
        onElementDragEnd(event: MouseEvent): void;
        draw(): void;
    }
}
declare module "foundation/editor/view/view3d/helper/V3d3DArrowHelper" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    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 { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dHelper } from "foundation/editor/view/view3d/helper/V3dHelper";
    export class V3d3DArrowHelper extends V3dHelper {
        context: V3dCanvasContext;
        protected _lineMesh: V3dGraphicMesh;
        protected _arrowMesh: V3dGraphicMesh;
        protected _baseNode: V3dGraphicContainer;
        protected _lineWidth: number;
        protected _lineLength: number;
        protected _arrowWidth: number;
        protected _arrowLength: number;
        protected _direction: Vector3;
        protected _materialArrow: V3dGraphicMeshMaterial;
        protected _materialLine: V3dGraphicMeshMaterial;
        protected _lineColor: Vector3;
        protected _arrowColor: Vector3;
        protected _rotation: Vector3;
        protected _showArrow: boolean;
        protected _useDirection: boolean;
        setLine(width: number, length: number): void;
        setArrow(width: number, length: number): void;
        set lineColor(color: Vector3);
        set arrowColor(color: Vector3);
        set showArrow(show: boolean);
        set degree(rot: Vector3);
        set direction(dir: Vector3);
        constructor();
        dispose(): void;
        setup(): void;
        protected updateLineMesh(): void;
        static createCylinderGEO(diameterTop: number, diameterBottom: number, height: number, tessellation: number, closeTop: boolean, closeBototm: boolean): BufferGeometry;
        protected updateArrowMesh(): void;
        protected updatePos(): void;
        protected updateArrowVisiable(): void;
    }
}
declare module "foundation/editor/view/view3d/helper/V3d3DPlaneHelper" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    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 { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dHelper } from "foundation/editor/view/view3d/helper/V3dHelper";
    export class V3d3DPlaneHelper extends V3dHelper {
        context: V3dCanvasContext;
        protected _planeMesh: V3dGraphicMesh;
        protected _size: Vector2;
        protected _direction: Vector3;
        protected _baseNode: V3dGraphicContainer;
        protected _rotation: Vector3;
        protected _useDirection: boolean;
        protected _materialPlane: V3dGraphicMeshMaterial;
        protected _planeColor: Vector3;
        protected _alpha: number;
        constructor();
        setSize(lenX: number, lenY: number): void;
        set planeColor(color: Vector3);
        set alpha(a: number);
        set degree(rot: Vector3);
        set direction(dir: Vector3);
        dispose(): void;
        setPosition(x: number, y: number, z: number): void;
        setup(): void;
        protected updatePlaneMesh(): void;
        protected updatePos(): void;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dAlignmentLineTypeEnum" {
    export class V3dAlignmentLineTypeEnum {
        static X: string;
        static Y: string;
        static Z: string;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dAlignmentLine" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { V3dAlignmentLineTypeEnum } from "foundation/editor/view/view3d/helper/V3dAlignmentLineTypeEnum";
    export class V3dAlignmentLine extends InstanceObject {
        typeCd: V3dAlignmentLineTypeEnum;
        position: Vector3;
        color: number;
        constructor();
        writeData(points: Types<number>, colors: Types<number>): void;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dAlignmentLineHelper" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { LineSegments } from 'foundation/runtime/graphics/actor/LineSegments';
    import { V3dAlignmentLine } from "foundation/editor/view/view3d/helper/V3dAlignmentLine";
    import { V3dHelper } from "foundation/editor/view/view3d/helper/V3dHelper";
    export class V3dAlignmentLineHelper extends V3dHelper {
        lines: Types<V3dAlignmentLine>;
        lineActor: LineSegments;
        protected _positions: Types<number>;
        protected _colors: Types<number>;
        constructor();
        setup(): void;
        pushLine(line: V3dAlignmentLine): void;
        update(): void;
        clear(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dArrowHelper" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Color3 } from 'foundation/runtime/math/Color3';
    import { Value3 } from 'foundation/runtime/math/Value3';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { ObserverChangeEvent } from "foundation/editor/view/base/ObserverChangeEvent";
    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 { V3dHelper } from "foundation/editor/view/view3d/helper/V3dHelper";
    export class ArrowStyleEnum {
        static ArrowStyle1: string;
        static ArrowStyle2: string;
    }
    export class V3dArrowHelper extends V3dHelper {
        protected _begin: Vector3;
        protected _end: Vector3;
        arrowWidth: number;
        arrowHeight: number;
        protected _arrowBeginShow: boolean;
        protected _arrowBeginColor: Vector3;
        protected _arrowBeginMaterial: V3dGraphicMeshMaterial;
        protected _arrowBeginMesh: V3dGraphicMesh;
        protected _arrowBeginMeshDirty: boolean;
        protected _arrowEndShow: boolean;
        protected _arrowEndColor: Vector3;
        protected _arrowEndMaterial: V3dGraphicMeshMaterial;
        protected _arrowEndMesh: V3dGraphicMesh;
        protected _arrowEndMeshDirty: boolean;
        protected _lineWidth: number;
        protected _lineColor: Color3;
        protected _lineMesh: V3dGraphicLines;
        protected _lineMeshBack: V3dGraphicLines;
        protected _lineMeshDirty: boolean;
        protected _dashLine: boolean;
        protected _arrowStyleBegin: string;
        protected _arrowStyleEnd: string;
        protected _dashPattern: Array<number>;
        protected _dashSize: number;
        protected _dashLength: number;
        protected _gapSize: number;
        protected _dashNumber: number;
        protected _beginExtentPosEnd: Vector3;
        protected _endExtentPosEnd: Vector3;
        protected _extentBegin: V3dGraphicLines;
        protected _extentEnd: V3dGraphicLines;
        protected _backMeshDashPattern: Array<number>;
        protected _beginExtentMeshDirty: boolean;
        protected _endExtentMeshDirty: boolean;
        constructor();
        get beginPos(): Readonly<Vector3>;
        get endPos(): Readonly<Vector3>;
        set lineWidth(value: number);
        set dashLine(b: boolean);
        set dashLength(len: number);
        set dashSize(s: number);
        set gapSize(s: number);
        set lineColor(c: Color3);
        set arrowColorBegin(c: Vector3);
        set arrowColorEnd(c: Vector3);
        set dashPattern(p: Array<number>);
        set showArrowBegin(show: boolean);
        set showArrowEnd(show: boolean);
        setup(): void;
        drawArrow(): void;
        protected onCameraChanged(sender: ListenerContext, event: ObserverChangeEvent): void;
        show(): void;
        hide(): void;
        setBeginEnd(begin: Value3, end: Value3): void;
        protected updateArrowPos(): void;
        protected updateArrowBeginMesh(): void;
        protected recalArrowBeginMesh(): void;
        protected updateArrowEndMesh(): void;
        protected updateBegineExtentMesh(): void;
        protected updateEndExtentMesh(): void;
        protected createArrowMesh(isEndArrow: boolean): V3dGraphicMesh;
        protected updateArrowMesh(isEndArrow: boolean): BufferGeometry;
        protected recalArrowEndMesh(): void;
        protected updateLineMesh(): void;
        setEnable(enable: boolean): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dBoxHelper" {
    import { V3dHelper } from "foundation/editor/view/view3d/helper/V3dHelper";
    export class V3dBoxHelper extends V3dHelper {
    }
}
declare module "foundation/editor/view/view3d/helper/V3dCoordinateHelper" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    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 { V3d3DArrowHelper } from "foundation/editor/view/view3d/helper/V3d3DArrowHelper";
    import { V3dHelper } from "foundation/editor/view/view3d/helper/V3dHelper";
    export class V3dCoordinateHelper extends V3dHelper {
        protected _axisX: Vector3;
        protected _axisY: Vector3;
        protected _axisZ: Vector3;
        protected _position: Vector3;
        protected _isVisiable: boolean;
        protected _axisLength: number;
        protected _sphereSize: number;
        protected _showX: boolean;
        protected _showY: boolean;
        protected _showZ: boolean;
        protected _showSphere: boolean;
        protected _meshSphere: V3dGraphicMesh;
        protected _arrowAxisX: V3d3DArrowHelper;
        protected _arrowAxisY: V3d3DArrowHelper;
        protected _arrowAxisZ: V3d3DArrowHelper;
        protected _colorAxisX: Vector3;
        protected _colorAxisY: Vector3;
        protected _colorAxisZ: Vector3;
        protected _baseNode: V3dGraphicContainer;
        protected _materialSphere: V3dGraphicMeshMaterial;
        protected _sphereSizeDirty: boolean;
        constructor();
        get showAxisX(): boolean;
        get showAxisY(): boolean;
        get showAxisZ(): boolean;
        get showShpere(): boolean;
        get sphereSize(): number;
        get axisLength(): number;
        set showAxisX(show: boolean);
        set showAxisY(show: boolean);
        set showAxisZ(show: boolean);
        set showShpere(show: boolean);
        set sphereSize(size: number);
        set axisLength(size: number);
        set isVisiable(show: boolean);
        setup(): void;
        setAxis(axisX: Vector3, axisY: Vector3, axisZ: Vector3): void;
        setRotation(x: number, y: number, z: number): void;
        setDegree(x: number, y: number, z: number): void;
        protected setVisibleAxisX(show: Boolean): void;
        protected setVisibleAxisY(show: Boolean): void;
        protected setVisibleAxisZ(show: Boolean): void;
        protected setVisibleShpere(show: Boolean): void;
        protected updateAxisMesh(): void;
        protected updateSphereMesh(): void;
        protected updateVisiable(): void;
        dispose(): void;
        static createShpereGEO(diameter: number, tessellationX: number, tessellationZ: number): BufferGeometry;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dLinesHelper" {
    import { Color } from 'foundation/runtime/math/Color';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { Polygon } from 'foundation/runtime/graphics/shape/brep/Polygon';
    import { Lines } from 'foundation/runtime/graphics/data/Lines';
    import { PlaneEnum } from 'foundation/runtime/graphics/shape/PlaneEnum';
    import { V3dGraphicLines } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLines";
    import { V3dHelper } from "foundation/editor/view/view3d/helper/V3dHelper";
    export class V3dLinesHelper extends V3dHelper {
        optionBorder: boolean;
        optionDash: boolean;
        borderPattern: Array<number>;
        borderColor: Color;
        borderOpacity: number;
        optionBorderBack: boolean;
        optionDashBack: boolean;
        borderBackPattern: Array<number>;
        borderBackOpacity: number;
        borderBackColor: Color;
        borderBackSolid: number;
        borderBackBreak: number;
        protected _frontLinesMesh: V3dGraphicLines;
        protected _backLinesMesh: V3dGraphicLines;
        constructor();
        setup(): void;
        get front(): V3dGraphicLines;
        get back(): V3dGraphicLines;
        private createLinesMesh;
        updateStyle(): void;
        callBothLines(funcName: string, ...parameters: any[]): void;
        updateLines(lines: Lines, segmentsMode?: boolean): void;
        updatePolygon(polygon: Polygon, planeCd: PlaneEnum, matrix: Matrix4): void;
        update(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dPlaneHelper" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    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 { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dCoordinateHelper } from "foundation/editor/view/view3d/helper/V3dCoordinateHelper";
    import { V3dHelper } from "foundation/editor/view/view3d/helper/V3dHelper";
    export class V3dPlaneHelper extends V3dHelper {
        context: V3dCanvasContext;
        protected _position: Vector3;
        protected _planeSize: number;
        protected _planeColor: Vector3;
        protected _showPlane: boolean;
        protected _showCoordinate: boolean;
        protected _nodeRoot: V3dGraphicContainer;
        protected _coordinateHelper: V3dCoordinateHelper;
        protected _meshPlane: V3dGraphicMesh;
        protected _materialPlane: V3dGraphicMeshMaterial;
        constructor();
        get position(): Vector3;
        set position(pos: Vector3);
        get planeSize(): number;
        set planeSize(s: number);
        get showPlane(): boolean;
        set showPlane(show: boolean);
        set showCoordinate(show: boolean);
        set planeColor(c: Vector3);
        setAxis(axisX: Vector3, axisY: Vector3, axisZ: Vector3): void;
        setRotation(x: number, y: number, z: number): void;
        setDegree(x: number, y: number, z: number): void;
        setup(): void;
        protected updatePlaneVisiable(): void;
        protected updateCoordinateVisiable(): void;
        protected updatePlaneMesh(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dPointHelper" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Color } from 'foundation/runtime/math/Color';
    import { BoxSolid } from 'foundation/runtime/geometry/solid/BoxSolid';
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dGraphicMeshMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial";
    import { V3dHelper } from "foundation/editor/view/view3d/helper/V3dHelper";
    export class V3dPointHelper extends V3dHelper {
        color: Color;
        hightlightColor: Color;
        selectColor: Color;
        adjustSize: number;
        zOffset: number;
        renderingGroupId: number;
        protected _material: V3dGraphicMeshMaterial;
        protected _highlightMaterial: V3dGraphicMeshMaterial;
        protected _selectMaterial: V3dGraphicMeshMaterial;
        protected _pointMesh: V3dGraphicMesh;
        protected _pointMeshes: Types<V3dGraphicMesh>;
        protected _selectMesh: V3dGraphicMesh;
        protected _highlightMesh: V3dGraphicMesh;
        constructor();
        setup(): void;
        private createPointMesh;
        updateByBox(box: BoxSolid): void;
        freezeWorldMatrix(): void;
        selectMesh(name: String): void;
        highlight(name: string, show: boolean): void;
        private updateStyle;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dPreloadedHelper" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dGraphicMeshMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial";
    import { V3dHelper } from "foundation/editor/view/view3d/helper/V3dHelper";
    export class V3dPreloadedHelper extends V3dHelper {
        protected _length: number;
        protected _width: number;
        protected _height: number;
        protected _preloaded: number;
        protected _colorBack: Vector3;
        protected _colorFront: Vector3;
        protected _materialBack: V3dGraphicMeshMaterial;
        protected _materialFront: V3dGraphicMeshMaterial;
        protected _meshBack: V3dGraphicMesh;
        protected _meshFront: V3dGraphicMesh;
        constructor();
        set colorBack(color: Vector3);
        set colorFront(color: Vector3);
        set boxSize(size: Vector3);
        setSize(length: number, width: number, height: number): void;
        set preLoaded(num: number);
        setup(): void;
        protected updateMesh(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dSphereHelper" {
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dGraphicMeshMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial";
    import { V3dHelper } from "foundation/editor/view/view3d/helper/V3dHelper";
    export class V3dSphereHelper extends V3dHelper {
        protected _sphereMesh: V3dGraphicMesh;
        protected _sphereDiameter: number;
        protected _materialSphere: V3dGraphicMeshMaterial;
        protected _sphereColor: Vector3;
        protected _renderGroupID: number;
        constructor();
        set color(color: Vector3);
        set diameter(d: number);
        set showFront(val: boolean);
        setup(): void;
        protected updateShpereMesh(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/helper/V3dTileHelper" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Size2 } from 'foundation/runtime/math/Size2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ObserverChangeEvent } from "foundation/editor/view/base/ObserverChangeEvent";
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dGraphicMeshMaterial } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMeshMaterial";
    import { V3dHelper } from "foundation/editor/view/view3d/helper/V3dHelper";
    export class V3dTileHelper extends V3dHelper {
        protected _tileMesh: V3dGraphicMesh;
        protected _tileMaterial: V3dGraphicMeshMaterial;
        protected _contentDirty: boolean;
        protected _charWidth: number;
        protected _charHeight: number;
        protected _position: Vector3;
        protected _width: number;
        protected _height: number;
        protected _content: Array<string>;
        protected _dict: Map<string, {
            uv: Vector2;
            size: Size2;
        }>;
        constructor();
        setup(): void;
        protected initDict(): void;
        private loadMaterial;
        private loadMaterailAsync;
        protected onCameraChanged(sender: ListenerContext, event: ObserverChangeEvent): void;
        protected updateTileMesh(): void;
        buildText(value: string): void;
        get width(): number;
        get height(): number;
        get position(): Readonly<Vector3>;
        set pos(value: Vector3);
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dContentIndicator" {
    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 { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { DataBlueprintNode } from 'foundation/data/common/model/DataBlueprintNode';
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dIndicator } from "foundation/editor/view/view3d/indicator/V3dIndicator";
    export class V3dContentIndicator extends V3dIndicator {
        context: V3dCanvasContext;
        entity: ContentNode;
        blueprint: DataBlueprintNode;
        protected _statusTransformChanged: boolean;
        protected _statusShapeChanged: boolean;
        constructor();
        setup(): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onEditOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
        protected updateTransform(): void;
        protected updateShape(): void;
        drawDisplay(displayContext?: DisplayContext): void;
        bindAction(): void;
        unbindAction(): void;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorEventEnum" {
    export class V3dIndicatorEventEnum {
        static Enter: string;
        static Leave: string;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorPipelinePointController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { ContentActionEvent } from "foundation/editor/view/action/content/ContentActionEvent";
    import { V3dIndicatorController } from "foundation/editor/view/view3d/indicator/V3dIndicatorController";
    import { V3dIndicatorPipelinePoint } from "foundation/editor/view/view3d/indicator/V3dIndicatorPipelinePoint";
    export class V3dIndicatorPipelinePointController extends V3dIndicatorController {
        display: V3dIndicatorPipelinePoint;
        protected _screenFactor: number;
        protected _startPoint: Vector3;
        protected _moveDir: Vector3;
        protected _screenDir: Vector2;
        private _indicatorMatrix;
        private info;
        onMouseEnter(sender: ListenerContext, event: any): void;
        onMouseEnterChange(sender: ListenerContext, event: any): void;
        onMouseLeave(sender: ListenerContext, event: any): void;
        onDragStart(sender: ListenerContext, event: any): boolean;
        onDragMove(sender: ListenerContext, event: ContentActionEvent): boolean;
        private onMoveStart;
        private onMove;
        private onRotateStart;
        private onRotate;
        onDragEnd(sender: ListenerContext, event: ContentActionEvent): boolean;
        dispatchToDisplay(code: any, event: any): void;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dIndicatorPipelinePoint" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Color3 } from 'foundation/runtime/math/Color3';
    import { Matrix3d } from 'foundation/runtime/math/Matrix3d';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { ObserverModeEnum } from 'foundation/data/common/model/brep/ObserverModeEnum';
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    import { V3dGraphicLines } from "foundation/editor/view/view3d/render/graphic/V3dGraphicLines";
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dIndicator } from "foundation/editor/view/view3d/indicator/V3dIndicator";
    import { V3dIndicatorPipelinePointController } from "foundation/editor/view/view3d/indicator/V3dIndicatorPipelinePointController";
    export type V3dIndicatorInfo = {
        type: string;
        dir?: Vector3;
        line: V3dGraphicLines;
        arrow: V3dGraphicMesh;
        color: Color3;
    };
    export class V3dIndicatorPipelinePoint extends V3dIndicator {
        context: V3dCanvasContext;
        controller: V3dIndicatorPipelinePointController;
        anchor: Vector3;
        normal: Vector3;
        hasHost: boolean;
        localMatrix: Matrix3d;
        nodeMatrix: Matrix3d;
        worldMatrix: Matrix3d;
        meshInfos: {
            [key: string]: V3dIndicatorInfo;
        };
        private _statusLocalMatrixChanged;
        private intersectionThreshold;
        constructor();
        setup(): void;
        updatePos(): void;
        private getLocalMatrixByAxisData;
        bindAction(): void;
        unbindAction(): void;
        protected onCameraChanged(owner: any, event: any): void;
        protected updateAxisByCameraModeCd(mode: ObserverModeEnum): void;
        setLocalMatrix(): void;
        private createMesh;
        private createLine;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onDraw(context?: DisplayContext): void;
        private updateTransform;
        highLight(name: string, bool: boolean): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dOpeningController" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { ContentActionEvent } from "foundation/editor/view/action/content/ContentActionEvent";
    import { DisplayController } from "foundation/editor/view/base/DisplayController";
    export class V3dOpeningController extends DisplayController {
        entity: any;
        originPos: any;
        setup(): void;
        onMouseEnter(sender: ListenerContext, event: ContentActionEvent): void;
        onMouseLeave(sender: ListenerContext, event: ContentActionEvent): void;
    }
}
declare module "foundation/editor/view/view3d/indicator/V3dOpeningIndicator" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { EnvironmentService } from 'cross/runtime/module/environment/EnvironmentService';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
    import { OpeningNode } from 'sk/data/family/model/instance/OpeningNode';
    import { ContentActionEvent } from "foundation/editor/view/action/content/ContentActionEvent";
    import { DisplayContext } from "foundation/editor/view/base/DisplayContext";
    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 { V3dContentIndicator } from "foundation/editor/view/view3d/indicator/V3dContentIndicator";
    export class V3dOpeningIndicator extends V3dContentIndicator {
        entity: OpeningNode;
        contentBoundingHeight: number;
        line: V3dGraphicLines;
        nodeDisplay: V3dGraphicLines;
        nodeDisplayArrow0: V3dGraphicMesh;
        nodeDisplayArrow1: V3dGraphicMesh;
        nodeDisplayArrow2: V3dGraphicMesh;
        nodeDisplayArrow3: V3dGraphicMesh;
        nodeMaterial: V3dGraphicMeshMaterial;
        rotation: number;
        protected _environmentService: EnvironmentService;
        private static _meshData;
        isReDraw: boolean;
        lastScaleX: number;
        lastScaleY: number;
        lastScaleZ: number;
        beginScaleX: number;
        beginScaleY: number;
        beginScaleZ: number;
        isNoHost: boolean;
        host: any;
        constructor();
        setup(): void;
        createDisplayNode(): void;
        onIndicatorEnter(sender: ListenerContext, event: ContentActionEvent): void;
        onIndicatorLeave(sender: ListenerContext, event: ContentActionEvent): void;
        getPosition(): Vector3;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        setTransform(): void;
        onCameraChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
        onDraw(context?: DisplayContext): void;
        onShow(): void;
        disposeDisplay(): void;
        onHide(): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/V3dDynamicMeshDisplay" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Matrix4 } from 'foundation/runtime/math/Matrix4';
    import { BufferGeometry } from 'foundation/runtime/graphics/data/BufferGeometry';
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    export class V3dDynamicMeshDisplay extends V3dGraphicMesh {
        isLighting: boolean;
        mergeGeometry: BufferGeometry;
        mergeGeometries: Types<BufferGeometry>;
        mergeMatrixs: Types<Matrix4>;
        constructor(name: string);
        isValidGemetry(): boolean;
        updateMerge(): void;
        reset(): void;
    }
    export type V3dDynamicMeshDisplayMap = {
        [key: string]: V3dDynamicMeshDisplay;
    };
}
declare module "foundation/editor/view/view3d/render/V3dDynamicMeshManager" {
    import { ObjectPool } from 'cross/runtime/lang/ObjectPool';
    import { ViewContext } from 'cross/runtime/framework/view/ViewContext';
    import { Manager } from 'cross/runtime/framework/Manager';
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dLayer } from "foundation/editor/view/view3d/V3dLayer";
    import { V3dDynamicLinesMesh } from "foundation/editor/view/view3d/render/V3dDynamicLinesMesh";
    import { V3dDynamicMesh } from "foundation/editor/view/view3d/render/V3dDynamicMesh";
    import { V3dDynamicMeshMerger, V3dDynamicMeshMergerMap } from "foundation/editor/view/view3d/render/V3dDynamicMeshMerger";
    export class V3dDynamicMeshManager extends Manager {
        context: V3dCanvasContext;
        pool: ObjectPool<V3dDynamicMeshMerger>;
        mergers: V3dDynamicMeshMergerMap;
        constructor();
        find(id: string): V3dDynamicMeshMerger;
        register(name: string, merger?: V3dDynamicMeshMerger, layer?: V3dLayer, viewLevel?: number): V3dDynamicMeshMerger;
        unregister(code: string): void;
        registerMesh(name: string, mesh: V3dDynamicMesh | V3dDynamicLinesMesh): V3dDynamicMeshMerger;
        unregisterMesh(name: string, mesh: V3dDynamicMesh | V3dDynamicLinesMesh): V3dDynamicMeshMerger;
        alloc(): V3dDynamicMeshMerger;
        freeMesh(mesh: V3dDynamicMeshMerger): void;
        process(viewContext: ViewContext): void;
    }
}
declare module "foundation/editor/view/view3d/render/V3dDynamicMeshManagerService" {
    import { Service } from 'cross/runtime/module/Service';
    import { V3dDynamicMeshManager } from "foundation/editor/view/view3d/render/V3dDynamicMeshManager";
    export class V3dDynamicMeshManagerService extends Service {
        private _managers;
        private _mergeDatas;
        registerManager(canvasId: string, manager: V3dDynamicMeshManager, replace?: boolean): void;
        registerMerge(canvasId: string, mergeId: string, options?: any, clazz?: any): void;
        fetchManager(canvasId: string): void;
        registerAndFetchManager(canvasId: string, manager: V3dDynamicMeshManager, replace?: boolean): void;
    }
}
declare module "foundation/editor/view/view3d/render/V3dMeshManager" {
    import { Manager } from 'cross/runtime/framework/Manager';
    import { V3dGraphicMeshMap, V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    export class V3dMeshManager extends Manager {
        meshs: V3dGraphicMeshMap;
        constructor();
        find(guid: string): V3dGraphicMesh;
        register(mesh: V3dGraphicMesh): void;
        unregister(mesh: V3dGraphicMesh): void;
        unregisterByGuid(guid: string): void;
        unregisterByGuids(guids: string[]): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/V3dFamilyModelActor" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Dispatcher } from 'cross/runtime/lang/Dispatcher';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { DocumentEvent } from 'cross/runtime/framework/document/DocumentEvent';
    import { ModelMeshNode } from 'sk/data/resource/model/model/ModelMeshNode';
    import { ModelNode } from 'sk/data/resource/model/model/ModelNode';
    import { V3dCanvasContext } from "foundation/editor/view/view3d/V3dCanvasContext";
    import { V3dGraphicContainer } from "foundation/editor/view/view3d/render/graphic/V3dGraphicContainer";
    import { V3dGraphicMesh } from "foundation/editor/view/view3d/render/graphic/V3dGraphicMesh";
    import { V3dMeshManager } from "foundation/editor/view/view3d/render/V3dMeshManager";
    export class ActorProperty {
        lengthXFormulaString: string;
        lengthYFormulaString: string;
        lengthZFormulaString: string;
        xFormulaString: string;
        yFormulaString: string;
        zFormulaString: string;
        constructor();
    }
    export class V3dFamilyModelActor extends Dispatcher {
        static EVENT_COMPLETE: string;
        static EVENT_FAILURE: string;
        context: V3dCanvasContext;
        id: string;
        version: string;
        node: V3dGraphicContainer;
        property: ActorProperty;
        familyContainerParent: any;
        _familyContainer: any;
        protected _modelNodes: Types<ModelNode>;
        protected _v3dMeshs: Types<V3dGraphicMesh>;
        protected _v3dMeshParents: Types<V3dGraphicContainer>;
        protected _loadedModelCount: number;
        protected _modelTotalCount: number;
        protected _meshManager: V3dMeshManager;
        constructor();
        protected setup(): void;
        protected loadModelData(guid: string, version: string, index: number): void;
        protected onLoadFamilyComplete(sender: ListenerContext, event: DocumentEvent): void;
        protected loadFamily(): void;
        protected onLoadFamilyFailure(sender: ListenerContext, event: DocumentEvent): void;
        protected onLoadModelComplete(sender: ListenerContext, event: DocumentEvent): void;
        protected isLoadAllModelComplete(): boolean;
        protected getFamilyModelNodeAt(index: number): any;
        protected onLoadModelFailure(sender: ListenerContext, event: DocumentEvent): void;
        protected createFamilyModelByModel(model: ModelNode): any;
        protected createDisplayMesh(meshNode: any, meshNode2: ModelMeshNode): V3dGraphicMesh;
        protected findDisplayMesh(meshNode: any, meshNode2: ModelMeshNode): V3dGraphicMesh;
        protected buildNode(modelNode: ModelNode, familyModelNode: any): void;
        protected unregisterDisplayMeshs(): void;
        protected unregisterDisplayMeshsOfFamilyModeNode(familyModelNode: any): void;
        protected updateAllMeshInFamilyContainer(): void;
        protected computeFamilyContainer(): void;
        protected updateMeshNode(node: V3dGraphicContainer, meshNode: any, meshNode2: ModelMeshNode): void;
        static create(context: V3dCanvasContext, guid: string, version: string, parent?: any): V3dFamilyModelActor;
        update(property?: ActorProperty): void;
        dispose(): void;
    }
}
declare module "foundation/editor/view/view3d/render/V3dModelEnum" {
    export class V3dModelPlaceEnum {
        static Origin: string;
        static Center: string;
    }
}
declare module "foundation/editor/view/view3d/render/graphic/V3dGraphicLightTypeEnum" {
    export class V3dGraphicLightTypeEnum {
        static Directional: string;
        static Spot: string;
        static Point: string;
        static Area: string;
    }
}