@unicom-cloud/ui 0.8.109 → 0.8.111

package/types/pc/rich-text/formats/underline.d.ts

@@ -0,0 +1,6 @@
+import Inline from '../blots/inline.js';
+declare class Underline extends Inline {
+    static blotName: string;
+    static tagName: string;
+}
+export default Underline;

package/types/pc/rich-text/formats/video.d.ts

@@ -0,0 +1,14 @@
+import { BlockEmbed } from '../blots/block.js';
+declare class Video extends BlockEmbed {
+    static blotName: string;
+    static className: string;
+    static tagName: string;
+    static create(value: string): Element;
+    static formats(domNode: Element): Record<string, string | null>;
+    static sanitize(url: string): string;
+    static value(domNode: Element): string | null;
+    domNode: HTMLVideoElement;
+    format(name: string, value: string): void;
+    html(): string;
+}
+export default Video;

package/types/pc/rich-text/index.d.ts

@@ -0,0 +1,6 @@
+import Rich from './rich';
+export * from './rich';
+export type { Bounds, DebugLevel, EmitterSource, ExpandedRichOptions, RichOptions, } from './rich';
+export { Rich };
+declare const RichText: import("react").ForwardRefExoticComponent<Omit<any, "ref"> & import("react").RefAttributes<unknown>>;
+export default RichText;

package/types/pc/rich-text/interface.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties } from 'react';
+import type { EmitterSource } from './core/emitter';
+import Delta from './delta';
+/**
+ * @title RichText
+ */
+export interface RichTextProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    readOnly?: boolean;
+    defaultValue?: object | string;
+    value?: object | string;
+    onChange?: (value: Delta, delta: Delta, preValue: Delta, source: EmitterSource) => void;
+    onTextChange?: (delta: Delta, preValue: Delta, source: EmitterSource) => void;
+    onSelectionChange?: (...args: any[]) => void;
+    onEditorChange?: (...args: any[]) => void;
+}

package/types/pc/rich-text/modules/clipboard.d.ts

@@ -0,0 +1,43 @@
+import type { EmitterSource } from '../core/emitter.js';
+import Module from '../core/module.js';
+import Rich from '../core/rich.js';
+import type { Range } from '../core/selection.js';
+import Delta from '../delta';
+import type { ScrollBlot } from '../parchment';
+type Selector = string | Node['TEXT_NODE'] | Node['ELEMENT_NODE'];
+type Matcher = (node: Node, delta: Delta, scroll: ScrollBlot) => Delta;
+interface ClipboardOptions {
+    matchers: [Selector, Matcher][];
+}
+declare class Clipboard extends Module<ClipboardOptions> {
+    static DEFAULTS: ClipboardOptions;
+    matchers: [Selector, Matcher][];
+    constructor(rich: Rich, options: Partial<ClipboardOptions>);
+    addMatcher(selector: Selector, matcher: Matcher): void;
+    convert({ html, text }: {
+        html?: string;
+        text?: string;
+    }, formats?: Record<string, unknown>): Delta;
+    protected normalizeHTML(doc: Document): void;
+    protected convertHTML(html: string): Delta;
+    dangerouslyPasteHTML(html: string, source?: EmitterSource): void;
+    dangerouslyPasteHTML(index: number, html: string, source?: EmitterSource): void;
+    onCaptureCopy(e: ClipboardEvent, isCut?: boolean): void;
+    private normalizeURIList;
+    onCapturePaste(e: ClipboardEvent): void;
+    onCopy(range: Range, isCut: boolean): {
+        html: string;
+        text: string;
+    };
+    onPaste(range: Range, { text, html }: {
+        text?: string;
+        html?: string;
+    }): void;
+    prepareMatching(container: Element, nodeMatches: WeakMap<Node, Matcher[]>): Matcher[][];
+}
+declare function traverse(scroll: ScrollBlot, node: ChildNode, elementMatchers: Matcher[], textMatchers: Matcher[], nodeMatches: WeakMap<Node, Matcher[]>): Delta;
+declare function matchAttributor(node: HTMLElement, delta: Delta, scroll: ScrollBlot): Delta;
+declare function matchBlot(node: Node, delta: Delta, scroll: ScrollBlot): Delta;
+declare function matchNewline(node: Node, delta: Delta, scroll: ScrollBlot): Delta;
+declare function matchText(node: HTMLElement, delta: Delta, scroll: ScrollBlot): Delta;
+export { Clipboard as default, matchAttributor, matchBlot, matchNewline, matchText, traverse, };

