import * as slate_dom from 'slate-dom';
import { DOMEditor, DOMNode, DOMElement, DOMPoint, DOMRange, DOMStaticRange, DOMSelection, DOMText } from 'slate-dom';
import * as slate from 'slate';
import { Descendant, Range as Range$1, Node, Editor, NodeEntry, Point, Element as Element$1, Path, Text, LeafPosition, Ancestor, BaseRange, Selection as Selection$1 } from 'slate';
import * as i0 from '@angular/core';
import { Injector, ViewContainerRef, TemplateRef, OnInit, OnChanges, OnDestroy, AfterViewChecked, DoCheck, ElementRef, Renderer2, ChangeDetectorRef, NgZone, SimpleChanges } from '@angular/core';
import { Subject } from 'rxjs';
import * as i1 from '@angular/common';

declare enum SlateErrorCode {
    ToNativeSelectionError = 2100,
    ToSlateSelectionError = 2101,
    OnDOMBeforeInputError = 2102,
    OnSyntheticBeforeInputError = 2103,
    OnDOMKeydownError = 2104,
    GetStartPointError = 2105,
    NotFoundPreviousRootNodeError = 3100,
    InvalidValueError = 4100
}
interface SlateError {
    code?: SlateErrorCode | number;
    name?: string;
    nativeError?: Error;
    data?: Descendant[];
}

interface CustomDOMEditor extends DOMEditor {
    hasEditableTarget: (editor: CustomDOMEditor, target: EventTarget | null) => target is DOMNode;
    hasRange: (editor: CustomDOMEditor, range: Range$1) => boolean;
    hasSelectableTarget: (editor: CustomDOMEditor, target: EventTarget | null) => boolean;
    hasTarget: (editor: CustomDOMEditor, target: EventTarget | null) => target is DOMNode;
    insertData: (data: DataTransfer) => void;
    insertFragmentData: (data: DataTransfer) => boolean;
    insertTextData: (data: DataTransfer) => boolean;
    isTargetInsideNonReadonlyVoid: (editor: CustomDOMEditor, target: EventTarget | null) => boolean;
    setFragmentData: (data: DataTransfer, originEvent?: 'drag' | 'copy' | 'cut') => void;
}
declare const CustomDOMEditor: {
    isNodeInEditor(editor: CustomDOMEditor, node: Node): boolean;
    isLeafInEditor(editor: CustomDOMEditor, leafNode: DOMElement): boolean;
    /**
     * Check if the editor is hanging right.
     */
    isBlockHangingRight(editor: Editor): boolean;
    isBlockCardLeftCursor(editor: Editor): boolean;
    isBlockCardRightCursor(editor: Editor): boolean;
    getCardCursorNode(editor: AngularEditor, blockCardNode: Node, options: {
        direction: "left" | "right" | "center";
    }): ChildNode;
    toSlateCardEntry(editor: AngularEditor, node: DOMNode): NodeEntry;
    androidPendingDiffs: (editor: Editor) => slate_dom.TextDiff[] | undefined;
    androidScheduleFlush: (editor: Editor) => void;
    blur: (editor: DOMEditor) => void;
    deselect: (editor: DOMEditor) => void;
    findDocumentOrShadowRoot: (editor: DOMEditor) => Document | ShadowRoot;
    findEventRange: (editor: DOMEditor, event: any) => Range$1;
    findKey: (editor: DOMEditor, node: Node) => slate_dom.Key;
    findPath: (editor: DOMEditor, node: Node) => slate.Path;
    focus: (editor: DOMEditor, options?: {
        retries: number;
    }) => void;
    getWindow: (editor: DOMEditor) => Window;
    hasDOMNode: (editor: DOMEditor, target: DOMNode, options?: {
        editable?: boolean;
    }) => boolean;
    hasEditableTarget: (editor: DOMEditor, target: EventTarget | null) => target is DOMNode;
    hasRange: (editor: DOMEditor, range: Range$1) => boolean;
    hasSelectableTarget: (editor: DOMEditor, target: EventTarget | null) => boolean;
    hasTarget: (editor: DOMEditor, target: EventTarget | null) => target is DOMNode;
    insertData: (editor: DOMEditor, data: DataTransfer) => void;
    insertFragmentData: (editor: DOMEditor, data: DataTransfer) => boolean;
    insertTextData: (editor: DOMEditor, data: DataTransfer) => boolean;
    isComposing: (editor: DOMEditor) => boolean;
    isFocused: (editor: DOMEditor) => boolean;
    isReadOnly: (editor: DOMEditor) => boolean;
    isTargetInsideNonReadonlyVoid: (editor: DOMEditor, target: EventTarget | null) => boolean;
    setFragmentData: (editor: DOMEditor, data: DataTransfer, originEvent?: "drag" | "copy" | "cut") => void;
    toDOMNode: (editor: DOMEditor, node: Node) => HTMLElement;
    toDOMPoint: (editor: DOMEditor, point: Point) => DOMPoint;
    toDOMRange: (editor: DOMEditor, range: Range$1) => DOMRange;
    toSlateNode: (editor: DOMEditor, domNode: DOMNode) => Node;
    toSlatePoint: <T extends boolean>(editor: DOMEditor, domPoint: DOMPoint, options: {
        exactMatch: boolean;
        suppressThrow: T;
        searchDirection?: "forward" | "backward";
    }) => T extends true ? Point | null : Point;
    toSlateRange: <T extends boolean>(editor: DOMEditor, domRange: DOMRange | DOMStaticRange | DOMSelection, options: {
        exactMatch: boolean;
        suppressThrow: T;
    }) => T extends true ? Range$1 | null : Range$1;
};

