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 i33 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 i35 from '@sellan/core';
import { EventBrokerService, UploadedFile, UploaderConfig, CoreBaseDestroyComponent } from '@sellan/core';
import * as i36 from '@angular/cdk/overlay';
import { Overlay, OverlayConfig } 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 i32 from '@angular/common';
import * as i34 from '@angular/material/tabs';

declare class MonitoredEditorItems {
    selectedClassList?: string;
    selectedTableCell?: any;
    fontSize?: number;
}

interface UploadResponse {
    imageUrl: string;
}
declare class EditorService {
    doc: any;
    savedSelection: Range | null;
    selectedText: string;
    uploadUrl: string;
    parentNodeIsHref: boolean;
    uploadWithCredentials: boolean;
    monitoredItems: MonitoredEditorItems;
    constructor(doc: any);
    /**
     * Executed command from editor header buttons exclude toggleEditorMode
     * @param command string from triggerCommand
     * @param value
     */
    executeCommand(command: string, value?: string): void;
    updateMonitoredItems(): void;
    /**
     * Create URL link
     * @param url string from UI prompt
     */
    /**
     * insert color either font or background
     *
     * @param color color to be inserted
     * @param where where the color has to be inserted either text/background
     */
    insertColor(color: string, where: string): void;
    /**
     * Set font name
     * @param fontName string
     */
    setFontName(fontName: string): void;
    /**
     * Create raw HTML
     * @param html HTML string
     */
    insertHtml(html: string): void;
    /**
     * save selection when the editor is focussed out
     */
    saveSelection: () => void;
    /**
     * restore selection when the editor is focused in
     *
     * saved selection when the editor is focused out
     */
    restoreSelection(): boolean;
    /**
     * setTimeout used for execute 'saveSelection' method in next event loop iteration
     */
    executeInNextQueueIteration(callbackFn: (...args: any[]) => any, timeout?: number): void;
    setDefaultParagraphSeparator(separator: string): void;
    nextNode(node: any): any;
    getRangeSelectedNodes(range: any, includePartiallySelectedContainers: any): any[];
    getEditorData(): any;
    getSelectedNodes(): any[];
    replaceWithOwnChildren(el: any): void;
    removeSelectedElements(tagNames: any): 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[][];
    rawPaste?: 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;
    execute: EventEmitter<any>;
    htmlButton: SlnEditorButtonHtmlComponent;
    constructor(doc: any, r: Renderer2, editorService: EditorService, er: ElementRef, _eventBroker: EventBrokerService);
    editMode: boolean;
    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; }; }, { "execute": "execute"; }, never, never, false, never>;
}

declare class SlnEditorTableEditorComponent {
    private _editorService;
    constructor(_editorService: EditorService);
    deleteTable(): void;
    addRowBefore(): void;
    addRowAfter(): void;
    deleteRow(): void;
    addColumnBefore(): void;
    addColumnAfter(): void;
    deleteColumn(): 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;
    modeVisual: boolean;
    showPlaceholder: boolean;
    disabled: boolean;
    focused: boolean;
    touched: boolean;
    changed: boolean;
    focusInstance: any;
    blurInstance: any;
    settings: IToolbarSettings;
    id: string;
    config: IEditorConfig;
    placeholder: string;
    tabIndex: number | null;
    html: any;
    textArea: ElementRef;
    editorWrapper: ElementRef;
    editorToolbar: SlnEditorToolbarComponent;
    customButtonsTemplateRef?: TemplateRef<any>;
    ref: ComponentRef<SlnEditorTableEditorComponent>;
    viewMode: EventEmitter<boolean>;
    blurEvent: EventEmitter<FocusEvent>;
    focusEvent: EventEmitter<FocusEvent>;
    tabindex: number;
    onFocus(): void;
    tableEditorIsOpen: boolean;
    selectedClassList: string;
    chekerTargetNodeId: any;
    constructor(_injector: Injector, defaultTabIndex: string, autoFocus: any, doc: any, sanitizer: DomSanitizer, overlay: Overlay, r: Renderer2, _editorService: EditorService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    handleForTargetNode(): void;
    onPaste(event: ClipboardEvent): string;
    /**
     * Executed command from editor header buttons
     * @param command string from triggerCommand
     * @param value
     */
    executeCommand(command: string, value?: string): void;
    /**
     * focus event
     */
    onTextAreaFocus(event: FocusEvent): void;
    /**
     * @description fires when cursor leaves textarea
     */
    onTextAreaMouseOut(event: MouseEvent): void;
    rowCount: string;
    activeTableId: string;
    tableTargetHandler(event: any): void;
    /**
     * blur event
     */
    onTextAreaBlur(event: FocusEvent): void;
    /**
     *  focus the text area when the editor is focused
     */
    focusFn(): void;
    /**
     * Executed from the contenteditable section while the input property changes
     * @param element html element from contenteditable
     */
    onContentChange(element: HTMLElement): void;
    /**
     * Set the function to be called
     * when the control receives a change event.
     *
     * @param fn a function
     */
    registerOnChange(fn: any): void;
    /**
     * Set the function to be called
     * when the control receives a touch event.
     *
     * @param fn a function
     */
    registerOnTouched(fn: any): void;
    /**
     * Write a new value to the element.
     *
     * @param value value to be executed when there is a change in contenteditable
     */
    writeValue(value: any): void;
    /**
     * refresh view/HTML of the editor
     *
     * @param value html string from the editor
     */
    refreshView(value: string): void;
    /**
     * toggles placeholder based on input string
     *
     * @param value A HTML string from the editor
     */
    togglePlaceholder(value: boolean): void;
    /**
     * Implements disabled state for this element
     *
     * @param isDisabled Disabled flag
     */
    setDisabledState(isDisabled: boolean): void;
    /**
     * toggles editor mode based on bToSource bool
     *
     * @param bToSource A boolean value from the editor
     */
    toggleEditorMode(bToSource: boolean): void;
    /**
     * toggles editor buttons when cursor moved or positioning
     *
     * Send a node array from the contentEditable of the editor
     */
    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);
    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>;
}

