/// <reference path="../library/typings/cross-editor.d.ts" />
/// <reference path="../typings/private/foundation-data-common.d.ts" />
/// <reference path="../typings/private/foundation-editor-base.d.ts" />
/// <reference path="../typings/private/foundation-editor-ui.d.ts" />
/// <reference path="../typings/private/sk-data-logic.d.ts" />
/// <reference path="../typings/private/sk-data-furniture.d.ts" />
/// <reference path="../typings/private/sk-rule-data.d.ts" />
/// <reference path="../typings/private/sk-rule-process.d.ts" />
/// <reference path="../typings/private/sk-editor-view.d.ts" />
/// <reference path="../typings/private/sk-editor-frame.d.ts" />
/// <reference path="../typings/private/sk-editor-family.d.ts" />
/// <reference path="../typings/private/sk-editor-product.d.ts" />
/// <reference path="../typings/private/sk-frame-logic.d.ts" />
/// <reference path="../typings/private/sk-frame-plugin-editor-module.d.ts" />
/// <reference path="../typings/private/sk-frame-plugin-product-base.d.ts" />
/// <reference types="react" />
declare module "copyright" {
    export class FramePluginProductRuleCopyright {
        static toString(): string;
    }
}
declare module "sk/frame/plugin/product/rule/IndexSpace" {
    export class IndexSpace {
        static namespaces(): string[];
    }
}
declare module "sk/frame/plugin/product/rule/RuleEditorModule" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { SchemeDocumentService } from 'sk/data/scheme/service/SchemeDocumentService';
    import { FrameEditorModule } from 'sk/editor/view/frame/FrameEditorModule';
    import { SchemeEditorDocument } from 'sk/frame/logic/scheme/SchemeEditorDocument';
    import { RuleEditorDocument } from 'sk/frame/plugin/editor/module/rule/rule/frame/RuleEditorDocument';
    export class RuleEditorModule extends FrameEditorModule {
        statusBuild: boolean;
        protected _schemeDocument: SchemeEditorDocument;
        protected _schemeDocumentService: SchemeDocumentService;
        constructor();
        get document(): RuleEditorDocument;
        get schemeDocument(): SchemeEditorDocument;
        onStartup(): void;
        onBindCanvasAsync(json?: any): Promise<any>;
        onReleaseCanvas(): void;
        buildWorkflowAsync(): Promise<ResultObject>;
        static get instance(): RuleEditorModule;
    }
}
declare module "sk/frame/plugin/product/rule/RuleEditorFrameBase" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
    import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
    import { RuleInstanceItemElement } from 'sk/data/family/rule/element/instance/RuleInstanceItemElement';
    import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
    import { RuleDocumentService } from 'sk/data/family/rule/RuleDocumentService';
    import { RuleTypeDocumentService } from 'sk/data/family/rule/RuleTypeDocumentService';
    import { FamilyConfigService } from 'sk/data/family/service/FamilyConfigService';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { FamilyTypeDocumentService } from 'sk/data/family/service/FamilyTypeDocumentService';
    import { SchemeElementPerformerContext } from 'sk/data/scheme/performer/element/SchemeElementPerformerContext';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { FrameEditorFrame, FrameEditorFrameProps, FrameEditorFrameState } from 'sk/editor/view/frame/FrameEditorFrame';
    import { RuleService } from 'sk/frame/logic/storage/module/rule/rule/RuleService';
    import { CanvasViewComponent } from 'sk/frame/logic/editor/component/CanvasViewComponent';
    import { SchemeEditorDocument } from 'sk/frame/logic/scheme/SchemeEditorDocument';
    import { RuleEditorDocument } from 'sk/frame/plugin/editor/module/rule/rule/frame/RuleEditorDocument';
    import { RuleDocumentLoader } from 'sk/frame/plugin/editor/module/rule/rule/ui/RuleDocumentLoader';
    import { RuleEditorModule } from "sk/frame/plugin/product/rule/RuleEditorModule";
    export class RuleEditorFrameBase<P extends FrameEditorFrameProps = any, S extends FrameEditorFrameState = any> extends FrameEditorFrame {
        document: RuleEditorDocument;
        schemeDocument: SchemeEditorDocument;
        module: RuleEditorModule;
        view2d: CanvasViewComponent;
        view3d: CanvasViewComponent;
        schemeDocumentJson: any;
        protected _ruleService: RuleService;
        _selectElement: any;
        protected _ruleDocumentService: RuleDocumentService;
        protected _ruleTypeDocumentService: RuleTypeDocumentService;
        ruleItemDocument: RuleEditorDocument;
        protected _documentService: FamilyDocumentService;
        protected _familyTypeDocumentService: FamilyTypeDocumentService;
        protected _familyConfigService: FamilyConfigService;
        protected _schemeConfigService: SchemeConfigService;
        protected _calculatorService: CalculatorService;
        protected _loader: RuleDocumentLoader;
        protected _ruleProcessMap: Map<string, string>;
        constructor(props?: any, context?: any);
        getDocument(): void;
        onBindCanvasAsync(): Promise<void>;
        onReleaseCanvas(): void;
        loadDocumentAsync(): Promise<any>;
        loadSchemeDocumentAsync(): Promise<any>;
        loadRuleDocumentAsync(): Promise<any>;
        loadDocumentByIdAsync(context: SchemeElementPerformerContext, id: string): Promise<ResultObject<RuleEditorDocument>>;
        loadRuleDocumentByIdAsync: (id: string, sync?: boolean) => Promise<RuleEditorDocument>;
        protected processRulesAsync(context: SchemeElementPerformerContext, element: ContentElement, node: ContentNode, rule: RuleInstanceItemElement): Promise<ResultObject>;
        onSaveAsync: () => Promise<void>;
        onCancel: () => void;
        onResize: () => void;
        render(): JSX.Element;
    }
}
declare module "sk/frame/plugin/product/rule/RuleEditorUtil" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { RuleInputElement } from 'sk/data/family/rule/element/instance/RuleInputElement';
    import { RuleInstanceItemElement } from 'sk/data/family/rule/element/instance/RuleInstanceItemElement';
    import { RuleParameterElement } from 'sk/data/family/rule/element/instance/RuleParameterElement';
    import { RuleDocumentService } from 'sk/data/family/rule/RuleDocumentService';
    import { RuleEditorDocument } from 'sk/frame/plugin/editor/module/rule/rule/frame/RuleEditorDocument';
    export class RuleEditorUtil {
        protected static _ruleDocumentService: RuleDocumentService;
        static documentToRuleInputElement: (document: RuleEditorDocument) => RuleInputElement;
        static codeToInputParameter(inputEle: RuleInputElement, pickCode: string): RuleParameterElement;
        static documentToRuleInstanceItem: (document: RuleEditorDocument, id: any) => RuleInstanceItemElement;
        static documentToRuleInstanceItems: (document: RuleEditorDocument) => Types<RuleInstanceItemElement>;
        static documentToRuleItemIdsAsync: (document: RuleEditorDocument, target?: Array<string>) => Promise<Array<string>>;
        static saveRuleEditorDocumentAsync(document: RuleEditorDocument): Promise<boolean>;
        static deleteRuleItemAsync(id: string): Promise<boolean>;
        static clearCacheAsync(document: RuleEditorDocument): Promise<void>;
    }
}
declare module "sk/frame/plugin/product/rule/handlerule/UiLogicHandleRuleModals" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { UiContainer } from 'foundation/editor/ui/core/UiContainer';
    import { UiTable } from 'foundation/editor/ui/table/UiTable';
    export class UiLogicHandleRuleModals extends UiContainer {
        state: any;
        _table: UiTable;
        props: any;
        private afterClose;
        private afterSubmit;
        private allseleRows;
        refTexturePickModals: any;
        refMaterialPickTree: any;
        _datasetController: any;
        defaultId: string;
        defaultBindCategory: Array<any>;
        defaultTreeId: string;
        initDefaultId: string;
        dataColumns: ({
            title: string;
            dataIndex: string;
            key: string;
            editable?: undefined;
        } | {
            title: string;
            dataIndex: string;
            key: string;
            editable: boolean;
        })[];
        constructor(props: any, context?: any);
        componentStatusChange(state: any, props: any): void;
        componentDidMount(): void;
        loadDefaultAsync(): Promise<ResultObject>;
        onCancel: (e: any) => void;
        onOK: (e: any) => Promise<void>;
        onCheckClick: (record: any) => Promise<void>;
        afterClosePick: () => void;
        onRowSave: (parameters: any) => Promise<void>;
        onInsertClick: () => void;
        onDeleteClick: () => void;
        render(): JSX.Element;
    }
}
declare module "sk/frame/plugin/product/rule/handle/HandleRuleTable" {
    import { UiContainer } from 'foundation/editor/ui/core/UiContainer';
    export class HandleRuleTable extends UiContainer {
        state: {
            yheight: number;
            xwidth: number;
            rotation: number;
            installPos: string;
            xoffset: number;
            yoffset: number;
            selectedRowKeys: any[];
            selectedRow: any[];
            dataSource: any[];
            showLoading: boolean;
            num: number;
        };
        recordChangeAsync: any;
        recordDefaultChange: any;
        private formRef;
        style: (bool: any) => {
            box: {
                position: string;
                top: string;
                bottom: string;
                background: string;
                opacity: string;
                zIndex: string;
                width: string;
                display: string;
            };
            content: {
                position: string;
            };
        };
        constructor(props: any, context?: any);
        componentStatusChange(state: any, props: any): void;
        posChange: (checkedValues: any) => void;
        rotationChange: (e: any) => void;
        distanceXChange: (e: any) => void;
        distanceYChange: (e: any) => void;
        onRowSelect: (record: any) => void;
        tableCellChange: (record: any, key: any, value: any, index?: any) => void;
        tableCellEnter: (record: any) => void;
        inversionChange: (record: any, v: any) => void;
        validChange: (record: any, key: any, v: any) => Promise<void>;
        defaultChange: (record: any, key: any, v: any) => Promise<void>;
        render(): JSX.Element;
    }
}
declare module "sk/frame/plugin/product/rule/handle/HandleRuleProperty" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { UiContainer } from 'foundation/editor/ui/core/UiContainer';
    import { HandleRuleParametersConfigAttributeStructure } from 'sk/data/family/database/furniture/element/handlerule/HandleRuleParametersConfigAttributeStructure';
    import { RuleInputElement } from 'sk/data/family/rule/element/instance/RuleInputElement';
    import { RuleParameterElement } from 'sk/data/family/rule/element/instance/RuleParameterElement';
    import { RuleDocumentService } from 'sk/data/family/rule/RuleDocumentService';
    import { RuleTypeDocumentService } from 'sk/data/family/rule/RuleTypeDocumentService';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { RuleService } from 'sk/frame/logic/storage/module/rule/rule/RuleService';
    import { RuleEditorDocument } from 'sk/frame/plugin/editor/module/rule/rule/frame/RuleEditorDocument';
    import { FamilyCodeService } from 'sk/frame/plugin/product/base/service/FamilyCodeService';
    class HandleRuleState {
        dataSource: Array<any>;
        showLoading: boolean;
        initCategoryId: string;
        typeId: string;
        visble: boolean;
        installList: Array<any>;
        oldInstallList: Array<any>;
        oldDocument: any;
    }
    export class HandleRuleProperty extends UiContainer<any, HandleRuleState> {
        columns: {};
        defaultFamilyId: string;
        needSave: boolean;
        initBool: boolean;
        dataArray: {
            optionValid: boolean;
            id: string;
            key: string;
            installTypeCd: string;
            angle: string;
        }[];
        installTypeCdEnum: any;
        protected _ruleTypeDocumentService: RuleTypeDocumentService;
        protected _ruleDocumentService: RuleDocumentService;
        protected _ruleService: RuleService;
        protected _documentService: FamilyDocumentService;
        protected _familyCodeService: FamilyCodeService;
        constructor(props: any, context?: any);
        componentDidMountAsync(): Promise<ResultObject>;
        isNeedSave(): boolean;
        insertTwoItemHandleRuleAsync: (index: any) => Promise<void>;
        insertThourItemHandleRuleAsync: () => Promise<void>;
        makeUpdateRuleParamsAsync(ruleInstance: any): Promise<any>;
        deleteDocumentToRuleInstanceParams(unit: HandleRuleParametersConfigAttributeStructure): void;
        makeInitRuleParams(ruleInstance: any, index: number): void;
        findRuleParams(ruleInstance: any): HandleRuleParametersConfigAttributeStructure;
        updateOneRuleAsync: (datas: any) => Promise<void>;
        updateGroupDefaultAsync: (datas: any) => Promise<void>;
        getOneRuleAsync: (id: any) => Promise<false | import("sk/data/logic/module/message/RuleGetResponse").RuleGetResponseVo>;
        documentToDatasTwoAsync: (value?: RuleEditorDocument) => Promise<any[]>;
        freshDatas: (value: any) => any;
        freshDatasDefaultRuleId: (value: any) => any;
        recordChangeAsync: (value: any) => Promise<void>;
        recordDefaultChangeAsync: (value: any) => Promise<void>;
        getHardwareInfoAsync: (id: any) => Promise<any>;
        documentToRuleInputElement: (document: RuleEditorDocument) => RuleInputElement;
        codeToInputParameter(inputEle: RuleInputElement, pickCode: string): RuleParameterElement;
        initEditorPanelAsync: (document: any) => Promise<void>;
        initAllHandleRuleAsync: (document: any, initBool?: boolean) => Promise<void>;
        deleteruleAsync(paramsObject: HandleRuleParametersConfigAttributeStructure, installTypeCd: string): Promise<void>;
        makeruleAsync(paramsObject: HandleRuleParametersConfigAttributeStructure, installTypeCd: any, id: any): Promise<void>;
        makedep(): number;
        datasToTable: (datas: any) => void;
        onCofigClick: () => void;
        showView: (record: any) => void;
        afterClosePick: () => void;
        configHandleAsync(): Promise<void>;
        afterSubmitPick: (data: any) => Promise<void>;
        render(): JSX.Element;
    }
}
declare module "sk/frame/plugin/product/rule/handle/HandleRuleEditorFrame" {
    import { FrameEditorFrameProps, FrameEditorFrameState } from 'sk/editor/view/frame/FrameEditorFrame';
    import { RuleEditorFrameBase } from "sk/frame/plugin/product/rule/RuleEditorFrameBase";
    export interface HandleRuleEditorFrameState extends FrameEditorFrameState {
        show3d: boolean;
        selectedKeys: any;
    }
    export class HandleRuleEditorFrame extends RuleEditorFrameBase<FrameEditorFrameProps, HandleRuleEditorFrameState> {
        private propertyRef;
        originalContent: any;
        constructor(props: any, context?: any);
        loadDocumentAsync(): Promise<any>;
        loadSchemeDocumentAsync(): Promise<any>;
        customOnSaveAsync(value?: any): Promise<boolean>;
        initRuleOnSaveAsync(value?: any): Promise<boolean>;
        insertElement(element: any, parent: any): void;
        insertElementTwo(index: number, element: any, parent: any): void;
        initView: (id: any, version: any, edgeLength: any) => Promise<void>;
        initRuleView: (record: any, edgeLength: any, id: any, familyId: any) => Promise<void>;
        protected checkDocumentChangedAsync(): Promise<boolean>;
        onDocumentsSaveAsync: () => Promise<void>;
        onEditorCloseAsync: () => Promise<void>;
        render(): JSX.Element;
    }
}
declare module "sk/frame/plugin/product/rule/util/RuleCanvas2dViewUtil" {
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    export class RuleCanvas2dViewUtil {
        static fitView2d(nodeMin: Vector2, nodeMax: Vector2, canvasId: string): void;
    }
}
declare module "sk/frame/plugin/product/rule/handle/display/W2dHandleRulePlank" {
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { DimensionEvent } from 'foundation/editor/ui/widget/DimensionEvent';
    import { C2dLinearDimension } from 'sk/editor/scheme/floorplan/view/canvas2d/gizmo/C2dLinearDimension';
    import { FloorplanEntity } from 'sk/editor/scheme/floorplan/entity/FloorplanEntity';
    import { SplitterEntity } from 'sk/editor/scheme/furniture/entity/SplitterEntity';
    import { C2dCanvas } from 'sk/editor/logic/view/canvas2d/C2dCanvas';
    import { C2dCanvasContext } from 'sk/editor/logic/view/canvas2d/C2dCanvasContext';
    import { C2dContent } from 'sk/editor/logic/view/canvas2d/C2dContent';
    export class W2dHandleRulePlank extends C2dContent {
        view: C2dCanvas;
        context: C2dCanvasContext;
        blueprint: any;
        floorplan: FloorplanEntity;
        entity: SplitterEntity;
        sizeDimensions: C2dLinearDimension[];
        dimensionOffset: number;
        constructor();
        createNode(): void;
        createSizeDimensions(): void;
        listenDimensionChange(): void;
        unlistenDimensionChange(): void;
        onValueChangeCommit(sender: ListenerContext, event: DimensionEvent): void;
        protected updateShape(): void;
        drawSizeDimensions(): void;
        drawBaseLines(): void;
        drawBasePoints(): void;
        calculateSplitLines(): Vector2[][];
        calculateBasePoints(): Vector2[];
        disposeDimensions(): void;
        dispose(): void;
        fitView(): void;
    }
}
declare module "sk/frame/plugin/product/rule/handle/display/W2dRuleHandle" {
    import { Bound2 } from 'foundation/runtime/math/Bound2';
    import { Line2 } from 'foundation/runtime/math/Line2';
    import { Vector2 } from 'foundation/runtime/math/Vector2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { V2dGraphicText } from 'foundation/editor/view/view2d/render/V2dGraphicText';
    import { C2dContent } from 'sk/editor/logic/view/canvas2d/C2dContent';
    type BasePointDimensionData = {
        line: Line2;
        distance: number;
    };
    export class W2dRuleHandle extends C2dContent {
        xDimensionText: V2dGraphicText;
        yDimensionText: V2dGraphicText;
        dimensionFontSize: number;
        constructor();
        createNode(): any;
        protected updateBound(): Bound2;
        protected updateTransform(): void;
        protected updateShape(): void;
        drawHandleAnchor(): void;
        drawHandleOutline(): void;
        calculateAnchor(): Vector2;
        calculateOutline(): Vector2[];
        convertHardwareToObservation(point: Vector3, target?: Vector3): Vector3;
        drawBasePointDimensions(): void;
        calculateBaseDimensions(): BasePointDimensionData[];
        createBasePointDimensions(): void;
        disposeBasePointDimension(): void;
        dispose(): void;
    }
}
declare module "sk/frame/plugin/product/rule/handle/view/HandleRuleCanvas2d" {
    import { SchemeCanvas2d } from 'sk/editor/scheme/view/canvas2d/SchemeCanvas2d';
    export class HandleRuleCanvas2d extends SchemeCanvas2d {
        constructor();
    }
}
declare module "sk/frame/plugin/product/rule/handlerule/HandleTable" {
    import { UiContainer } from 'foundation/editor/ui/core/UiContainer';
    export class HandleTable extends UiContainer {
        columns: any;
        constructor(props: any, context?: any);
        componentStatusChange(state: any, props: any): void;
        getRequest(): any;
        tableRowClick: (record: any, index: any) => void;
        rowSelectChange: (selectedRowKeys: any, selectedRows: any) => void;
        listChange: (page: any) => void;
        recordChangeAsync: (record: any, key: any, value: any) => void;
        useTexture: (record: any) => void;
        handleDelete: (key: any) => void;
        judgeNameAsync: (value: any) => Promise<boolean>;
        judgeCodeAsync: (value: any) => Promise<boolean>;
        showNormalConfirm: (text: any) => void;
        handleSaveAsync: (record: any, values: any) => Promise<void>;
        render(): JSX.Element;
    }
}
declare module "sk/frame/plugin/product/rule/handlerule/HardRuleDatasetController" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { PdmsBaseDatasetController } from 'sk/frame/plugin/product/base/ui/base/PdmsBaseDatasetController';
    export class HardRuleDatasetController extends PdmsBaseDatasetController {
        typeId: string;
        judgeCodeAsync(value: any): Promise<boolean>;
        judgeNameAsync(value: string): Promise<boolean>;
        onFetchAsync: (handle: any) => () => Promise<void>;
        fetchAsync: () => Promise<ResultObject>;
        insertAsync(data: any): Promise<ResultObject>;
        updateAsync(data: any): Promise<ResultObject>;
        deleteAsync(id: string): Promise<ResultObject>;
        pasteAsync(): Promise<ResultObject>;
    }
}
declare module "sk/frame/plugin/product/rule/handlerule/HardRulePage" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
    import { PdmsBasePage, PdmsBasePageProps, PdmsBasePageState } from 'sk/frame/plugin/product/base/ui/base/PdmsBasePage';
    import { HardRuleDatasetController } from "sk/frame/plugin/product/rule/handlerule/HardRuleDatasetController";
    export interface HardRulePageProps extends PdmsBasePageProps {
    }
    export interface HardRulePageState extends PdmsBasePageState {
        optionModalVisible: boolean;
        sortValue: any;
        searchMode: string;
        searchValue: string;
        scrolHeight: number;
        copyState: boolean;
        record: any;
    }
    export class HardRulePage extends PdmsBasePage<HardRulePageProps, HardRulePageState> {
        props: HardRulePageProps;
        state: HardRulePageState;
        protected _datasetController: HardRuleDatasetController;
        protected _schemeConfigService: SchemeConfigService;
        protected additions: {
            field: string;
            label: string;
        }[];
        constructor(props: any, context?: any);
        componentDidMount(): void;
        loadDefaultAsync(): Promise<ResultObject>;
        onOrderChanged: () => void;
        onSaveCheckAsync: (parameters: any) => Promise<boolean>;
        afterClosePick: () => void;
        afterSubmitPick: () => void;
        onOrderChange: (value: any) => void;
        onClickeditorAttributeHandle: (record: any) => Promise<void>;
        protected makeTable(): JSX.Element;
        protected makeExtraContent(): any;
    }
}
declare module "sk/frame/plugin/product/rule/hardware/data/HardwareFamilyPickController" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { PdmsBaseDatasetController } from 'sk/frame/plugin/product/base/ui/base/PdmsBaseDatasetController';
    export class HardwareFamilyPickController extends PdmsBaseDatasetController {
        fetchAsync: () => Promise<ResultObject>;
    }
}
declare module "sk/frame/plugin/product/rule/hardware/data/HardwareRuleEditorConstants" {
    export class HardwareRuleEditorConstants {
        static LengthX: number;
        static LengthY: number;
        static LengthZ: number;
        static DefaultStep: number;
        static MinStepValue: number;
        static BoundaryCount: number;
        static StepShowSplitChar: string;
        static StepStorageSplitChar: string;
        static SubStructureProcessCode: string;
        static MainStructureProcessCode: string;
    }
    export class HardwareRuleFields {
        static FamilyId: string;
        static LayoutTypeCd: string;
        static StepTypeCd: string;
        static Count: string;
        static OffsetStart: string;
        static OffsetEnd: string;
        static RemainTypeCd: string;
        static Steps: string;
        static IsForward: string;
        static Condition: string;
        static AvoidTypeCd: string;
        static AvoidDistance: string;
        static CurrentSubordination: string;
        static Children: string;
    }
    export type HardwareData = {
        name: string;
        width: number;
        depth: number;
        height: number;
    };
    export type RuleEditData = {
        index: number;
        ruleId: string;
        parentId: string;
        originalContent: any;
    };
    export enum HardwareRuleStepType {
        Average = "1",
        MaxIntegerTimesOfDistance = "2",
        AnyValue = "3",
        StepRatio = "4",
        MaxIntegerTimesOfDistanceStepRatio = "5"
    }
    export enum HardwareSubRuleLayoutType {
        Interval = "1",
        Forward = "2",
        Reverse = "3",
        Symmetric = "4",
        Centripetal = "5",
        CentripetalCross = "6"
    }
    export enum HardwareRuleFieldType {
        Parameter = 0,
        Attribute = 1
    }
}
declare module "sk/frame/plugin/product/rule/hardware/data/HardwareRuleEditorLogicRow" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { HardwareRuleAttributeStructure } from 'sk/data/family/database/furniture/element/rule/HardwareRuleAttributeStructure';
    import { RuleInputElement } from 'sk/data/family/rule/element/instance/RuleInputElement';
    import { RuleInstanceElement } from 'sk/data/family/rule/element/instance/RuleInstanceElement';
    import { RuleInstanceItemElement } from 'sk/data/family/rule/element/instance/RuleInstanceItemElement';
    import { RuleEditorDocument } from 'sk/frame/plugin/editor/module/rule/rule/frame/RuleEditorDocument';
    import { HardwareRuleFieldType } from "sk/frame/plugin/product/rule/hardware/data/HardwareRuleEditorConstants";
    export class HardwareRuleEditorLogicRow extends InstanceObject {
        index: number;
        id: string;
        familyId: string;
        name: string;
        width: number;
        depth: number;
        height: number;
        count: number;
        offsetStart: number;
        offsetEnd: number;
        remainTypeCd: number;
        stepTypeCd: string;
        steps: string;
        condition: string;
        currentSubordination: number;
        subordinationList: Types<number>;
        avoidTypeCd: number;
        avoidDistance: number;
        children: Types<string>;
        document: RuleEditorDocument;
        parentDocument: RuleEditorDocument;
        instance: RuleInstanceElement;
        input: RuleInputElement;
        linkInstance: RuleInstanceItemElement;
        isMain: boolean;
        constructor();
        update(fields: Array<string>): void;
        getFieldType(field: string): HardwareRuleFieldType;
        convertSteps(source: string): string;
        getAttributeValueByCode(instance: RuleInstanceElement, code: string): string;
        setAttributeValueByCode(instance: RuleInstanceElement, code: string, value: string, name?: string): void;
        getAttributeByCode(instance: RuleInstanceElement, code: string): HardwareRuleAttributeStructure;
        private setParameters;
        updateDynamicParameters(): void;
    }
}
declare module "sk/frame/plugin/product/rule/hardware/ui/HardwareRuleEditorFamilyPicker" {
    import { PdmsBasePage, PdmsBasePageProps, PdmsBasePageState } from 'sk/frame/plugin/product/base/ui/base/PdmsBasePage';
    import { FamilyCodeService } from 'sk/frame/plugin/product/base/service/FamilyCodeService';
    export interface HardwareRuleEditorFamilyPickerProps extends PdmsBasePageProps {
        ruleCategoryCode: string;
        visible?: boolean;
        onPickConfirm?: any;
        onPickCancel?: any;
    }
    export interface HardwareRuleEditorFamilyPickerState extends PdmsBasePageState {
        visible: boolean;
    }
    export class HardwareRuleEditorFamilyPicker<P extends HardwareRuleEditorFamilyPickerProps = any, S extends HardwareRuleEditorFamilyPickerState = any> extends PdmsBasePage<P, S> {
        props: HardwareRuleEditorFamilyPickerProps;
        state: HardwareRuleEditorFamilyPickerState;
        private _selectRecords;
        private _categoryCodeMap;
        protected _familyCodeService: FamilyCodeService;
        constructor(props?: any, context?: any);
        componentPropsChange(nextProps: any, nextContext: any): void;
        componentDidMount(): void;
        initAsync(): Promise<void>;
        onNodeSelectAsync: (keys: Array<string>) => Promise<void>;
        private onRowChange;
        private onCancel;
        private onOk;
        render(): JSX.Element;
    }
}
declare module "sk/frame/plugin/product/rule/hardware/ui/HardwareRuleEditorProperty" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { UiContainer, UiContainerProps, UiContainerState } from 'foundation/editor/ui/core/UiContainer';
    import { UiTable } from 'foundation/editor/ui/table/UiTable';
    import { UiTableRowEvent } from 'foundation/editor/ui/table/UiTableRowEvent';
    import { RuleInstanceItemElement } from 'sk/data/family/rule/element/instance/RuleInstanceItemElement';
    import { RuleEditorDocument } from 'sk/frame/plugin/editor/module/rule/rule/frame/RuleEditorDocument';
    import { HardwareRuleEditorController } from "sk/frame/plugin/product/rule/hardware/data/HardwareRuleEditorController";
    import { HardwareRuleEditorLogicRow } from "sk/frame/plugin/product/rule/hardware/data/HardwareRuleEditorLogicRow";
    import { HardwareRuleEditorFrame } from "sk/frame/plugin/product/rule/hardware/frame/HardwareRuleEditorFrame";
    export interface UiHardwareRuleEditPropertyProps extends UiContainerProps {
        ref: any;
        document: any;
        frame: HardwareRuleEditorFrame;
    }
    export interface UiHardwareRuleEditPropertyState extends UiContainerState {
        dataSource: Array<HardwareRuleEditorLogicRow>;
        record: HardwareRuleEditorLogicRow;
        stepsModalVisible: boolean;
        hardwarePickModalVisible: boolean;
        stepsEditable: boolean;
        cloneDisabled: boolean;
    }
    export class HardwareRuleEditorProperty<P extends UiHardwareRuleEditPropertyProps, S extends UiHardwareRuleEditPropertyState> extends UiContainer<P, S> {
        props: UiHardwareRuleEditPropertyProps;
        state: UiHardwareRuleEditPropertyState;
        protected _controller: HardwareRuleEditorController;
        protected _uiTable: UiTable;
        protected _steps: string;
        protected _hardware: Array<any>;
        protected _subordinationList: Types<number>;
        protected _subordination: number;
        protected _developMode: boolean;
        protected readonly _floatValidator: {
            pattern: RegExp;
            message: string;
        }[];
        protected readonly _integerValidator: {
            pattern: RegExp;
            message: string;
        }[];
        constructor(props?: any, context?: any);
        protected onTableRef: (value: any) => void;
        initPanelAsync(document?: RuleEditorDocument): Promise<void>;
        isNeedSave(): boolean;
        saveAsync(): Promise<ResultObject>;
        restoreAsync(): Promise<ResultObject>;
        private updateSelectedRule;
        protected onRowClick: (event: any, record: HardwareRuleEditorLogicRow) => void;
        protected onMouseLeave: (event: any, record: HardwareRuleEditorLogicRow) => void;
        onRowChange: (selectedKeys: Array<string>) => void;
        onRowSave: (event: UiTableRowEvent) => void;
        private onFieldChangeConfirm;
        private onAvoidDistanceConfirm;
        private buildInputSteps;
        protected onSubordinationChangeAsync: (value: any, record: HardwareRuleEditorLogicRow) => Promise<ResultObject>;
        protected onInsert: () => void;
        protected onDeleteAsync: (event: any) => Promise<void>;
        protected onCloneAsync: (event: any) => Promise<void>;
        protected onInsertAfterAsync(frame: HardwareRuleEditorFrame, parentDocument: RuleEditorDocument, itemElement: RuleInstanceItemElement): Promise<ResultObject>;
        protected onStepsClick: (event: any, record?: HardwareRuleEditorLogicRow) => void;
        protected onStepChange(event: any, record: HardwareRuleEditorLogicRow): void;
        protected onStepsSave: () => void;
        protected onHardwarePickConfirmAsync: (event: any, records: Array<any>) => Promise<void>;
        protected onHardwarePickCancel: () => void;
        protected makeStepInputs(record: HardwareRuleEditorLogicRow): any[];
        protected makeStepsEditModal(): JSX.Element;
        protected makeRemainTypeOptions(): any[];
        protected makeAvoidTypeOptions(): any[];
        protected makeSubordinationOptions(): any[];
        protected makeHardwarePickModal(): JSX.Element;
        private renderAvoidDistanceCell;
        render(): JSX.Element;
    }
}
declare module "sk/frame/plugin/product/rule/hardware/frame/HardwareRuleEditorFrame" {
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { UiDesktopService } from 'foundation/editor/ui/desktop/UiDesktopService';
    import { RuleGetResponseVo } from 'sk/data/logic/module/message/RuleGetResponse';
    import { FrameEditorFrameProps, FrameEditorFrameState } from 'sk/editor/view/frame/FrameEditorFrame';
    import { RuleEditorDocument } from 'sk/frame/plugin/editor/module/rule/rule/frame/RuleEditorDocument';
    import { RuleEditorFrameBase } from "sk/frame/plugin/product/rule/RuleEditorFrameBase";
    export interface HardwareRuleEditorFrameState extends FrameEditorFrameState {
        show3d: boolean;
        lengthX: any;
        selectedKeys: any;
        saveDisabled: boolean;
    }
    export class HardwareRuleEditorFrame extends RuleEditorFrameBase<FrameEditorFrameProps, HardwareRuleEditorFrameState> {
        protected _desktopService: UiDesktopService;
        state: HardwareRuleEditorFrameState;
        private _propertyRef;
        firstLeveTypeCode: string;
        firstLevelCategoryCode: string;
        secondLevelTypeCode: string;
        secondLevelCategoryCode: string;
        private _lengthX;
        private _selectRuleId;
        constructor(props?: any, context?: any);
        private get performerContext();
        loadDocumentAsync(): Promise<any>;
        loadRuleDataAsync(id: string, sync?: boolean): Promise<ResultObject<{
            document: RuleEditorDocument;
            unit: RuleGetResponseVo;
        }>>;
        syncDocumentFromTypeAsync(document: RuleEditorDocument, typeId: string, categoryCode: string): Promise<ResultObject<RuleEditorDocument>>;
        private syncRuleParameter;
        private addParameter;
        private deleteParameter;
        loadSchemeDocumentAsync(): Promise<any>;
        setSelectRule(ruleId: string): void;
        private onPreviewAsync;
        private computeAsync;
        private prepareRuleAsync;
        private prepareSchemeAsync;
        private onPreview;
        onDocumentsSaveAsync: () => Promise<void>;
        onEditorClose: () => void;
        onCloseAsync(): Promise<void>;
        protected onSaveDocumentAsync(): Promise<void>;
        private onLengthXChange;
        private makePreviewPanel;
        render(): JSX.Element;
    }
}
declare module "sk/frame/plugin/product/rule/hardware/data/HardwareRuleEditorController" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    import { ResultObject } from 'cross/runtime/lang/ResultObject';
    import { RuleInstanceElement } from 'sk/data/family/rule/element/instance/RuleInstanceElement';
    import { RuleInstanceItemElement } from 'sk/data/family/rule/element/instance/RuleInstanceItemElement';
    import { RuleDocumentService } from 'sk/data/family/rule/RuleDocumentService';
    import { FamilyDocumentService } from 'sk/data/family/service/FamilyDocumentService';
    import { RuleDeleteResponseVo } from 'sk/data/logic/module/message/RuleDeleteResponse';
    import { UiFrameService } from 'sk/editor/frame/ui/UiFrameService';
    import { RuleEditorDocument } from 'sk/frame/plugin/editor/module/rule/rule/frame/RuleEditorDocument';
    import { HardwareRuleEditorFrame } from "sk/frame/plugin/product/rule/hardware/frame/HardwareRuleEditorFrame";
    import { HardwareRuleEditorLogicRow } from "sk/frame/plugin/product/rule/hardware/data/HardwareRuleEditorLogicRow";
    export class HardwareRuleEditorController extends InstanceObject {
        private _firstLevelTypeId;
        private _firstLevelCategoryId;
        private _secondLevelTypeId;
        private _secondLevelCategoryId;
        private _unsavedDocuments;
        private _rules;
        _undeletedRules: Types<string>;
        _newRules: Types<string>;
        private _hardwareMap;
        private _subordinationIndexList;
        private _tenantId;
        private _libraryId;
        protected _familyDocumentService: FamilyDocumentService;
        protected _ruleDocumentService: RuleDocumentService;
        protected _uiFrameService: UiFrameService;
        constructor();
        private initData;
        initDataAsync(firstLevelTypeCode: string, firstLevelCategoryCode: string, secondLevelTypeCode: string, secondLevelCategoryCode: string): Promise<void>;
        buildDatasourceAsync(frame: HardwareRuleEditorFrame, sync?: boolean): Promise<Array<HardwareRuleEditorLogicRow>>;
        private buildItemsAsync;
        buildItemDataAsync(frame: HardwareRuleEditorFrame, parentDocument: RuleEditorDocument, itemElement: RuleInstanceItemElement, index: number, sync: boolean): Promise<ResultObject<HardwareRuleEditorLogicRow>>;
        private setHardwareFamilyDataAsync;
        private setRowParameters;
        private buildShowSteps;
        private repairStepParameters;
        private repairSteps;
        private repairStepTypeCd;
        private setRowAttributes;
        private repairAttributes;
        private fixCondition;
        private syncRuleDataAsync;
        private updateDynamicParametersAsync;
        private syncRuleDataByTypeAsync;
        private updateRuleRecordAsync;
        private buildRequestData;
        buildCurrentSubordinationOptionals(dataSource: Array<HardwareRuleEditorLogicRow>, rootRuleId: string): Array<HardwareRuleEditorLogicRow>;
        buildSubordinationOptionals(dataSource: Array<HardwareRuleEditorLogicRow>, rule: HardwareRuleEditorLogicRow): void;
        private isValidSubordinationIndex;
        private getHardwareDataAsync;
        addRuleAsync(frame: HardwareRuleEditorFrame, familyId: string, familyName: string): Promise<ResultObject<RuleInstanceItemElement>>;
        private insertRecordAsync;
        private setDefaultParameter;
        deleteRuleAsync(dataSource: Array<HardwareRuleEditorLogicRow>, ruleId: string): Promise<ResultObject>;
        deleteRecordAsync(ruleId: string): Promise<ResultObject<RuleDeleteResponseVo>>;
        cloneRuleAsync(frame: HardwareRuleEditorFrame, rowItem: HardwareRuleEditorLogicRow): Promise<ResultObject<RuleInstanceItemElement>>;
        private cloneParameters;
        private cloneAttributes;
        changeSubordinationAsync(frame: HardwareRuleEditorFrame, sourceIndex: number, targetIndex: number, ruleData: HardwareRuleEditorLogicRow, dataSource: Array<HardwareRuleEditorLogicRow>): Promise<ResultObject>;
        protected getRuleDataByIndex(dataSource: Array<HardwareRuleEditorLogicRow>, index: number): {
            id: string;
            instance: RuleInstanceElement;
            rowRule: HardwareRuleEditorLogicRow;
        };
        getRuleDataById(dataSource: Array<HardwareRuleEditorLogicRow>, ruleId: string): HardwareRuleEditorLogicRow;
        private deleteRowDataAsync;
        protected createInstanceItemElement(ruleId: string, document: RuleEditorDocument): RuleInstanceItemElement;
        protected handleUnsavedRuleAsync(ruleId: string, document: RuleEditorDocument, saveOss?: boolean): Promise<ResultObject>;
        isNeedSave(frame: HardwareRuleEditorFrame, dataSource: Array<HardwareRuleEditorLogicRow>): boolean;
        private getUnsavedDocuments;
        updateRuleDataAsync(record: HardwareRuleEditorLogicRow, fields: Array<string>): Promise<ResultObject>;
        saveAsync(): Promise<ResultObject>;
        restoreAsync(frame: HardwareRuleEditorFrame): Promise<ResultObject>;
        getMainRuleId(dataSource: Array<HardwareRuleEditorLogicRow>, rootId: string, ruleId: string): string;
    }
}
declare module "sk/frame/plugin/product/rule/hardware/display/W2dRuleDimensionController" {
    import { DisplayController } from 'foundation/editor/view/base/DisplayController';
    export class W2dRuleDimensionController extends DisplayController {
        onDispatchEvent(code: string, event: any): boolean;
    }
}
declare module "sk/frame/plugin/product/rule/hardware/display/W2dHardwareRuleDimension" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
    import { TransactionEvent } from 'foundation/editor/view/transaction/TransactionEvent';
    import { C2dLinearDimension } from 'sk/editor/scheme/floorplan/view/canvas2d/gizmo/C2dLinearDimension';
    import { DimensionTypeEnum } from 'sk/editor/scheme/floorplan/entity/DimensionTypeEnum';
    import { SplitterEntity } from 'sk/editor/scheme/furniture/entity/SplitterEntity';
    import { C2dGizmo } from 'sk/editor/logic/view/canvas2d/gizmo/C2dGizmo';
    import { HardwareEntity } from 'sk/editor/logic/entity/HardwareEntity';
    export class W2dHardwareRuleDimension extends C2dGizmo {
        entity: SplitterEntity;
        dimensionType: DimensionTypeEnum;
        dimensions: Types<C2dLinearDimension>;
        dimensionOffset: number;
        setup(): void;
        onActivate(): void;
        onDeactivate(): void;
        onScaleChange(): void;
        onSettingChanged(sender: ListenerContext, event: any): void;
        onTransactionUndone(sender: ListenerContext, event: TransactionEvent): void;
        onTransactionRedone(sender: ListenerContext, event: TransactionEvent): void;
        onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        onEntityFieldChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
        onEntityDirty(sender: ListenerContext, event: DataNodeFlagEvent): void;
        onValueChangeStart(sender: ListenerContext, event: any): void;
        onValueChanged(sender: ListenerContext, event: any): void;
        onValueChangeEnd(sender: ListenerContext, event: any): void;
        draw(): void;
        private drawDimensions;
        private drawDimension;
        private getHardwareList;
        private calculateDimensionSegments;
        private createHardwareAnchors;
        getHardwareAnchorPosition(hardware: HardwareEntity): Vector3;
        private updateDimensions;
        private createDimensions;
        private createC2dLinearDimension;
        disposeDimensions(): void;
        dispose(): void;
    }
}
declare module "sk/frame/plugin/product/rule/hardware/display/W2dRuleHardware" {
    import { Bound2 } from 'foundation/runtime/math/Bound2';
    import { Vector3 } from 'foundation/runtime/math/Vector3';
    import { C2dContent } from 'sk/editor/logic/view/canvas2d/C2dContent';
    import { HardwareEntity } from 'sk/editor/logic/entity/HardwareEntity';
    export class W2dRuleHardware extends C2dContent {
        private readonly _radius;
        private readonly _lineWidth;
        private readonly _lineColor;
        private readonly _fillColor;
        constructor();
        protected updateBound(): Bound2;
        protected updateShape(): void;
        private getFillColor;
        getHardwareAnchorPosition(hardware: HardwareEntity): Vector3;
    }
}
declare module "sk/frame/plugin/product/rule/hardware/display/W2dRulePlank" {
    import { SplitterEntity } from 'sk/editor/scheme/furniture/entity/SplitterEntity';
    import { C2dCanvas } from 'sk/editor/logic/view/canvas2d/C2dCanvas';
    import { C2dCanvasContext } from 'sk/editor/logic/view/canvas2d/C2dCanvasContext';
    import { C2dContent } from 'sk/editor/logic/view/canvas2d/C2dContent';
    export class W2dRulePlank extends C2dContent {
        view: C2dCanvas;
        context: C2dCanvasContext;
        entity: SplitterEntity;
        private readonly _lineColor;
        private readonly _lineWidth;
        constructor();
        createNode(): void;
        onAddToView(): void;
        onRemoveFromView(): void;
        protected updateShape(): void;
        protected drawPlank(): void;
        fitView(): void;
        getRuleIdByUrl(): string;
    }
}
declare module "sk/frame/plugin/product/rule/hardware/frame/HardwareHingeRuleEditorFrame" {
    import { HardwareRuleEditorFrame } from "sk/frame/plugin/product/rule/hardware/frame/HardwareRuleEditorFrame";
    export class HardwareHingeRuleEditorFrame extends HardwareRuleEditorFrame {
        constructor(props?: any, context?: any);
    }
}
declare module "sk/frame/plugin/product/rule/hardware/frame/HardwareStructureRuleEditorFrame" {
    import { HardwareRuleEditorFrame } from "sk/frame/plugin/product/rule/hardware/frame/HardwareRuleEditorFrame";
    export class HardwareStructureRuleEditorFrame extends HardwareRuleEditorFrame {
        constructor(props?: any, context?: any);
    }
}
declare module "sk/frame/plugin/product/rule/hardware/view/HardwareRuleCanvas2d" {
    import { SchemeCanvas2d } from 'sk/editor/scheme/view/canvas2d/SchemeCanvas2d';
    export class HardwareRuleCanvas2d extends SchemeCanvas2d {
        constructor();
    }
}