import { default as default_2 } from 'react';
import { MouseEvent as MouseEvent_2 } from 'react';
import { PointerEvent as PointerEvent_2 } from 'react';
import { TouchEvent as TouchEvent_2 } from 'react';
import { WheelEvent as WheelEvent_2 } from 'react';

export declare const createDimension: (startX: number, startY: number, endX: number, endY: number, value?: string, color?: string) => DimensionData;

export declare const createImage: (src: string, x?: number, y?: number, width?: number, height?: number) => SketchImage;

export declare const Dimension: default_2.FC<DimensionProps>;

export declare interface DimensionData {
    id: string;
    startX: number;
    startY: number;
    endX: number;
    endY: number;
    value: string;
    color?: string;
    fontSize?: number;
    lineWidth?: number;
}

export declare const DimensionModal: default_2.FC<DimensionModalProps>;

declare interface DimensionModalProps {
    isOpen: boolean;
    initialValue: string;
    onConfirm: (value: string) => void;
    onCancel: () => void;
}

declare interface DimensionProps {
    dimension: DimensionData;
    scale: number;
    selected?: boolean;
    onSelect?: (id: string) => void;
    onUpdate?: (id: string, updates: Partial<DimensionData>) => void;
    onDelete?: (id: string) => void;
    onDragStart?: (id: string, clientX: number, clientY: number) => void;
    onHandleDragStart?: (id: string, handle: 'start' | 'end', clientX: number, clientY: number) => void;
    enabled?: boolean;
}

/**
 * DrawingBoard - A complete, ready-to-use drawing board component
 *
 * This component provides a full-featured whiteboard with:
 * - Multiple drawing modes (pen, hand, dimension, select)
 * - Stylus-only mode for tablets
 * - Image support with drag & resize
 * - Dimension/measurement annotations
 * - Pan and zoom
 * - Grid background
 * - Fullscreen mode
 * - Undo functionality
 * - Export/Import (JSON and image)
 * - Floating toolbox
 */
export declare const DrawingBoard: default_2.ForwardRefExoticComponent<DrawingBoardProps & default_2.RefAttributes<DrawingBoardRef>>;

export declare interface DrawingBoardProps {
    /** Initial strokes to display */
    initialStrokes?: Stroke[];
    /** Initial images to display */
    initialImages?: SketchImage[];
    /** Initial dimensions to display */
    initialDimensions?: DimensionData[];
    /** Initial mode for the whiteboard */
    initialMode?: WhiteboardMode;
    /** Whether to show the grid */
    showGrid?: boolean;
    /** Grid size in pixels */
    gridSize?: number;
    /** Grid line color */
    gridColor?: string;
    /** Grid line opacity (0-1) */
    gridOpacity?: number;
    /** Minimum zoom level */
    minZoom?: number;
    /** Maximum zoom level */
    maxZoom?: number;
    /** Color for dimension lines */
    dimensionColor?: string;
    /** Default pen color */
    defaultPenColor?: string;
    /** Default pen width */
    defaultPenWidth?: number;
    /** Container style */
    style?: default_2.CSSProperties;
    /** Callback when strokes change */
    onChangeStrokes?: (strokes: Stroke[]) => void;
    /** Callback when images change */
    onChangeImages?: (images: SketchImage[]) => void;
    /** Callback when dimensions change */
    onChangeDimensions?: (dimensions: DimensionData[]) => void;
    /** Callback when fullscreen state changes */
    onFullscreenChange?: (isFullscreen: boolean) => void;
    /** Color palette for the color picker */
    colorPalette?: string[];
    /** Toolbox initial position */
    toolboxPosition?: {
        x: number;
        y: number;
    };
    /** Toolbox orientation */
    toolboxOrientation?: 'horizontal' | 'vertical';
    /** Custom actions to add to the toolbox */
    additionalActions?: ToolboxAction[];
    /** Hide specific default actions by their id */
    hideActions?: string[];
    /** Labels for UI elements (for i18n) */
    labels?: {
        pen?: string;
        hand?: string;
        dimension?: string;
        select?: string;
        penOnly?: string;
        color?: string;
        strokeWidth?: string;
        addImage?: string;
        undo?: string;
        clear?: string;
        grid?: string;
        fullscreen?: string;
        resetView?: string;
        exportJson?: string;
        importJson?: string;
        exportImage?: string;
        modeLabel?: string;
        penOnlyActive?: string;
        instructions?: string;
        eraser?: string;
        gallery?: string;
        camera?: string;
        highlighter?: string;
        clearConfirm?: string;
        clearConfirmTitle?: string;
        clearConfirmYes?: string;
        clearConfirmNo?: string;
    };
}

