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

package/src/view/attributeelement.d.ts

@@ -5,31 +5,31 @@
 /**
  * @module engine/view/attributeelement
  */
-import Element, { type ElementAttributes } from './element.js';
-import type Document from './document.js';
-import type Node from './node.js';
+import { ViewElement, type ViewElementAttributes } from './element.js';
+import { type ViewDocument } from './document.js';
+import { type ViewNode } from './node.js';
 /**
  * Attribute elements are used to represent formatting elements in the view (think – `<b>`, `<span style="font-size: 2em">`, etc.).
  * Most often they are created when downcasting model text attributes.
  *
  * Editing engine does not define a fixed HTML DTD. This is why a feature developer needs to choose between various
- * types (container element, {@link module:engine/view/attributeelement~AttributeElement attribute element},
- * {@link module:engine/view/emptyelement~EmptyElement empty element}, etc) when developing a feature.
+ * types (container element, {@link module:engine/view/attributeelement~ViewAttributeElement attribute element},
+ * {@link module:engine/view/emptyelement~ViewEmptyElement empty element}, etc) when developing a feature.
  *
  * To create a new attribute element instance use the
- * {@link module:engine/view/downcastwriter~DowncastWriter#createAttributeElement `DowncastWriter#createAttributeElement()`} method.
+ * {@link module:engine/view/downcastwriter~ViewDowncastWriter#createAttributeElement `ViewDowncastWriter#createAttributeElement()`} method.
  */
