/// <reference path="../../vendor/react/react.d.ts" />
//@ts-ignore
import React, { Component } from 'react';
import { Color, Size } from '@dt/core-ui';
/// <reference path="../../vendor/i18next.d.ts" />
//@ts-ignore
import { i18n } from 'i18next';
import { PaintToolsPlugin } from './PaintToolsPlugin';
import { Bounds, IGcSelectionBox, PointLocation, SelectionBoundsChangedParams } from '../../ImageViewer/Models/SelectionBoxTypes';
import { IViewerTransactionSupport } from '../../ImageViewer/Models/IViewerTransactionSupport';
import { IImageViewer, PaintToolType, ToolbarItemType } from '../../ImageViewer/Models/IImageViewer';
import { PaintToolbarProps, PaintToolbarState, PaintToolbarVariant, SharedUndoHeap } from './types';
import { IImageLayer, IPaintCommand, IPaintDesignerContext, IPaintObject, IPaintObjectDesigner, PaintCommandName, PaintObjectPropertyName } from '../../ImageViewer/Layers/types';
import { SelectedRegionsDispatcher } from './Tools/Selection/SelectedRegionsDispatcher';
import { InternalFilterName } from './Tools/InternalFilters';
import { SelectionToolType } from './Tools/Selection/types';
import { GcSelectionBox } from '../../ImageViewer/Tools/GcSelectionBox';
/**
 * Paint tools toolbar panel.
 **/