export declare interface DrawingBoardRef {
    /** Get the underlying Whiteboard ref */
    getWhiteboard: () => WhiteBoard | null;
    /** Export data as JSON object */
    exportData: () => ReturnType<WhiteBoard['exportData']> | undefined;
    /** Export data as JSON string */
    exportJSON: () => string | undefined;
    /** Import data from JSON object */
    importData: (data: Parameters<WhiteBoard['importData']>[0], options?: Parameters<WhiteBoard['importData']>[1]) => void;
    /** Import data from JSON string */
    importJSON: (json: string, options?: Parameters<WhiteBoard['importJSON']>[1]) => boolean | undefined;
    /** Download as image */
    downloadImage: (filename?: string, options?: Parameters<WhiteBoard['downloadImage']>[1]) => Promise<boolean>;
    /** Clear the board */
    clear: () => void;
    /** Undo last action */
    undo: () => void;
    /** Reset view (pan and zoom) */
    resetView: () => void;
    /** Toggle fullscreen */
    toggleFullscreen: () => void;
}

export declare const FloatingToolbox: default_2.FC<FloatingToolboxProps>;

declare interface FloatingToolboxProps {
    actions: ToolboxAction[];
    visible?: boolean;
    initialPosition?: {
        x: number;
        y: number;
    };
    orientation?: 'horizontal' | 'vertical';
    style?: default_2.CSSProperties;
    containerRef?: default_2.RefObject<HTMLElement | null>;
}

export declare const Grid: default_2.FC<GridProps>;

declare interface GridProps {
    width: number;
    height: number;
    gridSize?: number;
    gridColor?: string;
    gridOpacity?: number;
    showGrid?: boolean;
    offsetX?: number;
    offsetY?: number;
    scale?: number;
}

export declare const loadImageDimensions: (src: string) => Promise<{
    width: number;
    height: number;
}>;

export declare class Pen {
    strokes: Stroke[];
    _offsetX: number;
    _offsetY: number;
    constructor(strokes?: Stroke[]);
    addStroke(s: Stroke): void;
    undoStroke(): void;
    setOffset(options: Point): void;
    toSvg(currentBox: {
        width: number;
        height: number;
    }): default_2.ReactElement;
    toSvgWithScale(currentBox: {
        width: number;
        height: number;
    }, scale?: number, useAbsoluteCoords?: boolean): default_2.ReactElement;
    pointsToSvg(data: Stroke, currentBox: {
        width: number;
        height: number;
    }, useAbsoluteCoords?: boolean): string;
    clear: () => void;
    copy(): Pen;
}

export declare class Point {
    x: number;
    y: number;
    time: number;
    constructor(x: number, y: number, time?: number);
    velocityFrom(start: Point): number;
    distanceTo(start: Point): number;
    equals(point: Point): boolean;
}

export declare interface SketchImage {
    id: string;
    src: string;
    x: number;
    y: number;
    width: number;
    height: number;
    rotation?: number;
    opacity?: number;
}

export declare type Stroke = {
    box: {
        width: number;
        height: number;
    };
    points: Point[];
    color: string;
    width: number;
    opacity?: number;
};

export declare interface ToolboxAction {
    id: string;
    icon?: default_2.ReactNode;
    label: string;
    onClick?: () => void;
    active?: boolean;
    type?: 'button' | 'color' | 'number' | 'file' | 'slider' | 'colorPicker';
    value?: string | number | boolean;
    onChange?: (value: string | number | boolean) => void;
    min?: number;
    max?: number;
    accept?: string;
    colors?: string[];
    /** For file type with image accept: show camera capture option */
    showCameraOption?: boolean;
    /** Labels for camera/gallery picker (for i18n) */
    cameraLabels?: {
        gallery?: string;
        camera?: string;
    };
}

export declare type WhiteBoard = Whiteboard;

