edytor/protocol

Every name edytor/protocol exports, with its declaration and documentation (generated from the published types).

Every name edytor/protocol exports, generated from the package’s published type declarations, with the documentation its JSDoc carries. The guides explain how the pieces fit; this page is the exhaustive list. 91 names.

AdmissionResult

Non-throwing admission result — the audit/read-side counterpart of assertAdmission.

export type AdmissionResult = {
    admitted: true;
    verdict: AdmissionVerdict;
} | {
    admitted: false;
    error: UnsupportedDocError | SchemaMismatchError;
};

AdmissionVerdict

What an admitted doc carries — the sync() readiness decision:

• 'fresh' — no schema claim and an empty block registry; seeding (facade.init) is legal. Foreign/unrelated ROOTS may still exist — they are not schema claims and coexist next to the seeded schema.
• 'initialized' — supported schema content is committed; the doc is adopted as-is (hydrated), never seeded.

export type AdmissionVerdict = 'fresh' | 'initialized';

applyAwarenessUpdate

Apply an encoded awareness update. origin is forwarded on the emitted change/update events.

declare const applyAwarenessUpdate: (awareness: Awareness, update: Uint8Array, origin: unknown) => void;

assertAdmission

The document-level admission gate — runs the ordered checks and throws the typed refusal:

• UnsupportedDocError 'foreign' — not a v14 engine doc (foreign roots/engines may still attach content later; this is about doc shape);
• SchemaMismatchError 'unversioned' | 'unsupported' | 'foreign' — a schema claim this build cannot own.

PURE READS — a refusal leaves the doc byte-identical (the reads may materialize empty root SHARE entries in the doc’s share map, which do not encode into updates). Returns the AdmissionVerdict for the readiness decision.

declare const assertAdmission: (doc: EngineDoc, docName?: string) => AdmissionVerdict;

assertSchema

Hard gate — throws SchemaMismatchError when checkSchema reports a problem. Used by migration and by Edytor.sync() before mutating a synced document.

declare const assertSchema: (doc: EngineDoc, docName?: string) => void;

assertUsableDoc

Document-boundary guard run by EdytorDocBinding.create before the runs view attaches. The facade only speaks the v14 unified-node surface — without this gate a foreign doc dies obscurely inside buildView (registry.forEachAttr is not a function); it fails fast with an actionable error instead.

declare const assertUsableDoc: (doc: EngineDoc) => void;

AwarenessEntry

One awareness entry on the wire: a client’s clock and state (null = removed).

export type AwarenessEntry = {
    clientID: number;
    clock: number;
    state: Record<string, unknown> | null;
};

bindCrdt

