@ckeditor/ckeditor5-engine 45.2.1 → 46.0.0-alpha.1

package/src/model/selection.js

@@ -5,19 +5,19 @@
 /**
  * @module engine/model/selection
  */
-import TypeCheckable from './typecheckable.js';
-import Node from './node.js';
-import Position from './position.js';
-import Range from './range.js';
+import { ModelTypeCheckable } from './typecheckable.js';
+import { ModelNode } from './node.js';
+import { ModelPosition } from './position.js';
+import { ModelRange } from './range.js';
 import { CKEditorError, EmitterMixin, isIterable } from '@ckeditor/ckeditor5-utils';
 /**
- * Selection is a set of {@link module:engine/model/range~Range ranges}. It has a direction specified by its
- * {@link module:engine/model/selection~Selection#anchor anchor} and {@link module:engine/model/selection~Selection#focus focus}
- * (it can be {@link module:engine/model/selection~Selection#isBackward forward or backward}).
+ * Selection is a set of {@link module:engine/model/range~ModelRange ranges}. It has a direction specified by its
+ * {@link module:engine/model/selection~ModelSelection#anchor anchor} and {@link module:engine/model/selection~ModelSelection#focus focus}
+ * (it can be {@link module:engine/model/selection~ModelSelection#isBackward forward or backward}).
  * Additionally, selection may have its own attributes (think – whether text typed in in this selection
  * should have those attributes – e.g. whether you type a bolded text).
  */
-export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckable) {
+export class ModelSelection extends /* #__PURE__ */ EmitterMixin(ModelTypeCheckable) {
     /**
      * Specifies whether the last added range was added as a backward or forward range.
      */
@@ -29,7 +29,7 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
     /** @internal */
     _ranges = [];
     /**
-     * Creates a new selection instance based on the given {@link module:engine/model/selection~Selectable selectable}
+     * Creates a new selection instance based on the given {@link module:engine/model/selection~ModelSelectable selectable}
      * or creates an empty selection if no arguments were passed.
      *
      * ```ts
@@ -62,11 +62,11 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
      * const paragraph = writer.createElement( 'paragraph' );
      * const selection = writer.createSelection( paragraph, offset );
      *
-     * // Creates a range inside an {@link module:engine/model/element~Element element} which starts before the
+     * // Creates a range inside an {@link module:engine/model/element~ModelElement element} which starts before the
      * // first child of that element and ends after the last child of that element.
      * const selection = writer.createSelection( paragraph, 'in' );
      *
-     * // Creates a range on an {@link module:engine/model/item~Item item} which starts before the item and ends
+     * // Creates a range on an {@link module:engine/model/item~ModelItem item} which starts before the item and ends
      * // just after the item.
      * const selection = writer.createSelection( paragraph, 'on' );
      * ```
@@ -93,8 +93,8 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
      * Anchor and {@link #focus} define the direction of the selection, which is important
      * when expanding/shrinking selection. The focus moves, while the anchor should remain in the same place.
      *
-     * Anchor is always set to the {@link module:engine/model/range~Range#start start} or
-     * {@link module:engine/model/range~Range#end end} position of the last of selection's ranges. Whether it is
+     * Anchor is always set to the {@link module:engine/model/range~ModelRange#start start} or
+     * {@link module:engine/model/range~ModelRange#end end} position of the last of selection's ranges. Whether it is
      * the `start` or `end` depends on the specified `options.backward`. See the {@link #setTo `setTo()`} method.
      *
      * May be set to `null` if there are no ranges in the selection.
@@ -184,13 +184,13 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
      */
     *getRanges() {
         for (const range of this._ranges) {
-            yield new Range(range.start, range.end);
+            yield new ModelRange(range.start, range.end);
         }
     }
     /**
      * Returns a copy of the first range in the selection.
-     * First range is the one which {@link module:engine/model/range~Range#start start} position
-     * {@link module:engine/model/position~Position#isBefore is before} start position of all other ranges
+     * First range is the one which {@link module:engine/model/range~ModelRange#start start} position
+     * {@link module:engine/model/position~ModelPosition#isBefore is before} start position of all other ranges
      * (not to confuse with the first range added to the selection).
      *
      * Returns `null` if there are no ranges in selection.
@@ -202,13 +202,13 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
                 first = range;
             }
         }
-        return first ? new Range(first.start, first.end) : null;
+        return first ? new ModelRange(first.start, first.end) : null;
     }
     /**
      * Returns a copy of the last range in the selection.
-     * Last range is the one which {@link module:engine/model/range~Range#end end} position
-     * {@link module:engine/model/position~Position#isAfter is after} end position of all other ranges (not to confuse with the range most
-     * recently added to the selection).
+     * Last range is the one which {@link module:engine/model/range~ModelRange#end end} position
+     * {@link module:engine/model/position~ModelPosition#isAfter is after} end position of all other
+     * ranges (not to confuse with the range most recently added to the selection).
      *
      * Returns `null` if there are no ranges in selection.
      */
@@ -219,11 +219,11 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
                 last = range;
             }
         }