declare class Whiteboard extends default_2.Component<WhiteboardProps, WhiteboardState> {
    drawer: HTMLCanvasElement | null;
    containerElement: HTMLDivElement | null;
    longPressTimer: ReturnType<typeof setTimeout> | null;
    longPressStartPoint: {
        x: number;
        y: number;
    } | null;
    pinchResizeStartDistance: number | null;
    constructor(props: WhiteboardProps);
    componentDidUpdate(prevProps: WhiteboardProps): void;
    preventDefault: (e: Event) => void;
    addImage: (src: string, x?: number, y?: number, width?: number, height?: number) => Promise<SketchImage | null>;
    removeImage: (imageId: string) => void;
    updateImage: (imageId: string, updates: Partial<SketchImage>) => void;
    selectImage: (imageId: string | null) => void;
    onImagePointerDown: (e: default_2.PointerEvent, imageId: string) => void;
    onResizeHandlePointerDown: (e: default_2.PointerEvent, imageId: string, handle: string) => void;
    handleImageManipulation: (clientX: number, clientY: number) => void;
    endImageManipulation: () => void;
    deselectImage: () => void;
    startLongPress: (clientX: number, clientY: number) => void;
    cancelLongPress: () => void;
    getImages: () => SketchImage[];
    setMode: (mode: WhiteboardMode) => void;
    getMode: () => WhiteboardMode;
    setPenOnly: (enabled: boolean) => void;
    getPenOnly: () => boolean;
    addDimension: (startX: number, startY: number, endX: number, endY: number, value?: string) => DimensionData;
    removeDimension: (dimensionId: string) => void;
    updateDimension: (dimensionId: string, updates: Partial<DimensionData>) => void;
    selectDimension: (dimensionId: string | null) => void;
    getDimensions: () => DimensionData[];
    clearDimensions: () => void;
    onDimensionModalConfirm: (value: string) => void;
    onDimensionModalCancel: () => void;
    editDimensionValue: (dimensionId: string) => void;
    onDimensionEditConfirm: (value: string) => void;
    onDimensionMouseDown: (dimensionId: string, clientX: number, clientY: number) => void;
    onDimensionHandleMouseDown: (dimensionId: string, handle: "start" | "end", clientX: number, clientY: number) => void;
    handleDimensionManipulation: (clientX: number, clientY: number) => void;
    endDimensionManipulation: () => void;
    deleteSelectedDimension: () => void;
    deleteSelectedImage: () => void;
    findImageAtPoint: (x: number, y: number) => SketchImage | null;
    findImageResizeHandleAtPoint: (x: number, y: number) => {
        imageId: string;
        handle: string;
    } | null;
    findDimensionHandleAtPoint: (x: number, y: number) => {
        dimensionId: string;
        handle: "start" | "end" | "body";
    } | null;
    pointToSegmentDistance: (px: number, py: number, x1: number, y1: number, x2: number, y2: number) => number;
    eraseAtPoint: (x: number, y: number) => void;
    setPan: (x: number, y: number) => void;
    setZoom: (scale: number) => void;
    resetView: () => void;
    getBounds: () => {
        minX: number;
        minY: number;
        maxX: number;
        maxY: number;
    } | null;
    fitToContent: (padding?: number) => void;
    exportToImage: (options?: {
        format?: "png" | "jpeg";
        quality?: number;
        width?: number;
        height?: number;
        backgroundColor?: string;
        scale?: number;
    }) => Promise<string | null>;
    downloadImage: (filename?: string, options?: Parameters<typeof Whiteboard.exportToImage>[0]) => Promise<boolean>;
    toggleFullscreen: () => Promise<void>;
    isFullscreen: () => boolean;
    onWheel: (e: WheelEvent_2) => void;
    getTouchDistance: (touches: default_2.TouchList) => number;
    getTouchCenter: (touches: default_2.TouchList) => {
        x: number;
        y: number;
    };
    undo: () => void;
    changeColor: (color: string) => void;
    changeStrokeWidth: (width: number) => void;
    changeStrokeOpacity: (opacity: number) => void;
    _onChangeStrokes: (strokes: Stroke[]) => void;
    clear: () => void;
    clearStrokes: () => void;
    clearImages: () => void;
    dragging: boolean;
    screenToCanvas: (clientX: number, clientY: number) => {
        x: number;
        y: number;
    };
    onTouch: (evt: TouchEvent_2 | MouseEvent_2) => void;
    onResponderGrant: (evt: TouchEvent_2<HTMLCanvasElement> | MouseEvent_2<HTMLCanvasElement>) => void;
    onResponderMove: (evt: TouchEvent_2<HTMLCanvasElement> | MouseEvent_2<HTMLCanvasElement>) => void;
    onMouseDown: (evt: MouseEvent_2<HTMLCanvasElement>) => void;
    findDimensionAtPoint: (x: number, y: number) => DimensionData | null;
    findStrokeAtPoint: (x: number, y: number) => number;
    deleteSelectedStroke: () => void;
    onMouseMove: (evt: MouseEvent_2<HTMLCanvasElement>) => void;
    onMouseUp: () => void;
    handleTouchStart: (e: TouchEvent_2<HTMLCanvasElement>) => void;
    onResponderRelease: () => void;
    isInputAllowed: (pointerType: string) => boolean;
    getPointerDistance: (pointers: Map<number, {
        x: number;
        y: number;
        type: string;
    }>) => number;
    getPointerCenter: (pointers: Map<number, {
        x: number;
        y: number;
        type: string;
    }>) => {
        x: number;
        y: number;
    };
    onPointerDown: (evt: PointerEvent_2<HTMLCanvasElement>) => void;
    onPointerMove: (evt: PointerEvent_2<HTMLCanvasElement>) => void;
    onPointerUp: (evt: PointerEvent_2<HTMLCanvasElement>) => void;
    onPointerCancel: (evt: PointerEvent_2<HTMLCanvasElement>) => void;
    updateSvgPosition: () => void;
    componentDidMount(): void;
    componentWillUnmount(): void;
    preventBrowserZoom: (e: globalThis.WheelEvent) => void;
    preventTouchDefault: (e: Event) => void;
    handleKeyDown: (e: globalThis.KeyboardEvent) => void;
    handleGlobalMouseMove: (e: globalThis.MouseEvent) => void;
    handleGlobalMouseUp: () => void;
    handleGlobalPointerMove: (e: globalThis.PointerEvent) => void;
    handleGlobalPointerUp: () => void;
    handleFullscreenChange: () => void;
    getContainerRef: () => {
        current: HTMLDivElement | null;
    };
    exportData: () => WhiteboardData;
    exportJSON: () => string;
    importData: (data: WhiteboardData, options?: {
        clearExisting?: boolean;
        loadViewState?: boolean;
    }) => void;
    importJSON: (json: string, options?: {
        clearExisting?: boolean;
        loadViewState?: boolean;
    }) => boolean;
    render(): default_2.ReactElement;
}
export default Whiteboard;