package/types/pc/rich-text/modules/history.d.ts

@@ -0,0 +1,36 @@
+import type Scroll from '../blots/scroll.js';
+import Module from '../core/module.js';
+import Rich from '../core/rich.js';
+import type { Range } from '../core/selection.js';
+import type Delta from '../delta';
+export interface HistoryOptions {
+    userOnly: boolean;
+    delay: number;
+    maxStack: number;
+}
+export interface StackItem {
+    delta: Delta;
+    range: Range | null;
+}
+interface Stack {
+    undo: StackItem[];
+    redo: StackItem[];
+}
+declare class History extends Module<HistoryOptions> {
+    static DEFAULTS: HistoryOptions;
+    lastRecorded: number;
+    ignoreChange: boolean;
+    stack: Stack;
+    currentRange: Range | null;
+    constructor(rich: Rich, options: Partial<HistoryOptions>);
+    change(source: 'undo' | 'redo', dest: 'redo' | 'undo'): void;
+    clear(): void;
+    cutoff(): void;
+    record(changeDelta: Delta, oldDelta: Delta): void;
+    redo(): void;
+    transform(delta: Delta): void;
+    undo(): void;
+    protected restoreSelection(stackItem: StackItem): void;
+}
+declare function getLastChangeIndex(scroll: Scroll, delta: Delta): number;
+export { History as default, getLastChangeIndex };

package/types/pc/rich-text/modules/input.d.ts

@@ -0,0 +1,10 @@
+import Module from '../core/module.js';
+import Rich from '../core/rich.js';
+declare class Input extends Module {
+    constructor(rich: Rich, options: Record<string, never>);
+    private deleteRange;
+    private replaceText;
+    private handleBeforeInput;
+    private handleCompositionStart;
+}
+export default Input;

package/types/pc/rich-text/modules/keyboard.d.ts

@@ -0,0 +1,58 @@
+import type { BlockEmbed } from '../blots/block.js';
+import Module from '../core/module.js';
+import Rich from '../core/rich.js';
+import type { Range } from '../core/selection.js';
+import type { BlockBlot } from '../parchment';
+declare const SHORTKEY: string;
+export interface Context {
+    collapsed: boolean;
+    empty: boolean;
+    offset: number;
+    prefix: string;
+    suffix: string;
+    format: Record<string, unknown>;
+    event: KeyboardEvent;
+    line: BlockEmbed | BlockBlot;
+}
+interface BindingObject extends Partial<Omit<Context, 'prefix' | 'suffix' | 'format'>> {
+    key: number | string | string[];
+    shortKey?: boolean | null;
+    shiftKey?: boolean | null;
+    altKey?: boolean | null;
+    metaKey?: boolean | null;
+    ctrlKey?: boolean | null;
+    prefix?: RegExp;
+    suffix?: RegExp;
+    format?: Record<string, unknown> | string[];
+    handler?: (this: {
+        rich: Rich;
+    }, range: Range, curContext: Context, binding: NormalizedBinding) => boolean | void;
+}
+type Binding = BindingObject | string | number;
+interface NormalizedBinding extends Omit<BindingObject, 'key' | 'shortKey'> {
+    key: string | number;
+}
+interface KeyboardOptions {
+    bindings: Record<string, Binding>;
+}
+interface KeyboardOptions {
+    bindings: Record<string, Binding>;
+}
+declare class Keyboard extends Module<KeyboardOptions> {
+    static DEFAULTS: KeyboardOptions;
+    static match(evt: KeyboardEvent, binding: BindingObject): boolean;
+    bindings: Record<string, NormalizedBinding[]>;
+    constructor(rich: Rich, options: Partial<KeyboardOptions>);
+    addBinding(keyBinding: Binding, context?: Required<BindingObject['handler']> | Partial<Omit<BindingObject, 'key' | 'handler'>>, handler?: Required<BindingObject['handler']> | Partial<Omit<BindingObject, 'key' | 'handler'>>): void;
+    listen(): void;
+    handleBackspace(range: Range, context: Context): void;
+    handleDelete(range: Range, context: Context): void;
+    handleDeleteRange(range: Range): void;
+    handleEnter(range: Range, context: Context): void;
+}
+declare function normalize(binding: Binding): BindingObject | null;
+declare function deleteRange({ rich, range }: {
+    rich: Rich;
+    range: Range;
+}): void;
+export { Keyboard as default, deleteRange, normalize, SHORTKEY };