interface ClipboardData {
    files?: File[];
    elements?: Element$1[];
    text?: string;
    html?: string;
}
type OriginEvent = 'drag' | 'copy' | 'cut';

/**
 * An Angular and DOM-specific version of the `Editor` interface.
 */
interface AngularEditor extends CustomDOMEditor {
    deleteCutData: () => void;
    selectAll: () => void;
    isVisible: (element: Element$1) => boolean;
    getAllVisibleStates: () => boolean[];
    onKeydown: (event: KeyboardEvent) => void;
    onClick: (event: MouseEvent) => void;
    injector: Injector;
    isBlockCard: (node: Node) => boolean;
    isExpanded: (node: Element$1) => boolean;
    isFloating: (node: Element$1) => boolean;
    getRoughHeight: (node: Element$1, defaultHeight?: number) => number;
    onError: (errorData: SlateError) => void;
    customInsertFragmentData: (data: DataTransfer, clipboardData: ClipboardData | null) => Promise<boolean>;
    customInsertTextData: (data: DataTransfer) => Promise<boolean>;
}
declare const AngularEditor: {
    /**
     * handle editor error.
     */
    onError(errorData: SlateError): void;
    /**
     * onKeydown hook.
     */
    onKeydown(editor: AngularEditor, data: KeyboardEvent): void;
    /**
     * onClick hook.
     */
    onClick(editor: AngularEditor, data: MouseEvent): void;
    deleteCutData(editor: AngularEditor): void;
    isLeafBlock(editor: AngularEditor, node: Node): boolean;
    /**
     * move native selection to card-left or card-right
     * @param editor
     * @param blockCardNode
     * @param options
     */
    moveBlockCard(editor: AngularEditor, blockCardNode: Node, options: {
        direction: "left" | "right";
    }): void;
    /**
     * move slate selection to card-left or card-right
     * @param editor
     * @param path
     * @param options
     */
    moveBlockCardCursor(editor: AngularEditor, path: Path, options: {
        direction: "left" | "right";
    }): void;
    focus: (editor: any, options?: {
        retries: number;
    }) => void;
    isEnabledVirtualScroll(editor: AngularEditor): boolean;
    isNodeInEditor(editor: CustomDOMEditor, node: Node): boolean;
    isLeafInEditor(editor: CustomDOMEditor, leafNode: globalThis.Element): boolean;
    isBlockHangingRight(editor: Editor): boolean;
    isBlockCardLeftCursor(editor: Editor): boolean;
    isBlockCardRightCursor(editor: Editor): boolean;
    getCardCursorNode(editor: AngularEditor, blockCardNode: Node, options: {
        direction: "left" | "right" | "center";
    }): ChildNode;
    toSlateCardEntry(editor: AngularEditor, node: globalThis.Node): slate.NodeEntry;
    androidPendingDiffs: (editor: Editor) => slate_dom.TextDiff[] | undefined;
    androidScheduleFlush: (editor: Editor) => void;
    blur: (editor: DOMEditor) => void;
    deselect: (editor: DOMEditor) => void;
    findDocumentOrShadowRoot: (editor: DOMEditor) => Document | ShadowRoot;
    findEventRange: (editor: DOMEditor, event: any) => slate.Range;
    findKey: (editor: DOMEditor, node: Node) => slate_dom.Key;
    findPath: (editor: DOMEditor, node: Node) => Path;
    getWindow: (editor: DOMEditor) => Window;
    hasDOMNode: (editor: DOMEditor, target: globalThis.Node, options?: {
        editable?: boolean;
    }) => boolean;
    hasEditableTarget: (editor: DOMEditor, target: EventTarget | null) => target is globalThis.Node;
    hasRange: (editor: DOMEditor, range: slate.Range) => boolean;
    hasSelectableTarget: (editor: DOMEditor, target: EventTarget | null) => boolean;
    hasTarget: (editor: DOMEditor, target: EventTarget | null) => target is globalThis.Node;
    insertData: (editor: DOMEditor, data: DataTransfer) => void;
    insertFragmentData: (editor: DOMEditor, data: DataTransfer) => boolean;
    insertTextData: (editor: DOMEditor, data: DataTransfer) => boolean;
    isComposing: (editor: DOMEditor) => boolean;
    isFocused: (editor: DOMEditor) => boolean;
    isReadOnly: (editor: DOMEditor) => boolean;
    isTargetInsideNonReadonlyVoid: (editor: DOMEditor, target: EventTarget | null) => boolean;
    setFragmentData: (editor: DOMEditor, data: DataTransfer, originEvent?: "drag" | "copy" | "cut") => void;
    toDOMNode: (editor: DOMEditor, node: Node) => HTMLElement;
    toDOMPoint: (editor: DOMEditor, point: slate.Point) => slate_dom.DOMPoint;
    toDOMRange: (editor: DOMEditor, range: slate.Range) => Range;
    toSlateNode: (editor: DOMEditor, domNode: globalThis.Node) => Node;
    toSlatePoint: <T extends boolean>(editor: DOMEditor, domPoint: slate_dom.DOMPoint, options: {
        exactMatch: boolean;
        suppressThrow: T;
        searchDirection?: "forward" | "backward";
    }) => T extends true ? slate.Point | null : slate.Point;
    toSlateRange: <T extends boolean>(editor: DOMEditor, domRange: Range | StaticRange | Selection, options: {
        exactMatch: boolean;
        suppressThrow: T;
    }) => T extends true ? slate.Range | null : slate.Range;
};

declare const withAngular: <T extends Editor>(editor: T, clipboardFormatKey?: string) => T & AngularEditor;

