export type WhiteboardPageSize = {
    width: number;
    height: number;
    originalWidth?: number;
    originalHeight?: number;
};
export type Point = {
    x: number;
    y: number;
};
export type WhiteboardItemId = string | number;
export type WhiteboardStrokeType = 'draw' | 'erase';
export type WhiteboardStroke = {
    points: number[][];
    color?: string;
    width?: number;
    type?: WhiteboardStrokeType;
};
export type WhiteboardTextItem = {
    id?: WhiteboardItemId;
    x: number;
    y: number;
    content: string;
    fontSize?: number;
    width?: number;
};
export type WhiteboardImageItem = {
    id?: WhiteboardItemId;
    stickerId?: string;
    x: number;
    y: number;
    src: string;
    width?: number;
    height?: number;
    type?: string;
};
export type WhiteboardStoredStroke = {
    pointsN: number[][];
    widthN?: number;
    color?: string;
    type?: WhiteboardStrokeType;
};
export type WhiteboardStoredTextItem = {
    id: WhiteboardItemId;
    xN: number;
    yN: number;
    content: string;
    fontSizeN?: number;
    widthN?: number | null;
};
export type WhiteboardStoredImageItem = {
    id: WhiteboardItemId;
    stickerId?: WhiteboardItemId | null;
    xN: number;
    yN: number;
    src: string;
    widthN?: number | null;
    heightN?: number | null;
    type?: string;
};
export type WhiteboardStoredPageData = {
    strokes?: WhiteboardStoredStroke[];
    text?: WhiteboardStoredTextItem[];
    images?: WhiteboardStoredImageItem[];
};
export type WhiteboardSerializedPage = {
    strokes: WhiteboardStoredStroke[];
    text: WhiteboardStoredTextItem[];
    images: WhiteboardStoredImageItem[];
};
export type WhiteboardRendererEvent = {
    target?: unknown;
    cancelBubble?: boolean;
};
export interface WhiteboardRendererNode {
    _whiteboardId?: WhiteboardItemId;
    on(events: string, handler: (event: WhiteboardRendererEvent) => void): unknown;
    destroy(): unknown;
    name(): string;
    name(name: string): unknown;
}
export interface WhiteboardShapeNode extends WhiteboardRendererNode {
    x(): number;
    x(value: number): unknown;
    y(): number;
    y(value: number): unknown;
    width(): number;
    width(value: number): unknown;
    height(): number;
    height(value: number): unknown;
    scaleX(): number;
    scaleY(): number;
    scale(scale: Point): unknown;
    draggable(value: boolean): unknown;
    position(): Point;
}
export interface WhiteboardTextNode extends WhiteboardShapeNode {
    scaleY(): number;
    scaleY(value: number): unknown;
    setAttrs(attrs: {
        width: number;
        scaleX: number;
        scaleY?: number;
    }): unknown;
    text(): string;
    text(value: string): unknown;
    fontSize(): number;
    fontFamily(): string;
    fill(): string | CanvasGradient;
}
export interface WhiteboardLineNode extends WhiteboardRendererNode {
    points(points: number[]): unknown;
}
export type WhiteboardBox = {
    x: number;
    y: number;
    width: number;
    height: number;
    rotation: number;
};
export type WhiteboardBoundBoxFunc = (oldBox: WhiteboardBox, newBox: WhiteboardBox) => WhiteboardBox;
export interface WhiteboardTransformerNode {
    destroy(): unknown;
    nodes(nodes: WhiteboardShapeNode[]): unknown;
    enabledAnchors(anchors: string[]): unknown;
    boundBoxFunc(fn: WhiteboardBoundBoxFunc): unknown;
}
export interface WhiteboardLayerNode {
    add(child: WhiteboardRendererNode | WhiteboardTransformerNode): unknown;
    find(selector: string): WhiteboardShapeNode[];
    destroyChildren(): unknown;
    batchDraw(): unknown;
    listening(listening: boolean): unknown;
    getCanvas(): {
        setPixelRatio(ratio: number): unknown;
    };
}
export interface WhiteboardStageNode {
    on(events: string, handler: (event: WhiteboardRendererEvent) => void): unknown;
    add(layer: WhiteboardLayerNode): unknown;
    size(size: {
        width: number;
        height: number;
    }): unknown;
    getPointerPosition(): Point | null;
    destroy(): unknown;
}
export type WhiteboardLineConfig = {
    points: number[];
    stroke: string;
    strokeWidth: number;
    lineCap: 'round';
    lineJoin: 'round';
    globalCompositeOperation: 'destination-out' | 'source-over';
};
export interface WhiteboardPageRenderer {
    Stage: new (config: {
        container: HTMLDivElement;
        width: number;
        height: number;
    }) => WhiteboardStageNode;
    Layer: new () => WhiteboardLayerNode;
    Line: new (config: WhiteboardLineConfig) => WhiteboardLineNode;
    Text: new (config: {
        x: number;
        y: number;
        text: string;
        fontSize: number;
        fontFamily: string;
        fill: string;
        draggable: boolean;
        width: number | undefined;
    }) => WhiteboardTextNode;
    Image: new (config: {
        x: number;
        y: number;
        image: HTMLImageElement;
        width: number;
        height: number;
        draggable: boolean;
    }) => WhiteboardShapeNode;
    Transformer: new (config: {
        enabledAnchors: string[];
        rotateEnabled: boolean;
        keepRatio: boolean;
        boundBoxFunc: WhiteboardBoundBoxFunc;
    }) => WhiteboardTransformerNode;
}
export type WhiteboardPageInit = {
    pageIndex: number;
    enabled: boolean;
    Renderer?: WhiteboardPageRenderer;
    onChange?: () => void;
    onToolChange?: (tool: string) => void;
};
export declare class WhiteboardPage {
    #private;
    pageIndex: number;
    strokes: WhiteboardStoredStroke[];
    text: WhiteboardStoredTextItem[];
    images: WhiteboardStoredImageItem[];
    size: WhiteboardPageSize | null;
    originalSize: {
        width: number | null;
        height: number | null;
    } | null;
    constructor(props: WhiteboardPageInit);
    setTool(tool: string): void;
    getTool(): string;
    setEnabled(enabled: boolean): void;
    isEnabled(): boolean;
    setSize(size: WhiteboardPageSize): void;
    resize(width: number, height: number): void;
    mount(container: HTMLDivElement): void;
    render(): void;
    renderStrokes(): void;
    renderText(): void;
    renderImages(): void;
    destroy(): void;
    toJSON(): WhiteboardSerializedPage;
    applyData(data?: WhiteboardStoredPageData): void;
    addStroke(stroke: WhiteboardStroke): void;
    addText(item: WhiteboardTextItem): void;
    addImage(item: WhiteboardImageItem): void;
}