package/types/pc/rich-text/modules/normalizeExternalHTML/index.d.ts

@@ -0,0 +1,2 @@
+declare const normalizeExternalHTML: (doc: Document) => void;
+export default normalizeExternalHTML;

package/types/pc/rich-text/modules/normalizeExternalHTML/normalizers/googleDocs.d.ts

@@ -0,0 +1 @@
+export default function normalize(doc: Document): void;

package/types/pc/rich-text/modules/normalizeExternalHTML/normalizers/msWord.d.ts

@@ -0,0 +1 @@
+export default function normalize(doc: Document): void;

package/types/pc/rich-text/modules/syntax.d.ts

@@ -0,0 +1,50 @@
+import Inline from '../blots/inline.js';
+import Module from '../core/module.js';
+import Rich from '../core/rich.js';
+import Delta from '../delta';
+import CodeBlock, { CodeBlockContainer } from '../formats/code.js';
+import type { Blot, ScrollBlot } from '../parchment';
+declare class CodeToken extends Inline {
+    static formats(node: Element, scroll: ScrollBlot): any;
+    constructor(scroll: ScrollBlot, domNode: Node, value: unknown);
+    format(format: string, value: unknown): void;
+    optimize(...args: unknown[]): void;
+}
+declare class SyntaxCodeBlock extends CodeBlock {
+    static create(value: unknown): HTMLElement;
+    static formats(domNode: Node): any;
+    static register(): void;
+    format(name: string, value: unknown): void;
+    replaceWith(name: string | Blot, value?: any): Blot;
+}
+declare class SyntaxCodeBlockContainer extends CodeBlockContainer {
+    forceNext?: boolean;
+    cachedText?: string | null;
+    attach(): void;
+    format(name: string, value: unknown): void;
+    formatAt(index: number, length: number, name: string, value: unknown): void;
+    highlight(highlight: (text: string, language: string) => Delta, forced?: boolean): void;
+    html(index: number, length: number): string;
+    optimize(context: Record<string, any>): void;
+}
+interface SyntaxOptions {
+    interval: number;
+    languages: {
+        key: string;
+        label: string;
+    }[];
+    hljs: any;
+}
+declare class Syntax extends Module<SyntaxOptions> {
+    static DEFAULTS: SyntaxOptions & {
+        hljs: any;
+    };
+    static register(): void;
+    languages: Record<string, true>;
+    constructor(rich: Rich, options: Partial<SyntaxOptions>);
+    initListener(): void;
+    initTimer(): void;
+    highlight(blot?: SyntaxCodeBlockContainer | null, force?: boolean): void;
+    highlightBlot(text: string, language?: string): Delta;
+}
+export { SyntaxCodeBlock as CodeBlock, CodeToken, Syntax as default };