interface SlateViewContext<T extends AngularEditor = AngularEditor> {
    editor: T;
    trackBy: (element: Element$1) => any;
    renderElement?: (element: Element$1) => ViewType;
    renderLeaf?: (text: Text) => ViewType;
    renderText?: (text: Text) => ViewType;
    isStrictDecorate: boolean;
}
interface SlateChildrenContext {
    parent: Ancestor;
    selection: Range$1;
    decorations: Range$1[];
    decorate: (entry: NodeEntry) => Range$1[];
    readonly: boolean;
}
interface SlateElementContext<T extends Element$1 = Element$1> {
    element: T;
    selection: Range$1 | null;
    decorations: Range$1[];
    attributes: SlateElementAttributes;
    contentEditable?: boolean;
    decorate: (entry: NodeEntry) => Range$1[];
    readonly: boolean;
}
interface SlateTextContext<T extends Text = Text> {
    text: T;
    decorations: Range$1[];
    isLast: boolean;
    parent: Element$1;
}
interface SlateLeafContext {
    leaf: Text;
    leafPosition?: LeafPosition;
    text: Text;
    parent: Element$1;
    isLast: boolean;
    index: number;
}
interface SlateElementAttributes {
    'data-slate-node': 'element';
    'data-slate-void'?: boolean;
    'data-slate-inline'?: boolean;
    'data-slate-key'?: string;
    dir?: 'rtl';
}
interface SlateStringContext {
    text: string;
    elementStringLength: number;
    type: 'string' | 'lineBreakEmptyString';
}

declare abstract class BaseFlavour<T = SlateTextContext | SlateLeafContext | SlateElementContext, K extends AngularEditor = AngularEditor> {
    static isFlavour: boolean;
    initialized: boolean;
    protected _context: T;
    viewContainerRef: ViewContainerRef;
    set context(value: T);
    get context(): T;
    viewContext: SlateViewContext<K>;
    get editor(): K;
    nativeElement: HTMLElement;
    abstract onContextChange(): any;
    abstract onInit(): any;
    abstract onDestroy(): any;
    abstract render(): any;
    abstract rerender(): any;
}

interface ComponentType<T> {
    new (...args: any[]): T;
}
type ViewType = TemplateRef<any> | ComponentType<any> | BaseFlavour;

interface SlatePlaceholder extends BaseRange {
    placeholder: string;
}

interface SlateVirtualScrollConfig {
    enabled?: boolean;
    scrollContainer?: HTMLElement;
    scrollTop: number;
}
interface VirtualViewResult {
    inViewportChildren: Element$1[];
    inViewportIndics: number[];
    top: number;
    bottom: number;
    heights: number[];
}

type SafeAny = any;

declare const SLATE_BLOCK_CARD_CLASS_NAME = "slate-block-card";
declare class SlateBlockCard {
    centerRootNodes: HTMLElement[];
    nativeElement: HTMLElement;
    centerContainer: HTMLElement;
    onInit(): void;
    createContent(): void;
    append(): void;
    initializeCenter(rootNodes: HTMLElement[]): void;
    onDestroy(): void;
}
declare const getBlockCardByNativeElement: (nativeElement: HTMLElement) => HTMLElement;

declare class FlavourRef {
    instance: BaseFlavour;
    destroy(): void;
}
declare class BlockCardRef {
    instance: SlateBlockCard;
    destroy(): void;
}

declare class ListRender {
    private viewContext;
    private viewContainerRef;
    private getOutletParent;
    private getOutletElement;
    private children;
    private views;
    private blockCards;
    private contexts;
    private viewTypes;
    private differ;
    initialized: boolean;
    private preRenderingHTMLElement;
    private virtualTopHeightElement;
    constructor(viewContext: SlateViewContext, viewContainerRef: ViewContainerRef, getOutletParent: () => HTMLElement, getOutletElement: () => HTMLElement | null);
    initialize(children: Descendant[], parent: Ancestor, childrenContext: SlateChildrenContext, preRenderingCount?: number, childrenIndics?: number[]): void;
    update(children: Descendant[], parent: Ancestor, childrenContext: SlateChildrenContext, preRenderingCount?: number, childrenIndics?: number[]): void;
    destroy(): void;
}