export declare class PaintToolbar extends Component<PaintToolbarProps, PaintToolbarState> implements IViewerTransactionSupport, IPaintDesignerContext {
    static instances: {
        [id: string]: PaintToolbar | null;
    };
    useSerializedCopyPaste: boolean;
    private _activatedComboBox?;
    private _activatedDropdown?;
    private _colorDropdown;
    private _selectionToolDropdown;
    private _cloneStampSourcePoint?;
    private _cloneStampSourceDistance?;
    private _isMounted;
    private _onZoomChangedEventBusHandler?;
    private _objectDesigners;
    private _undoCommands;
    private _undoIndex;
    private _selectedRegionsDispatcher;
    insertImageArgs?: {
        imageData: Uint8Array;
        commandCreated: boolean;
    };
    private _copiedCommands;
    private _serializedCopiedCommands;
    private pendingInsertImageUrl?;
    constructor(props: any, context: any);
    /**
     * Get a reference to an array with object designers.
     **/
    getPaintObjectDesigners(): IPaintObjectDesigner[];
    /**
     * Removes an object designer by its ID and disposes of it.
     *
     * @param {string} id - The ID of the object to remove.
     * @returns {boolean} True if the object was found and removed, false otherwise.
     */
    removeObjectDesigner(id: string): boolean;
    /**
     * Finds a paint object designer by its unique identifier.
     *
     * @param {string} id - The unique identifier of the paint object designer.
     * @returns {IPaintObjectDesigner | undefined} The matching designer if found, otherwise undefined.
     */
    findObjectDesigner(id: string): IPaintObjectDesigner | undefined;
    get selectedRegionsDispatcher(): SelectedRegionsDispatcher;
    get in17n(): i18n;
    get isMounted(): boolean;
    /**
     * Gets the paint layer containing the HTML canvas for drawing the image.
     **/
    get paintLayer(): IImageLayer;
    get lastSelectedObjectDesigner(): IPaintObjectDesigner | null;
    get selectedObjectDesigners(): IPaintObjectDesigner[];
    /**
     * Selected tool type.
     **/
    get selectedToolKey(): PaintToolType;
    /**
     * Pencil color.
     **/
    get foreColor(): Color;
    set foreColor(color: Color);
    /**
     * Pencil size.
     **/
    get penSize(): number;
    set penSize(val: number);
    /**
     * Brush size.
     **/
    get brushSize(): number;
    set brushSize(val: number);
    /**
     * Eraser size.
     **/
    get eraserSize(): number;
    set eraserSize(val: number);
    /**
    * Clone Stamp size.
    **/
    get cloneStampSize(): number;
    set cloneStampSize(val: number);
    /**
     * Font size.
     **/
    get fontSize(): number;
    set fontSize(val: number);
    onFontSizeChanged(val: number, dirty: boolean): void;
    /**
     * Pencil opacity.
     **/
    get pencilOpacity(): number;
    set pencilOpacity(val: number);
    /**
     * Brush opacity.
     **/
    get brushOpacity(): number;
    set brushOpacity(val: number);
    /**
     * Eraser opacity.
     **/
    get eraserOpacity(): number;
    set eraserOpacity(val: number);
    /**
    * Clone Stamp opacity.
    **/
    get cloneStampOpacity(): number;
    set cloneStampOpacity(val: number);
    /**
     * Font opacity.
     **/
    get fontOpacity(): number;
    set fontOpacity(val: number);
    limitOpacityBounds(opacity: number): number;
    /**
     * Brush hardness.
     **/
    get brushHardness(): number;
    set brushHardness(val: number);
    /**
    * Eraser hardness.
    **/
    get eraserHardness(): number;
    set eraserHardness(val: number);
    /**
    * Clone Stamp hardness.
    **/
    get cloneStampHardness(): number;
    set cloneStampHardness(val: number);
    /**
     * Font name.
     **/
    get fontName(): string;
    set fontName(val: string);
    /**
    * Italic font style.
    **/
    get fontItalic(): boolean;
    set fontItalic(val: boolean);
    /**
    * Bold font style.
    **/
    get fontBold(): boolean;
    set fontBold(val: boolean);
    get fontNames(): string[];
    get selectionBox(): IGcSelectionBox;
    get viewer(): IImageViewer;
    get toolbarVariant(): PaintToolbarVariant;
    /**
     * Max possible crop width.
     **/
    get maxWidth(): number;
    /**
     * Max possible crop height.
     **/
    get maxHeight(): number;
    /**
     * Crop x position.
     **/
    getX(): number;
    setX(x: number, checkBounds?: boolean): void;
    /**
    * Crop y position.
    **/
    getY(): number;
    setY(y: number, checkBounds?: boolean): void;
    /**
     * Crop width.
     **/
    getWidth(): number;
    /**
    * Crop height.
    **/
    getHeight(): number;
    /**
     * Natural aspect ratio.
     **/
    get naturalRatio(): number;
    /**
     * Show toolbar.
     * @param paintToolsPlugin
     */
    static showDialog(paintToolsPlugin: PaintToolsPlugin): void;
    /**
     * Call this method to create paint layer.
     **/
    ensurePaintLayerReady(): Promise<IImageLayer>;
    getUndoCommands(): IPaintCommand[];
    get scrollContainer(): HTMLDivElement;
    toggleOriginalImageAppearance(hideOriginalImage: boolean): void;
    limitLineSizeBounds(val: number): number;
    limitHardnessBounds(val: number): number;
    limitFontSizeBounds(val: number): number;
    clearSelection(): void;
    /**
     * Use the original image as source while applying edits.
     **/
    get useOriginalImage(): boolean;
    /**
     * Use the original image as source while applying edits.
     **/
    set useOriginalImage(value: boolean);
    repaint(): Promise<void>;
    selectImageUsingDialog(): Promise<void>;
    /**
     * Toggle active paint tool.
     * @param toolKey Optional. Tool type.
     * @param checked Optional. Checked state.
     **/
    toggleTool(toolKey?: PaintToolType, checked?: boolean): Promise<void>;
    /**
     * Called when paint object property changed.
     **/
    onPaintObjectPropertyChanged(propertyName: PaintObjectPropertyName, val: any, dirty?: boolean): void;
    onPaintObjectSelection(designer: IPaintObjectDesigner, selected: boolean): void;
    /**
     * Show toolbar.
     **/
    show(): void;
    /**
     * Hide toolbar.
     **/
    hide(): void;
    _startSelectionCoords: PointLocation;
    executeTempPaintCommand(cmd: IPaintCommand): void;
    flushTempPaintCommands(mainCtx: CanvasRenderingContext2D, backCtx: CanvasRenderingContext2D): void;
    confirmClose(saveChangesVariant?: boolean): Promise<boolean>;
    onSelectionBoundsChanged(penCoords: PointLocation[] | Bounds, params: SelectionBoundsChangedParams): Promise<void>;
    _freeFormSelectionBox: GcSelectionBox;
    get freeFormSelectionBox(): GcSelectionBox;
    rasterizePaintObject(paintObject: IPaintObject): void;
    getSelectedClipPaths(relativeToBounds?: boolean): Path2D[];
    selectAll(): void;
    copySelectedRegions(): boolean;
    get paintCanvasScale(): number;
    get leftTopVisiblePosition(): PointLocation;
    pasteSelectedRegions(): void;
    executePaintCommand(cmd: IPaintCommand | null, mainCtx?: CanvasRenderingContext2D, backCtx?: CanvasRenderingContext2D): void;
    storePaintCommand(cmd: IPaintCommand): void;
    get hasUndoPaint(): boolean;
    get hasRedoPaint(): boolean;
    isObjectCommand(cmd?: IPaintCommand): boolean;
    shouldBreakUndoSequence(cmd: IPaintCommand | undefined, prevCmdName: PaintCommandName | undefined, sharedHeap?: SharedUndoHeap): boolean;
    get undoIndex(): number;
    /**
     *
     * @param endIndex Optional. End undo index (excluding).
     */
    undoPaint(endIndex?: number): Promise<void>;
    redoPaint(): Promise<void>;
    ensureSelectedObject(): void;
    paintCommands(startCommandIndex: number, endCommandIndex: number): Promise<void>;
    ensureSelectionBox(): void;
    showSelectionBox(toolKey: PaintToolType): void;
    updateSelectionBox(): void;
    disableSelectionBox(): void;
    hideSelectionBox(): void;
    componentWillUnmount(): void;
    componentDidMount(): void;
    saveStateToLocalStorage(): void;
    loadStateFromLocalStorage(callback: any): void;
    protected renderToolbarItems(toolbarLayout: ToolbarItemType[]): JSX.Element[];
    protected getCurrentToolbarLayout(): ToolbarItemType[];
    render(): React.JSX.Element | null;
    apply(): Promise<void>;
    confirmChanges(): Promise<void>;
    cancelChanges(): Promise<void | boolean>;
    /**
    * Undo viewer transaction step. Return true if undo operation is consumed.
    **/
    undoTransactionStep(): boolean | void;
    /**
     * Redo viewer transaction step. Return true if redo operation is consumed.
     **/
    redoTransactionStep(): boolean | void;
    getSizeToolParams(selectedToolKey?: PaintToolType): {
        sizeSelectDisabled: boolean;
        sizeFromState: string | number | undefined;
        hardnessFromState: string | number | undefined;
        opacityFromState: string | number | undefined;
        disableOpacity: any;
        disableHardness: any;
    };
    renderImageGalleryTool(selectedToolKey?: PaintToolType): JSX.Element;
    renderSizeTool(selectedToolKey?: PaintToolType, lastSelectedBrushToolKey?: PaintToolType): JSX.Element;
    private onColorSelect;
    onSelectionToolSelect(selectionToolType: SelectionToolType): void;
    get plugin(): PaintToolsPlugin;
    get selectionToolType(): SelectionToolType;
    set selectionToolType(selectionToolType: SelectionToolType);
    /**
     * Tool size.
     **/
    get toolSize(): number;
    getToolSize(paintToolType: PaintToolType, defaultValue?: number): number;
    set toolSize(val: number);
    getToolHardness(toolType: PaintToolType, defaultValue?: number): number;
    /**
     * Tool hardness.
     **/
    get toolHardness(): number;
    set toolHardness(val: number);
    /**
    * Tool opacity.
    **/
    get toolOpacity(): number;
    set toolOpacity(val: number);
    protected createNewObjectCommand(toolType: PaintToolType, coords: PointLocation): IPaintCommand;
    private onSizeSelect;
    private onFonSizeSelect;
    private onFontNameSelect;
    private closeActiveComboBox;
    private _bindEvents;
    onKeyDown(e: KeyboardEvent, params: {
        alt: boolean;
        space: boolean;
        shift: boolean;
    }): void;
    commitSelectedRegion(): void;
    finishSelectedRegion(force?: boolean): boolean;
    onKeyUp(e: KeyboardEvent, params: {
        alt: boolean;
        space: boolean;
        shift: boolean;
    }): void;
    onCut(): Promise<void>;
    /**
     * Serializes and downloads the current command stack as a JSON file.
     * If the browser supports the File System Access API, a native "Save as..." dialog
     * will be used (user can edit the filename). Otherwise the method falls back to
     * creating a Blob and triggering a download via an anchor element (with an optional prompt).
     *
     * @param args - Options for export. `objectsOnly: true` will attempt to export only object-related commands.
     * @returns {Promise<void>} Resolves when the download/save operation is initiated or completed.
     * @throws {Error} When serialization or file writing fails.
     */
    downloadCommandStack(args?: {
        objectsOnly: boolean;
    }): Promise<void>;
    uploadCommandStack(): Promise<void>;
    /**
     * Opens a file dialog to load commands from a JSON file
     * @returns {Promise<IPaintCommand[]>} Promise resolving with loaded commands
     */
    importCommandsFromFile(): Promise<IPaintCommand[]>;
    /**
     * Handles import errors and shows user-friendly messages
     * @param {Error} error - The error that occurred
     */
    private handleImportError;
    /**
     * Serializes an array of paint commands to a JSON string
     * @param {IPaintCommand[]} commands - Array of paint commands to serialize
     * @returns {string} JSON string representing the command stack
     * @throws {Error} When invalid commands are provided
     */
    exportCommands(commands: IPaintCommand[]): string;
    /**
     * Deserializes a JSON string to an array of paint commands
     * @param {string} serializedData - JSON string containing serialized commands
     * @returns {IPaintCommand[]} Array of reconstructed paint commands
     * @throws {Error} When the data cannot be deserialized
     */
    importCommands(serializedData: string): Promise<IPaintCommand[]>;
    copySelectedObjects(): void;
    pasteSelectedObjects(): Promise<void>;
    executePaintCommands(commands: (IPaintCommand | null)[]): void;
    deleteSelectedObjects(): void;
    onSelectAll(): void;
    onCopy(): void;
    onPaste(): void;
    applyRegionFilter(filter: InternalFilterName, intencityValue1?: number, intencityValue2?: number, replaceSameFilter?: boolean): Promise<void>;
    onDeleteKeyDown(): Promise<void>;
    deleteObject(objectDesigner: IPaintObjectDesigner): void;
    private _unbindEvents;
}
export declare function renderPenWidthComboBox(controlWidth: number, pencilWidthValue: number | string | undefined, in17n: any, onSelect: (value: any, dirty: boolean) => void, refCallback: any, size?: Size, disabled?: boolean): React.JSX.Element;