import * as react from 'react';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as _iplusplus_y_model_dist_BuildType from '@iplusplus/y-model/dist/BuildType';
import * as _iplusplus_y_model_dist_EditorPropertyValueType from '@iplusplus/y-model/dist/EditorPropertyValueType';
import { EditorProperty, EditorProperties, Infer } from '@iplusplus/y-model';
import * as createjs from 'createjs-module';
import createjs__default from 'createjs-module';

type SelectState = "select" | "mulityselect" | "noselect";
declare class DragLayer extends createjs.Container {
    readonly assControl: Control;
    dragBox: createjs.Shape;
    decorationLayer: createjs.Container;
    dragHandler: createjs.Shape;
    moveBeginX: number;
    moveBeginY: number;
    borderPadding: number;
    selectState: SelectState;
    border: createjs.Shape;
    constructor(assControl: Control);
    resize(width: number, height: number): void;
    reDraw(): void;
    drawDragBox(): void;
    drawBorder(): void;
    drawDragHandler(): void;
    createMeasuring(length: number, headwidth: number): createjs.Container;
    drawDecoration(): void;
    setSelectState(selectState: SelectState): void;
}

type GroupControlData = ControlData & {
    subControls: ControlData[];
    customName?: string;
};
type SortedEditorProperty = EditorProperty & {
    sortIndex: number;
};
declare class GroupControl implements Control {
    private controlData;
    size: Size;
    isLocked: boolean;
    originConfig: GroupControlData;
    container: createjs.Container;
    innerContainer: createjs.Container;
    controlTypeInfo: ControlTypeInfo;
    metaInfo?: ControlMeta;
    anchored: AnchorProp;
    propertyMapping: Record<string, [string, Control][]>;
    properties: SortedEditorProperty[];
    controlList: Control[];
    api?: DesignerApi | PageApi;
    customName?: string;
    constructor(controlData: GroupControlData);
    groupControlAttchInfo?: GroupControlAttchInfo | undefined;
    setMeta(metaInfo: ControlMeta): void;
    getDefaultMeta(): ControlMeta;
    getMeta(): ControlMeta;
    initSubControls(): void;
    getValueType(c: Control, propertyName: string): _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType | undefined;
    initSubMeta(): void;
    getProperty(propertyName: string): any;
    getCustomProperties(): Record<string, unknown>;
    getControlData(): GroupControlData;
    reDraw(): void;
    setProperty(newProperties: {
        [index: string]: unknown;
    }): void;
    initControl(api: DesignerApi | PageApi): void;
    startRun(): void;
    getDisplayObject(): createjs.DisplayObject;
    getProperties(): EditorProperties;
    destroy(): void;
    inPage(): PageApi | undefined;
    inDesign(): DesignerApi | undefined;
}
declare const groupControlFactory: ControlFactory;

type TypedControlConstructor<P extends EditorProperties> = {
    new (propDefine: P, controlTypeInfo: ControlTypeInfo, data?: ControlData): TypedControl<P>;
    typeName: string;
    title: string;
};
declare function createControlFactory<P extends EditorProperties>(propDefine: P, ctor: TypedControlConstructor<P>): ControlFactory;
declare abstract class TypedControl<P extends EditorProperties> implements Control {
    protected props: P;
    controlTypeInfo: ControlTypeInfo;
    protected controlData?: ControlData | undefined;
    p: Infer<P>;
    size: Size;
    api?: DesignerApi | PageApi;
    metaInfo?: ControlMeta;
    container: createjs.Container;
    destroyCallback: (() => void)[];
    anchored: AnchorProp;
    destroyed: boolean;
    isLocked: boolean;
    customName?: string;
    abstract getDefaultSize(): Size;
    /**
     *
     */
    constructor(props: P, controlTypeInfo: ControlTypeInfo, controlData?: ControlData | undefined);
    getProperty(propertyName: string): unknown;
    groupControlAttchInfo?: GroupControlAttchInfo | undefined;
    initControl(api: DesignerApi | PageApi): void;
    assembleComponents(): void;
    updateDefaultProps(): void;
    isInPage(api?: DesignerApi | PageApi): api is PageApi;
    startRun(): void;
    getDefaultMeta(): ControlMeta;
    setMeta(metaInfo: ControlMeta): void;
    getMeta(): ControlMeta;
    private loadControlData;
    getControlData(): ControlData;
    abstract reDraw(): void;
    setProperty(newProperties: {
        [index: string]: unknown;
    }): void;
    inPage(): PageApi | undefined;
    inDesign(): DesignerApi | undefined;
    run(_pageApi: PageApi): void;
    getDisplayObject(): createjs.Container;
    getProperties(): EditorProperties;
    protected addDestroyCallback(cb: () => void): void;
    protected callDestroyCallback(): void;
    destroy(): void;
}