declare const bindCrdt: (Y: EngineApi) => {
    createDoc: (opts?: ConstructorParameters<EngineApi["Doc"]>[0]) => YDoc;
    Awareness: typeof _Awareness;
    doc: {
        SCHEMA: {
            readonly version: 6;
            readonly name: "edytor-doc";
            readonly roots: {
                readonly registry: "blocks";
                readonly meta: "meta";
            };
            readonly metaAttrs: {
                readonly version: "v";
                readonly schema: "schema";
            };
        };
        SCHEMA_VERSION: 6;
        SCHEMA_NAME: "edytor-doc";
        META_KEY: "meta";
        init: (doc: import("./engine-api.js").EngineDoc, opts?: {
            content?: import("./index.js").BlockSpec[];
            defaultType?: string;
        }) => void;
        restore: (doc: import("./engine-api.js").EngineDoc, content: import("./index.js").BlockSpec[]) => void;
        seed: (doc: import("./engine-api.js").EngineDoc, value?: import("./index.js").JSONBlock[], defaultType?: string, data?: import("./doc/types.js").JsonObj) => void;
        isInitialized: (doc: import("./engine-api.js").EngineDoc) => boolean;
        schemaVersion: (doc: import("./engine-api.js").EngineDoc) => number | undefined;
        registryEmpty: (doc: import("./engine-api.js").EngineDoc) => boolean;
        checkSchema: (doc: import("./engine-api.js").EngineDoc) => import("./edytor-doc.js").SchemaProblem | null;
        assertSchema: (doc: import("./engine-api.js").EngineDoc, docName?: string) => void;
        SchemaMismatchError: typeof import("./edytor-doc.js").SchemaMismatchError;
        create: (doc: import("./engine-api.js").EngineDoc, config?: import("./edytor-doc.js").EdytorDocConfig) => {
            prepare: {
                insertFlow: (target: import("./flow.js").FlowTarget, flow: import("./flow.js").Flow, view?: import("./flow.js").FlowView) => import("./edytor-doc.js").Prepared;
                deleteRange: (from: import("./rangeDelete.js").DocPosition, to: import("./rangeDelete.js").DocPosition, view?: import("./rangeDelete.js").RangeView) => import("./edytor-doc.js").Prepared;
                replaceRange: (from: import("./rangeDelete.js").DocPosition, to: import("./rangeDelete.js").DocPosition, view?: import("./rangeDelete.js").RangeView) => import("./edytor-doc.js").Prepared;
                insertBlocks: (dest: import("./index.js").Destination, specs: readonly (import("./index.js").BlockSpec | import("./index.js").JSONBlock)[]) => import("./edytor-doc.js").Prepared;
                moveBlocks: (ids: readonly import("./index.js").BlockId[], dest: import("./index.js").Destination) => import("./edytor-doc.js").Prepared;
                nestBlock: (id: import("./index.js").BlockId, parent: import("./index.js").BlockId) => import("./edytor-doc.js").Prepared;
                unNestBlock: (id: import("./index.js").BlockId) => import("./edytor-doc.js").Prepared;
                unNestBlocks: (ids: readonly import("./index.js").BlockId[]) => import("./edytor-doc.js").Prepared;
                liftOut: (id: import("./index.js").BlockId, kind: string, { keep, after }?: {
                    keep?: boolean;
                    after?: readonly import("./index.js").BlockSpec[];
                }) => import("./edytor-doc.js").Prepared;
                placeBeside: (ids: readonly import("./index.js").BlockId[], target: import("./index.js").BlockId, side: "left" | "right", kind?: string) => import("./edytor-doc.js").Prepared;
                wrapInLayout: (ids: readonly import("./index.js").BlockId[], kind?: string, columns?: number) => import("./edytor-doc.js").Prepared;
                splitBlock: (id: import("./index.js").BlockId, offset: number, newId: import("./index.js").BlockId, tail?: import("./placement/model.js").SplitTail) => import("./edytor-doc.js").Prepared;
                mergeBlocks: (fromId: import("./index.js").BlockId, intoId: import("./index.js").BlockId) => import("./edytor-doc.js").Prepared;
                mergeBackward: (id: import("./index.js").BlockId) => import("./edytor-doc.js").Prepared;
                mergeForward: (id: import("./index.js").BlockId) => import("./edytor-doc.js").Prepared;
                deleteBlock: (id: import("./index.js").BlockId, opts?: {
                    keepChildren?: boolean;
                }) => import("./edytor-doc.js").Prepared;
                setBlock: (id: import("./index.js").BlockId, value: {
                    type?: string;
                    data?: Record<string, unknown>;
                    content?: (import("./index.js").ContentItem | import("./index.js").JSONText | import("./index.js").JSONInlineBlock)[];
                    children?: (import("./index.js").BlockSpec | import("./index.js").JSONBlock)[];
                }) => import("./edytor-doc.js").Prepared;
                setBlockType: (id: import("./index.js").BlockId, type: string) => import("./edytor-doc.js").Prepared;
                patchData: (target: import("./edytor-doc.js").DataTarget, patches: readonly import("./data.js").DataPatch[]) => import("./edytor-doc.js").Prepared;
                duplicateBlock: (id: import("./index.js").BlockId, freshId?: (oldId: string, kind: "block" | "inline") => string) => import("./edytor-doc.js").Prepared;
                insertText: (id: import("./index.js").BlockId, offset: number, text: string, marks?: Record<string, unknown>) => import("./edytor-doc.js").Prepared;
                deleteText: (id: import("./index.js").BlockId, offset: number, length: number) => import("./edytor-doc.js").Prepared;
                formatRange: (id: import("./index.js").BlockId, offset: number, length: number, marks: Record<string, unknown>) => import("./edytor-doc.js").Prepared;
                clearMarks: (id: import("./index.js").BlockId, offset: number, length: number) => import("./edytor-doc.js").Prepared;
                insertInline: (id: import("./index.js").BlockId, offset: number, atom: import("./doc/content.js").NewInline) => import("./edytor-doc.js").Prepared;
                removeInline: (id: import("./index.js").BlockId, inlineId: string) => import("./edytor-doc.js").Prepared;
                deleteBlocks: (ids: readonly import("./index.js").BlockId[]) => import("./edytor-doc.js").Prepared;
            };
            apply: (p: import("./edytor-doc.js").Prepared) => import("./edytor-doc.js").OpResult;
            compose: (...parts: import("./edytor-doc.js").Prepared[]) => import("./edytor-doc.js").Prepared;
            transact: <R>(fn: () => R, origin?: unknown) => R;
            model: {
                REGISTRY_KEY: string;
                registryOf: (doc: import("./engine-api.js").EngineDoc) => import("./engine-api.js").EngineNode;
                blockNodeOf: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => import("./engine-api.js").EngineNode | null;
                liveNodeOf: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => import("./engine-api.js").EngineNode | null;
                isLive: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => boolean;
                candidatesOf: (node: import("./engine-api.js").EngineNode) => import("./placement/model.js").PlacementCand[];
                view: (doc: import("./engine-api.js").EngineDoc) => import("./placement/model.js").ModelView;
                resolvePlacements: (blocks: Map<import("./index.js").BlockId, import("./placement/model.js").BlockRec>, ownerOf?: (b: import("./index.js").BlockId) => import("./text/model.js").Owner) => Map<import("./index.js").BlockId, import("./placement/model.js").ResolvedPlacement>;
                childrenIndex: (placements: Map<import("./index.js").BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./placement/model.js").DisplayOwnership) => Map<import("./index.js").BlockId | null, import("./placement/model.js").ChildSlot[]>;
                positionInView: (v: import("./placement/model.js").ModelView, id: import("./index.js").BlockId) => import("./index.js").Destination | null;
                buildInline: (atom: import("./index.js").InlineSpec) => import("./engine-api.js").EngineNode;
                isSelfOrDescendant: (placements: Map<import("./index.js").BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").Ownership, id: import("./index.js").BlockId, maybeAncestor: import("./index.js").BlockId) => boolean;
                ranksAt: (siblings: readonly {
                    rank: string;
                }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
                writePlacement: (doc: import("./engine-api.js").EngineDoc, node: import("./engine-api.js").EngineNode, p: import("./index.js").BlockId | null, r: string) => void;
                withdrawOnUndo: (doc: import("./engine-api.js").EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
                    inserts: {
                        has(client: number, clock: number): boolean;
                    };
                }) => boolean;
                materializeSpec: (doc: import("./engine-api.js").EngineDoc, sp: import("./index.js").BlockSpec, parent: import("./index.js").BlockId | null, rank: string) => void;
                collides: (doc: import("./engine-api.js").EngineDoc, specs: readonly import("./index.js").BlockSpec[]) => boolean;
                writeSplit: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId, offset: number, newId: import("./index.js").BlockId, tail: import("./placement/model.js").SplitTail, place: import("./placement/model.js").PlacementValue) => void;
                ownText: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => {
                    from: unknown;
                    to: number;
                };
                insertBlocks: (doc: import("./engine-api.js").EngineDoc, dest: import("./index.js").Destination, specs: import("./index.js").BlockSpec[]) => boolean;
                insertBlock: (doc: import("./engine-api.js").EngineDoc, dest: import("./index.js").Destination, spec: import("./index.js").BlockSpec) => boolean;
                restoreBlocks: (doc: import("./engine-api.js").EngineDoc, specs: import("./index.js").BlockSpec[]) => void;
                project: (doc: import("./engine-api.js").EngineDoc) => import("./index.js").ProjectedDoc;
                positionOf: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => import("./index.js").Destination | null;
                listBlockIds: (doc: import("./engine-api.js").EngineDoc) => import("./index.js").BlockId[];
                blockText: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => string | null;
                crdtId: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => string | null;
                resolveBlock: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => import("./engine-api.js").EngineNode | null;
            };
            text: {
                newNode: (name: string) => import("./engine-api.js").EngineNode;
                resolveAnchor: (doc: import("./engine-api.js").EngineDoc, text: import("./engine-api.js").EngineNode, anchor: import("./text/model.js").Anchor) => number | null;
                anchorAt: (text: import("./engine-api.js").EngineNode, index: number, assoc: number) => import("./text/model.js").Anchor;
                openRangeCursor: (text: import("./engine-api.js").EngineNode) => import("./text/model.js").RangeCursor;
                itemsOfRange: (text: import("./engine-api.js").EngineNode, i0: number, i1: number) => import("./text/model.js").RangeItem[];
                readSegs: (segs: readonly import("./text/model.js").Seg[], stats?: import("./text/model.js").RangeReadStats) => import("./text/model.js").RangeItem[];
                computeOwnership: (doc: import("./engine-api.js").EngineDoc, given: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>) => import("./text/model.js").Ownership;
                flatten: (b: import("./text/model.js").BlockId, blocks: unknown, own: import("./text/model.js").Ownership) => import("./text/model.js").Seg[];
                ownedLength: (segs: readonly import("./text/model.js").Seg[]) => number;
                contentItemsOf: (b: import("./text/model.js").BlockId, blocks: unknown, own: import("./text/model.js").Ownership) => import("./text/model.js").RangeItem[];
                blockTextOf: (b: import("./text/model.js").BlockId, blocks: unknown, own: import("./text/model.js").Ownership) => string;
                insertIntoText: (doc: import("./engine-api.js").EngineDoc, blocks: unknown, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, payload: string | import("./engine-api.js").EngineNode, marks?: Record<string, unknown>) => void;
                deleteRange: (doc: import("./engine-api.js").EngineDoc, blocks: unknown, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, length: number) => void;
                formatRangeIn: (doc: import("./engine-api.js").EngineDoc, blocks: unknown, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, length: number, formats: Record<string, unknown>) => void;
                purgeStreams: (streams: readonly import("./text/model.js").Stream[]) => void;
                findAtom: (own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, inlineId: string) => {
                    text: import("./engine-api.js").EngineNode;
                    at: number;
                    node: import("./engine-api.js").EngineNode;
                } | null;
                splitAt: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => import("./text/model.js").MergeClaim[];
                claimInto: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
                ownText: (doc: import("./engine-api.js").EngineDoc, rec: import("./text/model.js").TextBlockRec) => {
                    from: unknown;
                    to: number;
                };
            };
            runsView: import("./text/runs.js").RunView;
            version: number;
            insertFlow: (target: import("./flow.js").FlowTarget, flow: import("./flow.js").Flow, view?: import("./flow.js").FlowView | undefined) => import("./edytor-doc.js").OpResult;
            deleteRange: (from: import("./rangeDelete.js").DocPosition, to: import("./rangeDelete.js").DocPosition, view?: import("./rangeDelete.js").RangeView | undefined) => import("./edytor-doc.js").OpResult;
            replaceRange: (from: import("./rangeDelete.js").DocPosition, to: import("./rangeDelete.js").DocPosition, view?: import("./rangeDelete.js").RangeView | undefined) => import("./edytor-doc.js").OpResult;
            insertBlocks: (dest: import("./index.js").Destination, specs: readonly (import("./index.js").BlockSpec | import("./index.js").JSONBlock)[]) => import("./edytor-doc.js").OpResult;
            moveBlocks: (ids: readonly string[], dest: import("./index.js").Destination) => import("./edytor-doc.js").OpResult;
            nestBlock: (id: string, parent: string) => import("./edytor-doc.js").OpResult;
            unNestBlock: (id: string) => import("./edytor-doc.js").OpResult;
            unNestBlocks: (ids: readonly string[]) => import("./edytor-doc.js").OpResult;
            liftOut: (id: string, kind: string, args_2?: {
                keep?: boolean;
                after?: readonly import("./index.js").BlockSpec[];
            } | undefined) => import("./edytor-doc.js").OpResult;
            placeBeside: (ids: readonly string[], target: string, side: "right" | "left", kind?: string | undefined) => import("./edytor-doc.js").OpResult;
            wrapInLayout: (ids: readonly string[], kind?: string | undefined, columns?: number | undefined) => import("./edytor-doc.js").OpResult;
            splitBlock: (id: string, offset: number, newId: string, tail?: import("./placement/model.js").SplitTail | undefined) => import("./edytor-doc.js").OpResult;
            mergeBlocks: (fromId: string, intoId: string) => import("./edytor-doc.js").OpResult;
            mergeBackward: (id: string) => import("./edytor-doc.js").OpResult;
            mergeForward: (id: string) => import("./edytor-doc.js").OpResult;
            deleteBlock: (id: string, opts?: {
                keepChildren?: boolean;
            } | undefined) => import("./edytor-doc.js").OpResult;
            setBlock: (id: string, value: {
                type?: string;
                data?: Record<string, unknown>;
                content?: (import("./index.js").ContentItem | import("./index.js").JSONText | import("./index.js").JSONInlineBlock)[];
                children?: (import("./index.js").BlockSpec | import("./index.js").JSONBlock)[];
            }) => import("./edytor-doc.js").OpResult;
            setBlockType: (id: string, type: string) => import("./edytor-doc.js").OpResult;
            patchData: (target: import("./edytor-doc.js").DataTarget, patches: readonly import("./data.js").DataPatch[]) => import("./edytor-doc.js").OpResult;
            duplicateBlock: (id: string, freshId?: ((oldId: string, kind: "block" | "inline") => string) | undefined) => import("./edytor-doc.js").OpResult;
            insertText: (id: string, offset: number, text: string, marks?: Record<string, unknown> | undefined) => import("./edytor-doc.js").OpResult;
            deleteText: (id: string, offset: number, length: number) => import("./edytor-doc.js").OpResult;
            formatRange: (id: string, offset: number, length: number, marks: Record<string, unknown>) => import("./edytor-doc.js").OpResult;
            clearMarks: (id: string, offset: number, length: number) => import("./edytor-doc.js").OpResult;
            insertInline: (id: string, offset: number, atom: import("./doc/content.js").NewInline) => import("./edytor-doc.js").OpResult;
            removeInline: (id: string, inlineId: string) => import("./edytor-doc.js").OpResult;
            deleteBlocks: (ids: readonly string[]) => import("./edytor-doc.js").OpResult;
            init: (opts?: Parameters<(doc: import("./engine-api.js").EngineDoc, opts?: {
                content?: import("./index.js").BlockSpec[];
                defaultType?: string;
            }) => void>[1]) => void;
            seed: (value: import("./index.js").JSONBlock[], data?: import("./doc/types.js").JsonObj) => void;
            isInitialized: () => boolean;
            schemaVersion: () => number | undefined;
            checkSchema: () => import("./edytor-doc.js").SchemaProblem | null;
            assertSchema: () => void;
            dispose: () => void;
            createUndoManager: (options?: import("./doc/history.js").HistoryOptions) => import("./doc/history.js").UndoManager;
            project: () => import("./index.js").ProjectedDoc;
            toJSON: () => import("./index.js").JSONDoc;
            blockJSON: (id: string) => import("./index.js").JSONBlock;
            childrenIds: (id: string | null) => string[];
            childSlots: (parent: import("./index.js").BlockId | null) => import("./placement/model.js").ChildSlot[];
            slotOf: (id: string) => {
                parent: import("./index.js").BlockId | null;
                rank: string;
            } | null;
            positionOf: (id: string) => import("./index.js").Destination | null;
            pathOf: (id: string) => number[] | null;
            parentOf: (id: string) => string | null;
            ancestorsOf: (id: string) => string[];
            listBlockIds: () => string[];
            blockText: (id: string) => string | null;
            blockTypeOf: (id: string) => string | undefined;
            blockDataOf: (id: string) => Record<string, unknown> | undefined;
            docData: () => import("./doc/types.js").JsonObj;
            dataItemIds: (target: import("./edytor-doc.js").DataTarget, path: readonly string[]) => string[];
            blockAttribution: (id: string) => import("./index.js").BlockAttribution | undefined;
            crdtId: (id: string) => string | null;
            resolveBlock: (id: string) => import("./engine-api.js").EngineNode | null;
            displayLength: (id: string) => number;
            contentItems: (id: string) => import("./index.js").ContentItem[];
            hasBlock: (id: string) => boolean;
            isVisibleBlock: (id: string) => boolean;
            order: () => readonly import("./index.js").BlockId[];
            compare: (a: import("./index.js").BlockId, b: import("./index.js").BlockId) => number;
            next: (id: string, policy?: import("./edytor-doc.js").OrderPolicy | undefined) => string | null;
            previous: (id: string, policy?: import("./edytor-doc.js").OrderPolicy | undefined) => string | null;
            anchorAt: (id: string, offset: number, affinity?: import("./edytor-doc.js").AnchorAffinity | undefined) => import("./edytor-doc.js").DocAnchor | null;
            resolveAnchor: (anchor: import("./edytor-doc.js").DocAnchor) => {
                blockId: import("./index.js").BlockId;
                offset: number;
            } | null;
            followUndo: (anchor: import("./edytor-doc.js").DocAnchor) => import("./edytor-doc.js").DocAnchor;
            rolesChanged: () => void;
            isVoid: (id: string) => boolean;
            isIsland: (id: string) => boolean;
            isLines: (id: string) => boolean;
            isLayout: (id: string) => boolean;
            isLayoutItem: (id: string) => boolean;
            besideAt: (id: import("./index.js").BlockId, kind?: string) => string;
            islandOf: (id: string) => string | null;
            isTable: (id: string) => boolean;
            isTableRow: (id: string) => boolean;
            isTableCell: (id: string) => boolean;
            tableOf: (id: string) => string | null;
            tableColumns: (id: string) => {
                id: string;
                width?: number;
            }[] | null;
            tableGrid: (id: string) => {
                columns: string[];
                rows: {
                    id: import("./index.js").BlockId;
                    cells: (import("./index.js").BlockId | null)[];
                }[];
            } | null;
            insideIsland: (id: string) => boolean;
            canPlace: (ids: readonly import("./index.js").BlockId[], parent?: import("./index.js").BlockId | null) => boolean;
            canMerge: (from: import("./index.js").BlockId, into: import("./index.js").BlockId) => boolean;
            fits: (parent: import("./index.js").BlockId | null, kind: string) => boolean;
            nestParent: (ids: readonly import("./index.js").BlockId[], parent: import("./index.js").BlockId) => string;
            landingOf: (id: import("./index.js").BlockId, kind: string, after?: boolean) => {
                parent: string | null;
                levels: string[];
            };
            defaultChild: (id: string | null) => string;
            runs: (id: string) => readonly import("./index.js").ContentRun[];
            contentJSON: (id: string) => ({
                text: string;
                marks?: Record<string, unknown>;
            } | {
                id?: string;
                type: string;
                data?: unknown;
            })[];
            onChange: (cb: (change: import("./edytor-doc.js").DocChange) => void) => (() => void);
        };
        newDoc: (opts?: ConstructorParameters<EngineApi["Doc"]>[0]) => YDoc;
        keepCopies: (doc: import("./engine-api.js").EngineDoc) => void;
        purge: (doc: import("./engine-api.js").EngineDoc, facade: {
            model: import("./placement/model.js").PlacementModel;
            text: import("./text/model.js").TextEngine;
        }, horizon: import("./purge.js").Horizon) => import("./purge.js").PurgeReport;
        horizonOf: (doc: import("./engine-api.js").EngineDoc) => import("./purge.js").Horizon | null;
        restoreTo: <Plan>(doc: import("./engine-api.js").EngineDoc, facade: import("./restore.js").RestoreFacade<Plan>, json: import("./index.js").JSONDoc) => import("./restore.js").RestoreReport;
        model: {
            REGISTRY_KEY: string;
            registryOf: (doc: import("./engine-api.js").EngineDoc) => import("./engine-api.js").EngineNode;
            blockNodeOf: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => import("./engine-api.js").EngineNode | null;
            liveNodeOf: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => import("./engine-api.js").EngineNode | null;
            isLive: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => boolean;
            candidatesOf: (node: import("./engine-api.js").EngineNode) => import("./placement/model.js").PlacementCand[];
            view: (doc: import("./engine-api.js").EngineDoc) => import("./placement/model.js").ModelView;
            resolvePlacements: (blocks: Map<import("./index.js").BlockId, import("./placement/model.js").BlockRec>, ownerOf?: (b: import("./index.js").BlockId) => import("./text/model.js").Owner) => Map<import("./index.js").BlockId, import("./placement/model.js").ResolvedPlacement>;
            childrenIndex: (placements: Map<import("./index.js").BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./placement/model.js").DisplayOwnership) => Map<import("./index.js").BlockId | null, import("./placement/model.js").ChildSlot[]>;
            positionInView: (v: import("./placement/model.js").ModelView, id: import("./index.js").BlockId) => import("./index.js").Destination | null;
            buildInline: (atom: import("./index.js").InlineSpec) => import("./engine-api.js").EngineNode;
            isSelfOrDescendant: (placements: Map<import("./index.js").BlockId, import("./placement/model.js").ResolvedPlacement>, own: import("./text/model.js").Ownership, id: import("./index.js").BlockId, maybeAncestor: import("./index.js").BlockId) => boolean;
            ranksAt: (siblings: readonly {
                rank: string;
            }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
            writePlacement: (doc: import("./engine-api.js").EngineDoc, node: import("./engine-api.js").EngineNode, p: import("./index.js").BlockId | null, r: string) => void;
            withdrawOnUndo: (doc: import("./engine-api.js").EngineDoc) => (item: import("./engine-api.js").EngineItemRef, stackItem: {
                inserts: {
                    has(client: number, clock: number): boolean;
                };
            }) => boolean;
            materializeSpec: (doc: import("./engine-api.js").EngineDoc, sp: import("./index.js").BlockSpec, parent: import("./index.js").BlockId | null, rank: string) => void;
            collides: (doc: import("./engine-api.js").EngineDoc, specs: readonly import("./index.js").BlockSpec[]) => boolean;
            writeSplit: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId, offset: number, newId: import("./index.js").BlockId, tail: import("./placement/model.js").SplitTail, place: import("./placement/model.js").PlacementValue) => void;
            ownText: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => {
                from: unknown;
                to: number;
            };
            insertBlocks: (doc: import("./engine-api.js").EngineDoc, dest: import("./index.js").Destination, specs: import("./index.js").BlockSpec[]) => boolean;
            insertBlock: (doc: import("./engine-api.js").EngineDoc, dest: import("./index.js").Destination, spec: import("./index.js").BlockSpec) => boolean;
            restoreBlocks: (doc: import("./engine-api.js").EngineDoc, specs: import("./index.js").BlockSpec[]) => void;
            project: (doc: import("./engine-api.js").EngineDoc) => import("./index.js").ProjectedDoc;
            positionOf: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => import("./index.js").Destination | null;
            listBlockIds: (doc: import("./engine-api.js").EngineDoc) => import("./index.js").BlockId[];
            blockText: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => string | null;
            crdtId: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => string | null;
            resolveBlock: (doc: import("./engine-api.js").EngineDoc, id: import("./index.js").BlockId) => import("./engine-api.js").EngineNode | null;
        };
        text: {
            newNode: (name: string) => import("./engine-api.js").EngineNode;
            resolveAnchor: (doc: import("./engine-api.js").EngineDoc, text: import("./engine-api.js").EngineNode, anchor: import("./text/model.js").Anchor) => number | null;
            anchorAt: (text: import("./engine-api.js").EngineNode, index: number, assoc: number) => import("./text/model.js").Anchor;
            openRangeCursor: (text: import("./engine-api.js").EngineNode) => import("./text/model.js").RangeCursor;
            itemsOfRange: (text: import("./engine-api.js").EngineNode, i0: number, i1: number) => import("./text/model.js").RangeItem[];
            readSegs: (segs: readonly import("./text/model.js").Seg[], stats?: import("./text/model.js").RangeReadStats) => import("./text/model.js").RangeItem[];
            computeOwnership: (doc: import("./engine-api.js").EngineDoc, given: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>) => import("./text/model.js").Ownership;
            flatten: (b: import("./text/model.js").BlockId, blocks: unknown, own: import("./text/model.js").Ownership) => import("./text/model.js").Seg[];
            ownedLength: (segs: readonly import("./text/model.js").Seg[]) => number;
            contentItemsOf: (b: import("./text/model.js").BlockId, blocks: unknown, own: import("./text/model.js").Ownership) => import("./text/model.js").RangeItem[];
            blockTextOf: (b: import("./text/model.js").BlockId, blocks: unknown, own: import("./text/model.js").Ownership) => string;
            insertIntoText: (doc: import("./engine-api.js").EngineDoc, blocks: unknown, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, payload: string | import("./engine-api.js").EngineNode, marks?: Record<string, unknown>) => void;
            deleteRange: (doc: import("./engine-api.js").EngineDoc, blocks: unknown, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, length: number) => void;
            formatRangeIn: (doc: import("./engine-api.js").EngineDoc, blocks: unknown, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, length: number, formats: Record<string, unknown>) => void;
            purgeStreams: (streams: readonly import("./text/model.js").Stream[]) => void;
            findAtom: (own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, inlineId: string) => {
                text: import("./engine-api.js").EngineNode;
                at: number;
                node: import("./engine-api.js").EngineNode;
            } | null;
            splitAt: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: import("./text/model.js").Ownership, b: import("./text/model.js").BlockId, offset: number, newId: import("./text/model.js").BlockId, n: number) => import("./text/model.js").MergeClaim[];
            claimInto: (blocks: ReadonlyMap<import("./text/model.js").BlockId, import("./text/model.js").TextBlockRec>, own: Pick<import("./text/model.js").Ownership, "streamOf">, from: import("./text/model.js").BlockId, into: import("./text/model.js").BlockId) => void;
            ownText: (doc: import("./engine-api.js").EngineDoc, rec: import("./text/model.js").TextBlockRec) => {
                from: unknown;
                to: number;
            };
        };
        runs: {
            attach: (doc: import("./engine-api.js").EngineDoc) => import("./text/runs.js").RunView;
        };
    };
    providers: {
        prefetch: (options: PrefetchOptions) => Promise<import("./index.js").PrefetchResult>;
        lastUpdated: (options: import("./index.js").LastUpdatedOptions) => Promise<number | null>;
        documentSnapshot: (options: import("./index.js").LastUpdatedOptions) => Promise<import("./index.js").JSONDoc | null>;
        IndexeddbPersistence: {
            new (name: string, doc: YDoc, options?: import("./protocol.js").IndexeddbPersistenceOptions): {
                doc: YDoc;
                name: string;
                dbName: string;
                _dbref: number;
                _dbsize: number;
                db: IDBDatabase | null;
                _db: Promise<IDBDatabase>;
                _destroyed: boolean;
                hasSynced: boolean;
                whenSynced: Promise<any>;
                _failedEmitted?: boolean;
                _settleSynced: import("./providers/room.js").LifecycleHost["_settleSynced"];
                _leave: () => void;
                loadError: unknown;
                _storeTimeout: number;
                _storeTimeoutId: ReturnType<typeof setTimeout> | null;
                _storeUpdate: (update: Uint8Array, origin: unknown) => void;
                awareness: _Awareness;
                bcconnected: boolean;
                disableBc: boolean;
                _ownsAwareness: boolean;
                _bcSubscriber: (data: ArrayBuffer | Uint8Array, origin: unknown) => void;
                _awarenessUpdateHandler: (updates: {
                    added: number[];
                    updated: number[];
                    removed: number[];
                }, origin: unknown) => void;
                get synced(): boolean;
                messageHandlers: Record<number, import("./providers/room.js").RoomMessageHandler<any>>;
                readMessage: (buf: Uint8Array, emitSynced: boolean) => import("lib0-v14/encoding").Encoder;
                broadcastMessage(buf: Uint8Array): void;
                connectBc(): void;
                disconnectBc(): void;
                destroy(): Promise<void>;
                emit<N extends "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "load-error">(name: N, args: Parameters<{
                    synced: (provider: any) => void;
                    'protocol-mismatch': (mismatch: import("./protocol.js").ProtocolMismatch, provider: any) => void;
                    'load-error': (error: unknown, provider: any) => void;
                    'message-error': (error: unknown, provider: any) => void;
                    'schema-mismatch': (detail: import("./protocol.js").SchemaMismatchDetail, provider: any) => void;
                    failed: (error: unknown, provider: any) => void;
                }[N]>): void;
                _observers: Map<string, Set<any>>;
                on<NAME extends "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
                    synced: (provider: any) => void;
                    'protocol-mismatch': (mismatch: import("./protocol.js").ProtocolMismatch, provider: any) => void;
                    'load-error': (error: unknown, provider: any) => void;
                    'message-error': (error: unknown, provider: any) => void;
                    'schema-mismatch': (detail: import("./protocol.js").SchemaMismatchDetail, provider: any) => void;
                    failed: (error: unknown, provider: any) => void;
                }[NAME]): {
                    synced: (provider: any) => void;
                    'protocol-mismatch': (mismatch: import("./protocol.js").ProtocolMismatch, provider: any) => void;
                    'load-error': (error: unknown, provider: any) => void;
                    'message-error': (error: unknown, provider: any) => void;
                    'schema-mismatch': (detail: import("./protocol.js").SchemaMismatchDetail, provider: any) => void;
                    failed: (error: unknown, provider: any) => void;
                }[NAME];
                once<NAME extends "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
                    synced: (provider: any) => void;
                    'protocol-mismatch': (mismatch: import("./protocol.js").ProtocolMismatch, provider: any) => void;
                    'load-error': (error: unknown, provider: any) => void;
                    'message-error': (error: unknown, provider: any) => void;
                    'schema-mismatch': (detail: import("./protocol.js").SchemaMismatchDetail, provider: any) => void;
                    failed: (error: unknown, provider: any) => void;
                }[NAME]): void;
                off<NAME extends "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "load-error">(name: NAME, f: {
                    synced: (provider: any) => void;
                    'protocol-mismatch': (mismatch: import("./protocol.js").ProtocolMismatch, provider: any) => void;
                    'load-error': (error: unknown, provider: any) => void;
                    'message-error': (error: unknown, provider: any) => void;
                    'schema-mismatch': (detail: import("./protocol.js").SchemaMismatchDetail, provider: any) => void;
                    failed: (error: unknown, provider: any) => void;
                }[NAME]): void;
            };
        };
        WebsocketProvider: {
            new (serverUrl: string, roomname: string, doc: YDoc, { connect, awareness, params, WebSocketPolyfill, resyncInterval, maxBackoffTime, connectTimeout, disableBc, maxFrameBytes }?: import("./protocol.js").WebsocketProviderOptions): {
                serverUrl: string;
                roomname: string;
                doc: YDoc;
                awareness: _Awareness;
                params: Record<string, string>;
                maxBackoffTime: number;
                connectTimeout: number;
                maxFrameBytes: number;
                _WS: import("./protocol.js").WebsocketPolyfill;
                shouldConnect: boolean;
                ws: WebSocket | null;
                wsconnected: boolean;
                bcChannel: string;
                bcconnected: boolean;
                disableBc: boolean;
                _bcSubscriber: (data: ArrayBuffer | Uint8Array, origin: unknown) => void;
                _fromTab: {};
                wsUnsuccessfulReconnects: number;
                wsLastMessageReceived: number;
                wsLastPingSent: number;
                _synced: boolean;
                _chunks: import("./protocol.js").ChunkReader;
                _writes: {
                    pending: {
                        sv: Map<number, number>;
                        deletes: import("./protocols/sync.js").IdSet;
                    }[];
                    acked: Map<number, number>;
                    readOnly: boolean;
                    faults: number;
                    fault(): number;
                    readonly doc: YDoc;
                    readonly changed: (unsaved: number) => void;
                    trackDocument(): void;
                    track(sv: Map<number, number>, deletes: import("./protocols/sync.js").IdSet): void;
                    acknowledge(sv: Uint8Array, deletes?: import("./protocols/sync.js").IdSet | null): void;
                    deny(): void;
                    allow(): void;
                };
                messageHandlers: Record<number, import("./providers/room.js").RoomMessageHandler<any>>;
                hasSynced: boolean;
                whenSynced: Promise<unknown>;
                _destroyed: boolean;
                _failedEmitted?: boolean;
                _settleSynced: import("./providers/room.js").LifecycleHost["_settleSynced"];
                _leave: () => void;
                _resync: ReturnType<typeof setInterval> | undefined;
                _connectTimer: ReturnType<typeof setTimeout> | undefined;
                _checkInterval: ReturnType<typeof setInterval>;
                _updateHandler: (update: Uint8Array, origin: unknown, doc?: unknown, transaction?: {
                    local: boolean;
                }) => void;
                _awarenessUpdateHandler: (updates: {
                    added: number[];
                    updated: number[];
                    removed: number[];
                }, origin: unknown) => void;
                get url(): string;
                get unsaved(): number;
                get saved(): boolean;
                get readOnly(): boolean;
                get synced(): boolean;
                set synced(state: boolean);
                destroy(): void;
                disconnect(): void;
                connect(): void;
                emit<N extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: N, args: Parameters<import("./protocol.js").WebsocketProviderEvents[N]>): void;
                _observers: Map<string, Set<any>>;
                on<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: import("./protocol.js").WebsocketProviderEvents[NAME]): import("./protocol.js").WebsocketProviderEvents[NAME];
                once<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: import("./protocol.js").WebsocketProviderEvents[NAME]): void;
                off<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: import("./protocol.js").WebsocketProviderEvents[NAME]): void;
            };
        };
        watchComments: (server: string, roomName: string, listener: (message: import("./protocol.js").CommentMessage) => void) => (() => void);
        storeState: (idbPersistence: {
            db: IDBDatabase | null;
            name: string;
            doc: YDoc;
            _dbref: number;
            _dbsize: number;
            _destroyed: boolean;
        }, forceStore?: boolean) => Promise<undefined>;
        clearDocument: (name: string) => Promise<void>;
        PREFERRED_TRIM_SIZE: number;
        createIndexeddbSync: (name: string) => import("./index.js").EdytorSync;
        createWebsocketSync: (options: import("./index.js").WebsocketSyncOptions) => import("./index.js").WebsocketSync;
    };
    sync: {
        messageYjsSyncStep1: number;
        messageYjsSyncStep2: number;
        messageYjsUpdate: number;
        remoteApplyOrigin: symbol;
        writeSyncStep1: (encoder: import("lib0-v14/encoding").Encoder, doc: YDoc) => void;
        writeSyncStep2: (encoder: import("lib0-v14/encoding").Encoder, doc: YDoc, encodedStateVector?: Uint8Array) => void;
        writeUpdate: (encoder: import("lib0-v14/encoding").Encoder, update: Uint8Array) => void;
        applyRemote: (doc: YDoc, update: Uint8Array, transactionOrigin: unknown, errorHandler?: (error: Error) => unknown) => {
            applied: boolean;
            problem: import("./edytor-doc.js").SchemaProblem | null;
            discarded?: import("./edytor-doc.js").SchemaProblem;
        };
        lacks: (doc: YDoc, sv: Uint8Array) => boolean;
        writeSaved: (encoder: import("lib0-v14/encoding").Encoder, doc: YDoc, deletes?: import("./protocols/sync.js").IdSet, unstored?: import("./protocols/sync.js").IdSet | null) => void;
        readSaved: (decoder: import("lib0-v14/decoding").Decoder) => {
            stateVector: Uint8Array;
            deletes: import("./protocols/sync.js").IdSet | null;
        };
    };
    admission: {
        admitUpdate: (update: Uint8Array | ReadonlyArray<Uint8Array>, docName?: string, options?: {
            prepare?: (doc: YDoc) => void;
        }) => YDoc;
    };
    attribution: {
        attach: (doc: import("./engine-api.js").EngineDoc, opts: {
            actor: import("./index.js").AttributionActor;
        }) => import("./index.js").AttributionController;
    };
};