import { EventEmitter } from '../../stencil-public-runtime';
import { FormComponent } from '../form/form.types';
import { Languages } from '../date-picker/date.types';
import { CustomElementDefinition } from '../../global/shared-types/custom-element.types';
import { TriggerCharacter, TriggerEventDetail } from './text-editor.types';
import { EditorUiType } from './types';
/**
 * A rich text editor that offers a rich text editing experience with markdown support,
 * in the sense that you can easily type markdown syntax and see the rendered
 * result as rich text in real-time. For instance, you can type `# Hello, world!`
 * and see it directly turning to a heading 1 (an `<h1>` HTML element).
 *
 * Naturally, you can use standard keyboard hotkeys such as <kbd>Ctrl</kbd> + <kbd>B</kbd>
 * to toggle bold text, <kbd>Ctrl</kbd> + <kbd>I</kbd> to toggle italic text, and so on.
 *
 * @exampleComponent limel-example-text-editor-basic
 * @exampleComponent limel-example-text-editor-as-form-component
 * @exampleComponent limel-example-text-editor-with-markdown
 * @exampleComponent limel-example-text-editor-with-html
 * @exampleComponent limel-example-text-editor-with-tables
 * @exampleComponent limel-example-text-editor-with-inline-images-file-storage
 * @exampleComponent limel-example-text-editor-with-inline-images-base64
 * @exampleComponent limel-example-text-editor-allow-resize
 * @exampleComponent limel-example-text-editor-size
 * @exampleComponent limel-example-text-editor-ui
 * @exampleComponent limel-example-text-editor-custom-element
 * @exampleComponent limel-example-text-editor-triggers
 * @exampleComponent limel-example-text-editor-composite
 * @beta
 */
export declare class TextEditor implements FormComponent<string> {
    /**
     * The type of content that the editor should handle and emit, defaults to `markdown`
     *
     * Assumed to be set only once, so not reactive to changes
     */
    contentType: 'markdown' | 'html';
    /**
     * Defines the language for translations.
     */
    language: Languages;
    /**
     * Set to `true` to disable the field.
     * Use `disabled` to indicate that the field can normally be interacted
     * with, but is currently disabled. This tells the user that if certain
     * requirements are met, the field may become enabled again.
     */
    disabled?: boolean;
    /**
     * Set to `true` to make the component read-only.
     * Use `readonly` when the field is only there to present the data it holds,
     * and will not become possible for the current user to edit.
     * :::note
     * Consider that it might be better to use `limel-markdown`
     * instead of `limel-text-editor` when the goal is visualizing data.
     * :::
     */
    readonly?: boolean;
    /**
     * Optional helper text to display below the input field when it has focus
     */
    helperText?: string;
    /**
     * The placeholder text shown inside the input field,
     * when the field is empty.
     */
    placeholder?: string;
    /**
     * The label of the editor
     */
    label?: string;
    /**
     * Set to `true` to indicate that the current value of the editor is
     * invalid.
     */
    invalid?: boolean;
    /**
     * Description of the text inside the editor as markdown
     */
    value: string;
    /**
     * A list of custom elements
     *
     * Any `CustomElement` that should be used inside the text editor needs
     * to be defined here.
     *
     * @private
     * @alpha
     */
    customElements: CustomElementDefinition[];
    /**
     * A set of trigger characters
     *
     * Defining a character here will enable trigger events to be sent if the
     * character is detected in the editor.
     *
     * @private
     * @alpha
     */
    triggers: TriggerCharacter[];
    /**
     * Set to `true` to indicate that the field is required.
     *
     * :::important
     * An empty but required field is not automatically considered invalid.
     * You must make sure to check the validity of the field on your own,
     * and properly handle the `invalid` state.
     * :::
     */
    required?: boolean;
    /**
     * Set to `true` to allow the user to vertically resize the editor.
     * Set to `false` to disable the resize functionality.
     */
    allowResize: boolean;
    /**
     * Specifies the visual appearance of the editor.
     *
     * - `standard`: The default editor appearance with a full toolbar and
     *    standard layout.
     * - `minimal`: A compact editor appearance, ideal for limited space
     *    scenarios such as mobile devices. In this mode, the toolbar is hidden
     *    until the editor is focused.
     * - `no-toolbar`: A basic textarea appearance without any text styling toolbar.
     *    This mode is suitable for scenarios where you want to provide a simple
     *    text input without any visible formatting options; but still provide
     *    support for markdown syntax and rich text, using hotkeys or when pasting.
     */
    ui?: EditorUiType;
    /**
     * Dispatched when a change is made to the editor
     */
    change: EventEmitter<string>;
    /**
     * Dispatched when a image is pasted into the editor
     *
     * @private
     * @alpha
     */
    private readonly imagePasted;
    /**
     * Dispatched when a image is removed from the editor
     *
     * @private
     * @alpha
     * @deprecated - This event is deprecated and will be removed in a future version.
     * Use the `metadataChange` event instead to track image removals.
     */
    private readonly imageRemoved;
    /**
     * Dispatched when the metadata of the editor changes
     *
     * @private
     * @alpha
     */
    private readonly metadataChange;
    /**
     * Dispatched if a trigger character is detected.
     *
     * @private
     * @alpha
     */
    triggerStart: EventEmitter<TriggerEventDetail>;
    /**
     * Dispatched if a trigger session is ended. That is if the selection
     * goes outside the trigger input or if something is inserted using the
     * supplied `TextEditor` insert function.
     *
     * @private
     * @alpha
     */
    triggerStop: EventEmitter<TriggerEventDetail>;
    /**
     * Dispatched if a input is changed during an active trigger.
     *
     * @private
     * @alpha
     */
    triggerChange: EventEmitter<TriggerEventDetail>;
    private readonly helperTextId;
    private readonly editorId;
    constructor();
    render(): any;
    private renderEditor;
    private renderPlaceholder;
    private renderHelperLine;
    private isInvalid;
    private handleChange;
    private handleImagePasted;
    private handleMetadataChange;
    private handleImageRemoved;
}
//# sourceMappingURL=text-editor.d.ts.map