type ContainerControlPointsTypeInfo = {
    title: string;
    editorType: string;
};

declare class ControlLayer extends createjs.Container {
    api: DesignerApi;
    rightMax: number;
    bottomMax: number;
    constructor(rightMax: number, bottomMax: number, api: DesignerApi);
    changeSize(width: number, height: number): void;
    addControl(control: Control, x?: number, y?: number, needSelect?: boolean): void;
    moveControl(dragerLayer: DragLayer, movementX: number, movementY: number): void;
    moveControls(movementX: number, movementY: number): void;
    checkPosition: (d: DragLayer) => void;
    checkControlTypeIsSame(control1: Control, control2: Control): boolean;
    confirmSelectSame(dragLayer: DragLayer, isAdd: boolean): void;
    confirmSelect(dragLayer: DragLayer, isAdd: boolean): void;
    allControlExecute(fun: (dragLayer: DragLayer) => void): void;
    selectControl(x1: number, y1: number, x2: number, y2: number, isAdd: boolean): void;
    fireSelectedChanged(): void;
    getControlInfo(id: number): {
        typeInfo: ControlTypeInfo;
        properties: EditorProperties;
        data: ControlData;
    } | undefined;
    setSelectedControlProperty(newProperties: {
        [index: string]: unknown;
    }): void;
    applyCustomOperationToSelectedControls(fun: (control: Control) => void): void;
    getControlsData(): ControlData[];
    private drags;
    private selectedDrags;
    private selectedDrag;
    getSelectedDragId(): number;
    private selectedControls;
    getDragById(id: number): DragLayer | undefined;
    getDragsBySelectState(s: SelectState): DragLayer[];
    deleteControls(): void;
    setControlsLayer(layer: "top" | "bottom"): void;
    alignControl(alignType: "left" | "right" | "top" | "bottom" | "hcenter" | "vcenter"): void;
    resizeControls(resizeType: "width" | "height" | "both"): void;
    distributeControls(dType: "h" | "v"): void;
    lockControls(): void;
    getLockedDrags(): DragLayer[];
    getControlId(ctrl: Control): number;
    getControlTitle(ctrl: Control): string;
    getControlById(controlId: number): Control | undefined;
    unlockControl(ctrl: Control): void;
    combinControls(): void;
    private packageControlToContainerInternal;
    packageControlToContainer(pointsTypeInfoBuilder: (controlData: ControlData) => ContainerControlPointsTypeInfo | undefined): void;
    private deCombinGroupControls;
    private deCombinContainerControls;
    deCombinControls(): void;
    getSelectGroupControlData(): GroupControlData | undefined;
    deleteDrag: (d: DragLayer) => void;
    clear(): void;
    destroy(): void;
    getControlData: (d: DragLayer) => ControlData;
    serializeControls(): ControlData[];
    loadControls(controlDataList: ControlData[], offset?: number): void;
    getSelectedPosition(): PositionAndSizeProperty | undefined;
    setSelectedPosition(p: PositionAndSizeProperty): void;
    setSelectedPositionCustom(f: (old: PositionAndSizeProperty) => PositionAndSizeProperty): void;
    getSelectedAnchor(): AnchorProp | undefined;
    setSelectedAnchor(a: AnchorProp): void;
}

declare class SelectBorder extends createjs.Shape {
    x1: number;
    y1: number;
    x2: number;
    y2: number;
    constructor();
    setPoint1(x: number, y: number): void;
    setPoint2(x: number, y: number): void;
    reDraw(): void;
    end(): void;
}

