@ckeditor/ckeditor5-engine 45.2.1-alpha.9 → 46.0.0-alpha.0

package/src/model/model.js

@@ -5,24 +5,24 @@
 /**
  * @module engine/model/model
  */
-import Batch from './batch.js';
-import Document from './document.js';
-import MarkerCollection from './markercollection.js';
-import ModelPosition from './position.js';
-import ModelRange from './range.js';
-import ModelSelection from './selection.js';
-import OperationFactory from './operation/operationfactory.js';
-import DocumentSelection from './documentselection.js';
-import Schema from './schema.js';
-import Writer from './writer.js';
-import Node from './node.js';
+import { Batch } from './batch.js';
+import { ModelDocument } from './document.js';
+import { MarkerCollection } from './markercollection.js';
+import { ModelPosition } from './position.js';
+import { ModelRange } from './range.js';
+import { ModelSelection } from './selection.js';
+import { OperationFactory } from './operation/operationfactory.js';
+import { ModelDocumentSelection } from './documentselection.js';
+import { ModelSchema } from './schema.js';
+import { ModelWriter } from './writer.js';
+import { ModelNode } from './node.js';
 import { autoParagraphEmptyRoots } from './utils/autoparagraphing.js';
 import { injectSelectionPostFixer } from './utils/selection-post-fixer.js';
-import deleteContent from './utils/deletecontent.js';
-import getSelectedContent from './utils/getselectedcontent.js';
-import insertContent from './utils/insertcontent.js';
-import insertObject from './utils/insertobject.js';
-import modifySelection from './utils/modifyselection.js';
+import { deleteContent } from './utils/deletecontent.js';
+import { getSelectedContent } from './utils/getselectedcontent.js';
+import { insertContent } from './utils/insertcontent.js';
+import { insertObject } from './utils/insertobject.js';
+import { modifySelection } from './utils/modifyselection.js';
 import { CKEditorError, ObservableMixin } from '@ckeditor/ckeditor5-utils';
 // @if CK_DEBUG_ENGINE // const { dumpTrees, initDocumentDumping } = require( '../dev-utils/utils' );
 // @if CK_DEBUG_ENGINE // const { OperationReplayer } = require( '../dev-utils/operationreplayer' ).default;
@@ -30,7 +30,7 @@ import { CKEditorError, ObservableMixin } from '@ckeditor/ckeditor5-utils';
  * Editor's data model. Read about the model in the
  * {@glink framework/architecture/editing-engine engine architecture} guide.
  */