export declare interface WhiteboardData {
    version: string;
    strokes: Stroke[];
    images: SketchImage[];
    dimensions?: DimensionData[];
    viewState?: {
        panX: number;
        panY: number;
        scale: number;
    };
}

export declare type WhiteboardMode = 'pen' | 'hand' | 'dimension' | 'mouse' | 'eraser' | 'highlighter';

declare interface WhiteboardProps {
    enabled?: boolean;
    containerStyle?: default_2.DetailedHTMLProps<default_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
    strokeColor?: string;
    strokeWidth?: number;
    onChangeStrokes?: (strokes?: Stroke[]) => void;
    strokes?: Stroke[];
    initialStrokes?: Stroke[];
    zIndex?: number;
    showGrid?: boolean;
    gridSize?: number;
    gridColor?: string;
    gridOpacity?: number;
    enablePan?: boolean;
    enableZoom?: boolean;
    minZoom?: number;
    maxZoom?: number;
    images?: SketchImage[];
    initialImages?: SketchImage[];
    onChangeImages?: (images: SketchImage[]) => void;
    onFullscreenChange?: (isFullscreen: boolean) => void;
    autoFit?: boolean;
    autoFitPadding?: number;
    children?: default_2.ReactNode;
    mode?: WhiteboardMode;
    onModeChange?: (mode: WhiteboardMode) => void;
    penOnly?: boolean;
    onPenOnlyChange?: (penOnly: boolean) => void;
    dimensions?: DimensionData[];
    initialDimensions?: DimensionData[];
    onChangeDimensions?: (dimensions: DimensionData[]) => void;
    dimensionColor?: string;
    eraserWidth?: number;
}

declare interface WhiteboardState {
    tracker: number;
    currentPoints: Stroke;
    previousStrokes: Stroke[];
    pen: Pen;
    strokeWidth: number;
    strokeColor: string;
    strokeOpacity: number;
    height: number;
    width: number;
    px: number;
    py: number;
    panX: number;
    panY: number;
    scale: number;
    isPanning: boolean;
    lastPanPoint: {
        x: number;
        y: number;
    } | null;
    lastTouchDistance: number | null;
    sketchImages: SketchImage[];
    selectedImageId: string | null;
    isDraggingImage: boolean;
    isResizingImage: boolean;
    resizeHandle: string | null;
    imageStartPos: {
        x: number;
        y: number;
    } | null;
    imageDragStart: {
        x: number;
        y: number;
    } | null;
    imageStartSize: {
        width: number;
        height: number;
    } | null;
    isFullscreen: boolean;
    currentMode: WhiteboardMode;
    penOnly: boolean;
    dimensions: DimensionData[];
    selectedDimensionId: string | null;
    selectedStrokeIndex: number | null;
    isDimensionDrawing: boolean;
    dimensionStart: {
        x: number;
        y: number;
    } | null;
    tempDimension: DimensionData | null;
    showDimensionModal: boolean;
    pendingDimension: DimensionData | null;
    isDraggingDimension: boolean;
    isResizingDimension: boolean;
    dimensionResizeHandle: 'start' | 'end' | null;
    dimensionStartData: DimensionData | null;
    dimensionDragStart: {
        x: number;
        y: number;
    } | null;
    activePointerId: number | null;
    activePointerType: string | null;
    activePointers: Map<number, {
        x: number;
        y: number;
        type: string;
    }>;
    lastPinchDistance: number | null;
}

export { }