declare class BackgroundLayer extends createjs.Container {
    api: CommApi;
    backgroundImage: createjs.Bitmap | null;
    width: number;
    height: number;
    imageId: string | null;
    selectBorder: SelectBorder;
    constructor(width: number, height: number, api: CommApi);
    changeSize(width: number, height: number): void;
    setBackgroundImage(imageId: string): void;
}

declare class PageDesigner {
    private parentDiv;
    canvas: HTMLCanvasElement;
    stage: createjs.Stage;
    width: number;
    height: number;
    background: BackgroundLayer;
    controlLayer: ControlLayer;
    api: DesignerApi;
    private destroyed;
    instId: number;
    homeDiv: HTMLDivElement;
    constructor(api: CommApi, parentDiv: HTMLDivElement);
    loadPage(pageData: PageData, options?: {
        showDebug?: boolean;
    }): void;
    keyEventHandler: (ev: KeyboardEvent) => void;
    changeSize(width?: number, height?: number): void;
    addEventListener<E extends DesignerEventType, T extends DesignerEventDefine[E]>(eventType: DesignerEventType, handler: T): T;
    removeEventListener<E extends DesignerEventType, T extends DesignerEventDefine[E]>(eventType: DesignerEventType, handler: T): T;
    private initCanvas;
    private initHomeDiv;
    updateStage: () => void;
    private initStage;
    destroy(): void;
    isDestroyed(): boolean;
    getPageData(): PageData;
}

declare class PageLoader {
    private parentDiv;
    stage?: createjs__default.Stage;
    canvas?: HTMLCanvasElement;
    background?: BackgroundLayer;
    resizeObserver: ResizeObserver;
    mainControl?: Control;
    inFullscreen: boolean;
    instId: number;
    api: PageApi;
    adaptMode?: number;
    currentPageData?: PageData;
    private destroyed;
    homeDiv: HTMLDivElement;
    domDiv: HTMLDivElement;
    constructor(api: CommApi, parentDiv: HTMLDivElement, adaptMode?: number);
    private initHomeDiv;
    private initDomDiv;
    loadPage(pageData: PageData): void;
    resetSize: () => void;
    resetSize2: (entries: ResizeObserverEntry[]) => void;
    updateStage: () => void;
    switchFullscreen(): void;
    clear(): void;
    destroy(): void;
}

