import { Editor } from '@tiptap/core';
import * as i0 from '@angular/core';
import { EventEmitter, Renderer2, ElementRef, OnInit, AfterViewInit, OnDestroy, TemplateRef, ComponentRef, Injector, OnChanges, QueryList, SimpleChanges, ChangeDetectorRef, ViewContainerRef } from '@angular/core';
import * as i34 from '@angular/forms';
import { ControlValueAccessor } from '@angular/forms';
import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
import { HttpEvent } from '@angular/common/http';
import * as rxjs from 'rxjs';
import { Observable } from 'rxjs';
import * as i36 from '@sellan/core';
import { EventBrokerService, UploadedFile, UploaderConfig, CoreBaseDestroyComponent } from '@sellan/core';
import * as i37 from '@angular/cdk/overlay';
import { Overlay } from '@angular/cdk/overlay';
import { MatDialogRef, MatDialog } from '@angular/material/dialog';
import { FocusableOption } from '@angular/cdk/a11y';
import { Directionality } from '@angular/cdk/bidi';
import * as i33 from '@angular/common';
import * as i35 from '@angular/material/tabs';

declare class MonitoredEditorItems {
    selectedClassList?: string;
    selectedListType?: 'ol' | 'ul' | '';
    selectedTableCell?: any;
    fontSize?: number;
}

interface UploadResponse {
    imageUrl: string;
}
declare class EditorService {
    doc: any;
    /** TipTap instance — устанавливается из SlnEditorComponent. */
    editor: Editor | null;
    savedSelection: Range | null;
    selectedText: string;
    editorElementId: string;
    uploadUrl: string;
    parentNodeIsHref: boolean;
    uploadWithCredentials: boolean;
    monitoredItems: MonitoredEditorItems;
    /** Открыть диалог изображения (кнопка / double-click). */
    requestImageEdit: (() => void) | null;
    constructor(doc: any);
    setEditor(editor: Editor | null): void;
    static escapeHtml(value: string): string;
    static escapeAttr(value: string): string;
    isSelectionInEditor(): boolean;
    isActive(name: string, attrs?: Record<string, unknown>): boolean;
    /**
     * Команды тулбара → TipTap chain().
     */
    executeCommand(command: string, value?: string): void;
    insertColor(color: string, where: string): void;
    setFontName(fontName: string): void;
    setFontSize(fontSize: string): void;
    insertHtml(html: string): void;
    toggleCustomClass(className: string, tag?: string): void;
    getMarkdown(): string;
    getSelectedImageAttrs(): {
        src: string;
        alt: string;
        width: number | null;
        height: number | null;
        id: string | null;
        float: 'left' | 'right' | null;
    } | null;
    setOrUpdateImage(attrs: {
        src: string;
        alt?: string | null;
        width?: number | null;
        height?: number | null;
        id?: string | null;
        float?: 'left' | 'right' | null;
        placement?: 'block' | 'left' | 'right';
        /** Позиция узла image при редактировании (selection после диалога теряется). */
        imagePos?: number | null;
    }): void;
    /** Позиция выбранного image-узла (для update после диалога). */
    getSelectedImagePos(): number | null;
    insertOrderedList(type?: string): void;
    insertUnorderedList(cssClass?: string): void;
    getHtml(): string;
    setHtml(html: string | null | undefined): void;
    focus(): void;
    setEditable(editable: boolean): void;
    /**
     * Сохранение выделения (для диалогов ссылок/картинок).
     * TipTap держит selection сам; сохраняем текст и флаг ссылки.
     */
    saveSelection: () => void;
    restoreSelection(): boolean;
    executeInNextQueueIteration(callbackFn: (...args: any[]) => any, timeout?: number): void;
    setDefaultParagraphSeparator(_separator: string): void;
    updateMonitoredItems(): void;
    syncSelectionMeta(): void;
    nextNode(node: any): any;
    getRangeSelectedNodes(range: any, includePartiallySelectedContainers: boolean): any[];
    getEditorData(): HTMLElement | null;
    getSelectedNodes(): any[];
    replaceWithOwnChildren(el: any): void;
    removeSelectedElements(tagNames: string): void;
    destroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EditorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EditorService>;
}