-        return last ? new Range(last.start, last.end) : null;
+        return last ? new ModelRange(last.start, last.end) : null;
     }
     /**
      * Returns the first position in the selection.
-     * First position is the position that {@link module:engine/model/position~Position#isBefore is before}
+     * First position is the position that {@link module:engine/model/position~ModelPosition#isBefore is before}
      * any other position in the selection.
      *
      * Returns `null` if there are no ranges in selection.
@@ -234,7 +234,7 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
     }
     /**
      * Returns the last position in the selection.
-     * Last position is the position that {@link module:engine/model/position~Position#isAfter is after}
+     * Last position is the position that {@link module:engine/model/position~ModelPosition#isAfter is after}
      * any other position in the selection.
      *
      * Returns `null` if there are no ranges in selection.
@@ -245,7 +245,7 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
     }
     /**
      * Sets this selection's ranges and direction to the specified location based on the given
-     * {@link module:engine/model/selection~Selectable selectable}.
+     * {@link module:engine/model/selection~ModelSelectable selectable}.
      *
      * ```ts
      * // Removes all selection's ranges.
@@ -266,7 +266,7 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
      *
      * // Sets selection to the given document selection.
      * // Note: It doesn't copy selection attributes.
-     * const documentSelection = new DocumentSelection( doc );
+     * const documentSelection = new ModelDocumentSelection( doc );
      * selection.setTo( documentSelection );
      *
      * // Sets collapsed selection at the given position.
@@ -277,14 +277,14 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
      * selection.setTo( paragraph, offset );
      * ```
      *
-     * Creates a range inside an {@link module:engine/model/element~Element element} which starts before the first child of
+     * Creates a range inside an {@link module:engine/model/element~ModelElement element} which starts before the first child of
      * that element and ends after the last child of that element.
      *
      * ```ts
      * selection.setTo( paragraph, 'in' );
      * ```
      *
-     * Creates a range on an {@link module:engine/model/item~Item item} which starts before the item and ends just after the item.
+     * Creates a range on an {@link module:engine/model/item~ModelItem item} which starts before the item and ends just after the item.
      *
      * ```ts
      * selection.setTo( paragraph, 'on' );
@@ -306,31 +306,31 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
         if (selectable === null) {
             this._setRanges([]);
         }
-        else if (selectable instanceof Selection) {
+        else if (selectable instanceof ModelSelection) {
             this._setRanges(selectable.getRanges(), selectable.isBackward);
         }
         else if (selectable && typeof selectable.getRanges == 'function') {
-            // We assume that the selectable is a DocumentSelection.
+            // We assume that the selectable is a ModelDocumentSelection.
             // It can't be imported here, because it would lead to circular imports.
             this._setRanges(selectable.getRanges(), selectable.isBackward);
         }
-        else if (selectable instanceof Range) {
+        else if (selectable instanceof ModelRange) {
             this._setRanges([selectable], !!options && !!options.backward);
         }
-        else if (selectable instanceof Position) {
-            this._setRanges([new Range(selectable)]);
+        else if (selectable instanceof ModelPosition) {
+            this._setRanges([new ModelRange(selectable)]);
         }
-        else if (selectable instanceof Node) {
+        else if (selectable instanceof ModelNode) {
             const backward = !!options && !!options.backward;
             let range;
             if (placeOrOffset == 'in') {
-                range = Range._createIn(selectable);
+                range = ModelRange._createIn(selectable);
             }
             else if (placeOrOffset == 'on') {
-                range = Range._createOn(selectable);
+                range = ModelRange._createOn(selectable);
             }
             else if (placeOrOffset !== undefined) {
-                range = new Range(Position._createAt(selectable, placeOrOffset));
+                range = new ModelRange(ModelPosition._createAt(selectable, placeOrOffset));
             }
             else {
                 /**
@@ -352,8 +352,8 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
              *
              * Invalid parameters were specified when setting the selection. Common issues:
              *
-             * * A {@link module:engine/model/textproxy~TextProxy} instance was passed instead of
-             * a real {@link module:engine/model/text~Text}.
+             * * A {@link module:engine/model/textproxy~ModelTextProxy} instance was passed instead of
+             * a real {@link module:engine/model/text~ModelText}.
              * * View nodes were passed instead of model nodes.
              * * `null`/`undefined` was passed.
              *
@@ -364,8 +364,8 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
     }
     /**
      * Replaces all ranges that were added to the selection with given array of ranges. Last range of the array
-     * is treated like the last added range and is used to set {@link module:engine/model/selection~Selection#anchor} and
-     * {@link module:engine/model/selection~Selection#focus}. Accepts a flag describing in which direction the selection is made.
+     * is treated like the last added range and is used to set {@link module:engine/model/selection~ModelSelection#anchor} and
+     * {@link module:engine/model/selection~ModelSelection#focus}. Accepts a flag describing in which direction the selection is made.
      *
      * @fires change:range
      * @param newRanges Ranges to set.
@@ -376,11 +376,11 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
         const ranges = Array.from(newRanges);
         // Check whether there is any range in new ranges set that is different than all already added ranges.
         const anyNewRange = ranges.some(newRange => {
-            if (!(newRange instanceof Range)) {
+            if (!(newRange instanceof ModelRange)) {
                 /**
-                 * Selection range set to an object that is not an instance of {@link module:engine/model/range~Range}.
+                 * Selection range set to an object that is not an instance of {@link module:engine/model/range~ModelRange}.
                  *
-                 * Only {@link module:engine/model/range~Range} instances can be used to set a selection.
+                 * Only {@link module:engine/model/range~ModelRange} instances can be used to set a selection.
                  * Common mistakes leading to this error are:
                  *
                  * * using DOM `Range` object,
@@ -403,13 +403,13 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
         this.fire('change:range', { directChange: true });
     }
     /**
-     * Moves {@link module:engine/model/selection~Selection#focus} to the specified location.
+     * Moves {@link module:engine/model/selection~ModelSelection#focus} to the specified location.
      *
      * The location can be specified in the same form as
-     * {@link module:engine/model/writer~Writer#createPositionAt writer.createPositionAt()} parameters.
+     * {@link module:engine/model/writer~ModelWriter#createPositionAt writer.createPositionAt()} parameters.
      *
      * @fires change:range
-     * @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}.
      */
     setFocus(itemOrPosition, offset) {
         if (this.anchor === null) {
@@ -420,7 +420,7 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
              */
             throw new CKEditorError('model-selection-setfocus-no-ranges', [this, itemOrPosition]);
         }
-        const newFocus = Position._createAt(itemOrPosition, offset);
+        const newFocus = ModelPosition._createAt(itemOrPosition, offset);
         if (newFocus.compareWith(this.focus) == 'same') {
             return;
         }
@@ -429,11 +429,11 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
             this._popRange();
         }
         if (newFocus.compareWith(anchor) == 'before') {
-            this._pushRange(new Range(newFocus, anchor));
+            this._pushRange(new ModelRange(newFocus, anchor));
             this._lastRangeBackward = true;
         }
         else {
-            this._pushRange(new Range(anchor, newFocus));
+            this._pushRange(new ModelRange(anchor, newFocus));
             this._lastRangeBackward = false;
         }
         this.fire('change:range', { directChange: true });
