import { EventEmitter } from '../../stencil-public-runtime';
import type { TextareaResize } from './exports';
export declare class RTextarea {
    host: HTMLRTextareaElement;
    /** Specifies the `id` of the `<form>` to which the element belongs */
    form?: string;
    /** Specifies if element must be ignored during validation of the form elements */
    novalidate?: boolean;
    /** Sets the `name` attribute on the underlying `<textarea>`, allowing the control
     * to be identified during form submission. */
    name: string;
    /** Represents the current value of the `<textarea>`, reflecting the content entered
     * by the user or provided programmatically. */
    value?: string;
    /** Specifies a short hint that describes the expected value of the `<textarea>`,
     * displayed when it is empty.
     * @default: 'Provide an input'
     * */
    placeholder: string;
    /** Defines the number of visible text lines in the `<textarea>`,
     * controlling its vertical size. */
    rows?: number;
    /** Specifies the visible width of the `<textarea>` in terms
     * of the number of characters. */
    cols?: number;
    /** Controls the resizability of the `<textarea>`, allowing
     * or preventing the user from resizing it.
     * @default: 'none'
     * */
    resize: TextareaResize;
    /** Indicates whether the `<textarea>` is disabled, preventing
     * user interaction and input when set to true. */
    disabled?: boolean;
    /** Indicates whether the `<textarea>` is read-only, allowing focus and text selection
     * while preventing the user from modifying its value. */
    readonly?: boolean;
    /** Optional text displayed below the `<textarea>`, providing
     * additional context or guidance to the user. */
    hint?: string;
    /** Indicates that the `<textarea>` must be filled out
     * before submitting the form. */
    required?: boolean;
    /** Custom message for `valueMissing` property of a ValidityState
     * object (set by `required`) within Constrain Validation API. */
    valueMissingMessage?: string;
    /** Specifies the maximum number of characters allowed in the `<textarea>`,
     * enforcing input length limits. */
    maxlength?: number;
    /** Specifies if the character counter should be visible.
     *
     * Note: The counter will only be rendered when a `maxlength` value is provided.
     */
    showCounter?: boolean;
    /** Custom message when the character limit is reached to alert screen reader users. */
    characterLimitReachedMessage: string;
    /** Custom message for `tooLong` property of a ValidityState
     * object (set by `maxlength`) within Constrain Validation API. */
    tooLongMessage?: string;
    /** Specifies the minimum number of characters required in the `<textarea>`,
     * enforcing input length constraints. */
    minlength?: number;
    /** Set custom message for `tooShort` property of a ValidityState object
     * (set by `minlength`) within Constrain Validation API */
    tooShortMessage?: string;
    /** Custom error message displayed for any validation failures in the `<textarea>`. */
    customErrorMessage?: string;
    /** Indicates whether the value of the `<textarea>`
     * is valid based on validation rules. */
    valid?: boolean;
    /** Indicates whether the value of the `<textarea>`
     * is invalid based on validation rules. */
    invalid?: boolean;
    /** Custom error message provided independently of the
     * Constraint Validation API for the `<textarea>`. */
    error?: string;
    /** Text displayed as the label above the `<textarea>`,
     * indicating its purpose to the user. */
    label?: string;
    /** Text of an additional marker in the label */
    fieldIndicator?: string;
    /**
     * Controls how the browser wraps text in the textarea when submitting a form.
     * `soft` (default): lines are not wrapped; `hard`: lines are wrapped with CRLF at `cols` width.
     */
    wrap?: 'soft' | 'hard' | 'off';
    /**
     * Enables form submission of the textarea's text-direction. The value is the field
     * name used to submit the direction (`ltr` or `rtl`) as a separate form entry.
     */
    dirname?: string;
    /** Native `autocomplete` hint for browsers / password managers. */
    autocomplete?: string;
    /**
     * Hints to the browser which virtual keyboard to display on mobile devices.
     * Equivalent to the native `inputmode` attribute.
     */
    inputmode?: string;
    /**
     * Controls automatic capitalisation on mobile virtual keyboards.
     * Equivalent to the native `autocapitalize` attribute.
     */
    autocapitalize?: string;
    /**
     * Automatically focuses the textarea when the page loads.
     * Reflected to the host so it can be queried as an attribute.
     */
    autofocus?: boolean;
    /** Custom validity state */
    validityState: string;
    /** Custom validity message */
    validityMessage: string;
    /** Emits `rChange` when component's value has been changed  */
    rChange: EventEmitter<{
        element: HTMLRTextareaElement;
        value: any;
    }>;
    /** Emits `rInput` when component's value is changing */
    rInput: EventEmitter<{
        element: HTMLRTextareaElement;
        value: any;
    }>;
    /** Emits `rReset` when component was reset to initial state by form reset */
    rReset: EventEmitter<{
        element: HTMLRTextareaElement;
        value: any;
    }>;
    /** Emits event after each validation */
    rValidate: EventEmitter<{
        state: string;
        message: string;
    }>;
    /** Emits `rSelect` when text selection changes */
    rSelect: EventEmitter<{
        element: HTMLRTextareaElement;
        selectionStart: number;
        selectionEnd: number;
        selectionDirection: 'forward' | 'backward' | 'none';
        value: string;
    }>;
    /** Emits `rBeforeInput` before text modification */
    rBeforeInput: EventEmitter<{
        element: HTMLRTextareaElement;
        inputType: string;
        data: string | null;
        selectionStart: number;
        selectionEnd: number;
        cancelable: boolean;
    }>;
    /** Emits `rFocus` when the textarea receives focus */
    rFocus: EventEmitter<{
        element: HTMLRTextareaElement;
        value: any;
    }>;
    /** Emits `rBlur` when the textarea loses focus */
    rBlur: EventEmitter<{
        element: HTMLRTextareaElement;
        value: any;
    }>;
    /** Sets the value of the element. */
    setValue(value: string): Promise<void>;
    /** Gets the value of the element. */
    getValue(): Promise<string>;
    /** Resets value and validity state to initial. */
    reset(): Promise<void>;
    /** Sets focus on the element. */
    setFocus(): Promise<void>;
    /** Removes focus from the element. */
    setBlur(): Promise<void>;
    /** Focuses the textarea and sets the start and end positions of the text selection. */
    setSelectionRange(start: number, end: number, direction?: 'forward' | 'backward' | 'none'): Promise<void>;
    /** Focuses the textarea and replaces the current text selection with a new string. */
    setRangeText(replacement: string, start: number, end: number, selectionMode?: 'select' | 'start' | 'end' | 'preserve'): Promise<void>;
    /** Validates an element, displays provided message in case value is invalid. */
    setCustomValidity(message: string): Promise<void>;
    /**
     * Validates the textarea without triggering UI and returns a boolean indicating its validity.
     * @returns A boolean indicating whether the textarea is valid.
     */
    checkValidity(): Promise<boolean>;
    /** Validates an element and displays validity state. */
    reportValidity(): Promise<void>;
    /** Selects all text in the textarea and focuses it. */
    select(): Promise<void>;
    /** Returns the start position of the text selection. */
    getSelectionStart(): Promise<number>;
    /** Returns the end position of the text selection. */
    getSelectionEnd(): Promise<number>;
    /** Returns the direction of the current text selection. */
    getSelectionDirection(): Promise<'forward' | 'backward' | 'none' | null>;
    /** Returns the number of characters in the textarea (mirrors the native `textLength` property). */
    getTextLength(): Promise<number>;
    /** Returns whether this textarea participates in constraint validation. */
    getWillValidate(): Promise<boolean>;
    /** Returns the initial (default) value set on the textarea before any user edits. */
    getDefaultValue(): Promise<string>;
    /** Returns the native `ValidityState` object for the textarea. */
    getValidity(): Promise<ValidityState | null>;
    private readonlyIconElement;
    readonlyIconWidth: number;
    /** Identify wrapping form element. */
    private get parentFormEl();
    private get ariaDescribedBy();
    private get hasError();
    private get hasValidationError();
    private get hasMessage();
    /**
     * Determine whether this element should be ignored
     * during Constraint Validation API validation.
     * */
    private get isNoValidate();
    /**
     * Initial attributes state
     * */
    private initial;
    /** Unique id */
    private uniqueId;
    private nativeElement?;
    /**
     * Cache for passthrough attributes to avoid recomputing on every render.
     * Cleared when attributes might have changed.
     */
    private passthroughAttrsCache;
    private characterLimitReachedAlert?;
    /**
     * Checks if an attribute should be excluded from passthrough.
     */
    private shouldExcludeAttribute;
    /**
     * Collects custom `data-*` attributes from the host element so they are
     * forwarded to the native `<textarea>`.  Named native attributes (wrap,
     * dirname, autocomplete, etc.) are now declared as explicit `@Prop()`
     * entries and handled directly in `textareaAttrs`.
     */
    private collectNativeAttributes;
    private setNativeTextareaRef;
    private onInput;
    private onChange;
    private onFocus;
    private onBlur;
    private onSubmitForm;
    private onResetForm;
    private lastSelectionState;
    private onSelectionChange;
    private onBeforeInput;
    private getValidityStateData;
    private validateFormElement;
    private contributeToFormData;
    private hiddenTextarea?;
    private syncHiddenTextarea;
    private get textareaSlotValue();
    private connectFormEventListeners;
    private disconnectFormEventListeners;
    private get textareaFontSize();
    private computeColsFromFontSize;
    private calculateCols;
    private setTextareaCols;
    componentWillLoad(): void;
    componentDidLoad(): void;
    componentDidUpdate(): void;
    connectedCallback(): void;
    disconnectedCallback(): void;
    render(): any;
}