import { ElementName } from '@storyteller-platform/epub';

declare class ResolvedPos {
    readonly pos: number;
    readonly path: (Node | Root | number)[];
    readonly parentOffset: number;
    depth: number;
    private constructor();
    static resolve(doc: Root, pos: number): ResolvedPos;
    get parent(): Root | Node;
    node(depth?: number | null): Root | Node | TextNode;
    index(depth?: number | null): number;
    get nodeAfter(): Node | TextNode | null;
    before(depth?: number | null): number;
    private resolveDepth;
}

declare class Root {
    children: (Node | TextNode)[];
    constructor(children: (Node | TextNode)[]);
    isInline: boolean;
    isBlock: boolean;
    get border(): number;
    get textContent(): string;
    get nodeSize(): number;
    get contentSize(): number;
    split(at: number): Root;
    copy(opts?: {
        children?: (Node | TextNode)[];
    }): Root;
    findIndex(pos: number): {
        index: number;
        offset: number;
    };
    replace(at: number, withNode: Node): Root;
    cut(pos: number): Node | TextNode | null;
    resolve(pos: number): ResolvedPos;
}
declare class Node {
    tagName: ElementName;
    attrs: Record<string, string>;
    children: (Node | TextNode)[];
    marks: Mark[];
    constructor(tagName: ElementName, attrs?: Record<string, string>, children?: (Node | TextNode)[], marks?: Mark[]);
    get isLeaf(): boolean;
    get isInline(): boolean;
    get isBlock(): boolean;
    get border(): 0 | 1;
    get nodeSize(): number;
    get contentSize(): number;
    get textContent(): string;
    split(at: number): Node;
    static instance(): typeof Node;
    private static create;
    copy(opts?: {
        attrs?: Record<string, string>;
        children?: (Node | TextNode)[];
        marks?: Mark[];
    }): Node;
    replace(at: number, withNode: Node): Node;
    cut(pos: number): Node | TextNode | null;
    findIndex(pos: number): {
        index: number;
        offset: number;
    };
}
declare class NoterefNode extends Node {
}
declare class FootnoteNode extends Node {
}
declare class RubyParenthesisNode extends Node {
}
declare class RubyTextNode extends Node {
}
declare class RubyNode extends Node {
}
declare class Mark {
    tagName: ElementName;
    attrs: Record<string, string>;
    constructor(tagName: ElementName, attrs?: Record<string, string>);
    eq(other: Mark | undefined): boolean;
}
declare class TextNode {
    text: string;
    marks: Mark[];
    constructor(text: string, marks?: Mark[]);
    isLeaf: boolean;
    isInline: boolean;
    isBlock: boolean;
    border: number;
    get nodeSize(): number;
    get contentSize(): number;
    get textContent(): string;
    split(at: number): TextNode[];
    copy(opts?: {
        marks?: Mark[];
    }): TextNode;
    cut(pos: number): TextNode;
}
declare function descendants(node: Root | Node, cb: (node: Node | TextNode, pos: number, parent: Node | Root, index: number) => boolean, pos?: number): void;

export { FootnoteNode as F, Mark as M, Node as N, Root as R, TextNode as T, ResolvedPos as a, NoterefNode as b, RubyParenthesisNode as c, RubyTextNode as d, RubyNode as e, descendants as f };