@@ -503,7 +503,7 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
         }
     }
     /**
-     * Returns the selected element. {@link module:engine/model/element~Element Element} is considered as selected if there is only
+     * Returns the selected element. {@link module:engine/model/element~ModelElement Element} is considered as selected if there is only
      * one range in the selection, and that range contains exactly one element.
      * Returns `null` if there is no selected element.
      */
@@ -514,7 +514,7 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
         return this.getFirstRange().getContainedElement();
     }
     /**
-     * Gets elements of type {@link module:engine/model/schema~Schema#isBlock "block"} touched by the selection.
+     * Gets elements of type {@link module:engine/model/schema~ModelSchema#isBlock "block"} touched by the selection.
      *
      * This method's result can be used for example to apply block styling to all blocks covered by this selection.
      *
@@ -594,7 +594,7 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
                 else if (value.type == 'elementStart' &&
                     block.is('model:element') &&
                     block.root.document.model.schema.isBlock(block)) {
-                    treewalker.jumpTo(Position._createAt(block, 'end'));
+                    treewalker.jumpTo(ModelPosition._createAt(block, 'end'));
                 }
             }
             const endBlock = getParentBlock(range.end, visited);
@@ -605,15 +605,15 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
     }
     /**
      * Checks whether the selection contains the entire content of the given element. This means that selection must start
-     * at a position {@link module:engine/model/position~Position#isTouching touching} the element's start and ends at position
+     * at a position {@link module:engine/model/position~ModelPosition#isTouching touching} the element's start and ends at position
      * touching the element's end.
      *
      * By default, this method will check whether the entire content of the selection's current root is selected.
      * Useful to check if e.g. the user has just pressed <kbd>Ctrl</kbd> + <kbd>A</kbd>.
      */
     containsEntireContent(element = this.anchor.root) {
-        const limitStartPosition = Position._createAt(element, 0);
-        const limitEndPosition = Position._createAt(element, 'end');
+        const limitStartPosition = ModelPosition._createAt(element, 0);
+        const limitEndPosition = ModelPosition._createAt(element, 'end');
         return limitStartPosition.isTouching(this.getFirstPosition()) &&
             limitEndPosition.isTouching(this.getLastPosition());
     }