type Size = {
    width: number;
    height: number;
};
declare const metaPropDefine: readonly [_iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["originName", "原始属性名", "string", {
    defaultValue: string;
    dataTypeName: "string";
    validater?: (v: string) => boolean;
    validate(value: string): boolean;
    setValidater: (validater: (v: string) => boolean) => void;
    getDefaultValue(): string;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>, _iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["propertyType", "属性类型", "string", {
    defaultValue: string;
    dataTypeName: "string";
    validater?: (v: string) => boolean;
    validate(value: string): boolean;
    setValidater: (validater: (v: string) => boolean) => void;
    getDefaultValue(): string;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>, _iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["originTitle", "原始名称", "string", {
    defaultValue: string;
    dataTypeName: "string";
    validater?: (v: string) => boolean;
    validate(value: string): boolean;
    setValidater: (validater: (v: string) => boolean) => void;
    getDefaultValue(): string;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>, _iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["customTitle", "自定义名称", "string", {
    defaultValue: string;
    dataTypeName: "string";
    validater?: (v: string) => boolean;
    validate(value: string): boolean;
    setValidater: (validater: (v: string) => boolean) => void;
    getDefaultValue(): string;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>, _iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["isExport", "是否导出", "enable", {
    defaultValue: number;
    dataTypeName: "number";
    validate(value: number): boolean;
    getDefaultValue(): number;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>, _iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["customName", "自定义属性名", "string", {
    defaultValue: string;
    dataTypeName: "string";
    validater?: (v: string) => boolean;
    validate(value: string): boolean;
    setValidater: (validater: (v: string) => boolean) => void;
    getDefaultValue(): string;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>, _iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["sortIndex", "显示顺序", "number", {
    defaultValue: number;
    dataTypeName: "number";
    validate(value: number): boolean;
    getDefaultValue(): number;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>];
type MetaProperty = Infer<typeof metaPropDefine>;
type ControlMeta = {
    originTitle: string;
    controlType: string;
    properties: MetaProperty[];
};
declare const positionAndSizePropDefine: readonly [_iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["customName", "自定义名称", "string", {
    defaultValue: string;
    dataTypeName: "string";
    validater?: (v: string) => boolean;
    validate(value: string): boolean;
    setValidater: (validater: (v: string) => boolean) => void;
    getDefaultValue(): string;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>, _iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["x", "横坐标", "string", {
    defaultValue: number;
    dataTypeName: "number";
    validate(value: number): boolean;
    getDefaultValue(): number;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>, _iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["y", "纵坐标", "string", {
    defaultValue: number;
    dataTypeName: "number";
    validate(value: number): boolean;
    getDefaultValue(): number;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>, _iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["width", "宽度", "string", {
    defaultValue: number;
    dataTypeName: "number";
    validate(value: number): boolean;
    getDefaultValue(): number;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>, _iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["height", "高度", "string", {
    defaultValue: number;
    dataTypeName: "number";
    validate(value: number): boolean;
    getDefaultValue(): number;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>];
type PositionAndSizeProperty = Infer<typeof positionAndSizePropDefine>;
declare const anchorPropDefine: readonly [_iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["left", "左侧锚定", "enable", {
    defaultValue: number;
    dataTypeName: "number";
    validate(value: number): boolean;
    getDefaultValue(): number;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>, _iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["right", "右侧锚定", "enable", {
    defaultValue: number;
    dataTypeName: "number";
    validate(value: number): boolean;
    getDefaultValue(): number;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>, _iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["top", "上侧锚定", "enable", {
    defaultValue: number;
    dataTypeName: "number";
    validate(value: number): boolean;
    getDefaultValue(): number;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>, _iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["bottom", "下侧锚定", "enable", {
    defaultValue: number;
    dataTypeName: "number";
    validate(value: number): boolean;
    getDefaultValue(): number;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>];
type AnchorProp = Infer<typeof anchorPropDefine>;
declare const defaultAnchor: AnchorProp;
type ControlData = {
    x?: number;
    y?: number;
    controlType: string;
    width: number;
    height: number;
    customProperties: Record<string, unknown>;
    metaInfo?: ControlMeta;
    anchored?: AnchorProp;
    isLocked?: boolean;
    customName?: string;
};
type ControlFactory = {
    create(data?: ControlData): Control;
    typeName: string;
    title: string;
};
type DesignerContextProps = {
    getCommApi: () => CommApi;
};
type PageData = {
    width: number;
    height: number;
    backgroundImgId: string | null;
    controls: ControlData[];
};
type EventArgs = {
    source: object;
};
type SelectedChangeEventArgs = EventArgs & {
    selectedIds: number[];
    selectedId?: number;
};
type DesignerEventDefine = {
    selectedChanged: (args: SelectedChangeEventArgs) => void;
};
type DesignerEventType = keyof DesignerEventDefine;
type DesignerEventHandler<E extends DesignerEventType> = {
    eventType: E;
    handler: DesignerEventDefine[E];
};
type DesignerEventHandlers = DesignerEventHandler<DesignerEventType>[];
type PageDesignerContainerProps = {
    designer?: PageDesigner;
    clear: () => void;
    createDigner: (div: HTMLDivElement) => void;
};
declare const CreateJsDesignerContext: react.Context<DesignerContextProps>;
declare const PageDesignerContainerContext: react.Context<PageDesignerContainerProps>;
type PageLoaderContainerProps = {
    loader?: PageLoader;
    clear: () => void;
    createLoader: (div: HTMLDivElement) => void;
};
type GroupControlAttchInfo = {
    originX: number;
    originY: number;
    originWidth: number;
    originHeight: number;
};
interface ControlTypeInfo {
    typeName: string;
    title: string;
}
interface CommApi {
    getImg(imageId: string): Promise<HTMLImageElement>;
    createControl(args: string | ControlData): Control;
}
interface CommApi {
    getImg(imageId: string): Promise<HTMLImageElement>;
    createControl(data: ControlData): Control;
}
interface DesignerApi extends CommApi {
    apiName: "DesignerApi";
}
interface DesignerApi extends CommApi {
    apiName: "DesignerApi";
}
interface PageApi extends CommApi {
    apiName: "PageApi";
    getHomeDiv(): HTMLDivElement;
    getDomDiv(): HTMLDivElement;
}
interface PageApi extends CommApi {
    apiName: "PageApi";
    getHomeDiv(): HTMLDivElement;
}
interface Control {
    size: Size;
    getControlData(): ControlData;
    reDraw(): void;
    controlTypeInfo: ControlTypeInfo;
    setProperty(newProperties: {
        [index: string]: unknown;
    }): void;
    getProperty(propertyName: string): unknown;
    initControl(api: DesignerApi | PageApi): void;
    startRun(): void;
    getDisplayObject(): createjs__default.DisplayObject;
    getProperties(): EditorProperties;
    destroy(): void;
    groupControlAttchInfo?: GroupControlAttchInfo;
    setMeta(metaInfo: ControlMeta): void;
    getMeta(): ControlMeta;
    anchored: AnchorProp;
    isLocked: boolean;
    customName?: string;
}
interface Control {
    size: Size;
    getControlData(): ControlData;
    reDraw(): void;
    controlTypeInfo: ControlTypeInfo;
    setProperty(newProperties: {
        [index: string]: any;
    }): void;
    getProperty(propertyName: string): any;
    initControl(api: DesignerApi | PageApi): void;
    startRun(): void;
    getDisplayObject(): createjs__default.DisplayObject;
    getProperties(): EditorProperties;
    destroy(): void;
    groupControlAttchInfo?: GroupControlAttchInfo;
    setMeta(metaInfo: ControlMeta): void;
    getMeta(): ControlMeta;
    anchored: AnchorProp;
}
declare const PageLoaderContainerContext: react.Context<PageLoaderContainerProps>;

type CreateJsDesignerConfig = {
    getImageBlob: (imageId: string) => Promise<Blob>;
    controlFactories: ControlFactory[];
};
declare const CreateJsDesignerProvider: react.MemoExoticComponent<({ config, children }: {
    config: CreateJsDesignerConfig;
    children: JSX.Element | JSX.Element[];
}) => react_jsx_runtime.JSX.Element>;

declare const PageDesignerContainer: react.MemoExoticComponent<({ children }: {
    children: JSX.Element | JSX.Element[];
}) => react_jsx_runtime.JSX.Element>;

declare function usePageDesigner(): PageDesigner | undefined;

declare const PageLoaderContainer: react.MemoExoticComponent<({ children, adaptMode }: {
    children: JSX.Element | JSX.Element[];
    adaptMode?: number;
}) => react_jsx_runtime.JSX.Element>;

declare abstract class EmbeddedDivControl<P extends EditorProperties> extends TypedControl<P> {
    shape: createjs.Shape;
    divTag?: HTMLDivElement;
    constructor(props: P, controlTypeInfo: ControlTypeInfo, controlData?: ControlData);
    getDefaultSize(): Size;
    assembleComponents(): void;
    onDivSizeChanged(): void;
    reDraw(): void;
    abstract startRunDiv(div: HTMLDivElement): void;
    abstract destoryDiv(): void;
    startRun(): void;
}

declare abstract class EmbeddedPageControl<P extends EditorProperties> extends TypedControl<P> {
    internalUrl: string;
    shape: createjs.Shape;
    iframetag?: HTMLIFrameElement;
    constructor(props: P, controlTypeInfo: ControlTypeInfo, controlData?: ControlData);
    getDefaultSize(): Size;
    assembleComponents(): void;
    reDraw(): void;
    abstract getUrl(): string;
    startRun(): void;
}

declare const PropDefine: readonly [_iplusplus_y_model_dist_BuildType.BuildType<readonly [readonly ["name", () => string], readonly ["title", () => string], readonly ["editorType", () => string], readonly ["valueType", () => _iplusplus_y_model_dist_EditorPropertyValueType.EditorPropertyValueType]], readonly ["remark", "说明", "string", {
    defaultValue: string;
    dataTypeName: "string";
    validater?: (v: string) => boolean;
    validate(value: string): boolean;
    setValidater: (validater: (v: string) => boolean) => void;
    getDefaultValue(): string;
    _descr: string | undefined;
    _attach: Record<string, any>;
    description: (d: string | undefined) => /*elided*/ any;
    getDescription: () => string | undefined;
    attach: (key: string, payload: any) => /*elided*/ any;
    getAttach: (key: string) => any;
}]>];
declare class EmptyControl extends TypedControl<typeof PropDefine> {
    run(): void;
    getDefaultSize(): Size;
    reDraw(): void;
    constructor();
}

type createJsDesigner_AnchorProp = AnchorProp;
type createJsDesigner_CommApi = CommApi;
type createJsDesigner_Control = Control;
type createJsDesigner_ControlData = ControlData;
type createJsDesigner_ControlFactory = ControlFactory;
type createJsDesigner_ControlLayer = ControlLayer;
declare const createJsDesigner_ControlLayer: typeof ControlLayer;
type createJsDesigner_ControlMeta = ControlMeta;
type createJsDesigner_ControlTypeInfo = ControlTypeInfo;
type createJsDesigner_CreateJsDesignerConfig = CreateJsDesignerConfig;
declare const createJsDesigner_CreateJsDesignerContext: typeof CreateJsDesignerContext;
declare const createJsDesigner_CreateJsDesignerProvider: typeof CreateJsDesignerProvider;
type createJsDesigner_DesignerApi = DesignerApi;
type createJsDesigner_DesignerContextProps = DesignerContextProps;
type createJsDesigner_DesignerEventDefine = DesignerEventDefine;
type createJsDesigner_DesignerEventHandler<E extends DesignerEventType> = DesignerEventHandler<E>;
type createJsDesigner_DesignerEventHandlers = DesignerEventHandlers;
type createJsDesigner_DesignerEventType = DesignerEventType;
type createJsDesigner_EmbeddedDivControl<P extends EditorProperties> = EmbeddedDivControl<P>;
declare const createJsDesigner_EmbeddedDivControl: typeof EmbeddedDivControl;
type createJsDesigner_EmbeddedPageControl<P extends EditorProperties> = EmbeddedPageControl<P>;
declare const createJsDesigner_EmbeddedPageControl: typeof EmbeddedPageControl;
type createJsDesigner_EmptyControl = EmptyControl;
declare const createJsDesigner_EmptyControl: typeof EmptyControl;
type createJsDesigner_EventArgs = EventArgs;
type createJsDesigner_GroupControl = GroupControl;
declare const createJsDesigner_GroupControl: typeof GroupControl;
type createJsDesigner_GroupControlAttchInfo = GroupControlAttchInfo;
type createJsDesigner_GroupControlData = GroupControlData;
type createJsDesigner_MetaProperty = MetaProperty;
type createJsDesigner_PageApi = PageApi;
type createJsDesigner_PageData = PageData;
type createJsDesigner_PageDesigner = PageDesigner;
declare const createJsDesigner_PageDesigner: typeof PageDesigner;
declare const createJsDesigner_PageDesignerContainer: typeof PageDesignerContainer;
declare const createJsDesigner_PageDesignerContainerContext: typeof PageDesignerContainerContext;
type createJsDesigner_PageDesignerContainerProps = PageDesignerContainerProps;
type createJsDesigner_PageLoader = PageLoader;
declare const createJsDesigner_PageLoader: typeof PageLoader;
declare const createJsDesigner_PageLoaderContainer: typeof PageLoaderContainer;
declare const createJsDesigner_PageLoaderContainerContext: typeof PageLoaderContainerContext;
type createJsDesigner_PageLoaderContainerProps = PageLoaderContainerProps;
type createJsDesigner_PositionAndSizeProperty = PositionAndSizeProperty;
type createJsDesigner_SelectedChangeEventArgs = SelectedChangeEventArgs;
type createJsDesigner_Size = Size;
type createJsDesigner_TypedControl<P extends EditorProperties> = TypedControl<P>;
declare const createJsDesigner_TypedControl: typeof TypedControl;
declare const createJsDesigner_anchorPropDefine: typeof anchorPropDefine;
declare const createJsDesigner_createControlFactory: typeof createControlFactory;
declare const createJsDesigner_defaultAnchor: typeof defaultAnchor;
declare const createJsDesigner_groupControlFactory: typeof groupControlFactory;
declare const createJsDesigner_metaPropDefine: typeof metaPropDefine;
declare const createJsDesigner_positionAndSizePropDefine: typeof positionAndSizePropDefine;
declare const createJsDesigner_usePageDesigner: typeof usePageDesigner;
declare namespace createJsDesigner {
  export { createJsDesigner_ControlLayer as ControlLayer, createJsDesigner_CreateJsDesignerContext as CreateJsDesignerContext, createJsDesigner_CreateJsDesignerProvider as CreateJsDesignerProvider, createJsDesigner_EmbeddedDivControl as EmbeddedDivControl, createJsDesigner_EmbeddedPageControl as EmbeddedPageControl, createJsDesigner_EmptyControl as EmptyControl, createJsDesigner_GroupControl as GroupControl, createJsDesigner_PageDesigner as PageDesigner, createJsDesigner_PageDesignerContainer as PageDesignerContainer, createJsDesigner_PageDesignerContainerContext as PageDesignerContainerContext, createJsDesigner_PageLoader as PageLoader, createJsDesigner_PageLoaderContainer as PageLoaderContainer, createJsDesigner_PageLoaderContainerContext as PageLoaderContainerContext, createJsDesigner_TypedControl as TypedControl, createJsDesigner_anchorPropDefine as anchorPropDefine, createJsDesigner_createControlFactory as createControlFactory, createJsDesigner_defaultAnchor as defaultAnchor, createJsDesigner_groupControlFactory as groupControlFactory, createJsDesigner_metaPropDefine as metaPropDefine, createJsDesigner_positionAndSizePropDefine as positionAndSizePropDefine, createJsDesigner_usePageDesigner as usePageDesigner };
  export type { createJsDesigner_AnchorProp as AnchorProp, createJsDesigner_CommApi as CommApi, createJsDesigner_Control as Control, createJsDesigner_ControlData as ControlData, createJsDesigner_ControlFactory as ControlFactory, createJsDesigner_ControlMeta as ControlMeta, createJsDesigner_ControlTypeInfo as ControlTypeInfo, createJsDesigner_CreateJsDesignerConfig as CreateJsDesignerConfig, createJsDesigner_DesignerApi as DesignerApi, createJsDesigner_DesignerContextProps as DesignerContextProps, createJsDesigner_DesignerEventDefine as DesignerEventDefine, createJsDesigner_DesignerEventHandler as DesignerEventHandler, createJsDesigner_DesignerEventHandlers as DesignerEventHandlers, createJsDesigner_DesignerEventType as DesignerEventType, createJsDesigner_EventArgs as EventArgs, createJsDesigner_GroupControlAttchInfo as GroupControlAttchInfo, createJsDesigner_GroupControlData as GroupControlData, createJsDesigner_MetaProperty as MetaProperty, createJsDesigner_PageApi as PageApi, createJsDesigner_PageData as PageData, createJsDesigner_PageDesignerContainerProps as PageDesignerContainerProps, createJsDesigner_PageLoaderContainerProps as PageLoaderContainerProps, createJsDesigner_PositionAndSizeProperty as PositionAndSizeProperty, createJsDesigner_SelectedChangeEventArgs as SelectedChangeEventArgs, createJsDesigner_Size as Size };
}

export { ControlLayer, CreateJsDesignerContext, CreateJsDesignerProvider, EmbeddedDivControl, EmbeddedPageControl, EmptyControl, GroupControl, PageDesigner, PageDesignerContainer, PageDesignerContainerContext, PageLoader, PageLoaderContainer, PageLoaderContainerContext, TypedControl, anchorPropDefine, createControlFactory, createJsDesigner, createJsDesigner as default, defaultAnchor, groupControlFactory, metaPropDefine, positionAndSizePropDefine, usePageDesigner };
export type { AnchorProp, CommApi, Control, ControlData, ControlFactory, ControlMeta, ControlTypeInfo, CreateJsDesignerConfig, DesignerApi, DesignerContextProps, DesignerEventDefine, DesignerEventHandler, DesignerEventHandlers, DesignerEventType, EventArgs, GroupControlAttchInfo, GroupControlData, MetaProperty, PageApi, PageData, PageDesignerContainerProps, PageLoaderContainerProps, PositionAndSizeProperty, SelectedChangeEventArgs, Size };