@ckeditor/ckeditor5-engine 48.2.0 → 48.3.0-alpha.0

package/dist/view/typecheckable.d.ts

@@ -1,449 +1,449 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * @module engine/view/typecheckable
- */
-import { type ViewAttributeElement } from './attributeelement.js';
-import { type ViewContainerElement } from './containerelement.js';
-import { type ViewDocumentFragment } from './documentfragment.js';
-import { type ViewDocumentSelection } from './documentselection.js';
-import { type ViewEditableElement } from './editableelement.js';
-import { type ViewElement } from './element.js';
-import { type ViewEmptyElement } from './emptyelement.js';
-import { type ViewNode } from './node.js';
-import { type ViewPosition } from './position.js';
-import { type ViewRange } from './range.js';
-import { type ViewRawElement } from './rawelement.js';
-import { type ViewRootEditableElement } from './rooteditableelement.js';
-import { type ViewSelection } from './selection.js';
-import { type ViewText } from './text.js';
-import { type ViewTextProxy } from './textproxy.js';
-import { type ViewUIElement } from './uielement.js';
+* @module engine/view/typecheckable
+*/
+import { type ViewAttributeElement } from "./attributeelement.js";
+import { type ViewContainerElement } from "./containerelement.js";
+import { type ViewDocumentFragment } from "./documentfragment.js";
+import { type ViewDocumentSelection } from "./documentselection.js";
+import { type ViewEditableElement } from "./editableelement.js";
+import { type ViewElement } from "./element.js";
+import { type ViewEmptyElement } from "./emptyelement.js";
+import { type ViewNode } from "./node.js";
+import { type ViewPosition } from "./position.js";
+import { type ViewRange } from "./range.js";
+import { type ViewRawElement } from "./rawelement.js";
+import { type ViewRootEditableElement } from "./rooteditableelement.js";
+import { type ViewSelection } from "./selection.js";
+import { type ViewText } from "./text.js";
+import { type ViewTextProxy } from "./textproxy.js";
+import { type ViewUIElement } from "./uielement.js";
 export declare abstract class ViewTypeCheckable {
-    /**
-     * Checks whether this object is of type {@link module:engine/view/node~ViewNode} or its subclass.
-     *
-     * This method is useful when processing view objects that are of unknown type. For example, a function
-     * may return a {@link module:engine/view/documentfragment~ViewDocumentFragment} or a {@link module:engine/view/node~ViewNode}
-     * that can be either a text node or an element. This method can be used to check what kind of object is returned.
-     *
-     * ```ts
-     * someObject.is( 'element' ); // -> true if this is an element
-     * someObject.is( 'node' ); // -> true if this is a node (a text node or an element)
-     * someObject.is( 'documentFragment' ); // -> true if this is a document fragment
-     * ```
-     *
-     * Since this method is also available on a range of model objects, you can prefix the type of the object with
-     * `model:` or `view:` to check, for example, if this is the model's or view's element:
-     *
-     * ```ts
-     * viewElement.is( 'view:element' ); // -> true
-     * viewElement.is( 'model:element' ); // -> false
-     * ```
-     *
-     * By using this method it is also possible to check a name of an element:
-     *
-     * ```ts
-     * imgElement.is( 'element', 'img' ); // -> true
-     * imgElement.is( 'view:element', 'img' ); // -> same as above, but more precise
-     * ```
-     * @label NODE
-     */
-    is(type: 'node' | 'view:node'): this is (ViewNode | ViewText | ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement);
-    /**
-     * Checks whether this object is of type {@link module:engine/view/element~ViewElement} or its subclass.
-     *
-     * ```ts
-     * element.is( 'element' ); // -> true
-     * element.is( 'node' ); // -> true
-     * element.is( 'view:element' ); // -> true
-     * element.is( 'view:node' ); // -> true
-     *
-     * element.is( 'model:element' ); // -> false
-     * element.is( 'documentSelection' ); // -> false
-     * ```
-     *
-     * Assuming that the object being checked is an element, you can also check its
-     * {@link module:engine/view/element~ViewElement#name name}:
-     *
-     * ```ts
-     * element.is( 'element', 'img' ); // -> true if this is an <img> element
-     * text.is( 'element', 'img' ); -> false
-     * ```
-     *
-     * @label ELEMENT
-     */
-    is(type: 'element' | 'view:element'): this is (ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement);
-    /**
-     * Checks whether this object is of type {@link module:engine/view/attributeelement~ViewAttributeElement}.
-     *
-     * ```ts
-     * attributeElement.is( 'attributeElement' ); // -> true
-     * attributeElement.is( 'element' ); // -> true
-     * attributeElement.is( 'node' ); // -> true
-     * attributeElement.is( 'view:attributeElement' ); // -> true
-     * attributeElement.is( 'view:element' ); // -> true
-     * attributeElement.is( 'view:node' ); // -> true
-     *
-     * attributeElement.is( 'model:element' ); // -> false
-     * attributeElement.is( 'documentFragment' ); // -> false
-     * ```
-     *
-     * Assuming that the object being checked is an attribute element, you can also check its
-     * {@link module:engine/view/attributeelement~ViewAttributeElement#name name}:
-     *
-     * ```ts
-     * attributeElement.is( 'element', 'b' ); // -> true if this is a bold element
-     * attributeElement.is( 'attributeElement', 'b' ); // -> same as above
-     * text.is( 'element', 'b' ); -> false
-     * ```
-     *
-     * @label ATTRIBUTE_ELEMENT
-     */
-    is(type: 'attributeElement' | 'view:attributeElement'): this is ViewAttributeElement;
-    /**
-     * Checks whether this object is of type {@link module:engine/view/containerelement~ViewContainerElement} or its subclass.
-     *
-     * ```ts
-     * containerElement.is( 'containerElement' ); // -> true
-     * containerElement.is( 'element' ); // -> true
-     * containerElement.is( 'node' ); // -> true
-     * containerElement.is( 'view:containerElement' ); // -> true
-     * containerElement.is( 'view:element' ); // -> true
-     * containerElement.is( 'view:node' ); // -> true
-     *
-     * containerElement.is( 'model:element' ); // -> false
-     * containerElement.is( 'documentFragment' ); // -> false
-     * ```
-     *
-     * Assuming that the object being checked is a container element, you can also check its
-     * {@link module:engine/view/containerelement~ViewContainerElement#name name}:
-     *
-     * ```ts
-     * containerElement.is( 'element', 'div' ); // -> true if this is a div container element
-     * containerElement.is( 'contaienrElement', 'div' ); // -> same as above
-     * text.is( 'element', 'div' ); -> false
-     * ```
-     *
-     * @label CONTAINER_ELEMENT
-     */
-    is(type: 'containerElement' | 'view:containerElement'): this is ViewContainerElement | ViewEditableElement | ViewRootEditableElement;
-    /**
-     * Checks whether this object is of type {@link module:engine/view/editableelement~ViewEditableElement} or its subclass.
-     *
-     * ```ts
-     * editableElement.is( 'editableElement' ); // -> true
-     * editableElement.is( 'element' ); // -> true
-     * editableElement.is( 'node' ); // -> true
-     * editableElement.is( 'view:editableElement' ); // -> true
-     * editableElement.is( 'view:element' ); // -> true
-     * editableElement.is( 'view:node' ); // -> true
-     *
-     * editableElement.is( 'model:element' ); // -> false
-     * editableElement.is( 'documentFragment' ); // -> false
-     * ```
-     *
-     * Assuming that the object being checked is an editbale element, you can also check its
-     * {@link module:engine/view/editableelement~ViewEditableElement#name name}:
-     *
-     * ```ts
-     * editableElement.is( 'element', 'div' ); // -> true if this is a div element
-     * editableElement.is( 'editableElement', 'div' ); // -> same as above
-     * text.is( 'element', 'div' ); -> false
-     * ```
-     *
-     * @label EDITABLE_ELEMENT
-     */
-    is(type: 'editableElement' | 'view:editableElement'): this is ViewEditableElement | ViewRootEditableElement;
-    /**
-     * Checks whether this object is of type {@link module:engine/view/emptyelement~ViewEmptyElement}.
-     *
-     * ```ts
-     * emptyElement.is( 'emptyElement' ); // -> true
-     * emptyElement.is( 'element' ); // -> true
-     * emptyElement.is( 'node' ); // -> true
-     * emptyElement.is( 'view:emptyElement' ); // -> true
-     * emptyElement.is( 'view:element' ); // -> true
-     * emptyElement.is( 'view:node' ); // -> true
-     *
-     * emptyElement.is( 'model:element' ); // -> false
-     * emptyElement.is( 'documentFragment' ); // -> false
-     * ```
-     *
-     * Assuming that the object being checked is an empty element, you can also check its
-     * {@link module:engine/view/emptyelement~ViewEmptyElement#name name}:
-     *
-     * ```ts
-     * emptyElement.is( 'element', 'img' ); // -> true if this is a img element
-     * emptyElement.is( 'emptyElement', 'img' ); // -> same as above
-     * text.is( 'element', 'img' ); -> false
-     * ```
-     *
-     * @label EMPTY_ELEMENT
-     */
-    is(type: 'emptyElement' | 'view:emptyElement'): this is ViewEmptyElement;
-    /**
-     * Checks whether this object is of type {@link module:engine/view/rawelement~ViewRawElement}.
-     *
-     * ```ts
-     * rawElement.is( 'rawElement' ); // -> true
-     * rawElement.is( 'element' ); // -> true
-     * rawElement.is( 'node' ); // -> true
-     * rawElement.is( 'view:rawElement' ); // -> true
-     * rawElement.is( 'view:element' ); // -> true
-     * rawElement.is( 'view:node' ); // -> true
-     *
-     * rawElement.is( 'model:element' ); // -> false
-     * rawElement.is( 'documentFragment' ); // -> false
-     * ```
-     *
-     * Assuming that the object being checked is a raw element, you can also check its
-     * {@link module:engine/view/rawelement~ViewRawElement#name name}:
-     *
-     * ```ts
-     * rawElement.is( 'img' ); // -> true if this is an img element
-     * rawElement.is( 'rawElement', 'img' ); // -> same as above
-     * text.is( 'img' ); -> false
-     * ```
-     *
-     * @label RAW_ELEMENT
-     */
-    is(type: 'rawElement' | 'view:rawElement'): this is ViewRawElement;
-    /**
-     * Checks whether this object is of type {@link module:engine/view/rooteditableelement~ViewRootEditableElement}.
-     *
-     * ```ts
-     * rootEditableElement.is( 'rootElement' ); // -> true
-     * rootEditableElement.is( 'editableElement' ); // -> true
-     * rootEditableElement.is( 'element' ); // -> true
-     * rootEditableElement.is( 'node' ); // -> true
-     * rootEditableElement.is( 'view:editableElement' ); // -> true
-     * rootEditableElement.is( 'view:element' ); // -> true
-     * rootEditableElement.is( 'view:node' ); // -> true
-     *
-     * rootEditableElement.is( 'model:element' ); // -> false
-     * rootEditableElement.is( 'documentFragment' ); // -> false
-     * ```
-     *
-     * Assuming that the object being checked is a root editable element, you can also check its
-     * {@link module:engine/view/rooteditableelement~ViewRootEditableElement#name name}:
-     *
-     * ```ts
-     * rootEditableElement.is( 'element', 'div' ); // -> true if this is a div root editable element
-     * rootEditableElement.is( 'rootElement', 'div' ); // -> same as above
-     * text.is( 'element', 'div' ); -> false
-     * ```
-     *
-     * @label ROOT_ELEMENT
-     */
-    is(type: 'rootElement' | 'view:rootElement'): this is ViewRootEditableElement;
-    /**
-     * Checks whether this object is of type {@link module:engine/view/uielement~ViewUIElement}.
-     *
-     * ```ts
-     * uiElement.is( 'uiElement' ); // -> true
-     * uiElement.is( 'element' ); // -> true
-     * uiElement.is( 'node' ); // -> true
-     * uiElement.is( 'view:uiElement' ); // -> true
-     * uiElement.is( 'view:element' ); // -> true
-     * uiElement.is( 'view:node' ); // -> true
-     *
-     * uiElement.is( 'model:element' ); // -> false
-     * uiElement.is( 'documentFragment' ); // -> false
-     * ```
-     *
-     * Assuming that the object being checked is an ui element, you can also check its
-     * {@link module:engine/view/uielement~ViewUIElement#name name}:
-     *
-     * ```ts
-     * uiElement.is( 'element', 'span' ); // -> true if this is a span ui element
-     * uiElement.is( 'uiElement', 'span' ); // -> same as above
-     * text.is( 'element', 'span' ); -> false
-     * ```
-     *
-     * @label UI_ELEMENT
-     */
-    is(type: 'uiElement' | 'view:uiElement'): this is ViewUIElement;
-    /**
-     * Checks whether this object is of type {@link module:engine/view/text~ViewText}.
-     *
-     * ```ts
-     * text.is( '$text' ); // -> true
-     * text.is( 'node' ); // -> true
-     * text.is( 'view:$text' ); // -> true
-     * text.is( 'view:node' ); // -> true
-     *
-     * text.is( 'model:$text' ); // -> false
-     * text.is( 'element' ); // -> false
-     * text.is( 'range' ); // -> false
-     * ```
-     *
-     * @label TEXT
-     */
-    is(type: '$text' | 'view:$text'): this is ViewText;
-    /**
-     * hecks whether this object is of type {@link module:engine/view/documentfragment~ViewDocumentFragment}.
-     *
-     * ```ts
-     * docFrag.is( 'documentFragment' ); // -> true
-     * docFrag.is( 'view:documentFragment' ); // -> true
-     *
-     * docFrag.is( 'model:documentFragment' ); // -> false
-     * docFrag.is( 'element' ); // -> false
-     * docFrag.is( 'node' ); // -> false
-     * ```
-     *
-     * @label DOCUMENT_FRAGMENT
-     */
-    is(type: 'documentFragment' | 'view:documentFragment'): this is ViewDocumentFragment;
-    /**
-     * Checks whether this object is of type {@link module:engine/view/textproxy~ViewTextProxy}.
-     *
-     * ```ts
-     * textProxy.is( '$textProxy' ); // -> true
-     * textProxy.is( 'view:$textProxy' ); // -> true
-     *
-     * textProxy.is( 'model:$textProxy' ); // -> false
-     * textProxy.is( 'element' ); // -> false
-     * textProxy.is( 'range' ); // -> false
-     * ```
-     *
-     * **Note:** Until version 20.0.0 this method wasn't accepting `'$textProxy'` type. The legacy `'textProxy'` type is still
-     * accepted for backward compatibility.
-     *
-     * @label TEXT_PROXY
-     */
-    is(type: '$textProxy' | 'view:$textProxy'): this is ViewTextProxy;
-    /**
-     * Checks whether this object is of type {@link module:engine/view/position~ViewPosition}.
-     *
-     * ```ts
-     * position.is( 'position' ); // -> true
-     * position.is( 'view:position' ); // -> true
-     *
-     * position.is( 'model:position' ); // -> false
-     * position.is( 'element' ); // -> false
-     * position.is( 'range' ); // -> false
-     * ```
-     *
-     * @label POSITION
-     */
-    is(type: 'position' | 'view:position'): this is ViewPosition;
-    /**
-     * Checks whether this object is of type {@link module:engine/view/range~ViewRange}.
-     *
-     * ```ts
-     * range.is( 'range' ); // -> true
-     * range.is( 'view:range' ); // -> true
-     *
-     * range.is( 'model:range' ); // -> false
-     * range.is( 'element' ); // -> false
-     * range.is( 'selection' ); // -> false
-     * ```
-     *
-     * @label RANGE
-     */
-    is(type: 'range' | 'view:range'): this is ViewRange;
-    /**
-     * Checks whether this object is of type {@link module:engine/view/selection~ViewSelection} or
-     * {@link module:engine/view/documentselection~ViewDocumentSelection}.
-     *
-     * ```ts
-     * selection.is( 'selection' ); // -> true
-     * selection.is( 'view:selection' ); // -> true
-     *
-     * selection.is( 'model:selection' ); // -> false
-     * selection.is( 'element' ); // -> false
-     * selection.is( 'range' ); // -> false
-     * ```
-     *
-     * @label SELECTION
-     */
-    is(type: 'selection' | 'view:selection'): this is ViewSelection | ViewDocumentSelection;
-    /**
-     * Checks whether this object is of type {@link module:engine/view/documentselection~ViewDocumentSelection}.
-     *
-     * ```ts
-     * `docSelection.is( 'selection' ); // -> true
-     * docSelection.is( 'documentSelection' ); // -> true
-     * docSelection.is( 'view:selection' ); // -> true
-     * docSelection.is( 'view:documentSelection' ); // -> true
-     *
-     * docSelection.is( 'model:documentSelection' ); // -> false
-     * docSelection.is( 'element' ); // -> false
-     * docSelection.is( 'node' ); // -> false
-     * ```
-     *
-     * @label DOCUMENT_SELECTION
-     */
-    is(type: 'documentSelection' | 'view:documentSelection'): this is ViewDocumentSelection;
-    /**
-     * Checks whether the object is of type {@link module:engine/view/element~ViewElement} or its subclass and has the specified `name`.
-     *
-     * @label ELEMENT_NAME
-     */
-    is<N extends string>(type: 'element' | 'view:element', name: N): this is (ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement) & {
-        name: N;
-    };
-    /**
-     * Checks whether the object is of type {@link module:engine/view/attributeelement~ViewAttributeElement} and has the specified `name`.
-     *
-     * @label ATTRIBUTE_ELEMENT_NAME
-     */
-    is<N extends string>(type: 'attributeElement' | 'view:attributeElement', name: N): this is ViewAttributeElement & {
-        name: N;
-    };
-    /**
-     * Checks whether the object is of type {@link module:engine/view/containerelement~ViewContainerElement}
-     * or its subclass and has the specified `name`.
-     *
-     * @label CONTAINER_ELEMENT_NAME
-     */
-    is<N extends string>(type: 'containerElement' | 'view:containerElement', name: N): this is (ViewContainerElement | ViewEditableElement | ViewRootEditableElement) & {
-        name: N;
-    };
-    /**
-     * Checks whether the object is of type {@link module:engine/view/editableelement~ViewEditableElement}
-     * or its subclass and has the specified `name`.
-     *
-     * @label EDITABLE_ELEMENT_NAME
-     */
-    is<N extends string>(type: 'editableElement' | 'view:editableElement', name: N): this is (ViewEditableElement | ViewRootEditableElement) & {
-        name: N;
-    };
-    /**
-     * Checks whether the object is of type {@link module:engine/view/emptyelement~ViewEmptyElement} has the specified `name`.
-     *
-     * @label EMPTY_ELEMENT_NAME
-     */
-    is<N extends string>(type: 'emptyElement' | 'view:emptyElement', name: N): this is ViewEmptyElement & {
-        name: N;
-    };
-    /**
-     * Checks whether the object is of type {@link module:engine/view/rawelement~ViewRawElement} and has the specified `name`.
-     *
-     * @label RAW_ELEMENT_NAME
-     */
-    is<N extends string>(type: 'rawElement' | 'view:rawElement', name: N): this is ViewRawElement & {
-        name: N;
-    };
-    /**
-     * Checks whether the object is of type {@link module:engine/view/rooteditableelement~ViewRootEditableElement}
-     * and has the specified `name`.
-     *
-     * @label ROOT_ELEMENT_NAME
-     */
-    is<N extends string>(type: 'rootElement' | 'view:rootElement', name: N): this is ViewRootEditableElement & {
-        name: N;
-    };
-    /**
-     * Checks whether the object is of type {@link module:engine/view/uielement~ViewUIElement} and has the specified `name`.
-     *
-     * @label UI_ELEMENT_NAME
-     */
-    is<N extends string>(type: 'uiElement' | 'view:uiElement', name: N): this is ViewUIElement & {
-        name: N;
-    };
+	/**
+	* Checks whether this object is of type {@link module:engine/view/node~ViewNode} or its subclass.
+	*
+	* This method is useful when processing view objects that are of unknown type. For example, a function
+	* may return a {@link module:engine/view/documentfragment~ViewDocumentFragment} or a {@link module:engine/view/node~ViewNode}
+	* that can be either a text node or an element. This method can be used to check what kind of object is returned.
+	*
+	* ```ts
+	* someObject.is( 'element' ); // -> true if this is an element
+	* someObject.is( 'node' ); // -> true if this is a node (a text node or an element)
+	* someObject.is( 'documentFragment' ); // -> true if this is a document fragment
+	* ```
+	*
+	* Since this method is also available on a range of model objects, you can prefix the type of the object with
+	* `model:` or `view:` to check, for example, if this is the model's or view's element:
+	*
+	* ```ts
+	* viewElement.is( 'view:element' ); // -> true
+	* viewElement.is( 'model:element' ); // -> false
+	* ```
+	*
+	* By using this method it is also possible to check a name of an element:
+	*
+	* ```ts
+	* imgElement.is( 'element', 'img' ); // -> true
+	* imgElement.is( 'view:element', 'img' ); // -> same as above, but more precise
+	* ```
+	* @label NODE
+	*/
+	is(type: "node" | "view:node"): this is (ViewNode | ViewText | ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement);
+	/**
+	* Checks whether this object is of type {@link module:engine/view/element~ViewElement} or its subclass.
+	*
+	* ```ts
+	* element.is( 'element' ); // -> true
+	* element.is( 'node' ); // -> true
+	* element.is( 'view:element' ); // -> true
+	* element.is( 'view:node' ); // -> true
+	*
+	* element.is( 'model:element' ); // -> false
+	* element.is( 'documentSelection' ); // -> false
+	* ```
+	*
+	* Assuming that the object being checked is an element, you can also check its
+	* {@link module:engine/view/element~ViewElement#name name}:
+	*
+	* ```ts
+	* element.is( 'element', 'img' ); // -> true if this is an <img> element
+	* text.is( 'element', 'img' ); -> false
+	* ```
+	*
+	* @label ELEMENT
+	*/
+	is(type: "element" | "view:element"): this is (ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement);
+	/**
+	* Checks whether this object is of type {@link module:engine/view/attributeelement~ViewAttributeElement}.
+	*
+	* ```ts
+	* attributeElement.is( 'attributeElement' ); // -> true
+	* attributeElement.is( 'element' ); // -> true
+	* attributeElement.is( 'node' ); // -> true
+	* attributeElement.is( 'view:attributeElement' ); // -> true
+	* attributeElement.is( 'view:element' ); // -> true
+	* attributeElement.is( 'view:node' ); // -> true
+	*
+	* attributeElement.is( 'model:element' ); // -> false
+	* attributeElement.is( 'documentFragment' ); // -> false
+	* ```
+	*
+	* Assuming that the object being checked is an attribute element, you can also check its
+	* {@link module:engine/view/attributeelement~ViewAttributeElement#name name}:
+	*
+	* ```ts
+	* attributeElement.is( 'element', 'b' ); // -> true if this is a bold element
+	* attributeElement.is( 'attributeElement', 'b' ); // -> same as above
+	* text.is( 'element', 'b' ); -> false
+	* ```
+	*
+	* @label ATTRIBUTE_ELEMENT
+	*/
+	is(type: "attributeElement" | "view:attributeElement"): this is ViewAttributeElement;
+	/**
+	* Checks whether this object is of type {@link module:engine/view/containerelement~ViewContainerElement} or its subclass.
+	*
+	* ```ts
+	* containerElement.is( 'containerElement' ); // -> true
+	* containerElement.is( 'element' ); // -> true
+	* containerElement.is( 'node' ); // -> true
+	* containerElement.is( 'view:containerElement' ); // -> true
+	* containerElement.is( 'view:element' ); // -> true
+	* containerElement.is( 'view:node' ); // -> true
+	*
+	* containerElement.is( 'model:element' ); // -> false
+	* containerElement.is( 'documentFragment' ); // -> false
+	* ```
+	*
+	* Assuming that the object being checked is a container element, you can also check its
+	* {@link module:engine/view/containerelement~ViewContainerElement#name name}:
+	*
+	* ```ts
+	* containerElement.is( 'element', 'div' ); // -> true if this is a div container element
+	* containerElement.is( 'contaienrElement', 'div' ); // -> same as above
+	* text.is( 'element', 'div' ); -> false
+	* ```
+	*
+	* @label CONTAINER_ELEMENT
+	*/
+	is(type: "containerElement" | "view:containerElement"): this is ViewContainerElement | ViewEditableElement | ViewRootEditableElement;
+	/**
+	* Checks whether this object is of type {@link module:engine/view/editableelement~ViewEditableElement} or its subclass.
+	*
+	* ```ts
+	* editableElement.is( 'editableElement' ); // -> true
+	* editableElement.is( 'element' ); // -> true
+	* editableElement.is( 'node' ); // -> true
+	* editableElement.is( 'view:editableElement' ); // -> true
+	* editableElement.is( 'view:element' ); // -> true
+	* editableElement.is( 'view:node' ); // -> true
+	*
+	* editableElement.is( 'model:element' ); // -> false
+	* editableElement.is( 'documentFragment' ); // -> false
+	* ```
+	*
+	* Assuming that the object being checked is an editbale element, you can also check its
+	* {@link module:engine/view/editableelement~ViewEditableElement#name name}:
+	*
+	* ```ts
+	* editableElement.is( 'element', 'div' ); // -> true if this is a div element
+	* editableElement.is( 'editableElement', 'div' ); // -> same as above
+	* text.is( 'element', 'div' ); -> false
+	* ```
+	*
+	* @label EDITABLE_ELEMENT
+	*/
+	is(type: "editableElement" | "view:editableElement"): this is ViewEditableElement | ViewRootEditableElement;
+	/**
+	* Checks whether this object is of type {@link module:engine/view/emptyelement~ViewEmptyElement}.
+	*
+	* ```ts
+	* emptyElement.is( 'emptyElement' ); // -> true
+	* emptyElement.is( 'element' ); // -> true
+	* emptyElement.is( 'node' ); // -> true
+	* emptyElement.is( 'view:emptyElement' ); // -> true
+	* emptyElement.is( 'view:element' ); // -> true
+	* emptyElement.is( 'view:node' ); // -> true
+	*
+	* emptyElement.is( 'model:element' ); // -> false
+	* emptyElement.is( 'documentFragment' ); // -> false
+	* ```
+	*
+	* Assuming that the object being checked is an empty element, you can also check its
+	* {@link module:engine/view/emptyelement~ViewEmptyElement#name name}:
+	*
+	* ```ts
+	* emptyElement.is( 'element', 'img' ); // -> true if this is a img element
+	* emptyElement.is( 'emptyElement', 'img' ); // -> same as above
+	* text.is( 'element', 'img' ); -> false
+	* ```
+	*
+	* @label EMPTY_ELEMENT
+	*/
+	is(type: "emptyElement" | "view:emptyElement"): this is ViewEmptyElement;
+	/**
+	* Checks whether this object is of type {@link module:engine/view/rawelement~ViewRawElement}.
+	*
+	* ```ts
+	* rawElement.is( 'rawElement' ); // -> true
+	* rawElement.is( 'element' ); // -> true
+	* rawElement.is( 'node' ); // -> true
+	* rawElement.is( 'view:rawElement' ); // -> true
+	* rawElement.is( 'view:element' ); // -> true
+	* rawElement.is( 'view:node' ); // -> true
+	*
+	* rawElement.is( 'model:element' ); // -> false
+	* rawElement.is( 'documentFragment' ); // -> false
+	* ```
+	*
+	* Assuming that the object being checked is a raw element, you can also check its
+	* {@link module:engine/view/rawelement~ViewRawElement#name name}:
+	*
+	* ```ts
+	* rawElement.is( 'img' ); // -> true if this is an img element
+	* rawElement.is( 'rawElement', 'img' ); // -> same as above
+	* text.is( 'img' ); -> false
+	* ```
+	*
+	* @label RAW_ELEMENT
+	*/
+	is(type: "rawElement" | "view:rawElement"): this is ViewRawElement;
+	/**
+	* Checks whether this object is of type {@link module:engine/view/rooteditableelement~ViewRootEditableElement}.
+	*
+	* ```ts
+	* rootEditableElement.is( 'rootElement' ); // -> true
+	* rootEditableElement.is( 'editableElement' ); // -> true
+	* rootEditableElement.is( 'element' ); // -> true
+	* rootEditableElement.is( 'node' ); // -> true
+	* rootEditableElement.is( 'view:editableElement' ); // -> true
+	* rootEditableElement.is( 'view:element' ); // -> true
+	* rootEditableElement.is( 'view:node' ); // -> true
+	*
+	* rootEditableElement.is( 'model:element' ); // -> false
+	* rootEditableElement.is( 'documentFragment' ); // -> false
+	* ```
+	*
+	* Assuming that the object being checked is a root editable element, you can also check its
+	* {@link module:engine/view/rooteditableelement~ViewRootEditableElement#name name}:
+	*
+	* ```ts
+	* rootEditableElement.is( 'element', 'div' ); // -> true if this is a div root editable element
+	* rootEditableElement.is( 'rootElement', 'div' ); // -> same as above
+	* text.is( 'element', 'div' ); -> false
+	* ```
+	*
+	* @label ROOT_ELEMENT
+	*/
+	is(type: "rootElement" | "view:rootElement"): this is ViewRootEditableElement;
+	/**
+	* Checks whether this object is of type {@link module:engine/view/uielement~ViewUIElement}.
+	*
+	* ```ts
+	* uiElement.is( 'uiElement' ); // -> true
+	* uiElement.is( 'element' ); // -> true
+	* uiElement.is( 'node' ); // -> true
+	* uiElement.is( 'view:uiElement' ); // -> true
+	* uiElement.is( 'view:element' ); // -> true
+	* uiElement.is( 'view:node' ); // -> true
+	*
+	* uiElement.is( 'model:element' ); // -> false
+	* uiElement.is( 'documentFragment' ); // -> false
+	* ```
+	*
+	* Assuming that the object being checked is an ui element, you can also check its
+	* {@link module:engine/view/uielement~ViewUIElement#name name}:
+	*
+	* ```ts
+	* uiElement.is( 'element', 'span' ); // -> true if this is a span ui element
+	* uiElement.is( 'uiElement', 'span' ); // -> same as above
+	* text.is( 'element', 'span' ); -> false
+	* ```
+	*
+	* @label UI_ELEMENT
+	*/
+	is(type: "uiElement" | "view:uiElement"): this is ViewUIElement;
+	/**
+	* Checks whether this object is of type {@link module:engine/view/text~ViewText}.
+	*
+	* ```ts
+	* text.is( '$text' ); // -> true
+	* text.is( 'node' ); // -> true
+	* text.is( 'view:$text' ); // -> true
+	* text.is( 'view:node' ); // -> true
+	*
+	* text.is( 'model:$text' ); // -> false
+	* text.is( 'element' ); // -> false
+	* text.is( 'range' ); // -> false
+	* ```
+	*
+	* @label TEXT
+	*/
+	is(type: "$text" | "view:$text"): this is ViewText;
+	/**
+	* hecks whether this object is of type {@link module:engine/view/documentfragment~ViewDocumentFragment}.
+	*
+	* ```ts
+	* docFrag.is( 'documentFragment' ); // -> true
+	* docFrag.is( 'view:documentFragment' ); // -> true
+	*
+	* docFrag.is( 'model:documentFragment' ); // -> false
+	* docFrag.is( 'element' ); // -> false
+	* docFrag.is( 'node' ); // -> false
+	* ```
+	*
+	* @label DOCUMENT_FRAGMENT
+	*/
+	is(type: "documentFragment" | "view:documentFragment"): this is ViewDocumentFragment;
+	/**
+	* Checks whether this object is of type {@link module:engine/view/textproxy~ViewTextProxy}.
+	*
+	* ```ts
+	* textProxy.is( '$textProxy' ); // -> true
+	* textProxy.is( 'view:$textProxy' ); // -> true
+	*
+	* textProxy.is( 'model:$textProxy' ); // -> false
+	* textProxy.is( 'element' ); // -> false
+	* textProxy.is( 'range' ); // -> false
+	* ```
+	*
+	* **Note:** Until version 20.0.0 this method wasn't accepting `'$textProxy'` type. The legacy `'textProxy'` type is still
+	* accepted for backward compatibility.
+	*
+	* @label TEXT_PROXY
+	*/
+	is(type: "$textProxy" | "view:$textProxy"): this is ViewTextProxy;
+	/**
+	* Checks whether this object is of type {@link module:engine/view/position~ViewPosition}.
+	*
+	* ```ts
+	* position.is( 'position' ); // -> true
+	* position.is( 'view:position' ); // -> true
+	*
+	* position.is( 'model:position' ); // -> false
+	* position.is( 'element' ); // -> false
+	* position.is( 'range' ); // -> false
+	* ```
+	*
+	* @label POSITION
+	*/
+	is(type: "position" | "view:position"): this is ViewPosition;
+	/**
+	* Checks whether this object is of type {@link module:engine/view/range~ViewRange}.
+	*
+	* ```ts
+	* range.is( 'range' ); // -> true
+	* range.is( 'view:range' ); // -> true
+	*
+	* range.is( 'model:range' ); // -> false
+	* range.is( 'element' ); // -> false
+	* range.is( 'selection' ); // -> false
+	* ```
+	*
+	* @label RANGE
+	*/
+	is(type: "range" | "view:range"): this is ViewRange;
+	/**
+	* Checks whether this object is of type {@link module:engine/view/selection~ViewSelection} or
+	* {@link module:engine/view/documentselection~ViewDocumentSelection}.
+	*
+	* ```ts
+	* selection.is( 'selection' ); // -> true
+	* selection.is( 'view:selection' ); // -> true
+	*
+	* selection.is( 'model:selection' ); // -> false
+	* selection.is( 'element' ); // -> false
+	* selection.is( 'range' ); // -> false
+	* ```
+	*
+	* @label SELECTION
+	*/
+	is(type: "selection" | "view:selection"): this is ViewSelection | ViewDocumentSelection;
+	/**
+	* Checks whether this object is of type {@link module:engine/view/documentselection~ViewDocumentSelection}.
+	*
+	* ```ts
+	* `docSelection.is( 'selection' ); // -> true
+	* docSelection.is( 'documentSelection' ); // -> true
+	* docSelection.is( 'view:selection' ); // -> true
+	* docSelection.is( 'view:documentSelection' ); // -> true
+	*
+	* docSelection.is( 'model:documentSelection' ); // -> false
+	* docSelection.is( 'element' ); // -> false
+	* docSelection.is( 'node' ); // -> false
+	* ```
+	*
+	* @label DOCUMENT_SELECTION
+	*/
+	is(type: "documentSelection" | "view:documentSelection"): this is ViewDocumentSelection;
+	/**
+	* Checks whether the object is of type {@link module:engine/view/element~ViewElement} or its subclass and has the specified `name`.
+	*
+	* @label ELEMENT_NAME
+	*/
+	is<N extends string>(type: "element" | "view:element", name: N): this is (ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement) & {
+		name: N;
+	};
+	/**
+	* Checks whether the object is of type {@link module:engine/view/attributeelement~ViewAttributeElement} and has the specified `name`.
+	*
+	* @label ATTRIBUTE_ELEMENT_NAME
+	*/
+	is<N extends string>(type: "attributeElement" | "view:attributeElement", name: N): this is ViewAttributeElement & {
+		name: N;
+	};
+	/**
+	* Checks whether the object is of type {@link module:engine/view/containerelement~ViewContainerElement}
+	* or its subclass and has the specified `name`.
+	*
+	* @label CONTAINER_ELEMENT_NAME
+	*/
+	is<N extends string>(type: "containerElement" | "view:containerElement", name: N): this is (ViewContainerElement | ViewEditableElement | ViewRootEditableElement) & {
+		name: N;
+	};
+	/**
+	* Checks whether the object is of type {@link module:engine/view/editableelement~ViewEditableElement}
+	* or its subclass and has the specified `name`.
+	*
+	* @label EDITABLE_ELEMENT_NAME
+	*/
+	is<N extends string>(type: "editableElement" | "view:editableElement", name: N): this is (ViewEditableElement | ViewRootEditableElement) & {
+		name: N;
+	};
+	/**
+	* Checks whether the object is of type {@link module:engine/view/emptyelement~ViewEmptyElement} has the specified `name`.
+	*
+	* @label EMPTY_ELEMENT_NAME
+	*/
+	is<N extends string>(type: "emptyElement" | "view:emptyElement", name: N): this is ViewEmptyElement & {
+		name: N;
+	};
+	/**
+	* Checks whether the object is of type {@link module:engine/view/rawelement~ViewRawElement} and has the specified `name`.
+	*
+	* @label RAW_ELEMENT_NAME
+	*/
+	is<N extends string>(type: "rawElement" | "view:rawElement", name: N): this is ViewRawElement & {
+		name: N;
+	};
+	/**
+	* Checks whether the object is of type {@link module:engine/view/rooteditableelement~ViewRootEditableElement}
+	* and has the specified `name`.
+	*
+	* @label ROOT_ELEMENT_NAME
+	*/
+	is<N extends string>(type: "rootElement" | "view:rootElement", name: N): this is ViewRootEditableElement & {
+		name: N;
+	};
+	/**
+	* Checks whether the object is of type {@link module:engine/view/uielement~ViewUIElement} and has the specified `name`.
+	*
+	* @label UI_ELEMENT_NAME
+	*/
+	is<N extends string>(type: "uiElement" | "view:uiElement", name: N): this is ViewUIElement & {
+		name: N;
+	};
 }