import { TClassProperties } from '../../typedefs';
import { Textbox, TextboxProps } from '../Textbox';
export type { ITextProps, SerializedITextProps } from '../IText/IText';
export declare const shapeNotesDefaultValues: Partial<TClassProperties<ShapeNotes>>;
export interface ShapeNotesProps extends TextboxProps {
    icon: number;
    id: string;
}
/**
 * Textbox class, based on IText, allows the user to resize the text rectangle
 * and wraps lines automatically. Textboxes have their Y scaling locked, the
 * user can only change width. Height is adjusted automatically based on the
 * wrapping of lines.
 */
export declare class ShapeNotes extends Textbox {
    /**selectable
     * Minimum width of textbox, in pixels.
     * @type Number
     * @default
     */
    minWidth: number;
    lineWidth: number;
    __skipDimension: Boolean;
    objType: string;
    locked: boolean;
    whiteboardId: string;
    userId: string;
    timestamp: Date;
    verticalAlign: string;
    zIndex: number;
    lines: object[];
    relationship: object[];
    icon: string;
    maxHeight: number;
    extendPropeties: string[];
    /**
     * Minimum calculated width of a textbox, in pixels.
     * fixed to 2 so that an empty textbox cannot go to 0
     * and is still selectable without text.
     * @type Number
     * @default
     */
    dynamicMinWidth: number;
    /**
     * Use this boolean property in order to split strings that have no white space concept.
     * this is a cheap way to help with chinese/japanese
     * @type Boolean
     * @since 2.6.0
     */
    splitByGrapheme: boolean;
    static textLayoutProperties: string[];
    static ownDefaults: Record<string, any>;
    static getDefaults(): {
        controls: {
            mtaStart: import("../../..").Control;
            mbaStart: import("../../..").Control;
            mlaStart: import("../../..").Control;
            mraStart: import("../../..").Control;
            tl: import("../../..").Control;
            tr: import("../../..").Control;
            bl: import("../../..").Control;
            br: import("../../..").Control;
        };
    };
    constructor(text: string, options: Partial<ShapeNotesProps>);
    /**
     * Unlike superclass's version of this function, Textbox does not update
     * its width.
     * @private
     * @override
     */
    initDimensions(): number | undefined;
    /**
     * @param {Number} lineIndex
     * @param {Number} charIndex
     * @param {Object} style
     * @private
     */
    _setStyleDeclaration(lineIndex: number, charIndex: number, style: object): void;
    /**
     * @param {Number} lineIndex
     * @param {Number} charIndex
     * @private
     */
    _deleteStyleDeclaration(lineIndex: number, charIndex: number): void;
    /**
     * probably broken need a fix
     * Returns the real style line that correspond to the wrapped lineIndex line
     * Used just to verify if the line does exist or not.
     * @param {Number} lineIndex
     * @returns {Boolean} if the line exists or not
     * @private
     */
    _getLineStyle(lineIndex: number): boolean;
    /**
     * Set the line style to an empty object so that is initialized
     * @param {Number} lineIndex
     * @param {Object} style
     * @private
     */
    _setLineStyle(lineIndex: number): void;
    /**
     * Override this method to customize word splitting
     * Use with {@link Textbox#_measureWord}
     * @param {string} value
     * @returns {string[]} array of words
     */
    wordSplit(value: string): string[];
    /**
     * Wraps a line of text using the width of the Textbox and a context.
     * @param {Array} line The grapheme array that represent the line
     * @param {Number} lineIndex
     * @param {Number} desiredWidth width you want to wrap the line to
     * @param {Number} reservedSpace space to remove from wrapping for custom functionalities
     * @returns {Array} Array of line(s) into which the given text is wrapped
     * to.
     */
    /** This is the method of char split */
    graphemeSplitForRectNotes(textstring: string): string[];
    /**
     * Detect if the text line is ended with an hard break
     * text and itext do not have wrapping, return false
     * @param {Number} lineIndex text to split
     * @return {Boolean}
     */
    isEndOfWrapping(lineIndex: number): boolean;
    /**
     * Detect if a line has a linebreak and so we need to account for it when moving
     * and counting style.
     * @return Number
     */
    missingNewlineOffset(lineIndex: number): 0 | 1;
    /**
     * Gets lines of text to render in the Textbox. This function calculates
     * text wrapping on the fly every time it is called.
     * @param {String} text text to split
     * @returns {Array} Array of lines in the Textbox.
     * @override
     */
    textSplitTextIntoLines(text: string): {
        _unwrappedLines: string[][];
        lines: string[];
        graphemeText: string[];
        graphemeLines: string[][];
    };
    _splitTextIntoLines(text: string): {
        _unwrappedLines: string[][];
        lines: string[];
        graphemeText: string[];
        graphemeLines: string[][];
    };
    getMinWidth(): number;
    getObject(): {};
    /**boardx custom function */
    getObjectsIntersected(): any;
    setLockedShadow(locked: boolean): void;
    getCenteredTop(rectHeight: number): number;
    _renderBackground(ctx: any): void;
    getTopOffset(): number;
    getLeftOffset(): number;
    _getTopOffset(): number;
    _getTotalLineHeight(): number;
    _renderText(ctx: any): void;
    calcTextHeight(): number;
    _renderTextCommon(ctx: any, method: any): void;
    _getTotalLineHeights(): number;
    _getSVGLeftTopOffsets(): {
        textLeft: number;
        textTop: number;
        lineTop: number;
    };
    getWidgetMenuList(): string[];
    getWidgetMenuLength(): 50 | 420;
    getContextMenuList(): string[];
}
//# sourceMappingURL=X_ShapeNotes.d.ts.map