declare class RemeasureConfig {
    indics: number[];
    tryUpdateViewport: boolean;
}
declare class SlateEditable implements OnInit, OnChanges, OnDestroy, AfterViewChecked, DoCheck {
    viewContext: SlateViewContext;
    context: SlateChildrenContext;
    private destroy$;
    isComposing: boolean;
    isDraggingInternally: boolean;
    isUpdatingSelection: boolean;
    latestElement: DOMElement | null;
    protected manualListeners: (() => void)[];
    private initialized;
    private onTouchedCallback;
    private onChangeCallback;
    editor: AngularEditor;
    renderElement: (element: Element$1) => ViewType | null;
    renderLeaf: (text: Text) => ViewType | null;
    renderText: (text: Text) => ViewType | null;
    decorate: (entry: NodeEntry) => Range$1[];
    placeholderDecorate: (editor: Editor) => SlatePlaceholder[];
    scrollSelectionIntoView: (editor: AngularEditor, domRange: DOMRange) => void;
    isStrictDecorate: boolean;
    trackBy: (node: Element$1) => any;
    readonly: boolean;
    placeholder: string;
    set virtualScroll(config: SlateVirtualScrollConfig);
    beforeInput: (event: Event) => void;
    blur: (event: Event) => void;
    click: (event: MouseEvent) => void;
    compositionEnd: (event: CompositionEvent) => void;
    compositionUpdate: (event: CompositionEvent) => void;
    compositionStart: (event: CompositionEvent) => void;
    copy: (event: ClipboardEvent) => void;
    cut: (event: ClipboardEvent) => void;
    dragOver: (event: DragEvent) => void;
    dragStart: (event: DragEvent) => void;
    dragEnd: (event: DragEvent) => void;
    drop: (event: DragEvent) => void;
    focus: (event: Event) => void;
    keydown: (event: KeyboardEvent) => void;
    paste: (event: ClipboardEvent) => void;
    spellCheck: boolean;
    autoCorrect: boolean;
    autoCapitalize: boolean;
    dataSlateEditor: boolean;
    dataSlateNode: string;
    dataGramm: boolean;
    get hasBeforeInputSupport(): boolean;
    viewContainerRef: ViewContainerRef;
    getOutletParent: () => any;
    getOutletElement: () => HTMLElement;
    listRender: ListRender;
    private virtualScrollConfig;
    private inViewportChildren;
    private inViewportIndics;
    private keyHeightMap;
    private tryUpdateVirtualViewportAnimId;
    private editorResizeObserver?;
    private editorScrollContainerResizeObserver?;
    indicsOfNeedRemeasured$: Subject<RemeasureConfig>;
    virtualScrollInitialized: boolean;
    virtualTopHeightElement: HTMLElement;
    virtualBottomHeightElement: HTMLElement;
    virtualCenterOutlet: HTMLElement;
    elementRef: ElementRef<any>;
    renderer2: Renderer2;
    cdr: ChangeDetectorRef;
    ngZone: NgZone;
    injector: Injector;
    constructor();
    ngOnInit(): void;
    ngOnChanges(simpleChanges: SimpleChanges): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    writeValue(value: Element$1[]): void;
    initialize(): void;
    private isEnabledVirtualScroll;
    initializeVirtualScroll(): void;
    getChangedIndics(previousValue: Descendant[]): any[];
    setVirtualSpaceHeight(topHeight: number, bottomHeight?: number): void;
    setTopHeightDebugInfo(accumulatedHeight: number, accumulatedEndIndex: number): void;
    getActualVirtualTopHeight(): number;
    appendPreRenderingToViewport(visibleStates: boolean[]): {
        preRenderingCount: number;
        childrenWithPreRendering: slate.BaseElement[];
        childrenWithPreRenderingIndics: number[];
    };
    calculateIndicsStartAndEndBySelection(): {
        minStartIndex: number;
        minEndIndex: number;
    };
    private tryUpdateVirtualViewport;
    private calculateVirtualViewport;
    private applyVirtualView;
    private diffVirtualViewport;
    private addEventListener;
    calculateVirtualScrollSelection(selection: Selection$1): slate.BaseRange;
    private isSelectionInvisible;
    toNativeSelection(autoScroll?: boolean): void;
    onChange(): void;
    ngAfterViewChecked(): void;
    ngDoCheck(): void;
    forceRender(): void;
    render(): void;
    updateListRenderAndRemeasureHeights(origin: 'render' | 'forceRender'): void;
    updateContext(): boolean;
    initializeContext(): void;
    initializeViewContext(): void;
    composePlaceholderDecorate(editor: Editor): SlatePlaceholder[];
    generateDecorations(): slate.BaseRange[];
    private toSlateSelection;
    private onDOMBeforeInput;
    private onDOMBlur;
    private onDOMClick;
    private onDOMCompositionStart;
    private onDOMCompositionUpdate;
    private onDOMCompositionEnd;
    private onDOMCopy;
    private onDOMCut;
    private onDOMDragOver;
    private onDOMDragStart;
    private onDOMDrop;
    private onDOMDragEnd;
    private onDOMFocus;
    private onDOMKeydown;
    private onDOMPaste;
    private onFallbackBeforeInput;
    private isDOMEventHandled;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlateEditable, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlateEditable, "slate-editable", never, { "editor": { "alias": "editor"; "required": false; }; "renderElement": { "alias": "renderElement"; "required": false; }; "renderLeaf": { "alias": "renderLeaf"; "required": false; }; "renderText": { "alias": "renderText"; "required": false; }; "decorate": { "alias": "decorate"; "required": false; }; "placeholderDecorate": { "alias": "placeholderDecorate"; "required": false; }; "scrollSelectionIntoView": { "alias": "scrollSelectionIntoView"; "required": false; }; "isStrictDecorate": { "alias": "isStrictDecorate"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; }; "beforeInput": { "alias": "beforeInput"; "required": false; }; "blur": { "alias": "blur"; "required": false; }; "click": { "alias": "click"; "required": false; }; "compositionEnd": { "alias": "compositionEnd"; "required": false; }; "compositionUpdate": { "alias": "compositionUpdate"; "required": false; }; "compositionStart": { "alias": "compositionStart"; "required": false; }; "copy": { "alias": "copy"; "required": false; }; "cut": { "alias": "cut"; "required": false; }; "dragOver": { "alias": "dragOver"; "required": false; }; "dragStart": { "alias": "dragStart"; "required": false; }; "dragEnd": { "alias": "dragEnd"; "required": false; }; "drop": { "alias": "drop"; "required": false; }; "focus": { "alias": "focus"; "required": false; }; "keydown": { "alias": "keydown"; "required": false; }; "paste": { "alias": "paste"; "required": false; }; "spellCheck": { "alias": "spellCheck"; "required": false; }; "autoCorrect": { "alias": "autoCorrect"; "required": false; }; "autoCapitalize": { "alias": "autoCapitalize"; "required": false; }; }, {}, never, never, true, never>;
}
declare const defaultScrollSelectionIntoView: (editor: AngularEditor, domRange: DOMRange) => void;
declare const isSelectionInsideVoid: (editor: AngularEditor) => boolean;