package/types/pc/rich-text/modules/table.d.ts

@@ -0,0 +1,20 @@
+import Module from '../core/module.js';
+import { TableCell, TableRow } from '../formats/table.js';
+declare class Table extends Module {
+    static register(): void;
+    constructor(...args: ConstructorParameters<typeof Module>);
+    balanceTables(): void;
+    deleteColumn(): void;
+    deleteRow(): void;
+    deleteTable(): void;
+    getTable(range?: import("../core.js").Range | null): [null, null, null, -1] | [Table, TableRow, TableCell, number];
+    insertColumn(offset: number): void;
+    insertColumnLeft(): void;
+    insertColumnRight(): void;
+    insertRow(offset: number): void;
+    insertRowAbove(): void;
+    insertRowBelow(): void;
+    insertTable(rows: number, columns: number): void;
+    listenBalanceCells(): void;
+}
+export default Table;

package/types/pc/rich-text/modules/tableEmbed.d.ts

@@ -0,0 +1,27 @@
+import Module from '../core/module.js';
+import type { Op } from '../delta';
+import Delta from '../delta';
+export type CellData = {
+    content?: Delta['ops'];
+    attributes?: Record<string, unknown>;
+};
+export type TableRowColumnOp = Omit<Op, 'insert'> & {
+    insert?: {
+        id: string;
+    };
+};
+export interface TableData {
+    rows?: Delta['ops'];
+    columns?: Delta['ops'];
+    cells?: Record<string, CellData>;
+}
+export declare const composePosition: (delta: Delta, index: number) => number | null;
+export declare const tableHandler: {
+    compose(a: TableData, b: TableData, keepNull?: boolean): TableData;
+    transform(a: TableData, b: TableData, priority: boolean): TableData;
+    invert(change: TableData, base: TableData): TableData;
+};
+declare class TableEmbed extends Module {
+    static register(): void;
+}
+export default TableEmbed;

package/types/pc/rich-text/modules/toolbar.d.ts

@@ -0,0 +1,24 @@
+import Module from '../core/module.js';
+import Rich from '../core/rich.js';
+import type { Range } from '../core/selection.js';
+type Handler = (this: Toolbar, value: any) => void;
+export type ToolbarConfig = Array<string[] | Array<string | Record<string, unknown>>>;
+export interface ToolbarProps {
+    container?: HTMLElement | ToolbarConfig | null;
+    handlers?: Record<string, Handler>;
+    option?: number;
+    module?: boolean;
+    theme?: boolean;
+}
+declare class Toolbar extends Module<ToolbarProps> {
+    static DEFAULTS: ToolbarProps;
+    container?: HTMLElement | null;
+    controls: [string, HTMLElement][];
+    handlers: Record<string, Handler>;
+    constructor(rich: Rich, options: Partial<ToolbarProps>);
+    addHandler(format: string, handler: Handler): void;
+    attach(input: HTMLElement): void;
+    update(range: Range | null): void;
+}
+declare function addControls(container: HTMLElement, groups: (string | Record<string, unknown>)[][] | (string | Record<string, unknown>)[]): void;
+export { addControls, Toolbar as default };

package/types/pc/rich-text/modules/uiNode.d.ts

@@ -0,0 +1,19 @@
+import Module from '../core/module.js';
+import Rich from '../core/rich.js';
+export declare const TTL_FOR_VALID_SELECTION_CHANGE = 100;
+declare class UINode extends Module {
+    isListening: boolean;
+    selectionChangeDeadline: number;
+    constructor(rich: Rich, options: Record<string, never>);
+    private handleArrowKeys;
+    private handleNavigationShortcuts;
+    /**
+     * We only listen to the `selectionchange` event when
+     * there is an intention of moving the caret to the beginning using shortcuts.
+     * This is primarily implemented to prevent infinite loops, as we are changing
+     * the selection within the handler of a `selectionchange` event.
+     */
+    private ensureListeningToSelectionChange;
+    private handleSelectionChange;
+}
+export default UINode;

