import * as _angular_core from '@angular/core';
import { InjectionToken, Signal, WritableSignal, OnInit, OnDestroy, ElementRef, ViewContainerRef, TemplateRef } from '@angular/core';
import * as lexical from 'lexical';
import { LexicalEditor, Klass, LexicalNode, LexicalNodeReplacement, NodeKey, EditorConfig, DOMExportOutput, DecoratorNode, DOMConversionMap, Spread, SerializedLexicalNode, LexicalUpdateJSON, TextFormatType } from 'lexical';
import { ControlValueAccessor, FormControl } from '@angular/forms';
import { LuSimpleSelectInputComponent } from '@lucca-front/ng/simple-select';
import { LinkNode, LinkAttributes, SerializedLinkNode, AutoLinkNode, SerializedAutoLinkNode } from '@lexical/link';
import { LuccaIcon } from '@lucca-front/icons';

type UnregisterFn = () => void;
declare abstract class RichTextFormatter {
    /** Register the rich-text or plain-text Lexical plugin */
    abstract registerTextPlugin(editor: LexicalEditor): UnregisterFn;
    abstract parse(editor: LexicalEditor, text?: string | null): void;
    abstract format(editor: LexicalEditor): string;
}
declare const RICH_TEXT_FORMATTER: InjectionToken<RichTextFormatter>;

interface ILuRichTextInputLabel {
    clearFormat: string;
    linksCancel: string;
    linksDelete: string;
    linksHref: string;
    linksLabel: string;
    linksSubmit: string;
    linksPlaceholder: string;
    listsNumberedLabel: string;
    listsBulletLabel: string;
    headingsLabel: string;
    headings0: string;
    headings1: string;
    headings2: string;
    headings3: string;
    headings4: string;
    headings5: string;
    headings6: string;
    stylesItalic: string;
    stylesBold: string;
    stylesUnderline: string;
    stylesStrikethrough: string;
    insertTag: string;
}