declare class SlateChildrenOutlet {
    elementRef: ElementRef<any>;
    getNativeElement(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlateChildrenOutlet, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlateChildrenOutlet, "slate-children-outlet", never, {}, {}, never, never, true, never>;
}

declare class LeavesRender {
    private viewContext;
    private viewContainerRef;
    private getOutletParent;
    private getOutletElement;
    private decoratedLeaves;
    private views;
    private contexts;
    private viewTypes;
    private differ;
    constructor(viewContext: SlateViewContext, viewContainerRef: ViewContainerRef, getOutletParent: () => HTMLElement, getOutletElement: () => HTMLElement);
    initialize(context: SlateTextContext): void;
    update(context: SlateTextContext): void;
    private getLeaves;
    destroy(): void;
}

declare abstract class BaseTextFlavour<T extends Text = Text> extends BaseFlavour<SlateTextContext<T>> {
    get text(): T;
    leavesRender: LeavesRender;
    getOutletParent: () => HTMLElement;
    getOutletElement: () => HTMLElement | null;
    onInit(): void;
    updateWeakMap(): void;
    onDestroy(): void;
    onContextChange(): void;
    abstract render(): any;
    abstract rerender(): any;
}

declare class DefaultTextFlavour extends BaseTextFlavour {
    render(): void;
    rerender(): void;
}
declare class VoidTextFlavour extends BaseTextFlavour {
    render(): void;
    rerender(): void;
}
declare const createText: (text: string) => {
    nativeElement: HTMLSpanElement;
};

declare class SlateModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SlateModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SlateModule, never, [typeof i1.CommonModule, typeof SlateEditable, typeof SlateChildrenOutlet], [typeof SlateEditable, typeof SlateChildrenOutlet]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SlateModule>;
}

declare enum StringType {
    'normalString' = "normalString",
    'lineBreakEmptyString' = "lineBreakEmptyString",
    'normalEmptyText' = "normalEmptyText",
    'compatibleString' = "compatibleString",
    'voidString' = "voidString"
}
declare class SlateStringRender {
    context: SlateLeafContext;
    viewContext: SlateViewContext;
    nativeElement: HTMLElement;
    constructor(context: SlateLeafContext, viewContext: SlateViewContext);
    type: StringType;
    isEmptyText(): boolean;
    isCompatibleString(): boolean;
    isVoid(): boolean;
    get leaf(): Text;
    isLineBreakEmptyString(): boolean;
    createStringNode(type: StringType): HTMLElement;
    render(): HTMLElement;
    getType(): StringType;
    update(context: SlateLeafContext, viewContext: SlateViewContext): void;
    getElementStringLength(): number;
}

/**
 * base class for template
 */
interface BaseEmbeddedView<T, K extends AngularEditor = AngularEditor> {
    context: T;
    viewContext: SlateViewContext<K>;
}
/**
 * base class for custom element component or text component
 */
