@leafer-ui/interface 1.0.0-beta.9 → 1.0.0-rc.10

package/types/index.d.ts

@@ -0,0 +1,756 @@
+import { IPointData, IExportFileType, ISizeData, IWindingRule, IPathCommandData, IBlendMode, IMatrixData, ILeaferImage, ITaskItem, INumber, IBoolean, IString, IPathString, IPathCreator, IBoundsData, ILeaferImageConfig, ILeaferCanvas, IRenderOptions, IPickOptions, IPickResult, ILeaf, IPathDrawer, IExportOptions, IExportResult, IAnswer, ILeafData, IPath2D, ILeafComputedData, ILeafInputData, IObject, ILeaferAttrData, IControl, ILeaferConfig, ILeaferType, ILeafRender, ILeafBounds, ILeafHit, ICachedLeaf, IBooleanMap } from '@leafer/interface';
+export * from '@leafer/interface';
+import { IGroup as IGroup$1, ISelectorProxy, IUI as IUI$1, IObject as IObject$1, ILeaf as ILeaf$1, IEditSize, IDragEvent, IRotateEvent, IGroupInputData as IGroupInputData$1, IStroke as IStroke$1, IFill as IFill$1, IBoxInputData as IBoxInputData$1, IRectInputData as IRectInputData$1, ICursorType, IImageCursor, IAround } from '@leafer-ui/interface';
+
+type IPercent = string;
+type IColorString = string;
+type ICornerRadiusString = string;
+type IStrokeWidthString = string;
+type IDashPatternString = string;
+type IPaintString = ISolidPaintString | IGradientPaintString | IImagePaintString;
+type ISolidPaintString = string;
+type IGradientPaintString = string;
+type IImagePaintString = string;
+type IShadowString = string;
+
+interface IUnitData {
+    type: 'percent' | 'px';
+    value: number;
+}
+type IPaint = ISolidPaint | IGradientPaint | IImagePaint;
+type IFill = IPaint | IPaint[] | IPaintString;
+type IStroke = IPaint | IPaint[] | IPaintString;
+type IPaintAttr = 'fill' | 'stroke';
+interface IPaintBase {
+    type: IPaintType;
+    blendMode?: IBlendMode;
+    visible?: boolean;
+    opacity?: number;
+}
+type IPaintType = 'image' | 'solid' | IGradientType;
+type IGradientType = 'linear' | 'radial' | 'angular';
+interface ISolidPaint extends IPaintBase {
+    type: 'solid';
+    color: IColor;
+}
+type IColor = IColorString | IRGB | IRGBA;
+interface IRGB {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}
+interface IRGBA extends IRGB {
+    a: number;
+}
+interface IGradientPaint extends IPaintBase {
+    type: IGradientType;
+    from?: IPointData;
+    to?: IPointData;
+    stretch?: number;
+    stops: IColorStop[];
+}
+interface IColorStop {
+    offset: number;
+    color: IColor;
+}
+interface IImagePaint extends IPaintBase {
+    type: "image";
+    url: string;
+    mode?: IImagePaintMode;
+    format?: IExportFileType;
+    filters?: IImageFilters;
+    offset?: IPointData;
+    size?: number | ISizeData;
+    scale?: number | IPointData;
+    rotation?: number;
+    repeat?: IRepeat;
+}
+interface IImageFilters {
+    exposure?: number;
+    contrast?: number;
+    saturation?: number;
+    temperature?: number;
+    tint?: number;
+    highlights?: number;
+    shadows?: number;
+}
+type IImagePaintMode = 'cover' | 'fit' | 'strench' | 'clip' | 'repeat';
+type IRepeat = boolean | 'x' | 'y';
+type IStrokeAlign = 'inside' | 'outside' | 'center';
+type IStrokeCap = 'none' | 'round' | 'square' | 'arrow-lines' | 'arrow-equilateral';
+type IStrokeJoin = 'bevel' | 'round' | 'miter';
+type IArrowType = 'none' | 'line' | 'triangle' | 'circle';
+type ITextAlign = 'left' | 'center' | 'right' | 'justify';
+type IVerticalAlign = 'top' | 'middle' | 'bottom';
+type ITextCase = 'upper' | 'lower' | 'title' | 'none' | 'small-caps';
+type IFontWeight = IFontWeightNumer | IFontWeightString;
+type IFontWeightNumer = 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
+type IFontWeightString = 'thin' | 'extra-light' | 'light' | 'normal' | 'medium' | 'semi-bold' | 'bold' | 'extra-bold' | 'black';
+type ITextDecoration = 'none' | 'under' | 'delete';
+type ITextWrap = 'normal' | 'none' | 'break';
+interface IVectorPath {
+    rule?: IWindingRule;
+    data: string | IPathCommandData;
+}
+interface IShadowEffect {
+    x: number;
+    y: number;
+    blur: number;
+    spread?: number;
+    color: IColorString | IColor;
+    blendMode?: IBlendMode;
+    visible?: boolean;
+    box?: boolean;
+}
+interface IBlurEffect {
+    blur: number;
+    visible?: boolean;
+}
+interface IGrayscaleEffect {
+    grayscale: number;
+    visible?: boolean;
+}
+type IOverflow = 'show' | 'hide';
+
+type ILeafPaintColor = IColorString | CanvasGradient | CanvasPattern;
+interface ILeafPaint {
+    type?: IPaintType;
+    style?: ILeafPaintColor;
+    transform?: IMatrixData;
+    blendMode?: IBlendMode;
+    opacity?: number;
+    image?: ILeaferImage;
+    loadId?: number;
+    patternId?: string;
+    patternTask?: ITaskItem;
+    data?: ILeafPaintPatternData;
+}
+interface ILeafPaintPatternData {
+    width?: number;
+    height?: number;
+    scaleX?: number;
+    scaleY?: number;
+    opacity?: number;
+    transform?: IMatrixData;
+    mode?: IImagePaintMode;
+    repeat?: 'repeat' | 'repeat-x' | 'repeat-y';
+}
+type ILeafFill = ILeafPaint;
+interface ILeafStrokePaint extends ILeafPaint {
+    strokeAlign?: IStrokeAlign;
+    strokeWidth?: number;
+    strokeCap?: IStrokeCap;
+    strokeJoin?: IStrokeJoin;
+    dashPattern?: number[];
+    miterLimit?: number;
+}
+interface ILeafShadowEffect {
+    x: number;
+    y: number;
+    blur: number;
+    spread?: number;
+    color: IColorString;
+    blendMode?: IBlendMode;
+    box?: boolean;
+}
+
+interface ICornerRadiusAttrData {
+    cornerRadius: INumber | INumber[] | ICornerRadiusString;
+    cornerSmoothing: INumber;
+}
+interface ICornerRadiusInputData {
+    cornerRadius?: INumber | INumber[] | ICornerRadiusString;
+    cornerSmoothing?: INumber;
+}
+interface ICornerRadiusComputedData {
+    cornerRadius?: number;
+    cornerSmoothing?: number;
+}
+interface IFillAttrData {
+    fill: IFill;
+}
+interface IFillInputData {
+    fill?: IFill;
+}
+interface IFillComputedData {
+    fill?: IColorString | ILeafPaint[];
+}
+interface IBorderComputedData {
+    borderWidth?: number | number[];
+    borderRadius?: number | number[];
+}
+interface IStrokeAttrData {
+    stroke: IStroke;
+    strokeAlign: IStrokeAlign;
+    strokeWidth: INumber | INumber[] | IStrokeWidthString;
+    strokeWidthFixed: IBoolean;
+    strokeCap: IStrokeCap;
+    strokeJoin: IStrokeJoin;
+    dashPattern: INumber[] | IDashPatternString;
+    dashOffset: INumber;
+    miterLimit: INumber;
+    startArrow: IArrowType;
+    endArrow: IArrowType;
+}
+interface IStrokeInputData {
+    stroke?: IStroke;
+    strokeAlign?: IStrokeAlign;
+    strokeWidth?: INumber | INumber[] | IStrokeWidthString;
+    strokeWidthFixed?: IBoolean;
+    strokeCap?: IStrokeCap;
+    strokeJoin?: IStrokeJoin;
+    dashPattern?: INumber[] | IDashPatternString;
+    dashOffset?: INumber;
+    miterLimit?: INumber;
+    startArrow?: IArrowType;
+    endArrow?: IArrowType;
+}
+interface IStrokeComputedData {
+    stroke?: IColorString | ILeafStrokePaint[];
+    strokeAlign?: IStrokeAlign;
+    strokeWidth?: number;
+    strokeWidths?: number[];
+    strokeWidthFixed?: boolean;
+    strokeCap?: IStrokeCap;
+    strokeJoin?: IStrokeJoin;
+    dashPattern?: number[];
+    dashOffset?: number;
+    miterLimit?: number;
+}
+interface ITextStyleAttrData {
+    fontFamily: IString;
+    fontSize: INumber;
+    fontWeight: IFontWeight;
+    italic: IBoolean;
+    textCase: ITextCase;
+    textDecoration: ITextDecoration;
+    letterSpacing: INumber | IUnitData;
+    lineHeight: INumber | IUnitData;
+    paraIndent: INumber;
+    paraSpacing: INumber;
+    textAlign: ITextAlign;
+    verticalAlign: IVerticalAlign;
+    textWrap: ITextWrap;
+    textOverflow: IOverflow | string;
+}
+interface ITextStyleInputData {
+    fontFamily?: IString;
+    fontSize?: INumber;
+    fontWeight?: IFontWeight;
+    italic?: IBoolean;
+    textCase?: ITextCase;
+    textDecoration?: ITextDecoration;
+    letterSpacing?: INumber | IUnitData;
+    lineHeight?: INumber | IUnitData;
+    paraIndent?: INumber;
+    paraSpacing?: INumber;
+    textAlign?: ITextAlign;
+    verticalAlign?: IVerticalAlign;
+    textWrap?: ITextWrap;
+    textOverflow?: IOverflow | string;
+}
+interface ITextStyleComputedData {
+    fontFamily?: string;
+    fontSize?: number;
+    fontWeight?: IFontWeight;
+    italic?: boolean;
+    textCase?: ITextCase;
+    textDecoration?: ITextDecoration;
+    letterSpacing?: number;
+    lineHeight?: number;
+    paraIndent?: number;
+    paraSpacing?: number;
+    textAlign?: ITextAlign;
+    verticalAlign?: IVerticalAlign;
+    textWrap?: ITextWrap;
+    textOverflow?: IOverflow | string;
+}
+interface IEffectAttrData {
+    shadow: IShadowEffect | IShadowEffect[] | IShadowString;
+    innerShadow: IShadowEffect | IShadowEffect[] | IShadowString;
+    blur: INumber | IBlurEffect;
+    backgroundBlur: INumber | IBlurEffect;
+    grayscale: INumber | IGrayscaleEffect;
+}
+interface IEffectInputData {
+    shadow?: IShadowEffect | IShadowEffect[] | IShadowString;
+    innerShadow?: IShadowEffect | IShadowEffect[] | IShadowString;
+    blur?: INumber | IBlurEffect;
+    backgroundBlur?: INumber | IBlurEffect;
+    grayscale?: INumber | IGrayscaleEffect;
+}
+interface IEffectComputedData {
+    shadow?: ILeafShadowEffect[];
+    innerShadow?: ILeafShadowEffect[];
+    blur?: number;
+    backgroundBlur?: number;
+    grayscale?: number;
+}
+
+interface ILine extends IUI {
+    __: ILineData;
+    toPoint: IPointData;
+    points: number[];
+    curve: boolean | number;
+}
+interface ILineAttrData {
+    toPoint?: IPointData;
+    points?: number[];
+    curve?: boolean | number;
+}
+interface ILineData extends ILineAttrData, IUIData {
+}
+interface ILineInputData extends ILineAttrData, IUIBaseInputData {
+}
+interface IArrow extends ILine {
+    __: IArrowData;
+}
+interface IArrowAttrData {
+}
+interface IArrowData extends IArrowAttrData, ILineData {
+}
+interface IArrowInputData extends IArrowAttrData, IUIBaseInputData {
+}
+interface IRect extends IUI {
+    __: IRectData;
+}
+interface IRectData extends IUIData {
+}
+interface IRectInputData extends IUIBaseInputData {
+}
+interface IEllipse extends IUI {
+    __: IEllipseData;
+    startAngle: number;
+    endAngle: number;
+    innerRadius: number;
+}
+interface IEllipseAttrData {
+    startAngle?: number;
+    endAngle?: number;
+    innerRadius?: number;
+}
+interface IEllipseData extends IEllipseAttrData, IUIData {
+}
+interface IEllipseInputData extends IEllipseAttrData, IUIBaseInputData {
+}
+interface IPolygon extends IUI {
+    __: IPolygonData;
+    sides: number;
+    points: number[];
+    curve: boolean | number;
+}
+interface IPolygonAttrData {
+    sides?: number;
+    points?: number[];
+    curve?: boolean | number;
+}
+interface IPolygonData extends IPolygonAttrData, IUIData {
+}
+interface IPolygonInputData extends IPolygonAttrData, IUIBaseInputData {
+}
+interface IStar extends IUI {
+    __: IStarData;
+    corners: number;
+    innerRadius: number;
+}
+interface IStarAttrData {
+    corners?: number;
+    innerRadius?: number;
+}
+interface IStarData extends IStarAttrData, IUIData {
+}
+interface IStarInputData extends IStarAttrData, IUIBaseInputData {
+}
+interface IPath extends IUI {
+    __: IPathData;
+    path: IPathCommandData | IPathString;
+    windingRule: IWindingRule;
+}
+interface IPathData extends IUIData {
+    path?: IPathCommandData;
+    windingRule?: IWindingRule;
+}
+interface IPathInputData extends IUIBaseInputData {
+    path?: IPathCommandData | IPathString;
+    windingRule?: IWindingRule;
+}
+interface IPen extends IGroup, IPathCreator {
+    __: IPenData;
+    pathElement: IPath;
+    pathStyle: IPathInputData;
+    path: IPathCommandData;
+    paint(): void;
+    clear(): void;
+}
+interface IPenData extends IGroupData {
+}
+interface IPenInputData extends IGroupInputData {
+}
+interface IText extends ITextStyleAttrData, IUI {
+    __: ITextData;
+    text: string;
+}
+interface ITextAttrData {
+    text?: string;
+}
+interface ITextData extends ITextAttrData, ITextStyleComputedData, IUIData {
+    __baseLine?: number;
+    __lineHeight?: number;
+    __letterSpacing?: number;
+    __padding?: number[];
+    __clipText?: boolean;
+    __textBoxBounds?: IBoundsData;
+}
+interface ITextInputData extends ITextAttrData, ITextStyleInputData, IUIBaseInputData {
+}
+interface ITextRowData {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    text?: string;
+    data?: ITextCharData[];
+    words?: ITextWordData[];
+    startCharSize?: number;
+    endCharSize?: number;
+    paraStart?: boolean;
+    paraEnd?: boolean;
+    isOverflow?: boolean;
+    textMode?: boolean;
+}
+interface ITextWordData {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    data?: ITextCharData[];
+}
+interface ITextCharData {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    char?: string;
+}
+interface ITextDrawData {
+    bounds: IBoundsData;
+    rows: ITextRowData[];
+    paraNumber: number;
+    font: string;
+    decorationY?: number;
+    decorationHeight?: number;
+    overflow?: number;
+}
+interface IImage extends IRect, ILeaferImageConfig {
+    __: IImageData;
+    url: string;
+    ready: boolean;
+    image?: ILeaferImage;
+}
+interface IImageAttrData {
+    url?: string;
+}
+interface IImageData extends IImageAttrData, IRectData {
+    __setImageFill(value: string): void;
+}
+interface IImageInputData extends IImageAttrData, IUIBaseInputData {
+}
+interface ICanvas extends IRect {
+    __: ICanvasData;
+    pixelRatio: number;
+    smooth: boolean;
+    canvas: ILeaferCanvas;
+    __updateSize(): void;
+}
+interface ICanvasAttrData {
+    pixelRatio?: number;
+    smooth?: boolean;
+}
+interface ICanvasData extends ICanvasAttrData, IRectData {
+}
+interface ICanvasInputData extends ICanvasAttrData, IUIBaseInputData {
+}
+interface ILeaferData extends IGroupData {
+    pixelRatio?: number;
+}
+interface ILeaferInputData extends IGroupInputData {
+    pixelRatio?: number;
+}
+interface IAppData extends ILeaferData {
+}
+interface IAppInputData extends ILeaferInputData {
+}
+interface IFrame extends IBox {
+    __: IFrameData;
+}
+interface IFrameData extends IBoxData {
+}
+interface IFrameInputData extends IBoxInputData {
+}
+interface IBox extends IGroup {
+    __: IBoxData;
+    overflow: IOverflow;
+    __updateRectRenderBounds(): void;
+    __renderGroup(canvas: ILeaferCanvas, options: IRenderOptions): void;
+}
+interface IBoxData extends IGroupData {
+    overflow?: IOverflow;
+}
+interface IBoxInputData extends IGroupInputData {
+    overflow?: IOverflow;
+}
+interface IGroup extends IUI {
+    __: IGroupData;
+    children: IUI[];
+    pick(hitPoint: IPointData, options?: IPickOptions): IPickResult;
+    add(child: IUI, index?: number): void;
+    addAt(child: IUI, index: number): void;
+    addAfter(child: IUI, after: IUI): void;
+    addBefore(child: IUI, before: IUI): void;
+    addMany(...children: ILeaf[]): void;
+    remove(child?: IUI): void;
+    removeAll(): void;
+    clear(): void;
+}
+interface IGroupData extends IUIData {
+}
+interface IGroupInputData extends IUIBaseInputData {
+}
+interface IUI extends IFillAttrData, IStrokeAttrData, ICornerRadiusAttrData, IEffectAttrData, ILeaf {
+    __: IUIData;
+    readonly app: ILeafer;
+    leafer?: ILeafer;
+    parent?: IGroup;
+    isFrame?: boolean;
+    proxyData: IUIInputData;
+    __proxyData?: IUIInputData;
+    children?: IUI[];
+    reset(data?: IUIInputData): void;
+    set(data: IUIInputData): void;
+    toJSON(): IUIInputData;
+    get(): IUIInputData;
+    createProxyData(): IUIInputData;
+    find(condition: number | string | IFindUIMethod, options?: any): IUI[];
+    findOne(condition: number | string | IFindUIMethod, options?: any): IUI;
+    getPath(curve?: boolean, pathForRender?: boolean): IPathCommandData;
+    getPathString(curve?: boolean, pathForRender?: boolean): IPathString;
+    __drawPathByData(drawer: IPathDrawer, data: IPathCommandData): void;
+    __drawPathByBox(drawer: IPathDrawer): void;
+    __drawAfterFill?(canvas: ILeaferCanvas, options: IRenderOptions): void;
+    export(filename: string, options?: IExportOptions | number | boolean): Promise<IExportResult>;
+    clone(): IUI;
+}
+interface IFindUIMethod {
+    (leaf: IUI, options?: any): IAnswer;
+}
+interface IUIData extends IUIComputedData, ILeafData {
+    padding?: number | number[];
+    locked?: boolean;
+    __isFills?: boolean;
+    __isStrokes?: boolean;
+    readonly __strokeWidth: number;
+    __pixelFill?: boolean;
+    __pixelStroke?: boolean;
+    __opacityFill?: boolean;
+    __opacityStroke?: boolean;
+    __drawAfterFill?: boolean;
+    __isOverflow?: boolean;
+    __blendLayer?: boolean;
+    __useEffect?: boolean;
+    __autoWidth: boolean;
+    __autoHeight: boolean;
+    __autoBounds: boolean;
+    path?: IPathCommandData;
+    windingRule?: IWindingRule;
+    __pathForRender?: IPathCommandData;
+    __path2DForRender?: IPath2D;
+    __boxStroke?: boolean;
+    __font?: string;
+    __textDrawData?: ITextDrawData;
+    __needComputePaint: boolean;
+    __computePaint(): void;
+}
+interface IUIComputedData extends IFillComputedData, IBorderComputedData, IStrokeComputedData, ITextStyleComputedData, ICornerRadiusComputedData, IEffectComputedData, ILeafComputedData {
+    padding?: number | number[];
+    locked?: boolean;
+}
+interface IUIBaseInputData extends IFillInputData, IStrokeInputData, ITextStyleInputData, ICornerRadiusInputData, IEffectInputData, ILeafInputData {
+    padding?: number | number[];
+    locked?: boolean;
+    children?: IUIInputData[];
+}
+type IUITag = 'App' | 'Leafer' | 'Rect' | 'Ellipse' | 'Polygon' | 'Star' | 'Line' | 'Path' | 'Pen' | 'Text' | 'Image' | 'Canvas' | 'Group' | 'Frame' | 'Box';
+interface IUIInputData extends IRectInputData, IEllipseInputData, IPolygonInputData, IStarInputData, ILineInputData, IPathInputData, ITextInputData, IImageInputData, IGroupInputData, IFrameInputData, IUIBaseInputData, IObject {
+    children?: IUIInputData[];
+}
+
+interface IEditorBase extends IGroup$1, ISelectorProxy {
+    config: IEditorConfig;
+    hoverTarget: IUI$1;
+    target: IUI$1 | IUI$1[];
+    readonly list: IUI$1[];
+    readonly hasTarget: boolean;
+    readonly multiple: boolean;
+    readonly single: boolean;
+    readonly dragging: boolean;
+    element: IUI$1;
+    buttons: IGroup$1;
+    selector: IGroup$1;
+    editBox: IGroup$1;
+    editTool: IObject$1;
+    hasItem(item: IUI$1): boolean;
+    shiftItem(item: IUI$1): void;
+    addItem(item: IUI$1): void;
+    removeItem(item: IUI$1): void;
+    update(): void;
+    updateEditTool(): void;
+    getEditSize(ui: ILeaf$1): IEditSize;
+    onMove(e: IDragEvent): void;
+    onScale(e: IDragEvent): void;
+    onRotate(e: IDragEvent | IRotateEvent): void;
+    onSkew(e: IDragEvent): void;
+    group(group?: IGroup$1 | IGroupInputData$1): IGroup$1;
+    ungroup(): IUI$1[];
+    lock(): void;
+    unlock(): void;
+    toTop(): void;
+    toBottom(): void;
+}
+interface IEditorConfig {
+    editSize?: 'auto' | IEditSize;
+    stroke?: IStroke$1;
+    strokeWidth?: number;
+    pointFill?: IFill$1;
+    pointSize?: number;
+    pointRadius?: number;
+    point?: IBoxInputData$1 | IBoxInputData$1[];
+    middlePoint?: IBoxInputData$1 | IBoxInputData$1[];
+    rotatePoint?: IBoxInputData$1;
+    rect?: IBoxInputData$1;
+    area?: IRectInputData$1;
+    buttonsDirection?: 'top' | 'right' | 'bottom' | 'left';
+    buttonsFixed?: boolean;
+    buttonsMargin?: number;
+    hideOnMove?: boolean;
+    moveCursor?: ICursorType;
+    resizeCursor?: IImageCursor;
+    rotateCursor?: IImageCursor;
+    skewCursor?: IImageCursor;
+    around?: IAround;
+    lockRatio?: boolean;
+    rotateGap?: number;
+    selector?: boolean;
+    hover?: boolean;
+    boxSelect?: boolean;
+    rotateable?: boolean;
+    resizeable?: boolean;
+    skewable?: boolean;
+}
+
+interface ILeafer extends IGroup, ILeaferAttrData, IControl {
+    readonly isApp: boolean;
+    readonly app: ILeafer;
+    parent?: IApp;
+    zoomLayer: IGroup;
+    editor: IEditorBase;
+    ground?: ILeafer;
+    tree?: ILeafer;
+    sky?: ILeafer;
+    userConfig?: ILeaferConfig;
+    onInit(): void;
+    initType(type: ILeaferType): void;
+}
+
+interface IApp extends ILeafer {
+    children: ILeafer[];
+    realCanvas: boolean;
+}
+interface IAppConfig extends ILeaferConfig {
+    ground?: ILeaferConfig;
+    tree?: ILeaferConfig;
+    sky?: ILeaferConfig;
+    editor?: IEditorConfig;
+}
+
+type IUIRenderModule = IUIRender & ThisType<IUI>;
+interface IUIRender extends ILeafRender {
+    __drawAfterFill?(canvas: ILeaferCanvas, options: IRenderOptions): void;
+}
+type IRectRenderModule = IRectRender & ThisType<IRect>;
+interface IRectRender extends IUIRender {
+}
+type IImageRenderModule = IImageRender & ThisType<IImage>;
+interface IImageRender extends IUIRender {
+}
+type ITextRenderModule = ITextRender & ThisType<IText>;
+interface ITextRender extends IUIRender {
+}
+type IGroupRenderModule = IGroupRender & ThisType<IGroup>;
+interface IGroupRender extends IUIRender {
+}
+type IFrameRenderModule = IFrameRender & ThisType<IFrame>;
+interface IFrameRender extends IGroupRender {
+}
+
+type IUIBoundsModule = IUIBounds & ThisType<IUI>;
+interface IUIBounds extends ILeafBounds {
+}
+
+type IUIHitModule = ILeafHit & ThisType<IUI>;
+
+interface ITextConvertModule {
+    getDrawData(content: string, style: ITextData): ITextDrawData;
+}
+
+interface IColorConvertModule {
+    string(color: IColor, opacity?: number): string;
+}
+
+interface IExportModule {
+    running?: boolean;
+    export(leaf: ILeaf, filename: IExportFileType | string, options?: IExportOptions | number | boolean): Promise<IExportResult>;
+}
+
+interface ICachedShape extends ICachedLeaf {
+    worldCanvas?: ILeaferCanvas;
+    shapeBounds: IBoundsData;
+    scaleX: number;
+    scaleY: number;
+}
+
+interface IPaintModule {
+    compute(attrName: IPaintAttr, ui: IUI): void;
+    fill(fill: string, ui: IUI, canvas: ILeaferCanvas): void;
+    fills(fills: ILeafPaint[], ui: IUI, canvas: ILeaferCanvas): void;
+    fillText(ui: IUI, canvas: ILeaferCanvas): void;
+    stroke(stroke: string, ui: IUI, canvas: ILeaferCanvas): void;
+    strokes(strokes: ILeafPaint[], ui: IUI, canvas: ILeaferCanvas): void;
+    strokeText(stroke: string | ILeafPaint[], ui: IUI, canvas: ILeaferCanvas): void;
+    drawTextStroke(ui: IUI, canvas: ILeaferCanvas): void;
+    shape(ui: IUI, current: ILeaferCanvas, renderOptions: IRenderOptions): ICachedShape;
+}
+interface IPaintImageModule {
+    image(ui: IUI, attrName: string, paint: IImagePaint, boxBounds: IBoundsData, firstUse: boolean): ILeafPaint;
+    checkImage(ui: IUI, canvas: ILeaferCanvas, paint: ILeafPaint, allowPaint?: boolean): boolean;
+    createPattern(ui: IUI, paint: ILeafPaint, pixelRatio: number): boolean;
+    recycleImage(attrName: IPaintAttr, data: IUIData): IBooleanMap;
+    createData(leafPaint: ILeafPaint, image: ILeaferImage, paint: IImagePaint, box: IBoundsData): void;
+    fillOrFitMode(data: ILeafPaintPatternData, mode: IImagePaintMode, box: IBoundsData, width: number, height: number, rotation: number): void;
+    clipMode(data: ILeafPaintPatternData, box: IBoundsData, x: number, y: number, scaleX: number, scaleY: number, rotation: number): void;
+    repeatMode(data: ILeafPaintPatternData, box: IBoundsData, width: number, height: number, x: number, y: number, scaleX: number, scaleY: number, rotation: number): void;
+}
+interface IPaintGradientModule {
+    linearGradient(paint: IGradientPaint, box: IBoundsData): ILeafPaint;
+    radialGradient(paint: IGradientPaint, box: IBoundsData): ILeafPaint;
+    conicGradient(paint: IGradientPaint, box: IBoundsData): ILeafPaint;
+}
+
+interface IEffectModule {
+    shadow(ui: IUI, current: ILeaferCanvas, shape: ICachedShape): void;
+    innerShadow(ui: IUI, current: ILeaferCanvas, shape: ICachedShape): void;
+    blur(ui: IUI, current: ILeaferCanvas, origin: ILeaferCanvas): void;
+    backgroundBlur(ui: IUI, current: ILeaferCanvas, shape: ICachedShape): void;
+}
+
+export type { IApp, IAppConfig, IAppData, IAppInputData, IArrow, IArrowData, IArrowInputData, IArrowType, IBlurEffect, IBox, IBoxData, IBoxInputData, ICachedShape, ICanvas, ICanvasData, ICanvasInputData, IColor, IColorConvertModule, IColorStop, IColorString, ICornerRadiusString, IDashPatternString, IEditorBase, IEditorConfig, IEffectModule, IEllipse, IEllipseData, IEllipseInputData, IExportModule, IFill, IFindUIMethod, IFontWeight, IFrame, IFrameData, IFrameInputData, IFrameRenderModule, IGradientPaint, IGrayscaleEffect, IGroup, IGroupData, IGroupInputData, IGroupRenderModule, IImage, IImageData, IImageInputData, IImagePaint, IImagePaintMode, IImageRenderModule, ILeafFill, ILeafPaint, ILeafPaintColor, ILeafPaintPatternData, ILeafShadowEffect, ILeafStrokePaint, ILeafer, ILeaferData, ILeaferInputData, ILine, ILineData, ILineInputData, IOverflow, IPaint, IPaintAttr, IPaintGradientModule, IPaintImageModule, IPaintModule, IPaintString, IPath, IPathData, IPathInputData, IPen, IPenData, IPenInputData, IPercent, IPolygon, IPolygonData, IPolygonInputData, IRGB, IRGBA, IRect, IRectData, IRectInputData, IRectRenderModule, IRepeat, IShadowEffect, IShadowString, IStar, IStarData, IStarInputData, IStroke, IStrokeAlign, IStrokeCap, IStrokeJoin, IStrokeWidthString, IText, ITextAlign, ITextCase, ITextCharData, ITextConvertModule, ITextData, ITextDecoration, ITextDrawData, ITextInputData, ITextRenderModule, ITextRowData, ITextWordData, ITextWrap, IUI, IUIBaseInputData, IUIBoundsModule, IUIData, IUIHitModule, IUIInputData, IUIRenderModule, IUITag, IUnitData, IVectorPath, IVerticalAlign };