declare const INITIAL_UPDATE_TAG = "initial-update";
declare const SKIP_DOM_SELECTION_TAG = "skip-dom-selection";
interface RichTextPluginComponent {
    setEditorInstance(editor: LexicalEditor): void;
    getLexicalNodes?(): (Klass<LexicalNode> | LexicalNodeReplacement)[];
    setDisabledState(isDisabled: boolean): void;
    pluginComponents?: Signal<readonly RichTextPluginComponent[]>;
    tabindex?: WritableSignal<number>;
    focus?(): void;
}
declare const RICH_TEXT_PLUGIN_COMPONENT: InjectionToken<RichTextPluginComponent>;
declare class RichTextInputComponent implements OnInit, OnDestroy, ControlValueAccessor {
    #private;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly disableSpellcheck: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly autoResize: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly hideToolbar: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly content: Signal<ElementRef<HTMLElement>>;
    readonly contentPresentation: Signal<ElementRef<HTMLElement>>;
    readonly pluginComponents: Signal<readonly RichTextPluginComponent[]>;
    readonly currentCanShowPlaceholder: WritableSignal<boolean>;
    readonly isDisabled: WritableSignal<boolean>;
    readonly formFieldId: Signal<string>;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    writeValue(value: string | null): void;
    registerOnChange(onChange: (markdown: string | null) => void): void;
    registerOnTouched(onTouch: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    focusSiblingPlugin(event: Event, direction: -1 | 1): void;
    focus(): void;
    touch(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextInputComponent, "lu-rich-text-input", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disableSpellcheck": { "alias": "disableSpellcheck"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "hideToolbar": { "alias": "hideToolbar"; "required": false; "isSignal": true; }; }, {}, ["pluginComponents"], ["*"], true, never>;
}

declare class ClearFormatComponent implements RichTextPluginComponent, OnDestroy {
    #private;
    readonly intl: _angular_core.InputSignalWithTransform<ILuRichTextInputLabel, Partial<ILuRichTextInputLabel>>;
    readonly element: _angular_core.Signal<ElementRef<any>>;
    readonly tabindex: _angular_core.WritableSignal<number>;
    readonly isDisabled: _angular_core.WritableSignal<boolean>;
    setEditorInstance(editor: LexicalEditor): void;
    ngOnDestroy(): void;
    dispatchCommand(): void;
    setDisabledState(isDisabled: boolean): void;
    focus(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClearFormatComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ClearFormatComponent, "lu-rich-text-plugin-clear-format", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class HeadingsComponent implements OnDestroy, RichTextPluginComponent {
    #private;
    readonly element: _angular_core.Signal<LuSimpleSelectInputComponent<string>>;
    readonly tabindex: _angular_core.WritableSignal<number>;
    readonly maxHeadingLevel: _angular_core.InputSignal<1 | 2 | 3 | 4 | 5 | 6>;
    readonly headingOptions: _angular_core.Signal<("h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "paragraph")[]>;
    readonly intl: _angular_core.InputSignalWithTransform<ILuRichTextInputLabel, Partial<ILuRichTextInputLabel>>;
    readonly headingLabels: _angular_core.Signal<Record<"h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "paragraph", [string, number]>>;
    readonly formControl: FormControl<"h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "paragraph">;
    setEditorInstance(editor: LexicalEditor): void;
    getLexicalNodes(): Klass<LexicalNode>[];
    ngOnDestroy(): void;
    focus(): void;
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeadingsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HeadingsComponent, "lu-rich-text-plugin-headings", never, { "maxHeadingLevel": { "alias": "maxHeadingLevel"; "required": false; "isSignal": true; }; "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface LinkTemplateContext {
    href: string;
    title?: string | null;
    target?: string | null;
    isAutoLink: boolean;
}

declare class PopoverLinkNode extends LinkNode {
    #private;
    setViewContainerRef(vcr: ViewContainerRef): this;
    getViewContainerRef(): ViewContainerRef | undefined;
    setTemplateRef(templateRef: TemplateRef<LinkTemplateContext>): this;
    getTemplateRef(): TemplateRef<LinkTemplateContext> | undefined;
    static getType(): string;
    constructor(url?: string, attributes?: LinkAttributes & {
        viewContainerRef?: ViewContainerRef;
        templateRef?: TemplateRef<LinkTemplateContext>;
    }, key?: NodeKey);
    createDOM(config: EditorConfig): HTMLElement;
    updateDOM(prevNode: this): boolean;
    exportDOM(editor: LexicalEditor): DOMExportOutput;
    remove(preserveEmptyParent?: boolean): void;
    static importJSON(serializedNode: SerializedLinkNode): PopoverLinkNode;
    static clone(node: PopoverLinkNode): PopoverLinkNode;
}

declare class PopoverAutoLinkNode extends AutoLinkNode {
    #private;
    setViewContainerRef(vcr: ViewContainerRef): this;
    getViewContainerRef(): ViewContainerRef | undefined;
    setTemplateRef(templateRef: TemplateRef<LinkTemplateContext>): this;
    getTemplateRef(): TemplateRef<LinkTemplateContext> | undefined;
    static getType(): string;
    constructor(url?: string, attributes?: LinkAttributes & {
        viewContainerRef?: ViewContainerRef;
        templateRef?: TemplateRef<LinkTemplateContext>;
    }, key?: NodeKey);
    createDOM(config: EditorConfig): HTMLElement;
    updateDOM(prevNode: this): boolean;
    exportDOM(editor: LexicalEditor): DOMExportOutput;
    remove(preserveEmptyParent?: boolean): void;
    static importJSON(serializedNode: SerializedAutoLinkNode): PopoverAutoLinkNode;
    static clone(node: PopoverAutoLinkNode): PopoverAutoLinkNode;
}

declare class LinkComponent implements OnDestroy, RichTextPluginComponent {
    #private;
    readonly linkNodeTemplate: _angular_core.Signal<TemplateRef<any>>;
    readonly element: _angular_core.Signal<ElementRef<any>>;
    readonly tabindex: _angular_core.WritableSignal<number>;
    readonly active: _angular_core.WritableSignal<boolean>;
    readonly isDisabled: _angular_core.WritableSignal<boolean>;
    readonly intl: _angular_core.InputSignalWithTransform<ILuRichTextInputLabel, Partial<ILuRichTextInputLabel>>;
    setEditorInstance(editor: LexicalEditor): void;
    getLexicalNodes(): (typeof PopoverLinkNode | typeof PopoverAutoLinkNode | {
        replace: typeof LinkNode;
        with: (node: LinkNode) => PopoverLinkNode;
        withKlass: typeof PopoverLinkNode;
    } | {
        replace: typeof AutoLinkNode;
        with: (node: AutoLinkNode) => PopoverAutoLinkNode;
        withKlass: typeof PopoverAutoLinkNode;
    })[];
    ngOnDestroy(): void;
    dispatchCommand(): void;
    deleteLink(): void;
    focus(): void;
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LinkComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LinkComponent, "lu-rich-text-plugin-link", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ListStyleToolbarComponent implements OnDestroy, RichTextPluginComponent {
    #private;
    pluginComponents: _angular_core.Signal<readonly RichTextPluginComponent[]>;
    intl: _angular_core.InputSignalWithTransform<ILuRichTextInputLabel, Partial<ILuRichTextInputLabel>>;
    setEditorInstance(editor: LexicalEditor): void;
    getLexicalNodes?(): Klass<LexicalNode>[];
    setDisabledState(isDisabled: boolean): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListStyleToolbarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListStyleToolbarComponent, "lu-rich-text-toolbar-list-style", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type Tag = {
    key: string;
    description?: string;
};

declare class RichTextPluginTagComponent implements RichTextPluginComponent, OnDestroy {
    #private;
    readonly intl: _angular_core.InputSignalWithTransform<ILuRichTextInputLabel, Partial<ILuRichTextInputLabel>>;
    readonly tags: _angular_core.InputSignal<Tag[]>;
    readonly isDisabled: _angular_core.WritableSignal<boolean>;
    readonly focusIndex: _angular_core.WritableSignal<number>;
    readonly focusableElements: _angular_core.Signal<readonly ElementRef<any>[]>;
    editor: LexicalEditor | null;
    constructor();
    setEditorInstance(editor: LexicalEditor): void;
    getLexicalNodes(): Klass<LexicalNode>[];
    insertTag(tag: Tag): void;
    setDisabledState(isDisabled: boolean): void;
    focus(): void;
    focusTag(event: Event, direction: -1 | 1): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextPluginTagComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextPluginTagComponent, "lu-rich-text-plugin-tag", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; "tags": { "alias": "tags"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

type SerializedTagNode = Spread<{
    tagKey?: string;
    tagDescription?: string;
    disabled?: boolean;
}, SerializedLexicalNode>;
declare class TagNode extends DecoratorNode<string> {
    #private;
    setViewContainerRef(vcr: ViewContainerRef): this;
    getViewContainerRef(): ViewContainerRef;
    constructor(tagKey?: string, viewContainerRef?: ViewContainerRef, tagDescription?: string, disabled?: boolean, key?: NodeKey);
    isDisabled(): boolean;
    setDisabled(disabled: boolean): this;
    getTagKey(): string;
    setTagKey(tagKey: string): this;
    getTagDescription(): string;
    setTagDescription(description: string): this;
    static getType(): string;
    static clone(node: TagNode): TagNode;
    /**
     * This method must be implemented but has no purpose outside of react
     */
    decorate(): string;
    createDOM(_config: EditorConfig, editor: LexicalEditor): HTMLElement;
    updateDOM(prevNode: TagNode, _dom: HTMLElement, _config: EditorConfig): boolean;
    remove(preserveEmptyParent?: boolean): void;
    exportDOM(): DOMExportOutput;
    static importDOM(): DOMConversionMap;
    static importJSON(serializedNode: SerializedTagNode): TagNode;
    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedTagNode>): this;
    exportJSON(): SerializedTagNode;
    getTextContent(): string;
}
declare function $createTagNode(key?: string, viewContainerRef?: ViewContainerRef, description?: string): TagNode;
declare function $isTagNode(node: LexicalNode | null | undefined): node is TagNode;

declare class TextStyleComponent implements OnDestroy, RichTextPluginComponent {
    #private;
    format: _angular_core.InputSignal<TextFormatType>;
    icon: _angular_core.InputSignal<LuccaIcon>;
    tooltip: _angular_core.InputSignal<string>;
    tabindex: _angular_core.WritableSignal<number>;
    active: _angular_core.WritableSignal<boolean>;
    isDisabled: _angular_core.WritableSignal<boolean>;
    element: _angular_core.Signal<ElementRef<any>>;
    setEditorInstance(editor: LexicalEditor): void;
    ngOnDestroy(): void;
    dispatchCommand(): void;
    setDisabledState(isDisabled: boolean): void;
    focus(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextStyleComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextStyleComponent, "lu-rich-text-plugin-text-style", never, { "format": { "alias": "format"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": true; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TextStyleToolbarComponent implements RichTextPluginComponent {
    pluginComponents: _angular_core.Signal<readonly RichTextPluginComponent[]>;
    intl: _angular_core.InputSignalWithTransform<ILuRichTextInputLabel, Partial<ILuRichTextInputLabel>>;
    setEditorInstance(editor: LexicalEditor): void;
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextStyleToolbarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextStyleToolbarComponent, "lu-rich-text-toolbar-text-style", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class RichTextInputToolbarComponent implements RichTextPluginComponent {
    pluginComponents: _angular_core.Signal<readonly RichTextPluginComponent[]>;
    setEditorInstance(editor: LexicalEditor): void;
    getLexicalNodes(): (lexical.KlassConstructor<typeof LexicalNode> | lexical.LexicalNodeReplacement)[];
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextInputToolbarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextInputToolbarComponent, "lu-rich-text-input-toolbar", never, {}, {}, never, never, true, never>;
}

export { $createTagNode, $isTagNode, ClearFormatComponent, HeadingsComponent, INITIAL_UPDATE_TAG, LinkComponent, ListStyleToolbarComponent, RICH_TEXT_FORMATTER, RICH_TEXT_PLUGIN_COMPONENT, RichTextFormatter, RichTextInputComponent, RichTextInputToolbarComponent, RichTextPluginTagComponent, SKIP_DOM_SELECTION_TAG, TagNode, TextStyleComponent, TextStyleToolbarComponent };
export type { RichTextPluginComponent, SerializedTagNode, Tag };