package/types/pc/rich-text/modules/uploader.d.ts

@@ -0,0 +1,15 @@
+import Module from '../core/module.js';
+import type Rich from '../core/rich.js';
+import type { Range } from '../core/selection.js';
+interface UploaderOptions {
+    mimetypes: string[];
+    handler: (this: {
+        rich: Rich;
+    }, range: Range, files: File[]) => void;
+}
+declare class Uploader extends Module<UploaderOptions> {
+    static DEFAULTS: UploaderOptions;
+    constructor(rich: Rich, options: Partial<UploaderOptions>);
+    upload(range: Range, files: FileList | File[]): void;
+}
+export default Uploader;

package/types/pc/rich-text/parchment/attributor/attributor.d.ts

@@ -0,0 +1,17 @@
+import Scope from '../scope.js';
+export interface AttributorOptions {
+    scope?: Scope;
+    whitelist?: string[];
+}
+export default class Attributor {
+    readonly attrName: string;
+    readonly keyName: string;
+    static keys(node: HTMLElement): string[];
+    scope: Scope;
+    whitelist: string[] | undefined;
+    constructor(attrName: string, keyName: string, options?: AttributorOptions);
+    add(node: HTMLElement, value: any): boolean;
+    canAdd(_node: HTMLElement, value: any): boolean;
+    remove(node: HTMLElement): void;
+    value(node: HTMLElement): any;
+}

package/types/pc/rich-text/parchment/attributor/class.d.ts

@@ -0,0 +1,8 @@
+import Attributor from './attributor.js';
+declare class ClassAttributor extends Attributor {
+    static keys(node: HTMLElement): string[];
+    add(node: HTMLElement, value: any): boolean;
+    remove(node: HTMLElement): void;
+    value(node: HTMLElement): any;
+}
+export default ClassAttributor;

package/types/pc/rich-text/parchment/attributor/store.d.ts

@@ -0,0 +1,15 @@
+import type { Formattable } from '../blot/abstract/blot.js';
+import Attributor from './attributor.js';
+declare class AttributorStore {
+    private attributes;
+    private domNode;
+    constructor(domNode: HTMLElement);
+    attribute(attribute: Attributor, value: any): void;
+    build(): void;
+    copy(target: Formattable): void;
+    move(target: Formattable): void;
+    values(): {
+        [key: string]: any;
+    };
+}
+export default AttributorStore;

package/types/pc/rich-text/parchment/attributor/style.d.ts

@@ -0,0 +1,8 @@
+import Attributor from './attributor.js';
+declare class StyleAttributor extends Attributor {
+    static keys(node: HTMLElement): string[];
+    add(node: HTMLElement, value: any): boolean;
+    remove(node: HTMLElement): void;
+    value(node: HTMLElement): any;
+}
+export default StyleAttributor;

package/types/pc/rich-text/parchment/blot/abstract/blot.d.ts