declare abstract class BaseComponent<T = SlateTextContext | SlateLeafContext | SlateElementContext, K extends AngularEditor = AngularEditor> {
    initialized: boolean;
    protected _context: T;
    set context(value: T);
    get context(): T;
    viewContext: SlateViewContext<K>;
    get editor(): K;
    get nativeElement(): HTMLElement;
    elementRef: ElementRef<any>;
    cdr: ChangeDetectorRef;
    abstract onContextChange(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseComponent<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseComponent<any, any>, never, never, { "context": { "alias": "context"; "required": false; }; "viewContext": { "alias": "viewContext"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * base class for custom element component
 */
declare class BaseElementComponent<T extends Element$1 = Element$1, K extends AngularEditor = AngularEditor> extends BaseComponent<SlateElementContext<T>, K> implements OnInit, OnDestroy {
    viewContainerRef: ViewContainerRef;
    childrenContext: SlateChildrenContext;
    childrenOutletInstance?: SlateChildrenOutlet;
    get element(): T;
    get selection(): Range$1;
    get decorations(): Range$1[];
    get children(): Descendant[];
    get isCollapsed(): boolean;
    get isCollapsedAndNonReadonly(): boolean;
    get readonly(): boolean;
    getOutletParent: () => any;
    getOutletElement: () => any;
    listRender: ListRender;
    ngOnInit(): void;
    afterViewInit(): void;
    updateWeakMap(): void;
    ngOnDestroy(): void;
    onContextChange(): void;
    updateChildrenView(): void;
    getChildrenContext(): SlateChildrenContext;
    calcHeight(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseElementComponent<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseElementComponent<any, any>, never, never, {}, {}, never, never, true, never>;
}
/**
 * base class for custom text component
 */
declare class BaseTextComponent<T extends Text = Text> extends BaseComponent<SlateTextContext<T>> implements OnInit, OnDestroy {
    viewContainerRef: ViewContainerRef;
    get text(): T;
    leavesRender: LeavesRender;
    childrenOutletInstance?: SlateChildrenOutlet;
    getOutletParent: () => any;
    getOutletElement: () => any;
    ngOnInit(): void;
    updateWeakMap(): void;
    ngOnDestroy(): void;
    onContextChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTextComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseTextComponent<any>, never, never, {}, {}, never, never, true, never>;
}
/**
 * base class for custom leaf component
 */
declare class BaseLeafComponent extends BaseComponent<SlateLeafContext> implements OnInit {
    placeholderElement: HTMLSpanElement;
    stringRender: SlateStringRender | null;
    isSlateLeaf: boolean;
    get text(): Text;
    get leaf(): Text;
    getOutletParent: () => any;
    ngOnInit(): void;
    onContextChange(): void;
    renderPlaceholder(): void;
    createPlaceholder(): void;
    updatePlaceholder(): void;
    destroyPlaceholder(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseLeafComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseLeafComponent, never, never, {}, {}, never, never, true, never>;
}

declare const DEFAULT_ELEMENT_HEIGHT = 24;
declare abstract class BaseElementFlavour<T extends Element$1 = Element$1, K extends AngularEditor = AngularEditor> extends BaseFlavour<SlateElementContext<T>, K> {
    childrenContext: SlateChildrenContext;
    get element(): T;
    get selection(): Range$1;
    get decorations(): Range$1[];
    get children(): Descendant[];
    get isCollapsed(): boolean;
    get isCollapsedAndNonReadonly(): boolean;
    get readonly(): boolean;
    getOutletParent: () => HTMLElement;
    getOutletElement: () => HTMLElement | null;
    listRender: ListRender;
    onInit(): void;
    afterViewInit(): void;
    updateWeakMap(): void;
    onDestroy(): void;
    onContextChange(): void;
    updateChildrenView(): void;
    getChildrenContext(): SlateChildrenContext;
    calcHeight(): number;
    abstract render(): void;
    abstract rerender(): void;
}

declare abstract class BaseLeafFlavour extends BaseFlavour<SlateLeafContext> {
    placeholderElement: HTMLSpanElement;
    get text(): Text;
    get leaf(): Text;
    onInit(): void;
    onContextChange(): void;
    renderPlaceholder(): void;
    createPlaceholder(): void;
    updatePlaceholder(): void;
    destroyPlaceholder(): void;
    onDestroy(): void;
    abstract render(): any;
    abstract rerender(): any;
}

interface BeforeContextChange<T> {
    beforeContextChange: (value: T) => void;
}
interface AfterContextChange {
    afterContextChange: () => void;
}
type BeforeDomMoveOrigin = 'move' | 'virtual-scroll';
interface BeforeDomMove {
    beforeDomMove: (origin: BeforeDomMoveOrigin) => void;
}
interface BeforeDomMoveRef {
    instance: {
        beforeDomMove: (origin: BeforeDomMoveOrigin) => void;
    };
}
declare function hasBeforeContextChange<T>(value: any): value is BeforeContextChange<T>;
declare function hasAfterContextChange<T>(value: any): value is AfterContextChange;
declare function hasBeforeDomMove(value: any): value is BeforeDomMoveRef;

/**
 * Symbols.
 */
declare const PLACEHOLDER_SYMBOL: string;
/**
 * Weak map for associating the html element with the component.
 */
declare const ELEMENT_TO_COMPONENT: WeakMap<Node, BaseElementComponent | BaseFlavour>;
declare const EDITOR_TO_VIRTUAL_SCROLL_SELECTION: WeakMap<slate.BaseEditor, slate.BaseRange>;
declare const EDITOR_TO_AFTER_VIEW_INIT_QUEUE: WeakMap<Editor, (() => void)[]>;

/**
 * Hotkeys.
 */
declare const hotkeys: {
    isBold: (event: KeyboardEvent) => boolean;
    isCompose: (event: KeyboardEvent) => boolean;
    isMoveBackward: (event: KeyboardEvent) => boolean;
    isMoveForward: (event: KeyboardEvent) => boolean;
    isMoveUp: (event: KeyboardEvent) => boolean;
    isMoveDown: (event: KeyboardEvent) => boolean;
    isDeleteBackward: (event: KeyboardEvent) => boolean;
    isDeleteForward: (event: KeyboardEvent) => boolean;
    isDeleteLineBackward: (event: KeyboardEvent) => boolean;
    isDeleteLineForward: (event: KeyboardEvent) => boolean;
    isDeleteWordBackward: (event: KeyboardEvent) => boolean;
    isDeleteWordForward: (event: KeyboardEvent) => boolean;
    isExtendBackward: (event: KeyboardEvent) => boolean;
    isExtendForward: (event: KeyboardEvent) => boolean;
    isExtendLineBackward: (event: KeyboardEvent) => boolean;
    isExtendLineForward: (event: KeyboardEvent) => boolean;
    isItalic: (event: KeyboardEvent) => boolean;
    isMoveLineBackward: (event: KeyboardEvent) => boolean;
    isMoveLineForward: (event: KeyboardEvent) => boolean;
    isMoveWordBackward: (event: KeyboardEvent) => boolean;
    isMoveWordForward: (event: KeyboardEvent) => boolean;
    isRedo: (event: KeyboardEvent) => boolean;
    isSplitBlock: (event: KeyboardEvent) => boolean;
    isTransposeCharacter: (event: KeyboardEvent) => boolean;
    isUndo: (event: KeyboardEvent) => boolean;
};

declare function isTemplateRef<C>(value: ViewType): value is TemplateRef<C>;
declare function isComponentType<T>(value: ViewType): value is ComponentType<T>;
declare function isFlavourType<T>(value: ViewType): value is ComponentType<T>;

declare const IS_IOS: boolean;
declare const IS_APPLE: boolean;
declare const IS_ANDROID: boolean;
declare const IS_FIREFOX: boolean;
declare const IS_SAFARI: boolean;
declare const IS_EDGE_LEGACY: boolean;
declare const IS_CHROME: boolean;
declare const IS_CHROME_LEGACY: boolean;
declare const IS_FIREFOX_LEGACY: boolean;
declare const IS_QQBROWSER: boolean;
declare const IS_UC_MOBILE: boolean;
declare const IS_WECHATBROWSER: boolean;
declare const HAS_BEFORE_INPUT_SUPPORT: boolean;
declare const VIRTUAL_SCROLL_DEFAULT_BLOCK_HEIGHT = 32;
declare const SLATE_DEBUG_KEY = "__SLATE_DEBUG__";
declare const SLATE_DEBUG_KEY_SCROLL_TOP = "__SLATE_DEBUG_SCROLL_TOP__";
declare const SLATE_DEBUG_KEY_UPDATE = "__SLATE_DEBUG_UPDATE__";

declare const shallowCompare: (obj1: {}, obj2: {}) => boolean;
/**
 * Check if a list of decorator ranges are equal to another.
 *
 * PERF: this requires the two lists to also have the ranges inside them in the
 * same order, but this is an okay constraint for us since decorations are
 * kept in order, and the odd case where they aren't is okay to re-render for.
 */
declare const isDecoratorRangeListEqual: (list: Range$1[], another: Range$1[]) => boolean;

declare const FAKE_LEFT_BLOCK_CARD_OFFSET = -1;
declare const FAKE_RIGHT_BLOCK_CARD_OFFSET = -2;
declare function hasBlockCardWithNode(node: DOMNode): boolean;
declare function hasBlockCard(selection: DOMSelection): boolean;
declare function getCardTargetAttribute(node: DOMNode): any;
declare function isCardLeft(node: DOMNode): boolean;
declare function isCardLeftByTargetAttr(targetAttr: any): boolean;
declare function isCardRightByTargetAttr(targetAttr: any): boolean;
declare function isCardCenterByTargetAttr(targetAttr: any): boolean;

declare const isValid: (value: Descendant) => any;
declare const check: (document: Element$1[]) => boolean;
declare function normalize(document: Element$1[]): slate.BaseElement[];

declare const createThrottleRAF: () => (fn: () => void) => void;
type ThrottleRAF = (fn: () => void) => void;

declare const buildHTMLText: (wrapper: HTMLElement, attach: HTMLElement, data: Element$1[]) => string;
declare const getClipboardFromHTMLText: (html: string) => ClipboardData;
declare const createClipboardData: (html: string, elements: Element$1[], text: string, files: File[]) => ClipboardData;
declare const getClipboardData: (dataTransfer?: DataTransfer) => Promise<ClipboardData>;
/**
 * @param wrapper get wrapper.innerHTML string which will be written in clipboard
 * @param attach attach must be child element of wrapper which will be attached json data
 * @returns void
 */
declare const setClipboardData: (clipboardData: ClipboardData, wrapper: HTMLElement, attach: HTMLElement, dataTransfer?: Pick<DataTransfer, "getData" | "setData">) => Promise<void>;
declare const fallbackCopyText: (text: string) => Promise<void>;

declare const setDataTransferClipboard: (dataTransfer: Pick<DataTransfer, "getData" | "setData"> | null, htmlText: string) => void;
declare const setDataTransferClipboardText: (data: Pick<DataTransfer, "getData" | "setData"> | null, text: string) => void;
declare const getDataTransferClipboard: (data: Pick<DataTransfer, "getData" | "setData"> | null) => ClipboardData;
declare const getDataTransferClipboardText: (data: Pick<DataTransfer, "getData" | "setData"> | null) => ClipboardData;

declare const setNavigatorClipboard: (htmlText: string, data: Element$1[], text?: string) => Promise<void>;
declare const getNavigatorClipboard: () => Promise<ClipboardData>;

declare const isClipboardReadSupported: () => boolean;
declare const isClipboardWriteSupported: () => boolean;
declare const isClipboardWriteTextSupported: () => boolean;
declare const isClipboardFile: (item: ClipboardItem) => string;
declare const isInvalidTable: (nodes?: Element[]) => boolean;
declare const stripHtml: (html: string) => string;
declare const blobAsString: (blob: Blob) => Promise<string>;
declare const completeTable: (fragment: DocumentFragment) => DocumentFragment;

declare const SlateFragmentAttributeKey = "data-slate-angular-fragment";
declare const getSlateFragmentAttribute: (htmlData: string) => string | void;
/**
 * Check if a DOM node is an element node.
 */
declare const isDOMText: (value: any) => value is DOMText;
/**
 * Get a plaintext representation of the content of a node, accounting for block
 * elements which get a newline appended.
 *
 * The domNode must be attached to the DOM.
 */
declare const getPlainText: (domNode: DOMNode) => string;
/**
 * Get the dom selection from Shadow Root if possible, otherwise from the document
 */
declare const getSelection: (root: Document | ShadowRoot) => Selection | null;
declare const getContentHeight: (element: Element) => number;
declare const getZeroTextNode: () => DOMText;

declare const VIRTUAL_TOP_HEIGHT_CLASS_NAME = "virtual-top-height";
declare const VIRTUAL_BOTTOM_HEIGHT_CLASS_NAME = "virtual-bottom-height";
declare const VIRTUAL_CENTER_OUTLET_CLASS_NAME = "virtual-center-outlet";
declare const isDebug: boolean;
declare const isDebugScrollTop: boolean;
declare const isDebugUpdate: boolean;
declare const ELEMENT_KEY_TO_HEIGHTS: WeakMap<AngularEditor, Map<string, number>>;
declare const EDITOR_TO_BUSINESS_TOP: WeakMap<AngularEditor, number>;
declare const EDITOR_TO_VIRTUAL_SCROLL_CONFIG: WeakMap<AngularEditor, SlateVirtualScrollConfig>;
declare const EDITOR_TO_VIEWPORT_HEIGHT: WeakMap<AngularEditor, number>;
declare const EDITOR_TO_ROOT_NODE_WIDTH: WeakMap<AngularEditor, number>;
declare const EDITOR_TO_IS_FROM_SCROLL_TO: WeakMap<AngularEditor, boolean>;
declare const isValidNumber: (value: any) => boolean;
declare const debugLog: (type: "log" | "warn", ...args: any[]) => void;
declare const cacheHeightByElement: (editor: AngularEditor, element: Element$1, height: number) => void;
declare const setMinHeightByElement: (editor: AngularEditor, element: Element$1, rootElementMarginBottom: any) => void;
declare const clearMinHeightByElement: (editor: AngularEditor, element: Element$1) => boolean;
declare const calcHeightByElement: (editor: AngularEditor, element: Element$1) => number;
declare const measureHeightByIndics: (editor: AngularEditor, indics: number[], source: "need-remove-from-top" | "need-add-from-top" | "data-changed") => boolean;
declare const getBusinessTop: (editor: AngularEditor) => number;
declare const getViewportHeight: (editor: AngularEditor) => number;
declare const getScrollContainer: (editor: AngularEditor) => HTMLElement;
declare const getCachedHeightByElement: (editor: AngularEditor, element: Element$1) => number;
declare const buildHeightsAndAccumulatedHeights: (editor: AngularEditor, visibleStates: boolean[]) => {
    heights: any[];
    accumulatedHeights: any[];
};
declare const calculateAccumulatedTopHeight: (editor: AngularEditor, startIndex: number, visibleStates: boolean[]) => number;
declare const calcBusinessTop: (editor: AngularEditor) => number;
declare const scrollToElement: (editor: AngularEditor, element: Element$1, scrollTo: (scrollTop: number) => void) => void;

declare const roundTo: (value: number, precision?: number) => number;

export { AngularEditor, BaseComponent, BaseElementComponent, BaseElementFlavour, BaseFlavour, BaseLeafComponent, BaseLeafFlavour, BaseTextComponent, BaseTextFlavour, BlockCardRef, DEFAULT_ELEMENT_HEIGHT, DefaultTextFlavour, EDITOR_TO_AFTER_VIEW_INIT_QUEUE, EDITOR_TO_BUSINESS_TOP, EDITOR_TO_IS_FROM_SCROLL_TO, EDITOR_TO_ROOT_NODE_WIDTH, EDITOR_TO_VIEWPORT_HEIGHT, EDITOR_TO_VIRTUAL_SCROLL_CONFIG, EDITOR_TO_VIRTUAL_SCROLL_SELECTION, ELEMENT_KEY_TO_HEIGHTS, ELEMENT_TO_COMPONENT, FAKE_LEFT_BLOCK_CARD_OFFSET, FAKE_RIGHT_BLOCK_CARD_OFFSET, FlavourRef, HAS_BEFORE_INPUT_SUPPORT, IS_ANDROID, IS_APPLE, IS_CHROME, IS_CHROME_LEGACY, IS_EDGE_LEGACY, IS_FIREFOX, IS_FIREFOX_LEGACY, IS_IOS, IS_QQBROWSER, IS_SAFARI, IS_UC_MOBILE, IS_WECHATBROWSER, PLACEHOLDER_SYMBOL, SLATE_BLOCK_CARD_CLASS_NAME, SLATE_DEBUG_KEY, SLATE_DEBUG_KEY_SCROLL_TOP, SLATE_DEBUG_KEY_UPDATE, SlateBlockCard, SlateChildrenOutlet, SlateEditable, SlateErrorCode, SlateFragmentAttributeKey, SlateModule, VIRTUAL_BOTTOM_HEIGHT_CLASS_NAME, VIRTUAL_CENTER_OUTLET_CLASS_NAME, VIRTUAL_SCROLL_DEFAULT_BLOCK_HEIGHT, VIRTUAL_TOP_HEIGHT_CLASS_NAME, VoidTextFlavour, blobAsString, buildHTMLText, buildHeightsAndAccumulatedHeights, cacheHeightByElement, calcBusinessTop, calcHeightByElement, calculateAccumulatedTopHeight, check, clearMinHeightByElement, completeTable, createClipboardData, createText, createThrottleRAF, debugLog, defaultScrollSelectionIntoView, fallbackCopyText, getBlockCardByNativeElement, getBusinessTop, getCachedHeightByElement, getCardTargetAttribute, getClipboardData, getClipboardFromHTMLText, getContentHeight, getDataTransferClipboard, getDataTransferClipboardText, getNavigatorClipboard, getPlainText, getScrollContainer, getSelection, getSlateFragmentAttribute, getViewportHeight, getZeroTextNode, hasAfterContextChange, hasBeforeContextChange, hasBeforeDomMove, hasBlockCard, hasBlockCardWithNode, hotkeys, isCardCenterByTargetAttr, isCardLeft, isCardLeftByTargetAttr, isCardRightByTargetAttr, isClipboardFile, isClipboardReadSupported, isClipboardWriteSupported, isClipboardWriteTextSupported, isComponentType, isDOMText, isDebug, isDebugScrollTop, isDebugUpdate, isDecoratorRangeListEqual, isFlavourType, isInvalidTable, isSelectionInsideVoid, isTemplateRef, isValid, isValidNumber, measureHeightByIndics, normalize, roundTo, scrollToElement, setClipboardData, setDataTransferClipboard, setDataTransferClipboardText, setMinHeightByElement, setNavigatorClipboard, shallowCompare, stripHtml, withAngular };
export type { AfterContextChange, BaseEmbeddedView, BeforeContextChange, BeforeDomMove, BeforeDomMoveOrigin, BeforeDomMoveRef, ClipboardData, ComponentType, OriginEvent, SafeAny, SlateChildrenContext, SlateElementAttributes, SlateElementContext, SlateError, SlateLeafContext, SlatePlaceholder, SlateStringContext, SlateTextContext, SlateViewContext, SlateVirtualScrollConfig, ThrottleRAF, ViewType, VirtualViewResult };