-export default class Model extends /* #__PURE__ */ ObservableMixin() {
+export class Model extends /* #__PURE__ */ ObservableMixin() {
     /**
      * Model's marker collection.
      */
@@ -57,8 +57,8 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
     constructor() {
         super();
         this.markers = new MarkerCollection();
-        this.document = new Document(this);
-        this.schema = new Schema();
+        this.document = new ModelDocument(this);
+        this.schema = new ModelSchema();
         this._pendingChanges = [];
         this._currentWriter = null;
         ['deleteContent', 'modifySelection', 'getSelectedContent', 'applyOperation']
@@ -142,7 +142,7 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
     /**
      * The `change()` method is the primary way of changing the model. You should use it to modify all document nodes
      * (including detached nodes – i.e. nodes not added to the {@link module:engine/model/model~Model#document model document}),
-     * the {@link module:engine/model/document~Document#selection document's selection}, and
+     * the {@link module:engine/model/document~ModelDocument#selection document's selection}, and
      * {@link module:engine/model/model~Model#markers model markers}.
      *
      * ```ts
@@ -226,7 +226,7 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
      * {@link module:engine/model/operation/operation~Operation operations} to the model.
      *
      * This is a low-level way of changing the model. It is exposed for very specific use cases (like the undo feature).
-     * Normally, to modify the model, you will want to use {@link module:engine/model/writer~Writer `Writer`}.
+     * Normally, to modify the model, you will want to use {@link module:engine/model/writer~ModelWriter `Writer`}.
      * See also {@glink framework/architecture/editing-engine#changing-the-model Changing the model} section
      * of the {@glink framework/architecture/editing-engine Editing architecture} guide.
      *
@@ -260,9 +260,9 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
      * It can split elements, merge them, wrap bare text nodes with paragraphs, etc. – just like the
      * pasting feature should do.
      *
-     * For lower-level methods see {@link module:engine/model/writer~Writer `Writer`}.
+     * For lower-level methods see {@link module:engine/model/writer~ModelWriter `Writer`}.
      *
-     * This method, unlike {@link module:engine/model/writer~Writer `Writer`}'s methods, does not have to be used
+     * This method, unlike {@link module:engine/model/writer~ModelWriter `Writer`}'s methods, does not have to be used
      * inside a {@link #change `change()` block}.
      *
      * # Conversion and schema
@@ -349,7 +349,7 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
      * ```
      *
      * If you want the document selection to be moved to the inserted content, use the
-     * {@link module:engine/model/writer~Writer#setSelection `setSelection()`} method of the writer after inserting
+     * {@link module:engine/model/writer~ModelWriter#setSelection `setSelection()`} method of the writer after inserting
      * the content:
      *
      * ```ts
@@ -364,7 +364,7 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
      * } );
      * ```
      *
-     * If an instance of the {@link module:engine/model/selection~Selection model selection} is passed as `selectable`,
+     * If an instance of the {@link module:engine/model/selection~ModelSelection model selection} is passed as `selectable`,
      * the new content will be inserted at the passed selection (instead of document selection):
      *
      * ```ts
@@ -408,8 +408,8 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
      * # Notes
      *
      * * If you want to insert a non-object content, see {@link #insertContent} instead.
-     * * For lower-level API, see {@link module:engine/model/writer~Writer `Writer`}.
-     * * Unlike {@link module:engine/model/writer~Writer `Writer`}, this method does not have to be used inside
+     * * For lower-level API, see {@link module:engine/model/writer~ModelWriter `Writer`}.
+     * * Unlike {@link module:engine/model/writer~ModelWriter `Writer`}, this method does not have to be used inside
      * a {@link #change `change()` block}.
      * * Inserting object into the model is not enough to make CKEditor 5 render that content to the user.
      * CKEditor 5 implements a model-view-controller architecture and what `model.insertObject()` does
@@ -460,7 +460,7 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
      *
      * @param element An object to be inserted into the model document.
      * @param selectable A selectable where the content should be inserted. If not specified, the current
-     * {@link module:engine/model/document~Document#selection document selection} will be used instead.
+     * {@link module:engine/model/document~ModelDocument#selection document selection} will be used instead.
      * @param placeOrOffset Specifies the exact place or offset for the insertion to take place, relative to `selectable`.
      * @param options Additional options.
      * @param options.findOptimalPosition An option that, when set, adjusts the insertion position (relative to
@@ -471,7 +471,7 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
      *
      * Note that this option only works for block objects. Inline objects are inserted into text and do not split blocks.
      * @param options.setSelection An option that, when set, moves the
-     * {@link module:engine/model/document~Document#selection document selection} after inserting the object.
+     * {@link module:engine/model/document~ModelDocument#selection document selection} after inserting the object.
      * * When `'on'`, the document selection will be set on the inserted object.
      * * When `'after'`, the document selection will move to the closest text node after the inserted object. If there is no
      * such text node, a paragraph will be created and the document selection will be moved inside it.
@@ -503,7 +503,7 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
      * * `<heading1>x^y</heading1>` with the option disabled (`leaveUnmerged == false`)
      * * `<heading1>x^</heading1><paragraph>y</paragraph>` with enabled (`leaveUnmerged == true`).
      *
-     * Note: {@link module:engine/model/schema~Schema#isObject object} and {@link module:engine/model/schema~Schema#isLimit limit}
+     * Note: {@link module:engine/model/schema~ModelSchema#isObject object} and {@link module:engine/model/schema~ModelSchema#isLimit limit}
      * elements will not be merged.
      *
      * @param options.doNotResetEntireContent Whether to skip replacing the entire content with a
@@ -595,14 +595,14 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
         return getSelectedContent(this, selection);
     }
     /**
-     * Checks whether the given {@link module:engine/model/range~Range range} or
-     * {@link module:engine/model/element~Element element} has any meaningful content.
+     * Checks whether the given {@link module:engine/model/range~ModelRange range} or
+     * {@link module:engine/model/element~ModelElement element} has any meaningful content.
      *
      * Meaningful content is:
      *
      * * any text node (`options.ignoreWhitespaces` allows controlling whether this text node must also contain
      * any non-whitespace characters),
-     * * or any {@link module:engine/model/schema~Schema#isContent content element},
+     * * or any {@link module:engine/model/schema~ModelSchema#isContent content element},
      * * or any {@link module:engine/model/markercollection~Marker marker} which
      * {@link module:engine/model/markercollection~Marker#_affectsData affects data}.
      *
@@ -654,7 +654,7 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
      *
      * This method is decorated. Although this method accepts any parameter of `Selectable` type, the
      * {@link ~Model#event:canEditAt `canEditAt` event} is fired with `selectable` normalized to an instance of
-     * {@link module:engine/model/selection~Selection} or {@link module:engine/model/documentselection~DocumentSelection}
+     * {@link module:engine/model/selection~ModelSelection} or {@link module:engine/model/documentselection~ModelDocumentSelection}
      *
      * @fires canEditAt
      */
@@ -666,11 +666,11 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
      * Creates a position from the given root and path in that root.
      *
      * Note: This method is also available as
-     * {@link module:engine/model/writer~Writer#createPositionFromPath `Writer#createPositionFromPath()`}.
+     * {@link module:engine/model/writer~ModelWriter#createPositionFromPath `Writer#createPositionFromPath()`}.
      *
      * @param root Root of the position.
-     * @param path Position path. See {@link module:engine/model/position~Position#path}.
-     * @param stickiness Position stickiness. See {@link module:engine/model/position~PositionStickiness}.
+     * @param path Position path. See {@link module:engine/model/position~ModelPosition#path}.
+     * @param stickiness Position stickiness. See {@link module:engine/model/position~ModelPositionStickiness}.
      */
     createPositionFromPath(root, path, stickiness) {
         return new ModelPosition(root, path, stickiness);
@@ -678,10 +678,10 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
     /**
      * Creates position at the given location. The location can be specified as:
      *
-     * * a {@link module:engine/model/position~Position position},
+     * * a {@link module:engine/model/position~ModelPosition position},
      * * a parent element and offset in that element,
      * * a parent element and `'end'` (the position will be set at the end of that element),
-     * * a {@link module:engine/model/item~Item model item} and `'before'` or `'after'`
+     * * a {@link module:engine/model/item~ModelItem model item} and `'before'` or `'after'`
      * (the position will be set before or after the given model item).
      *
      * This method is a shortcut to other factory methods such as:
@@ -690,19 +690,19 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
      * * {@link module:engine/model/model~Model#createPositionAfter `createPositionAfter()`}.
      *
      * Note: This method is also available as
-     * {@link module:engine/model/writer~Writer#createPositionAt `Writer#createPositionAt()`},
+     * {@link module:engine/model/writer~ModelWriter#createPositionAt `Writer#createPositionAt()`},
      *
      * @param itemOrPosition
-     * @param offset Offset or one of the flags. Used only when first parameter is a {@link module:engine/model/item~Item model item}.
+     * @param offset Offset or one of the flags. Used only when first parameter is a {@link module:engine/model/item~ModelItem model item}.
      */
     createPositionAt(itemOrPosition, offset) {
         return ModelPosition._createAt(itemOrPosition, offset);
     }
     /**
-     * Creates a new position after the given {@link module:engine/model/item~Item model item}.
+     * Creates a new position after the given {@link module:engine/model/item~ModelItem model item}.
      *
      * Note: This method is also available as
-     * {@link module:engine/model/writer~Writer#createPositionAfter `Writer#createPositionAfter()`}.
+     * {@link module:engine/model/writer~ModelWriter#createPositionAfter `Writer#createPositionAfter()`}.
      *
      * @param item Item after which the position should be placed.
      */
@@ -710,10 +710,10 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
         return ModelPosition._createAfter(item);
     }
     /**
-     * Creates a new position before the given {@link module:engine/model/item~Item model item}.
+     * Creates a new position before the given {@link module:engine/model/item~ModelItem model item}.
      *
      * Note: This method is also available as
-     * {@link module:engine/model/writer~Writer#createPositionBefore `Writer#createPositionBefore()`}.
+     * {@link module:engine/model/writer~ModelWriter#createPositionBefore `Writer#createPositionBefore()`}.
      *
      * @param item Item before which the position should be placed.
      */
@@ -724,7 +724,7 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
      * Creates a range spanning from the `start` position to the `end` position.
      *
      * Note: This method is also available as
-     * {@link module:engine/model/writer~Writer#createRange `Writer#createRange()`}:
+     * {@link module:engine/model/writer~ModelWriter#createRange `Writer#createRange()`}:
      *
      * ```ts
      * model.change( writer => {
@@ -743,7 +743,7 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
      * that element and ends after the last child of that element.
      *
      * Note: This method is also available as
-     * {@link module:engine/model/writer~Writer#createRangeIn `Writer#createRangeIn()`}:
+     * {@link module:engine/model/writer~ModelWriter#createRangeIn `Writer#createRangeIn()`}:
      *
      * ```ts
      * model.change( writer => {
@@ -757,10 +757,10 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
         return ModelRange._createIn(element);
     }
     /**
-     * Creates a range that starts before the given {@link module:engine/model/item~Item model item} and ends after it.
+     * Creates a range that starts before the given {@link module:engine/model/item~ModelItem model item} and ends after it.
      *
      * Note: This method is also available on `writer` instance as
-     * {@link module:engine/model/writer~Writer#createRangeOn `Writer.createRangeOn()`}:
+     * {@link module:engine/model/writer~ModelWriter#createRangeOn `Writer.createRangeOn()`}:
      *
      * ```ts
      * model.change( writer => {
@@ -800,7 +800,7 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
         return OperationFactory.fromJSON(json, this.document);
     }
     /**
-     * Removes all events listeners set by model instance and destroys {@link module:engine/model/document~Document}.
+     * Removes all events listeners set by model instance and destroys {@link module:engine/model/document~ModelDocument}.
      */
     destroy() {
         this.document.destroy();
@@ -817,7 +817,7 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
             while (this._pendingChanges.length) {
                 // Create a new writer using batch instance created for this chain of changes.
                 const currentBatch = this._pendingChanges[0].batch;
-                this._currentWriter = new Writer(this, currentBatch);
+                this._currentWriter = new ModelWriter(this, currentBatch);
                 // Execute changes callback and gather the returned value.
                 const callbackReturnValue = this._pendingChanges[0].callback(this._currentWriter);
                 ret.push(callbackReturnValue);
@@ -835,16 +835,16 @@ export default class Model extends /* #__PURE__ */ ObservableMixin() {
     }
 }
 /**
- * Normalizes a selectable to a Selection or DocumentSelection.
+ * Normalizes a selectable to a Selection or ModelDocumentSelection.
  */
 function normalizeSelectable(selectable, placeOrOffset) {
     if (!selectable) {
         return;
     }
-    if (selectable instanceof ModelSelection || selectable instanceof DocumentSelection) {
+    if (selectable instanceof ModelSelection || selectable instanceof ModelDocumentSelection) {
         return selectable;
     }
-    if (selectable instanceof Node) {
+    if (selectable instanceof ModelNode) {
         if (placeOrOffset || placeOrOffset === 0) {
             return new ModelSelection(selectable, placeOrOffset);
         }

package/src/model/node.d.ts

@@ -5,10 +5,10 @@
 /**
  * @module engine/model/node
  */
-import TypeCheckable from './typecheckable.js';
-import type Document from './document.js';
-import type DocumentFragment from './documentfragment.js';
-import type Element from './element.js';
+import { ModelTypeCheckable } from './typecheckable.js';
+import { type ModelDocument } from './document.js';
+import { type ModelDocumentFragment } from './documentfragment.js';
+import { type ModelElement } from './element.js';
 /**
  * Model node. Most basic structure of model tree.
  *
@@ -16,12 +16,12 @@ import type Element from './element.js';
  *
  * **Note:** If a node is detached from the model tree, you can manipulate it using it's API.
  * However, it is **very important** that nodes already attached to model tree should be only changed through
- * {@link module:engine/model/writer~Writer Writer API}.
+ * {@link module:engine/model/writer~ModelWriter Writer API}.
  *
- * Changes done by `Node` methods, like {@link module:engine/model/element~Element#_insertChild _insertChild} or
- * {@link module:engine/model/node~Node#_setAttribute _setAttribute}
+ * Changes done by `Node` methods, like {@link module:engine/model/element~ModelElement#_insertChild _insertChild} or
+ * {@link module:engine/model/node~ModelNode#_setAttribute _setAttribute}
  * do not generate {@link module:engine/model/operation/operation~Operation operations}
- * which are essential for correct editor work if you modify nodes in {@link module:engine/model/document~Document document} root.
+ * which are essential for correct editor work if you modify nodes in {@link module:engine/model/document~ModelDocument document} root.
  *
  * The flow of working on `Node` (and classes that inherits from it) is as such:
  * 1. You can create a `Node` instance, modify it using it's API.
@@ -29,23 +29,23 @@ import type Element from './element.js';
  * 3. Change `Node` that was already added to the model using `Batch` API.
  *
  * Similarly, you cannot use `Batch` API on a node that has not been added to the model tree, with the exception
- * of {@link module:engine/model/writer~Writer#insert inserting} that node to the model tree.
+ * of {@link module:engine/model/writer~ModelWriter#insert inserting} that node to the model tree.
  *
- * Be aware that using {@link module:engine/model/writer~Writer#remove remove from Batch API} does not allow to use `Node` API because
+ * Be aware that using {@link module:engine/model/writer~ModelWriter#remove remove from Batch API} does not allow to use `Node` API because
  * the information about `Node` is still kept in model document.
  *
- * In case of {@link module:engine/model/element~Element element node}, adding and removing children also counts as changing a node and
+ * In case of {@link module:engine/model/element~ModelElement element node}, adding and removing children also counts as changing a node and
  * follows same rules.
  */
-export default abstract class Node extends TypeCheckable {
+export declare abstract class ModelNode extends ModelTypeCheckable {
     /**
-     * Parent of this node. It could be {@link module:engine/model/element~Element}
-     * or {@link module:engine/model/documentfragment~DocumentFragment}.
+     * Parent of this node. It could be {@link module:engine/model/element~ModelElement}
+     * or {@link module:engine/model/documentfragment~ModelDocumentFragment}.
      * Equals to `null` if the node has no parent.
      */
-    readonly parent: Element | DocumentFragment | null;
+    readonly parent: ModelElement | ModelDocumentFragment | null;
     /**
-     * Unique root name used to identify this root element by {@link module:engine/model/document~Document}.
+     * Unique root name used to identify this root element by {@link module:engine/model/document~ModelDocument}.
      */
     readonly rootName: string | undefined;
     /**
@@ -71,11 +71,11 @@ export default abstract class Node extends TypeCheckable {
      *
      * @param attrs Node's attributes. See {@link module:utils/tomap~toMap} for a list of accepted values.
      */
-    constructor(attrs?: NodeAttributes);
+    constructor(attrs?: ModelNodeAttributes);
     /**
-     * {@link module:engine/model/document~Document Document} that owns this root element.
+     * {@link module:engine/model/document~ModelDocument Document} that owns this root element.
      */
-    get document(): Document | null;
+    get document(): ModelDocument | null;
     /**
      * Index of this node in its parent or `null` if the node has no parent.
      */
@@ -89,45 +89,45 @@ export default abstract class Node extends TypeCheckable {
      * Offset size of this node.
      *
      * Represents how much "offset space" is occupied by the node in its parent. It is important for
-     * {@link module:engine/model/position~Position position}. When node has `offsetSize` greater than `1`, position can be placed between
-     * that node start and end. `offsetSize` greater than `1` is for nodes that represents more than one entity, i.e.
-     * a {@link module:engine/model/text~Text text node}.
+     * {@link module:engine/model/position~ModelPosition position}. When node has `offsetSize` greater
+     * than `1`, position can be placed between that node start and end. `offsetSize` greater than `1` is for
+     * nodes that represents more than one entity, i.e. a {@link module:engine/model/text~ModelText text node}.
      */
     get offsetSize(): number;
     /**
      * Offset at which this node ends in its parent. It is equal to the sum of this node's
-     * {@link module:engine/model/node~Node#startOffset start offset} and {@link #offsetSize offset size}.
+     * {@link module:engine/model/node~ModelNode#startOffset start offset} and {@link #offsetSize offset size}.
      * Equals to `null` if the node has no parent.
      */
     get endOffset(): number | null;
     /**
      * Node's next sibling or `null` if the node is a last child of it's parent or if the node has no parent.
      */
-    get nextSibling(): Node | null;
+    get nextSibling(): ModelNode | null;
     /**
      * Node's previous sibling or `null` if the node is a first child of it's parent or if the node has no parent.
      */
-    get previousSibling(): Node | null;
+    get previousSibling(): ModelNode | null;
     /**
      * The top-most ancestor of the node. If node has no parent it is the root itself. If the node is a part
-     * of {@link module:engine/model/documentfragment~DocumentFragment}, it's `root` is equal to that `DocumentFragment`.
+     * of {@link module:engine/model/documentfragment~ModelDocumentFragment}, it's `root` is equal to that `DocumentFragment`.
      */
-    get root(): Node | DocumentFragment;
+    get root(): ModelNode | ModelDocumentFragment;
     /**
      * Returns `true` if the node is inside a document root that is attached to the document.
      */
     isAttached(): boolean;
     /**
      * Gets path to the node. The path is an array containing starting offsets of consecutive ancestors of this node,
-     * beginning from {@link module:engine/model/node~Node#root root}, down to this node's starting offset. The path can be used to
-     * create {@link module:engine/model/position~Position Position} instance.
+     * beginning from {@link module:engine/model/node~ModelNode#root root}, down to this node's starting offset. The path can be used to
+     * create {@link module:engine/model/position~ModelPosition Position} instance.
      *
      * ```ts
      * const abc = new Text( 'abc' );
      * const foo = new Text( 'foo' );
-     * const h1 = new Element( 'h1', null, new Text( 'header' ) );
-     * const p = new Element( 'p', null, [ abc, foo ] );
-     * const div = new Element( 'div', null, [ h1, p ] );
+     * const h1 = new ModelElement( 'h1', null, new Text( 'header' ) );
+     * const p = new ModelElement( 'p', null, [ abc, foo ] );
+     * const div = new ModelElement( 'div', null, [ h1, p ] );
      * foo.getPath(); // Returns [ 1, 3 ]. `foo` is in `p` which is in `div`. `p` starts at offset 1, while `foo` at 3.
      * h1.getPath(); // Returns [ 0 ].
      * div.getPath(); // Returns [].
@@ -146,9 +146,9 @@ export default abstract class Node extends TypeCheckable {
     getAncestors(options?: {
         includeSelf?: boolean;
         parentFirst?: boolean;
-    }): Array<Node | DocumentFragment>;
+    }): Array<ModelNode | ModelDocumentFragment>;
     /**
-     * Returns a {@link module:engine/model/element~Element} or {@link module:engine/model/documentfragment~DocumentFragment}
+     * Returns a {@link module:engine/model/element~ModelElement} or {@link module:engine/model/documentfragment~ModelDocumentFragment}
      * which is a common ancestor of both nodes.
      *
      * @param node The second node.
@@ -156,23 +156,23 @@ export default abstract class Node extends TypeCheckable {
      * @param options.includeSelf When set to `true` both nodes will be considered "ancestors" too.
      * Which means that if e.g. node A is inside B, then their common ancestor will be B.
      */
-    getCommonAncestor(node: Node, options?: {
+    getCommonAncestor(node: ModelNode, options?: {
         includeSelf?: boolean;
-    }): Element | DocumentFragment | null;
+    }): ModelElement | ModelDocumentFragment | null;
     /**
      * Returns whether this node is before given node. `false` is returned if nodes are in different trees (for example,
-     * in different {@link module:engine/model/documentfragment~DocumentFragment}s).
+     * in different {@link module:engine/model/documentfragment~ModelDocumentFragment}s).
      *
      * @param node Node to compare with.
      */
-    isBefore(node: Node): boolean;
+    isBefore(node: ModelNode): boolean;
     /**
      * Returns whether this node is after given node. `false` is returned if nodes are in different trees (for example,
-     * in different {@link module:engine/model/documentfragment~DocumentFragment}s).
+     * in different {@link module:engine/model/documentfragment~ModelDocumentFragment}s).
      *
      * @param node Node to compare with.
      */
-    isAfter(node: Node): boolean;
+    isAfter(node: ModelNode): boolean;
     /**
      * Checks if the node has an attribute with given key.
      *
@@ -210,18 +210,18 @@ export default abstract class Node extends TypeCheckable {
      * @internal
      * @returns Node with same attributes as this node.
      */
-    _clone(_deep?: boolean): Node;
+    _clone(_deep?: boolean): ModelNode;
     /**
      * Removes this node from its parent.
      *
      * @internal
-     * @see module:engine/model/writer~Writer#remove
+     * @see module:engine/model/writer~ModelWriter#remove
      */
     _remove(): void;
     /**
      * Sets attribute on the node. If attribute with the same key already is set, it's value is overwritten.
      *
-     * @see module:engine/model/writer~Writer#setAttribute
+     * @see module:engine/model/writer~ModelWriter#setAttribute
      * @internal
      * @param key Key of attribute to set.
      * @param value Attribute value.
@@ -230,15 +230,15 @@ export default abstract class Node extends TypeCheckable {
     /**
      * Removes all attributes from the node and sets given attributes.
      *
-     * @see module:engine/model/writer~Writer#setAttributes
+     * @see module:engine/model/writer~ModelWriter#setAttributes
      * @internal
      * @param attrs Attributes to set. See {@link module:utils/tomap~toMap} for a list of accepted values.
      */
-    _setAttributesTo(attrs: NodeAttributes): void;
+    _setAttributesTo(attrs: ModelNodeAttributes): void;
     /**
      * Removes an attribute with given key from the node.
      *
-     * @see module:engine/model/writer~Writer#removeAttribute
+     * @see module:engine/model/writer~ModelWriter#removeAttribute
      * @internal
      * @param key Key of attribute to remove.
      * @returns `true` if the attribute was set on the element, `false` otherwise.
@@ -247,7 +247,7 @@ export default abstract class Node extends TypeCheckable {
     /**
      * Removes all attributes from the node.
      *
-     * @see module:engine/model/writer~Writer#clearAttributes
+     * @see module:engine/model/writer~ModelWriter#clearAttributes
      * @internal
      */
     _clearAttributes(): void;
@@ -255,4 +255,4 @@ export default abstract class Node extends TypeCheckable {
 /**
  * Node's attributes. See {@link module:utils/tomap~toMap} for a list of accepted values.
  */
-export type NodeAttributes = Record<string, unknown> | Iterable<[string, unknown]>;
+export type ModelNodeAttributes = Record<string, unknown> | Iterable<[string, unknown]>;