@@ -0,0 +1,115 @@
+import type LinkedList from '../../collection/linked-list.js';
+import type LinkedNode from '../../collection/linked-node.js';
+import type { RegistryDefinition } from '../../registry.js';
+import Scope from '../../scope.js';
+export interface BlotConstructor {
+    new (...args: any[]): Blot;
+    /**
+     * Creates corresponding DOM node
+     */
+    create(value?: any): Node;
+    blotName: string;
+    tagName: string | string[];
+    scope: Scope;
+    className?: string;
+    requiredContainer?: BlotConstructor;
+    allowedChildren?: BlotConstructor[];
+    defaultChild?: BlotConstructor;
+}
+/**
+ * Blots are the basic building blocks of a Parchment document.
+ *
+ * Several basic implementations such as Block, Inline, and Embed are provided.
+ * In general you will want to extend one of these, instead of building from scratch.
+ * After implementation, blots need to be registered before usage.
+ *
+ * At the very minimum a Blot must be named with a static blotName and associated with either a tagName or className.
+ * If a Blot is defined with both a tag and class, the class takes precedence, but the tag may be used as a fallback.
+ * Blots must also have a scope, which determine if it is inline or block.
+ */
+export interface Blot extends LinkedNode {
+    scroll: Root;
+    parent: Parent;
+    prev: Blot | null;
+    next: Blot | null;
+    domNode: Node;
+    statics: BlotConstructor;
+    attach(): void;
+    clone(): Blot;
+    detach(): void;
+    isolate(index: number, length: number): Blot;
+    /**
+     * For leaves, length of blot's value()
+     * For parents, sum of children's values
+     */
+    length(): number;
+    /**
+     * Returns offset between this blot and an ancestor's
+     */
+    offset(root?: Blot): number;
+    remove(): void;
+    replaceWith(name: string, value: any): Blot;
+    replaceWith(replacement: Blot): Blot;
+    split(index: number, force?: boolean): Blot | null;
+    wrap(name: string, value?: any): Parent;
+    wrap(wrapper: Parent): Parent;
+    deleteAt(index: number, length: number): void;
+    formatAt(index: number, length: number, name: string, value: any): void;
+    insertAt(index: number, value: string, def?: any): void;
+    /**
+     * Called after update cycle completes. Cannot change the value or length
+     * of the document, and any DOM operation must reduce complexity of the DOM
+     * tree. A shared context object is passed through all blots.
+     */
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+    optimize(mutations: MutationRecord[], context: {
+        [key: string]: any;
+    }): void;
+    /**
+     * Called when blot changes, with the mutation records of its change.
+     * Internal records of the blot values can be updated, and modifications of
+     * the blot itself is permitted. Can be trigger from user change or API call.
+     * A shared context object is passed through all blots.
+     */
+    update(mutations: MutationRecord[], context: {
+        [key: string]: any;
+    }): void;
+}
+export interface Parent extends Blot {
+    children: LinkedList<Blot>;
+    domNode: HTMLElement;
+    appendChild(child: Blot): void;
+    descendant<T>(type: new () => T, index: number): [T, number];
+    descendant<T>(matcher: (blot: Blot) => boolean, index: number): [T, number];
+    descendants<T>(type: new () => T, index: number, length: number): T[];
+    descendants<T>(matcher: (blot: Blot) => boolean, index: number, length: number): T[];
+    insertBefore(child: Blot, refNode?: Blot | null): void;
+    moveChildren(parent: Parent, refNode?: Blot | null): void;
+    path(index: number, inclusive?: boolean): [Blot, number][];
+    removeChild(child: Blot): void;
+    unwrap(): void;
+}
+export interface Root extends Parent {
+    create(input: Node | string | Scope, value?: any): Blot;
+    find(node: Node | null, bubble?: boolean): Blot | null;
+    query(query: string | Node | Scope, scope?: Scope): RegistryDefinition | null;
+}
+export interface Formattable extends Blot {
+    /**
+     * Apply format to blot. Should not pass onto child or other blot.
+     */
+    format(name: string, value: any): void;
+    /**
+     * Return formats represented by blot, including from Attributors.
+     */
+    formats(): {
+        [index: string]: any;
+    };
+}
+export interface Leaf extends Blot {
+    index(node: Node, offset: number): number;
+    position(index: number, inclusive: boolean): [Node, number];
+    value(): any;
+}

package/types/pc/rich-text/parchment/blot/abstract/container.d.ts