interface ICustomClass {
    name: string;
    class: string;
    tag?: string;
}
interface IEditorConfig {
    editable?: boolean;
    spellcheck?: boolean;
    height?: 'auto' | string;
    minHeight?: '0' | string;
    maxHeight?: 'auto' | string;
    width?: 'auto' | string;
    minWidth?: '0' | string;
    translate?: 'yes' | 'now' | string;
    enableToolbar?: boolean;
    showToolbar?: boolean;
    placeholder?: string;
    defaultParagraphSeparator?: string;
    defaultFontName?: string;
    defaultFontSize?: '1' | '2' | '3' | '4' | '5' | '6' | '7' | string;
    uploadUrl?: string;
    upload?: (file: File) => Observable<HttpEvent<UploadResponse>>;
    uploadWithCredentials?: boolean;
    customClasses?: ICustomClass[];
    sanitize?: boolean;
    outline?: boolean;
    toolbarHiddenButtons?: string[][];
    /** Вставлять HTML как есть, без cleanup / Markdown paste. */
    rawPaste?: boolean;
    /**
     * Парсить plain-text Markdown при paste (если нет богатого HTML).
     * @default true
     */
    enableMarkdownPaste?: boolean;
}

interface IToolbarSettings {
    id: string;
    htmlMode: boolean;
    linkSelected: boolean;
    block: string;
    fontName: string;
    fontSize: string;
    foreColour: string;
    backColor: string;
    hiddenButtons?: string[][];
}

