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

package/src/model/position.d.ts

@@ -5,57 +5,57 @@
 /**
  * @module engine/model/position
  */
-import TypeCheckable from './typecheckable.js';
-import { type TreeWalkerOptions, type TreeWalkerValue } from './treewalker.js';
-import type Document from './document.js';
-import type DocumentFragment from './documentfragment.js';
-import type Element from './element.js';
-import type InsertOperation from './operation/insertoperation.js';
-import type Item from './item.js';
-import type MergeOperation from './operation/mergeoperation.js';
-import type MoveOperation from './operation/moveoperation.js';
-import type Node from './node.js';
-import type Operation from './operation/operation.js';
-import type SplitOperation from './operation/splitoperation.js';
-import type Text from './text.js';
+import { ModelTypeCheckable } from './typecheckable.js';
+import { type ModelTreeWalkerOptions, type ModelTreeWalkerValue } from './treewalker.js';
+import { type ModelDocument } from './document.js';
+import { type ModelDocumentFragment } from './documentfragment.js';
+import { type ModelElement } from './element.js';
+import { type InsertOperation } from './operation/insertoperation.js';
+import { type ModelItem } from './item.js';
+import { type MergeOperation } from './operation/mergeoperation.js';
+import { type MoveOperation } from './operation/moveoperation.js';
+import { type ModelNode } from './node.js';
+import { type Operation } from './operation/operation.js';
+import { type SplitOperation } from './operation/splitoperation.js';
+import { type ModelText } from './text.js';
 /**
  * Represents a position in the model tree.
  *
- * A position is represented by its {@link module:engine/model/position~Position#root} and
- * a {@link module:engine/model/position~Position#path} in that root.
+ * A position is represented by its {@link module:engine/model/position~ModelPosition#root} and
+ * a {@link module:engine/model/position~ModelPosition#path} in that root.
  *
  * You can create position instances via its constructor or the `createPosition*()` factory methods of
- * {@link module:engine/model/model~Model} and {@link module:engine/model/writer~Writer}.
+ * {@link module:engine/model/model~Model} and {@link module:engine/model/writer~ModelWriter}.
  *
  * **Note:** Position is based on offsets, not indexes. This means that a position between two text nodes
- * `foo` and `bar` has offset `3`, not `1`. See {@link module:engine/model/position~Position#path} for more information.
+ * `foo` and `bar` has offset `3`, not `1`. See {@link module:engine/model/position~ModelPosition#path} for more information.
  *
- * Since a position in the model is represented by a {@link module:engine/model/position~Position#root position root} and
- * {@link module:engine/model/position~Position#path position path} it is possible to create positions placed in non-existing places.
+ * Since a position in the model is represented by a {@link module:engine/model/position~ModelPosition#root position root} and
+ * {@link module:engine/model/position~ModelPosition#path position path} it is possible to create positions placed in non-existing places.
  * This requirement is important for operational transformation algorithms.
  *
  * Also, {@link module:engine/model/operation/operation~Operation operations}
- * kept in the {@link module:engine/model/document~Document#history document history}
+ * kept in the {@link module:engine/model/document~ModelDocument#history document history}
  * are storing positions (and ranges) which were correct when those operations were applied, but may not be correct
  * after the document has changed.
  *
- * When changes are applied to the model, it may also happen that {@link module:engine/model/position~Position#parent position parent}
+ * When changes are applied to the model, it may also happen that {@link module:engine/model/position~ModelPosition#parent position parent}
  * will change even if position path has not changed. Keep in mind, that if a position leads to non-existing element,
- * {@link module:engine/model/position~Position#parent} and some other properties and methods will throw errors.
+ * {@link module:engine/model/position~ModelPosition#parent} and some other properties and methods will throw errors.
  *
  * In most cases, position with wrong path is caused by an error in code, but it is sometimes needed, as described above.
  */