declare class SlnImageDialogComponent implements OnInit {
    private _dialogRef;
    id: string;
    autoSize: boolean;
    description: string;
    address: string;
    width: number;
    height: number;
    files: UploadedFile[];
    config: UploaderConfig;
    constructor(_dialogRef: MatDialogRef<SlnImageDialogComponent>);
    ngOnInit(): void;
    onValuesChange($event: UploadedFile[]): void;
    execute(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlnImageDialogComponent, never>;
    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 {
    bar: ElementRef;
    width: number | null;
    ngAfterViewInit(): void;
    onClick(event: any): 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: any;
    private _editorService;
    docData: SafeHtml;
    constructor(_dialogRef: MatDialogRef<any>, sanitizer: DomSanitizer, data: any, _editorService: EditorService);
    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;
    /**
     *
     */
    constructor(doc: any, _dialog: MatDialog);
    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 keyManager;
    createColorBlockOpen: boolean;
    isOpen: boolean;
    template: TemplateRef<any>;
    gridCells: QueryList<ColorDirective>;
    colors: object[];
    value: object;
    isBackground: boolean;
    rowSize: number;
    valueChange: EventEmitter<object>;
    private groupedColors;
    colorChekerId: any;
    R: number;
    G: number;
    B: number;
    constructor(dir: Directionality, _editorService: EditorService);
    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;
    elRef: ElementRef;
    constructor(elRef: ElementRef, _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 {
    overlay: Overlay;
    private viewContainerRef;
    private dir;
    private _overlayRef;
    colorPicker: ColorPickerComponent;
    overlayConfig: OverlayConfig;
    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, dir: Directionality);
    private init;
    click($event: any): 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;
    apply(where: string): 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: any): void;
    clickOut(event: any): 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 {
    private _editorService;
    private _dialog;
    get isLinkButtonDisabled(): boolean;
    constructor(doc: any, _editorService: EditorService, _dialog: MatDialog);
    addImage(): void;
    private getImageSize;
    private _calculateRatioFit;
    addLink(): void;
    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;
    private _editorService;
    constructor(doc: any, _editorService: EditorService);
    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 {
    doc: any;
    private _editorService;
    listsChekerId: any;
    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;
    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;
    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;
    fontChekerId: any;
    constructor(_editorService: EditorService);
    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 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 SlnEditorButtonFontsComponent, typeof SlnEditorButtonFontSizesComponent, typeof SlnEditorComponent, typeof SlnEditorToolbarComponent, typeof SlnEditorSelectComponent], [typeof i32.CommonModule, typeof i33.FormsModule, typeof i34.MatTabsModule, typeof i35.CoreControlModule, typeof i36.OverlayModule, typeof i33.ReactiveFormsModule, typeof i35.CoreDialogModule, typeof i35.CoreUploaderModule], [typeof SlnEditorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SlnEditorModule>;
}

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