@@ -0,0 +1,18 @@
+import Scope from '../../scope.js';
+import BlockBlot from '../block.js';
+import ParentBlot from './parent.js';
+declare class ContainerBlot extends ParentBlot {
+    static blotName: string;
+    static scope: Scope;
+    static tagName: string | string[];
+    prev: BlockBlot | ContainerBlot | null;
+    next: BlockBlot | ContainerBlot | null;
+    checkMerge(): boolean;
+    deleteAt(index: number, length: number): void;
+    formatAt(index: number, length: number, name: string, value: any): void;
+    insertAt(index: number, value: string, def?: any): void;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+}
+export default ContainerBlot;

package/types/pc/rich-text/parchment/blot/abstract/leaf.d.ts

@@ -0,0 +1,29 @@
+import Scope from '../../scope.js';
+import type { Leaf } from './blot.js';
+import ShadowBlot from './shadow.js';
+declare class LeafBlot extends ShadowBlot implements Leaf {
+    static scope: Scope;
+    /**
+     * Returns the value represented by domNode if it is this Blot's type
+     * No checking that domNode can represent this Blot type is required so
+     * applications needing it should check externally before calling.
+     */
+    static value(_domNode: Node): any;
+    /**
+     * Given location represented by node and offset from DOM Selection Range,
+     * return index to that location.
+     */
+    index(node: Node, offset: number): number;
+    /**
+     * Given index to location within blot, return node and offset representing
+     * that location, consumable by DOM Selection Range
+     */
+    position(index: number, _inclusive?: boolean): [Node, number];
+    /**
+     * Return value represented by this blot
+     * Should not change without interaction from API or
+     * user change detectable by update()
+     */
+    value(): any;
+}
+export default LeafBlot;

package/types/pc/rich-text/parchment/blot/abstract/parent.d.ts

@@ -0,0 +1,50 @@
+import LinkedList from '../../collection/linked-list.js';
+import type { Blot, BlotConstructor, Parent, Root } from './blot.js';
+import ShadowBlot from './shadow.js';
+declare class ParentBlot extends ShadowBlot implements Parent {
+    /**
+     * Whitelist array of Blots that can be direct children.
+     */
+    static allowedChildren?: BlotConstructor[];
+    /**
+     * Default child blot to be inserted if this blot becomes empty.
+     */
+    static defaultChild?: BlotConstructor;
+    static uiClass: string;
+    children: LinkedList<Blot>;
+    domNode: HTMLElement;
+    uiNode: HTMLElement | null;
+    constructor(scroll: Root, domNode: Node);
+    appendChild(other: Blot): void;
+    attach(): void;
+    attachUI(node: HTMLElement): void;
+    /**
+     * Called during construction, should fill its own children LinkedList.
+     */
+    build(): void;
+    deleteAt(index: number, length: number): void;
+    descendant<T extends Blot>(criteria: new (...args: any[]) => T, index: number): [T | null, number];
+    descendant(criteria: (blot: Blot) => boolean, index: number): [Blot | null, number];
+    descendants<T extends Blot>(criteria: new (...args: any[]) => T, index?: number, length?: number): T[];
+    descendants(criteria: (blot: Blot) => boolean, index?: number, length?: number): Blot[];
+    detach(): void;
+    enforceAllowedChildren(): void;
+    formatAt(index: number, length: number, name: string, value: any): void;
+    insertAt(index: number, value: string, def?: any): void;
+    insertBefore(childBlot: Blot, refBlot?: Blot | null): void;
+    length(): number;
+    moveChildren(targetParent: Parent, refNode?: Blot | null): void;
+    optimize(context?: {
+        [key: string]: any;
+    }): void;
+    path(index: number, inclusive?: boolean): [Blot, number][];
+    removeChild(child: Blot): void;
+    replaceWith(name: string | Blot, value?: any): Blot;
+    split(index: number, force?: boolean): Blot | null;
+    splitAfter(child: Blot): Parent;
+    unwrap(): void;
+    update(mutations: MutationRecord[], _context: {
+        [key: string]: any;
+    }): void;
+}
+export default ParentBlot;