@@ -623,7 +623,7 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
      */
     _pushRange(range) {
         this._checkRange(range);
-        this._ranges.push(new Range(range.start, range.end));
+        this._ranges.push(new ModelRange(range.start, range.end));
     }
     /**
      * Checks if given range intersects with ranges that are already in the selection. Throws an error if it does.
@@ -635,8 +635,8 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
                  * Trying to add a range that intersects with another range in the selection.
                  *
                  * @error model-selection-range-intersects
-                 * @param {module:engine/model/range~Range} addedRange Range that was added to the selection.
-                 * @param {module:engine/model/range~Range} intersectingRange Range in the selection that intersects with `addedRange`.
+                 * @param {module:engine/model/range~ModelRange} addedRange Range that was added to the selection.
+                 * @param {module:engine/model/range~ModelRange} intersectingRange Range in the selection that intersects with `addedRange`.
                  */
                 throw new CKEditorError('model-selection-range-intersects', [this, range], { addedRange: range, intersectingRange: this._ranges[i] });
             }
@@ -670,7 +670,7 @@ export default class Selection extends /* #__PURE__ */ EmitterMixin(TypeCheckabl
 }
 // The magic of type inference using `is` method is centralized in `TypeCheckable` class.
 // Proper overload would interfere with that.
-Selection.prototype.is = function (type) {
+ModelSelection.prototype.is = function (type) {
     return type === 'selection' || type === 'model:selection';
 };
 /**
@@ -722,7 +722,7 @@ function isTopBlockInRange(block, range) {
         return true;
     }
     // Add loose flag to check as parentRange can be equal to range.
-    const isParentInRange = range.containsRange(Range._createOn(parentBlock), true);
+    const isParentInRange = range.containsRange(ModelRange._createOn(parentBlock), true);
     return !isParentInRange;
 }
 /**
@@ -748,7 +748,7 @@ function isStartBlockSelected(startBlock, range) {
     if (range.isCollapsed || startBlock.isEmpty) {
         return true;
     }
-    if (range.start.isTouching(Position._createAt(startBlock, startBlock.maxOffset))) {
+    if (range.start.isTouching(ModelPosition._createAt(startBlock, startBlock.maxOffset))) {
         return false;
     }
     return isTopBlockInRange(startBlock, range);
@@ -776,7 +776,7 @@ function isEndBlockSelected(endBlock, range) {
     if (range.isCollapsed || endBlock.isEmpty) {
         return true;
     }
-    if (range.end.isTouching(Position._createAt(endBlock, 0))) {
+    if (range.end.isTouching(ModelPosition._createAt(endBlock, 0))) {
         return false;
     }
     return isTopBlockInRange(endBlock, range);

package/src/model/text.d.ts

@@ -5,19 +5,20 @@
 /**
  * @module engine/model/text
  */
-import Node, { type NodeAttributes } from './node.js';
+import { ModelNode, type ModelNodeAttributes } from './node.js';
 /**
- * Model text node. Type of {@link module:engine/model/node~Node node} that contains {@link module:engine/model/text~Text#data text data}.
+ * Model text node. Type of {@link module:engine/model/node~ModelNode node} that
+ * contains {@link module:engine/model/text~ModelText#data text data}.
  *
- * **Important:** see {@link module:engine/model/node~Node} to read about restrictions using `Text` and `Node` API.
+ * **Important:** see {@link module:engine/model/node~ModelNode} to read about restrictions using `Text` and `Node` API.
  *
  * **Note:** keep in mind that `Text` instances might indirectly got removed from model tree when model is changed.
- * This happens when {@link module:engine/model/writer~Writer model writer} is used to change model and the text node is merged with
+ * This happens when {@link module:engine/model/writer~ModelWriter model writer} is used to change model and the text node is merged with
  * another text node. Then, both text nodes are removed and a new text node is inserted into the model. Because of
  * this behavior, keeping references to `Text` is not recommended. Instead, consider creating
- * {@link module:engine/model/liveposition~LivePosition live position} placed before the text node.
+ * {@link module:engine/model/liveposition~ModelLivePosition live position} placed before the text node.
  */
-export default class Text extends Node {
+export declare class ModelText extends ModelNode {
     /**
      * Text data contained in this text node.
      *
@@ -28,13 +29,13 @@ export default class Text extends Node {
      * Creates a text node.
      *
      * **Note:** Constructor of this class shouldn't be used directly in the code.
-     * Use the {@link module:engine/model/writer~Writer#createText} method instead.
+     * Use the {@link module:engine/model/writer~ModelWriter#createText} method instead.
      *
      * @internal
      * @param data Node's text.
      * @param attrs Node's attributes. See {@link module:utils/tomap~toMap} for a list of accepted values.
      */
-    constructor(data?: string, attrs?: NodeAttributes);
+    constructor(data?: string, attrs?: ModelNodeAttributes);
     /**
      * @inheritDoc
      */
@@ -55,12 +56,12 @@ export default class Text extends Node {
      * @internal
      * @returns `Text` instance created using given plain object.
      */
-    _clone(): Text;
+    _clone(): ModelText;
     /**
      * Creates a `Text` instance from given plain object (i.e. parsed JSON string).
      *
      * @param json Plain object to be converted to `Text`.
      * @returns `Text` instance created using given plain object.
      */
-    static fromJSON(json: any): Text;
+    static fromJSON(json: any): ModelText;
 }

package/src/model/text.js

@@ -5,20 +5,21 @@
 /**
  * @module engine/model/text
  */
-import Node from './node.js';
+import { ModelNode } from './node.js';
 // @if CK_DEBUG_ENGINE // const { convertMapToStringifiedObject } = require( '../dev-utils/utils' );
 /**
- * Model text node. Type of {@link module:engine/model/node~Node node} that contains {@link module:engine/model/text~Text#data text data}.
+ * Model text node. Type of {@link module:engine/model/node~ModelNode node} that
+ * contains {@link module:engine/model/text~ModelText#data text data}.
  *
- * **Important:** see {@link module:engine/model/node~Node} to read about restrictions using `Text` and `Node` API.
+ * **Important:** see {@link module:engine/model/node~ModelNode} to read about restrictions using `Text` and `Node` API.
  *
  * **Note:** keep in mind that `Text` instances might indirectly got removed from model tree when model is changed.
- * This happens when {@link module:engine/model/writer~Writer model writer} is used to change model and the text node is merged with
+ * This happens when {@link module:engine/model/writer~ModelWriter model writer} is used to change model and the text node is merged with
  * another text node. Then, both text nodes are removed and a new text node is inserted into the model. Because of
  * this behavior, keeping references to `Text` is not recommended. Instead, consider creating
- * {@link module:engine/model/liveposition~LivePosition live position} placed before the text node.
+ * {@link module:engine/model/liveposition~ModelLivePosition live position} placed before the text node.
  */
-export default class Text extends Node {
+export class ModelText extends ModelNode {
     /**
      * Text data contained in this text node.
      *
@@ -29,7 +30,7 @@ export default class Text extends Node {
      * Creates a text node.
      *
      * **Note:** Constructor of this class shouldn't be used directly in the code.
-     * Use the {@link module:engine/model/writer~Writer#createText} method instead.
+     * Use the {@link module:engine/model/writer~ModelWriter#createText} method instead.
      *
      * @internal
      * @param data Node's text.
@@ -68,7 +69,7 @@ export default class Text extends Node {
      * @returns `Text` instance created using given plain object.
      */
     _clone() {
-        return new Text(this.data, this.getAttributes());
+        return new ModelText(this.data, this.getAttributes());
     }
     /**
      * Creates a `Text` instance from given plain object (i.e. parsed JSON string).
@@ -77,12 +78,12 @@ export default class Text extends Node {
      * @returns `Text` instance created using given plain object.
      */
     static fromJSON(json) {
-        return new Text(json.data, json.attributes);
+        return new ModelText(json.data, json.attributes);
     }
 }
 // The magic of type inference using `is` method is centralized in `TypeCheckable` class.
 // Proper overload would interfere with that.
-Text.prototype.is = function (type) {
+ModelText.prototype.is = function (type) {
     return type === '$text' || type === 'model:$text' ||
         // This are legacy values kept for backward compatibility.
         type === 'text' || type === 'model:text' ||

package/src/model/textproxy.d.ts

@@ -5,51 +5,51 @@
 /**
  * @module engine/model/textproxy
  */
-import TypeCheckable from './typecheckable.js';
-import type DocumentFragment from './documentfragment.js';
-import type Element from './element.js';
-import type Node from './node.js';
-import type Text from './text.js';
+import { ModelTypeCheckable } from './typecheckable.js';
+import { type ModelDocumentFragment } from './documentfragment.js';
+import { type ModelElement } from './element.js';
+import { type ModelNode } from './node.js';
+import { type ModelText } from './text.js';
 /**
- * `TextProxy` represents a part of {@link module:engine/model/text~Text text node}.
+ * `ModelTextProxy` represents a part of {@link module:engine/model/text~ModelText text node}.
  *
- * Since {@link module:engine/model/position~Position positions} can be placed between characters of a text node,
- * {@link module:engine/model/range~Range ranges} may contain only parts of text nodes. When {@link module:engine/model/range~Range#getItems
- * getting items}
+ * Since {@link module:engine/model/position~ModelPosition positions} can be placed between characters of a text node,
+ * {@link module:engine/model/range~ModelRange ranges} may contain only parts of text nodes.
+ * When {@link module:engine/model/range~ModelRange#getItems getting items}
  * contained in such range, we need to represent a part of that text node, since returning the whole text node would be incorrect.
- * `TextProxy` solves this issue.
+ * `ModelTextProxy` solves this issue.
  *
- * `TextProxy` has an API similar to {@link module:engine/model/text~Text Text} and allows to do most of the common tasks performed
- * on model nodes.
+ * `ModelTextProxy` has an API similar to {@link module:engine/model/text~ModelText Text} and allows to do
+ * most of the common tasks performed on model nodes.
  *
- * **Note:** Some `TextProxy` instances may represent whole text node, not just a part of it.
- * See {@link module:engine/model/textproxy~TextProxy#isPartial}.
+ * **Note:** Some `ModelTextProxy` instances may represent whole text node, not just a part of it.
+ * See {@link module:engine/model/textproxy~ModelTextProxy#isPartial}.
  *
- * **Note:** `TextProxy` is not an instance of {@link module:engine/model/node~Node node}. Keep this in mind when using it as a
+ * **Note:** `ModelTextProxy` is not an instance of {@link module:engine/model/node~ModelNode node}. Keep this in mind when using it as a
  * parameter of methods.
  *
- * **Note:** `TextProxy` is a readonly interface. If you want to perform changes on model data represented by a `TextProxy`
- * use {@link module:engine/model/writer~Writer model writer API}.
+ * **Note:** `ModelTextProxy` is a readonly interface. If you want to perform changes on model data represented by a `ModelTextProxy`
+ * use {@link module:engine/model/writer~ModelWriter model writer API}.
  *
- * **Note:** `TextProxy` instances are created on the fly, basing on the current state of model. Because of this, it is
- * highly unrecommended to store references to `TextProxy` instances. `TextProxy` instances are not refreshed when
- * model changes, so they might get invalidated. Instead, consider creating {@link module:engine/model/liveposition~LivePosition live
+ * **Note:** `ModelTextProxy` instances are created on the fly, basing on the current state of model. Because of this, it is
+ * highly unrecommended to store references to `ModelTextProxy` instances. `ModelTextProxy` instances are not refreshed when
+ * model changes, so they might get invalidated. Instead, consider creating {@link module:engine/model/liveposition~ModelLivePosition live
  * position}.
  *
- * `TextProxy` instances are created by {@link module:engine/model/treewalker~TreeWalker model tree walker}. You should not need to create
- * an instance of this class by your own.
+ * `ModelTextProxy` instances are created by {@link module:engine/model/treewalker~ModelTreeWalker model tree walker}.
+ * You should not need to create an instance of this class by your own.
  */
-export default class TextProxy extends TypeCheckable {
+export declare class ModelTextProxy extends ModelTypeCheckable {
     /**
      * Text node which part is represented by this text proxy.
      */
-    readonly textNode: Text;
+    readonly textNode: ModelText;
     /**
      * Text data represented by this text proxy.
      */
     readonly data: string;
     /**
-     * Offset in {@link module:engine/model/textproxy~TextProxy#textNode text node} from which the text proxy starts.
+     * Offset in {@link module:engine/model/textproxy~ModelTextProxy#textNode text node} from which the text proxy starts.
      */
     readonly offsetInText: number;
     /**
@@ -57,50 +57,51 @@ export default class TextProxy extends TypeCheckable {
      *
      * @internal
      * @param textNode Text node which part is represented by this text proxy.
-     * @param offsetInText Offset in {@link module:engine/model/textproxy~TextProxy#textNode text node} from which the text proxy
+     * @param offsetInText Offset in {@link module:engine/model/textproxy~ModelTextProxy#textNode text node} from which the text proxy
      * starts.
      * @param length Text proxy length, that is how many text node's characters, starting from `offsetInText` it represents.
      */
-    constructor(textNode: Text, offsetInText: number, length: number);
+    constructor(textNode: ModelText, offsetInText: number, length: number);
     /**
      * Offset at which this text proxy starts in it's parent.
      *
-     * @see module:engine/model/node~Node#startOffset
+     * @see module:engine/model/node~ModelNode#startOffset
      */
     get startOffset(): number | null;
     /**
      * Offset size of this text proxy. Equal to the number of characters represented by the text proxy.
      *
-     * @see module:engine/model/node~Node#offsetSize
+     * @see module:engine/model/node~ModelNode#offsetSize
      */
     get offsetSize(): number;
     /**
      * Offset at which this text proxy ends in it's parent.
      *
-     * @see module:engine/model/node~Node#endOffset
+     * @see module:engine/model/node~ModelNode#endOffset
      */
     get endOffset(): number | null;
     /**
-     * Flag indicating whether `TextProxy` instance covers only part of the original {@link module:engine/model/text~Text text node}
-     * (`true`) or the whole text node (`false`).
+     * Flag indicating whether `ModelTextProxy` instance covers only part of the original
+     * {@link module:engine/model/text~ModelText text node} (`true`) or the whole text node (`false`).
      *
-     * This is `false` when text proxy starts at the very beginning of {@link module:engine/model/textproxy~TextProxy#textNode textNode}
-     * ({@link module:engine/model/textproxy~TextProxy#offsetInText offsetInText} equals `0`) and text proxy sizes is equal to
+     * This is `false` when text proxy starts at the very beginning of
+     * {@link module:engine/model/textproxy~ModelTextProxy#textNode textNode}
+     * ({@link module:engine/model/textproxy~ModelTextProxy#offsetInText offsetInText} equals `0`) and text proxy sizes is equal to
      * text node size.
      */
     get isPartial(): boolean;
     /**
      * Parent of this text proxy, which is same as parent of text node represented by this text proxy.
      */
-    get parent(): Element | DocumentFragment | null;
+    get parent(): ModelElement | ModelDocumentFragment | null;
     /**
      * Root of this text proxy, which is same as root of text node represented by this text proxy.
      */
-    get root(): Node | DocumentFragment;
+    get root(): ModelNode | ModelDocumentFragment;
     /**
      * Gets path to this text proxy.
      *
-     * @see module:engine/model/node~Node#getPath
+     * @see module:engine/model/node~ModelNode#getPath
      */
     getPath(): Array<number>;
     /**
@@ -115,7 +116,7 @@ export default class TextProxy extends TypeCheckable {
     getAncestors(options?: {
         includeSelf?: boolean;
         parentFirst?: boolean;
-    }): Array<TextProxy | Element | DocumentFragment>;
+    }): Array<ModelTextProxy | ModelElement | ModelDocumentFragment>;
     /**
      * Checks if this text proxy has an attribute for given key.
      *