-export default class AttributeElement extends Element {
+export declare class ViewAttributeElement extends ViewElement {
     static readonly DEFAULT_PRIORITY: number;
     /**
-     * Element priority. Decides in what order elements are wrapped by {@link module:engine/view/downcastwriter~DowncastWriter}.
+     * Element priority. Decides in what order elements are wrapped by {@link module:engine/view/downcastwriter~ViewDowncastWriter}.
      *
      * @internal
      * @readonly
      */
     _priority: number;
     /**
-     * Element identifier. If set, it is used by {@link module:engine/view/element~Element#isSimilar},
+     * Element identifier. If set, it is used by {@link module:engine/view/element~ViewElement#isSimilar},
      * and then two elements are considered similar if, and only if they have the same `_id`.
      *
      * @internal
@@ -37,36 +37,36 @@ export default class AttributeElement extends Element {
      */
     _id: string | number | null;
     /**
-     * Keeps all the attribute elements that have the same {@link module:engine/view/attributeelement~AttributeElement#id ids}
+     * Keeps all the attribute elements that have the same {@link module:engine/view/attributeelement~ViewAttributeElement#id ids}
      * and still exist in the view tree.
      *
-     * This property is managed by {@link module:engine/view/downcastwriter~DowncastWriter}.
+     * This property is managed by {@link module:engine/view/downcastwriter~ViewDowncastWriter}.
      */
     private readonly _clonesGroup;
     /**
      * Creates an attribute element.
      *
-     * @see module:engine/view/downcastwriter~DowncastWriter#createAttributeElement
-     * @see module:engine/view/element~Element
+     * @see module:engine/view/downcastwriter~ViewDowncastWriter#createAttributeElement
+     * @see module:engine/view/element~ViewElement
      * @protected
      * @param document The document instance to which this element belongs.
      * @param name Node name.
      * @param attrs Collection of attributes.
      * @param children A list of nodes to be inserted into created element.
      */
-    constructor(document: Document, name: string, attrs?: ElementAttributes, children?: Node | Iterable<Node>);
+    constructor(document: ViewDocument, name: string, attrs?: ViewElementAttributes, children?: ViewNode | Iterable<ViewNode>);
     /**
-     * Element priority. Decides in what order elements are wrapped by {@link module:engine/view/downcastwriter~DowncastWriter}.
+     * Element priority. Decides in what order elements are wrapped by {@link module:engine/view/downcastwriter~ViewDowncastWriter}.
      */
     get priority(): number;
     /**
-     * Element identifier. If set, it is used by {@link module:engine/view/element~Element#isSimilar},
+     * Element identifier. If set, it is used by {@link module:engine/view/element~ViewElement#isSimilar},
      * and then two elements are considered similar if, and only if they have the same `id`.
      */
     get id(): string | number | null;
     /**
-     * Returns all {@link module:engine/view/attributeelement~AttributeElement attribute elements} that has the
-     * same {@link module:engine/view/attributeelement~AttributeElement#id id} and are in the view tree (were not removed).
+     * Returns all {@link module:engine/view/attributeelement~ViewAttributeElement attribute elements} that has the
+     * same {@link module:engine/view/attributeelement~ViewAttributeElement#id id} and are in the view tree (were not removed).
      *
      * Note: If this element has been removed from the tree, returned set will not include it.
      *
@@ -76,26 +76,26 @@ export default class AttributeElement extends Element {
      * @returns Set containing all the attribute elements
      * with the same `id` that were added and not removed from the view tree.
      */
-    getElementsWithSameId(): Set<AttributeElement>;
+    getElementsWithSameId(): Set<ViewAttributeElement>;
     /**
      * Checks if this element is similar to other element.
      *
-     * If none of elements has set {@link module:engine/view/attributeelement~AttributeElement#id}, then both elements
+     * If none of elements has set {@link module:engine/view/attributeelement~ViewAttributeElement#id}, then both elements
      * should have the same name, attributes and priority to be considered as similar. Two similar elements can contain
      * different set of children nodes.
      *
-     * If at least one element has {@link module:engine/view/attributeelement~AttributeElement#id} set, then both
-     * elements have to have the same {@link module:engine/view/attributeelement~AttributeElement#id} value to be
+     * If at least one element has {@link module:engine/view/attributeelement~ViewAttributeElement#id} set, then both
+     * elements have to have the same {@link module:engine/view/attributeelement~ViewAttributeElement#id} value to be
      * considered similar.
      *
-     * Similarity is important for {@link module:engine/view/downcastwriter~DowncastWriter}. For example:
+     * Similarity is important for {@link module:engine/view/downcastwriter~ViewDowncastWriter}. For example:
      *
      * * two following similar elements can be merged together into one, longer element,
-     * * {@link module:engine/view/downcastwriter~DowncastWriter#unwrap} checks similarity of passed element and processed element to
+     * * {@link module:engine/view/downcastwriter~ViewDowncastWriter#unwrap} checks similarity of passed element and processed element to
      * decide whether processed element should be unwrapped,
      * * etc.
      */
-    isSimilar(otherElement: Element): boolean;
+    isSimilar(otherElement: ViewElement): boolean;
     /**
      * Clones provided element with priority.
      *
@@ -106,17 +106,17 @@ export default class AttributeElement extends Element {
      */
     _clone(deep?: boolean): this;
     /**
-     * Used by {@link module:engine/view/element~Element#_mergeAttributesFrom} to verify if the given element can be merged without
+     * Used by {@link module:engine/view/element~ViewElement#_mergeAttributesFrom} to verify if the given element can be merged without
      * conflicts into this element.
      *
      * @internal
      */
-    _canMergeAttributesFrom(otherElement: AttributeElement): boolean;
+    _canMergeAttributesFrom(otherElement: ViewAttributeElement): boolean;
     /**
-     * Used by {@link module:engine/view/element~Element#_subtractAttributesOf} to verify if the given element attributes
+     * Used by {@link module:engine/view/element~ViewElement#_subtractAttributesOf} to verify if the given element attributes
      * can be fully subtracted from this element.
      *
      * @internal
      */
-    _canSubtractAttributesOf(otherElement: AttributeElement): boolean;
+    _canSubtractAttributesOf(otherElement: ViewAttributeElement): boolean;
 }

package/src/view/attributeelement.js

@@ -5,7 +5,7 @@
 /**
  * @module engine/view/attributeelement
  */
-import Element from './element.js';
+import { ViewElement } from './element.js';
 import { CKEditorError } from '@ckeditor/ckeditor5-utils';
 // Default attribute priority.
 const DEFAULT_PRIORITY = 10;
@@ -14,23 +14,23 @@ const DEFAULT_PRIORITY = 10;
  * Most often they are created when downcasting model text attributes.
  *
  * Editing engine does not define a fixed HTML DTD. This is why a feature developer needs to choose between various
- * types (container element, {@link module:engine/view/attributeelement~AttributeElement attribute element},
- * {@link module:engine/view/emptyelement~EmptyElement empty element}, etc) when developing a feature.
+ * types (container element, {@link module:engine/view/attributeelement~ViewAttributeElement attribute element},
+ * {@link module:engine/view/emptyelement~ViewEmptyElement empty element}, etc) when developing a feature.
  *
  * To create a new attribute element instance use the
- * {@link module:engine/view/downcastwriter~DowncastWriter#createAttributeElement `DowncastWriter#createAttributeElement()`} method.
+ * {@link module:engine/view/downcastwriter~ViewDowncastWriter#createAttributeElement `ViewDowncastWriter#createAttributeElement()`} method.
  */
-class AttributeElement extends Element {
+class ViewAttributeElement extends ViewElement {
     static DEFAULT_PRIORITY = DEFAULT_PRIORITY;
     /**
-     * Element priority. Decides in what order elements are wrapped by {@link module:engine/view/downcastwriter~DowncastWriter}.
+     * Element priority. Decides in what order elements are wrapped by {@link module:engine/view/downcastwriter~ViewDowncastWriter}.
      *
      * @internal
      * @readonly
      */
     _priority = DEFAULT_PRIORITY;
     /**
-     * Element identifier. If set, it is used by {@link module:engine/view/element~Element#isSimilar},
+     * Element identifier. If set, it is used by {@link module:engine/view/element~ViewElement#isSimilar},
      * and then two elements are considered similar if, and only if they have the same `_id`.
      *
      * @internal
@@ -38,17 +38,17 @@ class AttributeElement extends Element {
      */
     _id = null;
     /**
-     * Keeps all the attribute elements that have the same {@link module:engine/view/attributeelement~AttributeElement#id ids}
+     * Keeps all the attribute elements that have the same {@link module:engine/view/attributeelement~ViewAttributeElement#id ids}
      * and still exist in the view tree.
      *
-     * This property is managed by {@link module:engine/view/downcastwriter~DowncastWriter}.
+     * This property is managed by {@link module:engine/view/downcastwriter~ViewDowncastWriter}.
      */
     _clonesGroup = null;
     /**
      * Creates an attribute element.
      *
-     * @see module:engine/view/downcastwriter~DowncastWriter#createAttributeElement
-     * @see module:engine/view/element~Element
+     * @see module:engine/view/downcastwriter~ViewDowncastWriter#createAttributeElement
+     * @see module:engine/view/element~ViewElement
      * @protected
      * @param document The document instance to which this element belongs.
      * @param name Node name.
@@ -60,21 +60,21 @@ class AttributeElement extends Element {
         this.getFillerOffset = getFillerOffset;
     }
     /**
-     * Element priority. Decides in what order elements are wrapped by {@link module:engine/view/downcastwriter~DowncastWriter}.
+     * Element priority. Decides in what order elements are wrapped by {@link module:engine/view/downcastwriter~ViewDowncastWriter}.
      */
     get priority() {
         return this._priority;
     }
     /**
-     * Element identifier. If set, it is used by {@link module:engine/view/element~Element#isSimilar},
+     * Element identifier. If set, it is used by {@link module:engine/view/element~ViewElement#isSimilar},
      * and then two elements are considered similar if, and only if they have the same `id`.
      */
     get id() {
         return this._id;
     }
     /**
-     * Returns all {@link module:engine/view/attributeelement~AttributeElement attribute elements} that has the
-     * same {@link module:engine/view/attributeelement~AttributeElement#id id} and are in the view tree (were not removed).
+     * Returns all {@link module:engine/view/attributeelement~ViewAttributeElement attribute elements} that has the
+     * same {@link module:engine/view/attributeelement~ViewAttributeElement#id id} and are in the view tree (were not removed).
      *
      * Note: If this element has been removed from the tree, returned set will not include it.
      *
@@ -98,18 +98,18 @@ class AttributeElement extends Element {
     /**
      * Checks if this element is similar to other element.
      *
-     * If none of elements has set {@link module:engine/view/attributeelement~AttributeElement#id}, then both elements
+     * If none of elements has set {@link module:engine/view/attributeelement~ViewAttributeElement#id}, then both elements
      * should have the same name, attributes and priority to be considered as similar. Two similar elements can contain
      * different set of children nodes.
      *
-     * If at least one element has {@link module:engine/view/attributeelement~AttributeElement#id} set, then both
-     * elements have to have the same {@link module:engine/view/attributeelement~AttributeElement#id} value to be
+     * If at least one element has {@link module:engine/view/attributeelement~ViewAttributeElement#id} set, then both
+     * elements have to have the same {@link module:engine/view/attributeelement~ViewAttributeElement#id} value to be
      * considered similar.
      *
-     * Similarity is important for {@link module:engine/view/downcastwriter~DowncastWriter}. For example:
+     * Similarity is important for {@link module:engine/view/downcastwriter~ViewDowncastWriter}. For example:
      *
      * * two following similar elements can be merged together into one, longer element,
-     * * {@link module:engine/view/downcastwriter~DowncastWriter#unwrap} checks similarity of passed element and processed element to
+     * * {@link module:engine/view/downcastwriter~ViewDowncastWriter#unwrap} checks similarity of passed element and processed element to
      * decide whether processed element should be unwrapped,
      * * etc.
      */
@@ -137,7 +137,7 @@ class AttributeElement extends Element {
         return cloned;
     }
     /**
-     * Used by {@link module:engine/view/element~Element#_mergeAttributesFrom} to verify if the given element can be merged without
+     * Used by {@link module:engine/view/element~ViewElement#_mergeAttributesFrom} to verify if the given element can be merged without
      * conflicts into this element.
      *
      * @internal
@@ -150,7 +150,7 @@ class AttributeElement extends Element {
         return super._canMergeAttributesFrom(otherElement);
     }
     /**
-     * Used by {@link module:engine/view/element~Element#_subtractAttributesOf} to verify if the given element attributes
+     * Used by {@link module:engine/view/element~ViewElement#_subtractAttributesOf} to verify if the given element attributes
      * can be fully subtracted from this element.
      *
      * @internal
@@ -163,10 +163,10 @@ class AttributeElement extends Element {
         return super._canSubtractAttributesOf(otherElement);
     }
 }
-export default AttributeElement;
+export { ViewAttributeElement };
 // The magic of type inference using `is` method is centralized in `TypeCheckable` class.
 // Proper overload would interfere with that.
-AttributeElement.prototype.is = function (type, name) {
+ViewAttributeElement.prototype.is = function (type, name) {
     if (!name) {
         return type === 'attributeElement' || type === 'view:attributeElement' ||
             // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.
@@ -204,7 +204,7 @@ function getFillerOffset() {
     return this.childCount;
 }
 /**
- * Returns total count of children that are not {@link module:engine/view/uielement~UIElement UIElements}.
+ * Returns total count of children that are not {@link module:engine/view/uielement~ViewUIElement UIElements}.
  */
 function nonUiChildrenCount(element) {
     return Array.from(element.getChildren()).filter(element => !element.is('uiElement')).length;

package/src/view/containerelement.d.ts

@@ -5,45 +5,46 @@
 /**
  * @module engine/view/containerelement
  */
-import Element, { type ElementAttributes } from './element.js';
-import type Document from './document.js';
-import type Node from './node.js';
+import { ViewElement, type ViewElementAttributes } from './element.js';
+import { type ViewDocument } from './document.js';
+import { type ViewNode } from './node.js';
 /**
  * Containers are elements which define document structure. They define boundaries for
- * {@link module:engine/view/attributeelement~AttributeElement attributes}. They are mostly used for block elements like `<p>` or `<div>`.
+ * {@link module:engine/view/attributeelement~ViewAttributeElement attributes}.
+ * They are mostly used for block elements like `<p>` or `<div>`.
  *
  * Editing engine does not define a fixed HTML DTD. This is why a feature developer needs to choose between various
- * types (container element, {@link module:engine/view/attributeelement~AttributeElement attribute element},
- * {@link module:engine/view/emptyelement~EmptyElement empty element}, etc) when developing a feature.
+ * types (container element, {@link module:engine/view/attributeelement~ViewAttributeElement attribute element},
+ * {@link module:engine/view/emptyelement~ViewEmptyElement empty element}, etc) when developing a feature.
  *
  * The container element should be your default choice when writing a converter, unless:
  *
- * * this element represents a model text attribute (then use {@link module:engine/view/attributeelement~AttributeElement}),
- * * this is an empty element like `<img>` (then use {@link module:engine/view/emptyelement~EmptyElement}),
+ * * this element represents a model text attribute (then use {@link module:engine/view/attributeelement~ViewAttributeElement}),
+ * * this is an empty element like `<img>` (then use {@link module:engine/view/emptyelement~ViewEmptyElement}),
  * * this is a root element,
- * * this is a nested editable element (then use  {@link module:engine/view/editableelement~EditableElement}).
+ * * this is a nested editable element (then use  {@link module:engine/view/editableelement~ViewEditableElement}).
  *
  * To create a new container element instance use the
- * {@link module:engine/view/downcastwriter~DowncastWriter#createContainerElement `DowncastWriter#createContainerElement()`}
+ * {@link module:engine/view/downcastwriter~ViewDowncastWriter#createContainerElement `ViewDowncastWriter#createContainerElement()`}
  * method.
  */
-export default class ContainerElement extends Element {
+export declare class ViewContainerElement extends ViewElement {
     /**
      * Creates a container element.
      *
-     * @see module:engine/view/downcastwriter~DowncastWriter#createContainerElement
-     * @see module:engine/view/element~Element
+     * @see module:engine/view/downcastwriter~ViewDowncastWriter#createContainerElement
+     * @see module:engine/view/element~ViewElement
      * @internal
      * @param document The document instance to which this element belongs.
      * @param name Node name.
      * @param attrs Collection of attributes.
      * @param children A list of nodes to be inserted into created element.
      */
-    constructor(document: Document, name: string, attrs?: ElementAttributes, children?: Node | Iterable<Node>);
+    constructor(document: ViewDocument, name: string, attrs?: ViewElementAttributes, children?: ViewNode | Iterable<ViewNode>);
 }
 /**
  * Returns block {@link module:engine/view/filler filler} offset or `null` if block filler is not needed.
  *
  * @returns Block filler offset or `null` if block filler is not needed.
  */
-export declare function getFillerOffset(this: ContainerElement): number | null;
+export declare function getViewFillerOffset(this: ViewContainerElement): number | null;

package/src/view/containerelement.js

@@ -5,32 +5,33 @@
 /**
  * @module engine/view/containerelement
  */
-import Element from './element.js';
+import { ViewElement } from './element.js';
 /**
  * Containers are elements which define document structure. They define boundaries for
- * {@link module:engine/view/attributeelement~AttributeElement attributes}. They are mostly used for block elements like `<p>` or `<div>`.
+ * {@link module:engine/view/attributeelement~ViewAttributeElement attributes}.
+ * They are mostly used for block elements like `<p>` or `<div>`.
  *
  * Editing engine does not define a fixed HTML DTD. This is why a feature developer needs to choose between various
- * types (container element, {@link module:engine/view/attributeelement~AttributeElement attribute element},
- * {@link module:engine/view/emptyelement~EmptyElement empty element}, etc) when developing a feature.
+ * types (container element, {@link module:engine/view/attributeelement~ViewAttributeElement attribute element},
+ * {@link module:engine/view/emptyelement~ViewEmptyElement empty element}, etc) when developing a feature.
  *
  * The container element should be your default choice when writing a converter, unless:
  *
- * * this element represents a model text attribute (then use {@link module:engine/view/attributeelement~AttributeElement}),
- * * this is an empty element like `<img>` (then use {@link module:engine/view/emptyelement~EmptyElement}),
+ * * this element represents a model text attribute (then use {@link module:engine/view/attributeelement~ViewAttributeElement}),
+ * * this is an empty element like `<img>` (then use {@link module:engine/view/emptyelement~ViewEmptyElement}),
  * * this is a root element,
- * * this is a nested editable element (then use  {@link module:engine/view/editableelement~EditableElement}).
+ * * this is a nested editable element (then use  {@link module:engine/view/editableelement~ViewEditableElement}).
  *
  * To create a new container element instance use the
- * {@link module:engine/view/downcastwriter~DowncastWriter#createContainerElement `DowncastWriter#createContainerElement()`}
+ * {@link module:engine/view/downcastwriter~ViewDowncastWriter#createContainerElement `ViewDowncastWriter#createContainerElement()`}
  * method.
  */
-export default class ContainerElement extends Element {
+export class ViewContainerElement extends ViewElement {
     /**
      * Creates a container element.
      *
-     * @see module:engine/view/downcastwriter~DowncastWriter#createContainerElement
-     * @see module:engine/view/element~Element
+     * @see module:engine/view/downcastwriter~ViewDowncastWriter#createContainerElement
+     * @see module:engine/view/element~ViewElement
      * @internal
      * @param document The document instance to which this element belongs.
      * @param name Node name.
@@ -39,12 +40,12 @@ export default class ContainerElement extends Element {
      */
     constructor(document, name, attrs, children) {
         super(document, name, attrs, children);
-        this.getFillerOffset = getFillerOffset;
+        this.getFillerOffset = getViewFillerOffset;
     }
 }
 // The magic of type inference using `is` method is centralized in `TypeCheckable` class.
 // Proper overload would interfere with that.
-ContainerElement.prototype.is = function (type, name) {
+ViewContainerElement.prototype.is = function (type, name) {
     if (!name) {
         return type === 'containerElement' || type === 'view:containerElement' ||
             // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.
@@ -62,7 +63,7 @@ ContainerElement.prototype.is = function (type, name) {
  *
  * @returns Block filler offset or `null` if block filler is not needed.
  */
-export function getFillerOffset() {
+export function getViewFillerOffset() {
     const children = [...this.getChildren()];
     const lastChild = children[this.childCount - 1];
     // Block filler is required after a `<br>` if it's the last element in its container. See #1422.

package/src/view/datatransfer.d.ts

@@ -9,7 +9,7 @@ type DomDataTransfer = globalThis.DataTransfer;
 /**
  * A facade over the native [`DataTransfer`](https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer) object.
  */
-export default class DataTransfer {
+export declare class ViewDataTransfer {
     /**
      * The array of files created from the native `DataTransfer#files` or `DataTransfer#items`.
      */
@@ -52,13 +52,13 @@ export default class DataTransfer {
     /**
      * The effect that is allowed for a drag operation.
      */
-    set effectAllowed(value: EffectAllowed);
-    get effectAllowed(): EffectAllowed;
+    set effectAllowed(value: ViewEffectAllowed);
+    get effectAllowed(): ViewEffectAllowed;
     /**
      * The actual drop effect.
      */
-    set dropEffect(value: DropEffect);
-    get dropEffect(): DropEffect;
+    set dropEffect(value: ViewDropEffect);
+    get dropEffect(): ViewDropEffect;
     /**
      * Set a preview image of the dragged content.
      */
@@ -71,9 +71,9 @@ export default class DataTransfer {
 /**
  * The effect that is allowed for a drag operation.
  */
-export type EffectAllowed = DomDataTransfer['effectAllowed'];
+export type ViewEffectAllowed = DomDataTransfer['effectAllowed'];
 /**
  * The actual drop effect.
  */
-export type DropEffect = DomDataTransfer['dropEffect'];
+export type ViewDropEffect = DomDataTransfer['dropEffect'];
 export {};

package/src/view/datatransfer.js

@@ -5,7 +5,7 @@
 /**
  * A facade over the native [`DataTransfer`](https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer) object.
  */
-export default class DataTransfer {
+export class ViewDataTransfer {
     /**
      * The array of files created from the native `DataTransfer#files` or `DataTransfer#items`.
      */

package/src/view/document.d.ts

@@ -5,33 +5,33 @@
 /**
  * @module engine/view/document
  */
-import DocumentSelection from './documentselection.js';
+import { ViewDocumentSelection } from './documentselection.js';
 import { Collection } from '@ckeditor/ckeditor5-utils';
 import type { StylesProcessor } from './stylesmap.js';
-import type RootEditableElement from './rooteditableelement.js';
-import type DowncastWriter from './downcastwriter.js';
-declare const Document_base: import("@ckeditor/ckeditor5-utils").Mixed<{
+import { type ViewRootEditableElement } from './rooteditableelement.js';
+import { type ViewDowncastWriter } from './downcastwriter.js';
+declare const ViewDocument_base: import("@ckeditor/ckeditor5-utils").Mixed<{
     new (): import("@ckeditor/ckeditor5-utils").Observable;
     prototype: import("@ckeditor/ckeditor5-utils").Observable;
 }, import("@ckeditor/ckeditor5-utils").Emitter>;
 /**
  * Document class creates an abstract layer over the content editable area, contains a tree of view elements and
- * {@link module:engine/view/documentselection~DocumentSelection view selection} associated with this document.
+ * {@link module:engine/view/documentselection~ViewDocumentSelection view selection} associated with this document.
  */
-export default class Document extends /* #__PURE__ */ Document_base {
+export declare class ViewDocument extends /* #__PURE__ */ ViewDocument_base {
     /**
      * Selection done on this document.
      */
-    readonly selection: DocumentSelection;
+    readonly selection: ViewDocumentSelection;
     /**
-     * Roots of the view tree. Collection of the {@link module:engine/view/element~Element view elements}.
+     * Roots of the view tree. Collection of the {@link module:engine/view/element~ViewElement view elements}.
      *
-     * View roots are created as a result of binding between {@link module:engine/view/document~Document#roots} and
-     * {@link module:engine/model/document~Document#roots} and this is handled by
+     * View roots are created as a result of binding between {@link module:engine/view/document~ViewDocument#roots} and
+     * {@link module:engine/model/document~ModelDocument#roots} and this is handled by
      * {@link module:engine/controller/editingcontroller~EditingController}, so to create view root we need to create
-     * model root using {@link module:engine/model/document~Document#createRoot}.
+     * model root using {@link module:engine/model/document~ModelDocument#createRoot}.
      */
-    readonly roots: Collection<RootEditableElement>;
+    readonly roots: Collection<ViewRootEditableElement>;
     /**
      * The styles processor instance used by this document when normalizing styles.
      */
@@ -85,19 +85,19 @@ export default class Document extends /* #__PURE__ */ Document_base {
      */
     constructor(stylesProcessor: StylesProcessor);
     /**
-     * Gets a {@link module:engine/view/document~Document#roots view root element} with the specified name. If the name is not
+     * Gets a {@link module:engine/view/document~ViewDocument#roots view root element} with the specified name. If the name is not
      * specific "main" root is returned.
      *
      * @param name Name of the root.
      * @returns The view root element with the specified name or null when there is no root of given name.
      */
-    getRoot(name?: string): RootEditableElement | null;
+    getRoot(name?: string): ViewRootEditableElement | null;
     /**
      * Allows registering post-fixer callbacks. A post-fixers mechanism allows to update the view tree just before it is rendered
      * to the DOM.
      *
      * Post-fixers are executed right after all changes from the outermost change block were applied but
-     * before the {@link module:engine/view/view~View#event:render render event} is fired. If a post-fixer callback made
+     * before the {@link module:engine/view/view~EditingView#event:render render event} is fired. If a post-fixer callback made
      * a change, it should return `true`. When this happens, all post-fixers are fired again to check if something else should
      * not be fixed in the new document tree state.
      *
@@ -107,7 +107,7 @@ export default class Document extends /* #__PURE__ */ Document_base {
      * The types of changes which should be safe:
      *
      * * adding or removing attribute from elements,
-     * * changes inside of {@link module:engine/view/uielement~UIElement UI elements},
+     * * changes inside of {@link module:engine/view/uielement~ViewUIElement UI elements},
      * * {@link module:engine/controller/editingcontroller~EditingController#reconvertItem marking some of the model elements to be
      * re-converted}.
      *
@@ -116,7 +116,7 @@ export default class Document extends /* #__PURE__ */ Document_base {
      * * you should not add or remove nor wrap or unwrap any view elements,
      * * you should not change the editor data model in a view post-fixer.
      *
-     * As a parameter, a post-fixer callback receives a {@link module:engine/view/downcastwriter~DowncastWriter downcast writer}.
+     * As a parameter, a post-fixer callback receives a {@link module:engine/view/downcastwriter~ViewDowncastWriter downcast writer}.
      *
      * Typically, a post-fixer will look like this:
      *
@@ -137,10 +137,10 @@ export default class Document extends /* #__PURE__ */ Document_base {
      * That is because adding a post-fixer does not execute it.
      * The post-fixer will be executed as soon as any change in the document needs to cause its rendering.
      * If you want to re-render the editor's view after registering the post-fixer then you should do it manually by calling
-     * {@link module:engine/view/view~View#forceRender `view.forceRender()`}.
+     * {@link module:engine/view/view~EditingView#forceRender `view.forceRender()`}.
      *
      * If you need to register a callback which is executed when DOM elements are already updated,
-     * use {@link module:engine/view/view~View#event:render render event}.
+     * use {@link module:engine/view/view~EditingView#event:render render event}.
      */
     registerPostFixer(postFixer: ViewDocumentPostFixer): void;
     /**
@@ -152,14 +152,14 @@ export default class Document extends /* #__PURE__ */ Document_base {
      *
      * @internal
      */
-    _callPostFixers(writer: DowncastWriter): void;
+    _callPostFixers(writer: ViewDowncastWriter): void;
 }
 /**
  * Document PostFixer.
  *
- * @see module:engine/view/document~Document#registerPostFixer
+ * @see module:engine/view/document~ViewDocument#registerPostFixer
  */
-export type ViewDocumentPostFixer = (writer: DowncastWriter) => boolean;
+export type ViewDocumentPostFixer = (writer: ViewDowncastWriter) => boolean;
 /**
  * Enum representing type of the change.
  *
@@ -169,13 +169,13 @@ export type ViewDocumentPostFixer = (writer: DowncastWriter) => boolean;
  * * `attributes` - for element attributes changes,
  * * `text` - for text nodes changes.
  */
-export type ChangeType = 'children' | 'attributes' | 'text';
+export type ViewDocumentChangeType = 'children' | 'attributes' | 'text';
 /**
  * Event fired whenever document content layout changes. It is fired whenever content is
- * {@link module:engine/view/view~View#event:render rendered}, but should be also fired by observers in case of
+ * {@link module:engine/view/view~EditingView#event:render rendered}, but should be also fired by observers in case of
  * other actions which may change layout, for instance when image loads.
  *
- * @eventName ~Document#layoutChanged
+ * @eventName ~ViewDocument#layoutChanged
  */
 export type ViewDocumentLayoutChangedEvent = {
     name: 'layoutChanged';