-export default class Position extends TypeCheckable {
+export declare class ModelPosition extends ModelTypeCheckable {
     /**
      * Root of the position path.
      */
-    readonly root: Element | DocumentFragment;
+    readonly root: ModelElement | ModelDocumentFragment;
     /**
      * Position of the node in the tree. **Path contains offsets, not indexes.**
      *
-     * Position can be placed before, after or in a {@link module:engine/model/node~Node node} if that node has
-     * {@link module:engine/model/node~Node#offsetSize} greater than `1`. Items in position path are
-     * {@link module:engine/model/node~Node#startOffset starting offsets} of position ancestors, starting from direct root children,
+     * Position can be placed before, after or in a {@link module:engine/model/node~ModelNode node} if that node has
+     * {@link module:engine/model/node~ModelNode#offsetSize} greater than `1`. Items in position path are
+     * {@link module:engine/model/node~ModelNode#startOffset starting offsets} of position ancestors, starting from direct root children,
      * down to the position offset in it's parent.
      *
      * ```
@@ -68,7 +68,7 @@ export default class Position extends TypeCheckable {
      *        |- bar    before: [ 1, 1, 0 ]   after: [ 1, 1, 3 ]
      * ```
      *
-     * `foo` and `bar` are representing {@link module:engine/model/text~Text text nodes}. Since text nodes has offset size
+     * `foo` and `bar` are representing {@link module:engine/model/text~ModelText text nodes}. Since text nodes has offset size
      * greater than `1` you can place position offset between their start and end:
      *
      * ```
@@ -83,20 +83,20 @@ export default class Position extends TypeCheckable {
      */
     readonly path: ReadonlyArray<number>;
     /**
-     * Position stickiness. See {@link module:engine/model/position~PositionStickiness}.
+     * Position stickiness. See {@link module:engine/model/position~ModelPositionStickiness}.
      */
-    stickiness: PositionStickiness;
+    stickiness: ModelPositionStickiness;
     /**
      * Creates a position.
      *
      * @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}.
      */
-    constructor(root: Element | DocumentFragment, path: ReadonlyArray<number>, stickiness?: PositionStickiness);
+    constructor(root: ModelElement | ModelDocumentFragment, path: ReadonlyArray<number>, stickiness?: ModelPositionStickiness);
     /**
-     * Offset at which this position is located in its {@link module:engine/model/position~Position#parent parent}. It is equal
-     * to the last item in position {@link module:engine/model/position~Position#path path}.
+     * Offset at which this position is located in its {@link module:engine/model/position~ModelPosition#parent parent}. It is equal
+     * to the last item in position {@link module:engine/model/position~ModelPosition#path path}.
      *
      * @type {Number}
      */
@@ -106,37 +106,37 @@ export default class Position extends TypeCheckable {
      * Parent element of this position.
      *
      * Keep in mind that `parent` value is calculated when the property is accessed.
-     * If {@link module:engine/model/position~Position#path position path}
+     * If {@link module:engine/model/position~ModelPosition#path position path}
      * leads to a non-existing element, `parent` property will throw error.
      *
      * Also it is a good idea to cache `parent` property if it is used frequently in an algorithm (i.e. in a long loop).
      */
-    get parent(): Element | DocumentFragment;
+    get parent(): ModelElement | ModelDocumentFragment;
     /**
-     * Position {@link module:engine/model/position~Position#offset offset} converted to an index in position's parent node. It is
-     * equal to the {@link module:engine/model/node~Node#index index} of a node after this position. If position is placed
+     * Position {@link module:engine/model/position~ModelPosition#offset offset} converted to an index in position's parent node. It is
+     * equal to the {@link module:engine/model/node~ModelNode#index index} of a node after this position. If position is placed
      * in text node, position index is equal to the index of that text node.
      */
     get index(): number;
     /**
-     * Returns {@link module:engine/model/text~Text text node} instance in which this position is placed or `null` if this
+     * Returns {@link module:engine/model/text~ModelText text node} instance in which this position is placed or `null` if this
      * position is not in a text node.
      */
-    get textNode(): Text | null;
+    get textNode(): ModelText | null;
     /**
      * Node directly after this position. Returns `null` if this position is at the end of its parent, or if it is in a text node.
      */
-    get nodeAfter(): Node | null;
+    get nodeAfter(): ModelNode | null;
     /**
      * Node directly before this position. Returns `null` if this position is at the start of its parent, or if it is in a text node.
      */
-    get nodeBefore(): Node | null;
+    get nodeBefore(): ModelNode | null;
     /**
-     * Is `true` if position is at the beginning of its {@link module:engine/model/position~Position#parent parent}, `false` otherwise.
+     * Is `true` if position is at the beginning of its {@link module:engine/model/position~ModelPosition#parent parent}, `false` otherwise.
      */
     get isAtStart(): boolean;
     /**
-     * Is `true` if position is at the end of its {@link module:engine/model/position~Position#parent parent}, `false` otherwise.
+     * Is `true` if position is at the end of its {@link module:engine/model/position~ModelPosition#parent parent}, `false` otherwise.
      */
     get isAtEnd(): boolean;
     /**
@@ -148,10 +148,10 @@ export default class Position extends TypeCheckable {
      *
      * This method is safe to use it on non-existing positions (for example during operational transformation).
      */
-    compareWith(otherPosition: Position): PositionRelation;
+    compareWith(otherPosition: ModelPosition): ModelPositionRelation;
     /**
      * Gets the farthest position which matches the callback using
-     * {@link module:engine/model/treewalker~TreeWalker TreeWalker}.
+     * {@link module:engine/model/treewalker~ModelTreeWalker TreeWalker}.
      *
      * For example:
      *
@@ -166,16 +166,16 @@ export default class Position extends TypeCheckable {
      * // Do not move the position.
      * ```
      *
-     * @param skip Callback function. Gets {@link module:engine/model/treewalker~TreeWalkerValue} and should
+     * @param skip Callback function. Gets {@link module:engine/model/treewalker~ModelTreeWalkerValue} and should
      * return `true` if the value should be skipped or `false` if not.
-     * @param options Object with configuration options. See {@link module:engine/model/treewalker~TreeWalker}.
+     * @param options Object with configuration options. See {@link module:engine/model/treewalker~ModelTreeWalker}.
      *
      * @returns The position after the last item which matches the `skip` callback test.
      */
-    getLastMatchingPosition(skip: (value: TreeWalkerValue) => boolean, options?: TreeWalkerOptions): Position;
+    getLastMatchingPosition(skip: (value: ModelTreeWalkerValue) => boolean, options?: ModelTreeWalkerOptions): ModelPosition;
     /**
-     * Returns a path to this position's parent. Parent path is equal to position {@link module:engine/model/position~Position#path path}
-     * but without the last item.
+     * Returns a path to this position's parent. Parent path is equal to position
+     * {@link module:engine/model/position~ModelPosition#path path} but without the last item.
      *
      * This method is safe to use it on non-existing positions (for example during operational transformation).
      *
@@ -187,13 +187,13 @@ export default class Position extends TypeCheckable {
      *
      * @returns Array with ancestors.
      */
-    getAncestors(): Array<Element | DocumentFragment>;
+    getAncestors(): Array<ModelElement | ModelDocumentFragment>;
     /**
      * Returns the parent element of the given name. Returns null if the position is not inside the desired parent.
      *
      * @param parentName The name of the parent element to find.
      */
-    findAncestor(parentName: string): Element | null;
+    findAncestor(parentName: string): ModelElement | null;
     /**
      * Returns the slice of two position {@link #path paths} which is identical. The {@link #root roots}
      * of these two paths must be identical.
@@ -203,14 +203,14 @@ export default class Position extends TypeCheckable {
      * @param position The second position.
      * @returns The common path.
      */
-    getCommonPath(position: Position): Array<number>;
+    getCommonPath(position: ModelPosition): Array<number>;
     /**
-     * Returns an {@link module:engine/model/element~Element} or {@link module:engine/model/documentfragment~DocumentFragment}
+     * Returns an {@link module:engine/model/element~ModelElement} or {@link module:engine/model/documentfragment~ModelDocumentFragment}
      * which is a common ancestor of both positions. The {@link #root roots} of these two positions must be identical.
      *
      * @param position The second position.
      */
-    getCommonAncestor(position: Position): Element | DocumentFragment | null;
+    getCommonAncestor(position: ModelPosition): ModelElement | ModelDocumentFragment | null;
     /**
      * Returns a new instance of `Position`, that has same {@link #parent parent} but it's offset
      * is shifted by `shift` value (can be a negative value).
@@ -220,17 +220,17 @@ export default class Position extends TypeCheckable {
      * @param shift Offset shift. Can be a negative value.
      * @returns Shifted position.
      */
-    getShiftedBy(shift: number): Position;
+    getShiftedBy(shift: number): ModelPosition;
     /**
      * Checks whether this position is after given position.
      *
      * This method is safe to use it on non-existing positions (for example during operational transformation).
      *
-     * @see module:engine/model/position~Position#isBefore
+     * @see module:engine/model/position~ModelPosition#isBefore
      * @param  otherPosition Position to compare with.
      * @returns True if this position is after given position.
      */
-    isAfter(otherPosition: Position): boolean;
+    isAfter(otherPosition: ModelPosition): boolean;
     /**
      * Checks whether this position is before given position.
      *
@@ -270,7 +270,7 @@ export default class Position extends TypeCheckable {
      * @param otherPosition Position to compare with.
      * @returns True if this position is before given position.
      */
-    isBefore(otherPosition: Position): boolean;
+    isBefore(otherPosition: ModelPosition): boolean;
     /**
      * Checks whether this position is equal to given position.
      *
@@ -279,7 +279,7 @@ export default class Position extends TypeCheckable {
      * @param otherPosition Position to compare with.
      * @returns True if positions are same.
      */
-    isEqual(otherPosition: Position): boolean;
+    isEqual(otherPosition: ModelPosition): boolean;
     /**
      * Checks whether this position is touching given position. Positions touch when there are no text nodes
      * or empty nodes in a range between them. Technically, those positions are not equal but in many cases
@@ -288,7 +288,7 @@ export default class Position extends TypeCheckable {
      * @param otherPosition Position to compare with.
      * @returns True if positions touch.
      */
-    isTouching(otherPosition: Position): boolean;
+    isTouching(otherPosition: ModelPosition): boolean;
     /**
      * Checks if two positions are in the same parent.
      *
@@ -297,13 +297,13 @@ export default class Position extends TypeCheckable {
      * @param position Position to compare with.
      * @returns `true` if positions have the same parent, `false` otherwise.
      */
-    hasSameParentAs(position: Position): boolean;
+    hasSameParentAs(position: ModelPosition): boolean;
     /**
      * Returns a copy of this position that is transformed by given `operation`.
      *
      * The new position's parameters are updated accordingly to the effect of the `operation`.
      *
-     * For example, if `n` nodes are inserted before the position, the returned position {@link ~Position#offset} will be
+     * For example, if `n` nodes are inserted before the position, the returned position {@link ~ModelPosition#offset} will be
      * increased by `n`. If the position was in a merged element, it will be accordingly moved to the new element, etc.
      *
      * This method is safe to use it on non-existing positions (for example during operational transformation).
@@ -311,31 +311,31 @@ export default class Position extends TypeCheckable {
      * @param operation Operation to transform by.
      * @returns Transformed position.
      */
-    getTransformedByOperation(operation: Operation): Position;
+    getTransformedByOperation(operation: Operation): ModelPosition;
     /**
      * Returns a copy of this position transformed by an insert operation.
      *
      * @internal
      */
-    _getTransformedByInsertOperation(operation: InsertOperation): Position;
+    _getTransformedByInsertOperation(operation: InsertOperation): ModelPosition;
     /**
      * Returns a copy of this position transformed by a move operation.
      *
      * @internal
      */
-    _getTransformedByMoveOperation(operation: MoveOperation): Position;
+    _getTransformedByMoveOperation(operation: MoveOperation): ModelPosition;
     /**
      * Returns a copy of this position transformed by a split operation.
      *
      * @internal
      */
-    _getTransformedBySplitOperation(operation: SplitOperation): Position;
+    _getTransformedBySplitOperation(operation: SplitOperation): ModelPosition;
     /**
      * Returns a copy of this position transformed by merge operation.
      *
      * @internal
      */
-    _getTransformedByMergeOperation(operation: MergeOperation): Position;
+    _getTransformedByMergeOperation(operation: MergeOperation): ModelPosition;
     /**
      * Returns a copy of this position that is updated by removing `howMany` nodes starting from `deletePosition`.
      * It may happen that this position is in a removed node. If that is the case, `null` is returned instead.
@@ -345,7 +345,7 @@ export default class Position extends TypeCheckable {
      * @param howMany How many nodes are removed.
      * @returns Transformed position or `null`.
      */
-    _getTransformedByDeletion(deletePosition: Position, howMany: number): Position | null;
+    _getTransformedByDeletion(deletePosition: ModelPosition, howMany: number): ModelPosition | null;
     /**
      * Returns a copy of this position that is updated by inserting `howMany` nodes at `insertPosition`.
      *
@@ -354,7 +354,7 @@ export default class Position extends TypeCheckable {
      * @param howMany How many nodes are inserted.
      * @returns Transformed position.
      */
-    _getTransformedByInsertion(insertPosition: Position, howMany: number): Position;
+    _getTransformedByInsertion(insertPosition: ModelPosition, howMany: number): ModelPosition;
     /**
      * Returns a copy of this position that is updated by moving `howMany` nodes from `sourcePosition` to `targetPosition`.
      *
@@ -364,7 +364,7 @@ export default class Position extends TypeCheckable {
      * @param howMany How many consecutive nodes to move, starting from `sourcePosition`.
      * @returns Transformed position.
      */
-    _getTransformedByMove(sourcePosition: Position, targetPosition: Position, howMany: number): Position;
+    _getTransformedByMove(sourcePosition: ModelPosition, targetPosition: ModelPosition, howMany: number): ModelPosition;
     /**
      * Returns a new position that is a combination of this position and given positions.
      *
@@ -394,7 +394,7 @@ export default class Position extends TypeCheckable {
      * @param target Position where the range is moved.
      * @returns Combined position.
      */
-    _getCombined(source: Position, target: Position): Position;
+    _getCombined(source: ModelPosition, target: ModelPosition): ModelPosition;
     /**
      * @inheritDoc
      */
@@ -406,37 +406,38 @@ export default class Position extends TypeCheckable {
     /**
      * 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},
      * * parent element and offset (offset defaults to `0`),
      * * parent element and `'end'` (sets position at the end of that element),
-     * * {@link module:engine/model/item~Item model item} and `'before'` or `'after'` (sets position before or after given model item).
+     * * {@link module:engine/model/item~ModelItem model item} and `'before'` or `'after'` (sets position before or after given model item).
      *
      * This method is a shortcut to other factory methods such as:
      *
-     * * {@link module:engine/model/position~Position._createBefore},
-     * * {@link module:engine/model/position~Position._createAfter}.
+     * * {@link module:engine/model/position~ModelPosition._createBefore},
+     * * {@link module:engine/model/position~ModelPosition._createAfter}.
      *
      * @internal
-     * @param offset Offset or one of the flags. Used only when the first parameter is a {@link module:engine/model/item~Item model item}.
-     * @param stickiness Position stickiness. Used only when the first parameter is a {@link module:engine/model/item~Item model item}.
+     * @param offset Offset or one of the flags. Used only when the first parameter
+     * is a {@link module:engine/model/item~ModelItem model item}.
+     * @param stickiness Position stickiness. Used only when the first parameter is a {@link module:engine/model/item~ModelItem model item}.
      */
-    static _createAt(itemOrPosition: Item | Position | DocumentFragment, offset?: PositionOffset, stickiness?: PositionStickiness): Position;
+    static _createAt(itemOrPosition: ModelItem | ModelPosition | ModelDocumentFragment, offset?: ModelPositionOffset, stickiness?: ModelPositionStickiness): ModelPosition;
     /**
-     * Creates a new position, after given {@link module:engine/model/item~Item model item}.
+     * Creates a new position, after given {@link module:engine/model/item~ModelItem model item}.
      *
      * @internal
      * @param item Item after which the position should be placed.
      * @param stickiness Position stickiness.
      */
-    static _createAfter(item: Item | DocumentFragment, stickiness?: PositionStickiness): Position;
+    static _createAfter(item: ModelItem | ModelDocumentFragment, stickiness?: ModelPositionStickiness): ModelPosition;
     /**
-     * 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}.
      *
      * @internal
      * @param item Item before which the position should be placed.
      * @param stickiness Position stickiness.
      */
-    static _createBefore(item: Item | DocumentFragment, stickiness?: PositionStickiness): Position;
+    static _createBefore(item: ModelItem | ModelDocumentFragment, stickiness?: ModelPositionStickiness): ModelPosition;
     /**
      * Creates a `Position` instance from given plain object (i.e. parsed JSON string).
      *
@@ -444,17 +445,17 @@ export default class Position extends TypeCheckable {
      * @param doc Document object that will be position owner.
      * @returns `Position` instance created using given plain object.
      */
-    static fromJSON(json: any, doc: Document): Position;
+    static fromJSON(json: any, doc: ModelDocument): ModelPosition;
 }
 /**
  * A flag indicating whether this position is `'before'` or `'after'` or `'same'` as given position.
  * If positions are in different roots `'different'` flag is returned.
  */
-export type PositionRelation = 'before' | 'after' | 'same' | 'different';
+export type ModelPositionRelation = 'before' | 'after' | 'same' | 'different';
 /**
  * Offset or one of the flags.
  */
-export type PositionOffset = number | 'before' | 'after' | 'end';
+export type ModelPositionOffset = number | 'before' | 'after' | 'end';
 /**
  * Represents how position is "sticking" with neighbour nodes. Used to define how position should be transformed (moved)
  * in edge cases. Possible values: `'toNone'`, `'toNext'`, `'toPrevious'`.
@@ -483,14 +484,14 @@ export type PositionOffset = number | 'before' | 'after' | 'end';
  * - sticks to previous node:  <p>f[oo]|</p><p>b^ar</p>  ->  <p>f</p><p>boo|ar</p>
  * ```
  */
-export type PositionStickiness = 'toNone' | 'toNext' | 'toPrevious';
+export type ModelPositionStickiness = 'toNone' | 'toNext' | 'toPrevious';
 /**
  * Returns a text node at the given position.
  *
  * This is a helper function optimized to reuse the position parent instance for performance reasons.
  *
- * Normally, you should use {@link module:engine/model/position~Position#textNode `Position#textNode`}.
- * If you start hitting performance issues with {@link module:engine/model/position~Position#parent `Position#parent`}
+ * Normally, you should use {@link module:engine/model/position~ModelPosition#textNode `Position#textNode`}.
+ * If you start hitting performance issues with {@link module:engine/model/position~ModelPosition#parent `Position#parent`}
  * check if your algorithm does not access it multiple times (which can happen directly or indirectly via other position properties).
  *
  * See https://github.com/ckeditor/ckeditor5/issues/6579.
@@ -502,17 +503,18 @@ export type PositionStickiness = 'toNone' | 'toNext' | 'toPrevious';
  *
  * @param position
  * @param positionParent The parent of the given position.
+ * @internal
  */
-export declare function getTextNodeAtPosition(position: Position, positionParent: Element | DocumentFragment): Text | null;
+export declare function getTextNodeAtPosition(position: ModelPosition, positionParent: ModelElement | ModelDocumentFragment): ModelText | null;
 /**
  * Returns the node after the given position.
  *
  * This is a helper function optimized to reuse the position parent instance and the calculation of the text node at the
  * specific position for performance reasons.
  *
- * Normally, you should use {@link module:engine/model/position~Position#nodeAfter `Position#nodeAfter`}.
- * If you start hitting performance issues with {@link module:engine/model/position~Position#parent `Position#parent`} and/or
- * {@link module:engine/model/position~Position#textNode `Position#textNode`}
+ * Normally, you should use {@link module:engine/model/position~ModelPosition#nodeAfter `Position#nodeAfter`}.
+ * If you start hitting performance issues with {@link module:engine/model/position~ModelPosition#parent `Position#parent`} and/or
+ * {@link module:engine/model/position~ModelPosition#textNode `Position#textNode`}
  * check if your algorithm does not access those properties multiple times
  * (which can happen directly or indirectly via other position properties).
  *
@@ -526,8 +528,9 @@ export declare function getTextNodeAtPosition(position: Position, positionParent
  * @param position Position to check.
  * @param positionParent The parent of the given position.
  * @param textNode Text node at the given position.
+ * @internal
  */
-export declare function getNodeAfterPosition(position: Position, positionParent: Element | DocumentFragment, textNode: Text | null): Node | null;
+export declare function getNodeAfterPosition(position: ModelPosition, positionParent: ModelElement | ModelDocumentFragment, textNode: ModelText | null): ModelNode | null;
 /**
  * Returns the node before the given position.
  *
@@ -541,5 +544,6 @@ export declare function getNodeAfterPosition(position: Position, positionParent:
  * @param position Position to check.
  * @param positionParent The parent of the given position.
  * @param textNode Text node at the given position.
+ * @internal
  */
-export declare function getNodeBeforePosition(position: Position, positionParent: Element | DocumentFragment, textNode: Text | null): Node | null;
+export declare function getNodeBeforePosition(position: ModelPosition, positionParent: ModelElement | ModelDocumentFragment, textNode: ModelText | null): ModelNode | null;