declare class BaseButtonComponent {
    doc: any;
    settings: IToolbarSettings;
    execute: EventEmitter<string>;
    constructor(doc: any);
    triggerCommand(command: string): void;
    isButtonHidden(name: string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseButtonComponent, "ng-component", never, { "settings": { "alias": "settings"; "required": false; }; }, { "execute": "execute"; }, never, never, false, never>;
}

declare class SlnEditorButtonHtmlComponent extends BaseButtonComponent {
    private r;
    constructor(doc: any, r: Renderer2);
    setEditorMode(m: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonHtmlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonHtmlComponent, "sln-editor-button-html", never, {}, {}, never, never, false, never>;
}

declare class SlnEditorToolbarComponent {
    private doc;
    private r;
    private editorService;
    private er;
    private _eventBroker;
    settings: IToolbarSettings;
    showToolbar: boolean;
    customClasses: ICustomClass[];
    execute: EventEmitter<any>;
    htmlButton: SlnEditorButtonHtmlComponent;
    constructor(doc: any, r: Renderer2, editorService: EditorService, er: ElementRef, _eventBroker: EventBrokerService);
    editMode: boolean;
    /**
     * Только проброс в SlnEditorComponent — иначе команды toggle вызываются дважды.
     */
    triggerCommand($event: any): void;
    triggerButtons(): void;
    triggerBlocks(nodes: Node[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorToolbarComponent, "sln-editor-toolbar", never, { "settings": { "alias": "settings"; "required": false; }; "showToolbar": { "alias": "showToolbar"; "required": false; }; "customClasses": { "alias": "customClasses"; "required": false; }; }, { "execute": "execute"; }, never, never, false, never>;
}

declare class SlnEditorTableEditorComponent {
    private _editorService;
    constructor(_editorService: EditorService);
    private get currentCell();
    deleteTable(): void;
    addRowBefore(): void;
    addRowAfter(): void;
    deleteRow(): void;
    addColumnBefore(): void;
    addColumnAfter(): void;
    deleteColumn(): void;
    mergeCells(): void;
    splitCell(): void;
    toggleHeaderRow(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorTableEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorTableEditorComponent, "sln-table-editor", never, {}, {}, never, never, false, never>;
}

declare class SlnEditorComponent implements OnInit, ControlValueAccessor, AfterViewInit, OnDestroy {
    private _injector;
    private autoFocus;
    private doc;
    private sanitizer;
    private overlay;
    private r;
    private _editorService;
    private onChange;
    private onTouched;
    private pendingContent;
    private editorReady;
    modeVisual: boolean;
    showPlaceholder: boolean;
    disabled: boolean;
    focused: boolean;
    touched: boolean;
    changed: boolean;
    sourceHtml: string;
    settings: IToolbarSettings;
    id: string;
    config: IEditorConfig;
    placeholder: string;
    tabIndex: number | null;
    html: EventEmitter<string>;
    editorHost: ElementRef<HTMLElement>;
    editorWrapper: ElementRef;
    editorToolbar: SlnEditorToolbarComponent;
    sourceTextRef: ElementRef<HTMLTextAreaElement>;
    customButtonsTemplateRef?: TemplateRef<any>;
    ref: ComponentRef<SlnEditorTableEditorComponent>;
    viewMode: EventEmitter<boolean>;
    blurEvent: EventEmitter<FocusEvent>;
    focusEvent: EventEmitter<FocusEvent>;
    tabindex: number;
    onFocus(): void;
    tableEditorIsOpen: boolean;
    rowCount: number;
    activeTableId: string;
    constructor(_injector: Injector, defaultTabIndex: string, autoFocus: any, doc: any, sanitizer: DomSanitizer, overlay: Overlay, r: Renderer2, _editorService: EditorService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private initTipTap;
    handleForTargetNode(): void;
    executeCommand(command: string, value?: string): void;
    onTextAreaFocus(event: FocusEvent): void;
    onTextAreaMouseOut(_event: MouseEvent): void;
    tableTargetHandler(event: HTMLElement): void;
    onTextAreaBlur(event: FocusEvent): void;
    focusFn(): void;
    private emitHtml;
    onSourceInput(event: Event): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    writeValue(value: any): void;
    togglePlaceholder(empty: boolean): void;
    setDisabledState(isDisabled: boolean): void;
    toggleEditorMode(bToSource: boolean): void;
    exec(): void;
    private configure;
    getCustomTags(): string;
    ngOnDestroy(): void;
    filterStyles(html: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorComponent, [null, { attribute: "tabindex"; }, { attribute: "autofocus"; }, null, null, null, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorComponent, "sln-editor", never, { "id": { "alias": "id"; "required": false; }; "config": { "alias": "config"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; }, { "html": "html"; "viewMode": "viewMode"; "blurEvent": "blurEvent"; "focusEvent": "focusEvent"; }, ["customButtonsTemplateRef"], never, false, never>;
}

declare class SlnEditorButtonAlignComponent extends BaseButtonComponent {
    doc: any;
    groupName: string;
    imageUrl: string;
    constructor(doc: any, _eventBroker: EventBrokerService);
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonAlignComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonAlignComponent, "sln-editor-button-align", never, {}, {}, never, never, false, never>;
}

declare class SlnEditorButtonTextCaseComponent extends BaseButtonComponent {
    doc: any;
    private _editorService;
    groupName: string;
    constructor(doc: any, _editorService: EditorService);
    private replaceSelectedText;
    toUpperCase(): void;
    toLowerCase(): void;
    toTitleCase(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonTextCaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonTextCaseComponent, "sln-editor-button-text-case", never, {}, {}, never, never, false, never>;
}

type SlnImagePlacement = 'block' | 'left' | 'right';

interface ImageDialogData {
    edit?: boolean;
    id?: string;
    description?: string;
    address?: string;
    autoSize?: boolean;
    width?: number;
    height?: number;
    placement?: SlnImagePlacement;
    keepAspectRatio?: boolean;
    selectedText?: boolean;
}
declare class SlnImageDialogComponent implements OnInit {
    private _dialogRef;
    data: ImageDialogData | null;
    id: string;
    autoSize: boolean;
    description: string;
    address: string;
    width: number;
    height: number;
    placement: SlnImagePlacement;
    keepAspectRatio: boolean;
    files: UploadedFile[];
    config: UploaderConfig;
    editMode: boolean;
    private aspectRatio;
    private syncingSize;
    placementOptions: {
        label: string;
        value: SlnImagePlacement;
    }[];
    get dialogTitle(): string;
    constructor(_dialogRef: MatDialogRef<SlnImageDialogComponent>, data: ImageDialogData | null);
    ngOnInit(): void;
    onValuesChange($event: UploadedFile[]): void;
    onAddressBlur(): void;
    onWidthChange(value: number | string): void;
    onHeightChange(value: number | string): void;
    onKeepAspectRatioChange(value: boolean): void;
    private refreshAspectRatio;
    private loadNaturalRatio;
    execute(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnImageDialogComponent, [null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnImageDialogComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class SlnResizableDirective {
    private readonly documentRef;
    private readonly elementRef;
    readonly resizable: rxjs.Observable<number>;
    constructor(documentRef: Document, elementRef: ElementRef<HTMLElement>);
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnResizableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SlnResizableDirective, "[resizable]", never, {}, { "resizable": "resizable"; }, never, never, false, never>;
}

declare class SlnResizableComponent implements AfterViewInit, OnDestroy {
    width: number | null;
    resizableDir: SlnResizableDirective;
    private resizeSub;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    onResize(width: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnResizableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnResizableComponent, "th[resizable]", never, {}, {}, never, ["*"], false, never>;
}

declare class SlnPreviewDocumentDialogComponent extends CoreBaseDestroyComponent implements OnInit {
    private _dialogRef;
    private sanitizer;
    data: {
        html: string;
    };
    docData: SafeHtml;
    constructor(_dialogRef: MatDialogRef<any>, sanitizer: DomSanitizer, data: {
        html: string;
    });
    ngOnInit(): void;
    execute(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnPreviewDocumentDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnPreviewDocumentDialogComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class SlnEditorButtonPreviewComponent extends BaseButtonComponent {
    doc: any;
    private _dialog;
    private _injector;
    private _editorService;
    constructor(doc: any, _dialog: MatDialog, _injector: Injector, _editorService: EditorService);
    openInModal(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonPreviewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonPreviewComponent, "sln-editor-button-preview", never, {}, {}, never, never, false, never>;
}

declare class ColorDirective implements FocusableOption {
    private elementRef;
    constructor(elementRef: ElementRef);
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorDirective, "[color]", never, {}, {}, never, never, false, never>;
}

declare class ColorPickerComponent implements OnChanges, AfterViewInit, OnDestroy {
    private dir;
    private _editorService;
    private doc;
    private keyManager;
    createColorBlockOpen: boolean;
    isOpen: boolean;
    template: TemplateRef<any>;
    gridCells: QueryList<ColorDirective>;
    colors: object[];
    value: object;
    isBackground: boolean;
    rowSize: number;
    valueChange: EventEmitter<object>;
    private groupedColors;
    private selectionChangeHandler;
    R: number;
    G: number;
    B: number;
    constructor(dir: Directionality, _editorService: EditorService, doc: Document);
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    insertColor(color: any): void;
    changeRGBvalue(r: any, g: any, b: any): void;
    handleForSelectedColor(): void;
    createNewColor(): void;
    componentToHex(c: any): any;
    rgbToHex(r: any, g: any, b: any): string;
    getRGBColorString(): string;
    setActiveItem(value: any): void;
    onKeyDown(ev: KeyboardEvent): void;
    hexToRgb(hex: any): {
        r: number;
        g: number;
        b: number;
    };
    onGridCellKeyDown(ev: KeyboardEvent, color: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ColorPickerComponent, "sln-color-picker", ["colorPicker"], { "colors": { "alias": "colors"; "required": false; }; "value": { "alias": "value"; "required": false; }; "isBackground": { "alias": "isBackground"; "required": false; }; "rowSize": { "alias": "rowSize"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
}

interface Item {
    id: number;
    title: string;
}

declare class TableData {
    isVisible: boolean;
    rows: Item[];
    columns: Item[];
    constructor(rows?: number, cols?: number);
    addRow(rowTitle: string): void;
    addCol(colTitle: string): void;
}

interface SelectedItem {
    selectedX: number;
    selectedY: number;
}

declare class SlnEditorButtonTablePickerComponent extends BaseButtonComponent {
    doc: any;
    private _eRef;
    private _editorService;
    private cdRef;
    table: ElementRef;
    tableView: TableData;
    hidePicker: boolean;
    isWasSelected: boolean;
    constructor(doc: any, _eRef: ElementRef, _editorService: EditorService, cdRef: ChangeDetectorRef);
    emitSelected(event: SelectedItem): void;
    clickOut(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonTablePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonTablePickerComponent, "sln-editor-button-table-picker", never, {}, {}, never, never, false, never>;
}

declare class SlnEditorWindowTablePickerComponent {
    doc: any;
    fieldX: number[];
    fieldY: number[];
    selectedX: number;
    selectedY: number;
    selected: EventEmitter<SelectedItem>;
    constructor(doc: any);
    focusTableItem(x: any, y: any): void;
    isSelected(x: any, y: any): boolean;
    clickItem(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorWindowTablePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorWindowTablePickerComponent, "sln-editor-window-table-picker", never, {}, { "selected": "selected"; }, never, never, false, never>;
}

declare class SlnEditorTableResolverComponent implements OnInit, AfterViewInit {
    private _editorService;
    tableView: TableData;
    table: ElementRef;
    constructor(_editorService: EditorService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorTableResolverComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorTableResolverComponent, "sln-editor-button-table-resolver", never, { "tableView": { "alias": "tableView"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ColorPickerTriggerDirective implements OnDestroy {
    overlay: Overlay;
    private viewContainerRef;
    private dir;
    private _overlayRef;
    colorPicker: ColorPickerComponent;
    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, dir: Directionality);
    ngOnDestroy(): void;
    private close;
    private openAt;
    onClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPickerTriggerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorPickerTriggerDirective, "[color-picker-trigger]", never, { "colorPicker": { "alias": "color-picker-trigger"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SlnEditorButtonArrowComponent extends BaseButtonComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonArrowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonArrowComponent, "sln-editor-button-arrow", never, {}, {}, never, never, false, never>;
}

declare class SlnEditorButtonColorsComponent extends BaseButtonComponent {
    private _editorService;
    constructor(doc: any, _editorService: EditorService);
    colors: {
        name: string;
        value: string;
    }[];
    textColor: string;
    backColor: string;
    insertColor(color: string, where: string): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonColorsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonColorsComponent, "sln-editor-button-colors", never, {}, {}, never, never, false, never>;
}

declare class SlnListButtonHtmlComponent extends BaseButtonComponent {
    private _eRef;
    iconUrl: string;
    altText: string;
    name: string;
    constructor(doc: any, _eRef: ElementRef);
    showBtnList: boolean;
    changeBtnListState(event: MouseEvent): void;
    clickOut(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnListButtonHtmlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnListButtonHtmlComponent, "sln-list-button-html", never, { "iconUrl": { "alias": "iconUrl"; "required": false; }; "altText": { "alias": "altText"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class SlnEditorButtonSpecialComponent extends BaseButtonComponent implements OnInit, OnDestroy {
    private _editorService;
    private _dialog;
    private _injector;
    get isLinkButtonDisabled(): boolean;
    get imageButtonTitle(): string;
    constructor(doc: any, _editorService: EditorService, _dialog: MatDialog, _injector: Injector);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private escapeHtml;
    private escapeAttr;
    addImage(): void;
    private resolveImageSize;
    private getImageSize;
    private _calculateRatioFit;
    addLink(): void;
    private _findAnchor;
    private _createLink;
    removeLink(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonSpecialComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonSpecialComponent, "sln-editor-button-special", never, {}, {}, never, never, false, never>;
}

declare class SlnEditorButtonFormatComponent extends BaseButtonComponent {
    doc: any;
    constructor(doc: any);
    setBold(): void;
    setItalic(): void;
    setUnderline(): void;
    setStrikeThrough(): void;
    setSubscript(): void;
    setSuperscript(): void;
    private _commanHandle;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonFormatComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonFormatComponent, "sln-editor-button-format", never, {}, {}, never, never, false, never>;
}

declare class SlnEditorButtonListsComponent extends BaseButtonComponent implements OnInit, OnDestroy {
    doc: any;
    private _editorService;
    private selectionChangeHandler;
    defaultSortedListIconUrl: string;
    defaultMarkedListIconUrl: string;
    groupNameNum: string;
    groupNameMark: string;
    icons: {
        iconUrl: string;
        altText: string;
        type: string;
    }[];
    sortedListIconUrl: string;
    markedListIconUrl: string;
    constructor(doc: any, _editorService: EditorService);
    ngOnInit(): void;
    getIconUrl(type: string): string;
    handleForSelectedList(): void;
    insertUnorderedList(type: string): void;
    private _createCustomListClass;
    insertOrderedList(type: string): void;
    ngOnDestroy(): void;
    isActive(classStyle: string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonListsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonListsComponent, "sln-editor-button-lists", never, {}, {}, never, never, false, never>;
}

declare class SlnEditorButtonTabsComponent extends BaseButtonComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonTabsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonTabsComponent, "sln-editor-button-tabs", never, {}, {}, never, never, false, never>;
}

declare class SlnHrefDialogComponent extends CoreBaseDestroyComponent implements OnInit {
    private _dialogRef;
    data: any;
    isNewWindow: boolean;
    hrefTitle: string;
    address: string;
    hrefEnabled: boolean;
    constructor(_dialogRef: MatDialogRef<SlnHrefDialogComponent>, data: any);
    ngOnInit(): void;
    execute(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnHrefDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnHrefDialogComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class SlnEditorButtonFormatClearComponent extends BaseButtonComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonFormatClearComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonFormatClearComponent, "sln-editor-button-format-clear", never, {}, {}, never, never, false, never>;
}

declare class SlnStepInputComponent implements OnDestroy, OnInit {
    private _editorService;
    private doc;
    title: string;
    initialValue: number;
    step: number;
    min: number;
    max: number;
    symbol: string;
    ariaLabelLess: string;
    ariaLabelMore: string;
    isHidden: boolean;
    disabled: boolean;
    changeEvent: EventEmitter<any>;
    renderedValue: number;
    value: number;
    wrapperHide: boolean;
    private selectionChangeHandler;
    constructor(_editorService: EditorService, doc: Document);
    ngOnInit(): void;
    ngOnDestroy(): void;
    handleForSelectedFontSize(): void;
    toggleMore: () => void;
    toggleLess: () => void;
    changeValue(value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnStepInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnStepInputComponent, "sln-step-input", never, { "initialValue": { "alias": "initialValue"; "required": false; }; "step": { "alias": "step"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "symbol": { "alias": "symbol"; "required": false; }; "ariaLabelLess": { "alias": "ariaLabelLess"; "required": false; }; "ariaLabelMore": { "alias": "ariaLabelMore"; "required": false; }; "isHidden": { "alias": "isHidden"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "changeEvent": "changeEvent"; }, never, never, false, never>;
}

interface SelectOption {
    label: string;
    value: string;
}
declare class SlnEditorSelectComponent implements OnInit, ControlValueAccessor {
    private elRef;
    private r;
    options: SelectOption[];
    isHidden: boolean;
    selectedOption: SelectOption;
    disabled: boolean;
    optionId: number;
    get label(): string;
    opened: boolean;
    get value(): string;
    hidden: string;
    changeEvent: EventEmitter<any>;
    labelButton: ElementRef;
    constructor(elRef: ElementRef, r: Renderer2);
    ngOnInit(): void;
    hide(): void;
    optionSelect(option: SelectOption, event: MouseEvent): void;
    toggleOpen(event: MouseEvent): void;
    onClick($event: MouseEvent): void;
    close(): void;
    get isOpen(): boolean;
    writeValue(value: any): void;
    setValue(value: any): void;
    onChange: any;
    onTouched: any;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    handleKeyDown($event: KeyboardEvent): void;
    _handleArrowDown($event: any): void;
    _handleArrowUp($event: any): void;
    _handleSpace($event: any): void;
    _handleEnter($event: any): void;
    _handleTab($event: any): void;
    _handleBackspace(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorSelectComponent, "sln-editor-select", never, { "options": { "alias": "options"; "required": false; }; "isHidden": { "alias": "isHidden"; "required": false; }; }, { "changeEvent": "changeEvent"; }, never, never, false, never>;
}

declare class SlnEditorButtonTextsComponent extends BaseButtonComponent {
    headings: SelectOption[];
    constructor(doc: any);
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonTextsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonTextsComponent, "sln-editor-button-texts", never, {}, {}, never, never, false, never>;
}

declare class SlnEditorButtonTextCustomsComponent extends BaseButtonComponent implements OnChanges, OnInit {
    private _editorService;
    customClasses: ICustomClass[];
    options: SelectOption[];
    constructor(doc: any, _editorService: EditorService);
    ngOnInit(): void;
    ngOnChanges(): void;
    private buildOptions;
    applyCustomClass(className: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonTextCustomsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonTextCustomsComponent, "sln-editor-button-text-customs", never, { "customClasses": { "alias": "customClasses"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SlnEditorButtonFontsComponent extends BaseButtonComponent {
    private _editorService;
    fonts: SelectOption[];
    constructor(doc: any, _editorService: EditorService);
    setFontName(fontName: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonFontsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonFontsComponent, "sln-editor-button-fonts", never, {}, {}, never, never, false, never>;
}

declare class SlnEditorButtonFontSizesComponent extends BaseButtonComponent {
    private _editorService;
    constructor(doc: any, _editorService: EditorService);
    setFontSize(fontSize: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorButtonFontSizesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlnEditorButtonFontSizesComponent, "sln-editor-button-font-sizes", never, {}, {}, never, never, false, never>;
}

declare class SlnEditorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnEditorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SlnEditorModule, [typeof SlnEditorButtonAlignComponent, typeof SlnEditorButtonTextCaseComponent, typeof SlnImageDialogComponent, typeof SlnResizableDirective, typeof SlnResizableComponent, typeof SlnPreviewDocumentDialogComponent, typeof SlnEditorButtonPreviewComponent, typeof ColorDirective, typeof ColorPickerComponent, typeof SlnEditorButtonTablePickerComponent, typeof SlnEditorWindowTablePickerComponent, typeof SlnEditorTableEditorComponent, typeof SlnEditorTableResolverComponent, typeof ColorPickerTriggerDirective, typeof SlnEditorButtonArrowComponent, typeof SlnEditorButtonColorsComponent, typeof SlnListButtonHtmlComponent, typeof SlnEditorButtonSpecialComponent, typeof SlnEditorButtonFormatComponent, typeof SlnEditorButtonListsComponent, typeof SlnEditorButtonTabsComponent, typeof SlnHrefDialogComponent, typeof SlnEditorButtonFormatClearComponent, typeof SlnEditorButtonHtmlComponent, typeof SlnStepInputComponent, typeof SlnEditorButtonTextsComponent, typeof SlnEditorButtonTextCustomsComponent, typeof SlnEditorButtonFontsComponent, typeof SlnEditorButtonFontSizesComponent, typeof SlnEditorComponent, typeof SlnEditorToolbarComponent, typeof SlnEditorSelectComponent], [typeof i33.CommonModule, typeof i34.FormsModule, typeof i35.MatTabsModule, typeof i36.CoreControlModule, typeof i37.OverlayModule, typeof i34.ReactiveFormsModule, typeof i36.CoreDialogModule, typeof i36.CoreUploaderModule], [typeof SlnEditorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SlnEditorModule>;
}

export { EditorService, SlnEditorComponent, SlnEditorModule, SlnEditorToolbarComponent };
export type { ICustomClass, IEditorConfig, UploadResponse };
