slate-angular 19.4.0-next.1 → 20.0.0

package/index.d.ts

@@ -1,5 +1,769 @@
+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 } from 'slate';
+import * as i0 from '@angular/core';
+import { Injector, ViewContainerRef, TemplateRef, OnInit, ElementRef, OnChanges, OnDestroy, AfterViewChecked, DoCheck, Renderer2, ChangeDetectorRef, NgZone, SimpleChanges } from '@angular/core';
+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';
+
 /**
- * Generated bundle index. Do not edit.
+ * An Angular and DOM-specific version of the `Editor` interface.
  */
-/// <amd-module name="slate-angular" />
-export * from './public-api';
+interface AngularEditor extends CustomDOMEditor {
+    deleteCutData: () => void;
+    onKeydown: (event: KeyboardEvent) => void;
+    onClick: (event: MouseEvent) => void;
+    injector: Injector;
+    isBlockCard: (node: Node) => boolean;
+    isExpanded: (node: Element$1) => boolean;
+    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;
+    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;
+
+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 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';
+}
+
+interface SlatePlaceholder extends BaseRange {
+    placeholder: string;
+}
+
+declare class SlateBlockCard implements OnInit {
+    private elementRef;
+    centerContainer: ElementRef;
+    centerRootNodes: HTMLElement[];
+    get nativeElement(): any;
+    get centerContainerElement(): HTMLElement;
+    constructor(elementRef: ElementRef);
+    ngOnInit(): void;
+    append(): void;
+    initializeCenter(rootNodes: HTMLElement[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateBlockCard, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateBlockCard, "slate-block-card, [slateBlockCard]", never, {}, {}, never, never, true, never>;
+}
+
+declare class FlavourRef {
+    instance: BaseFlavour;
+    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;
+    constructor(viewContext: SlateViewContext, viewContainerRef: ViewContainerRef, getOutletParent: () => HTMLElement, getOutletElement: () => HTMLElement | null);
+    initialize(children: Descendant[], parent: Ancestor, childrenContext: SlateChildrenContext): void;
+    update(children: Descendant[], parent: Ancestor, childrenContext: SlateChildrenContext): void;
+    destroy(): void;
+}
+
+declare class SlateEditable implements OnInit, OnChanges, OnDestroy, AfterViewChecked, DoCheck {
+    elementRef: ElementRef;
+    renderer2: Renderer2;
+    cdr: ChangeDetectorRef;
+    private ngZone;
+    private injector;
+    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;
+    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;
+    listRender: ListRender;
+    constructor(elementRef: ElementRef, renderer2: Renderer2, cdr: ChangeDetectorRef, ngZone: NgZone, injector: Injector);
+    ngOnInit(): void;
+    ngOnChanges(simpleChanges: SimpleChanges): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(value: Element$1[]): void;
+    initialize(): void;
+    toNativeSelection(): void;
+    onChange(): void;
+    ngAfterViewChecked(): void;
+    ngDoCheck(): void;
+    forceRender(): void;
+    render(): void;
+    updateContext(): boolean;
+    initializeContext(): void;
+    initializeViewContext(): void;
+    composePlaceholderDecorate(editor: Editor): SlatePlaceholder[];
+    generateDecorations(): slate.BaseRange[];
+    private addEventListener;
+    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; }; "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 class SlateChildrenOutlet {
+    private elementRef;
+    constructor(elementRef: ElementRef<HTMLElement>);
+    getNativeElement(): HTMLElement;
+    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;
+}
+
+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 SlateString {
+    context: SlateLeafContext;
+    viewContext: SlateViewContext;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateString, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlateString, "span[slateString]", never, { "context": { "alias": "context"; "required": false; }; "viewContext": { "alias": "viewContext"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SlateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SlateModule, never, [typeof i1.CommonModule, typeof SlateEditable, typeof SlateBlockCard, typeof SlateChildrenOutlet, typeof SlateString], [typeof SlateEditable, typeof SlateChildrenOutlet, typeof SlateString]>;
+    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: () => HTMLElement;
+    listRender: ListRender;
+    ngOnInit(): void;
+    afterViewInit(): void;
+    updateWeakMap(): void;
+    ngOnDestroy(): void;
+    onContextChange(): void;
+    updateChildrenView(): void;
+    getChildrenContext(): SlateChildrenContext;
+    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: () => HTMLElement;
+    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;
+    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 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;
+    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;
+}
+declare function hasBeforeContextChange<T>(value: any): value is BeforeContextChange<T>;
+declare function hasAfterContextChange<T>(value: any): value is AfterContextChange;
+
+/**
+ * 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_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 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;
+
+type SafeAny = any;
+
+export { AngularEditor, BaseComponent, BaseElementComponent, BaseElementFlavour, BaseFlavour, BaseLeafComponent, BaseLeafFlavour, BaseTextComponent, BaseTextFlavour, DefaultTextFlavour, EDITOR_TO_AFTER_VIEW_INIT_QUEUE, 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, SlateChildrenOutlet, SlateEditable, SlateErrorCode, SlateFragmentAttributeKey, SlateModule, SlateString, VoidTextFlavour, blobAsString, buildHTMLText, check, completeTable, createClipboardData, createText, createThrottleRAF, defaultScrollSelectionIntoView, fallbackCopyText, getCardTargetAttribute, getClipboardData, getClipboardFromHTMLText, getContentHeight, getDataTransferClipboard, getDataTransferClipboardText, getNavigatorClipboard, getPlainText, getSelection, getSlateFragmentAttribute, hasAfterContextChange, hasBeforeContextChange, hasBlockCard, hasBlockCardWithNode, hotkeys, isCardCenterByTargetAttr, isCardLeft, isCardLeftByTargetAttr, isCardRightByTargetAttr, isClipboardFile, isClipboardReadSupported, isClipboardWriteSupported, isClipboardWriteTextSupported, isComponentType, isDOMText, isDecoratorRangeListEqual, isFlavourType, isInvalidTable, isTemplateRef, isValid, normalize, setClipboardData, setDataTransferClipboard, setDataTransferClipboardText, setNavigatorClipboard, shallowCompare, stripHtml, withAngular };
+export type { AfterContextChange, BaseEmbeddedView, BeforeContextChange, ClipboardData, ComponentType, OriginEvent, SafeAny, SlateChildrenContext, SlateElementAttributes, SlateElementContext, SlateError, SlateLeafContext, SlatePlaceholder, SlateStringContext, SlateTextContext, SlateViewContext, ThrottleRAF, ViewType };