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

package/src/model/schema.d.ts

@@ -5,16 +5,16 @@
 /**
  * @module engine/model/schema
  */
-import Element from './element.js';
-import Position from './position.js';
-import Range from './range.js';
-import type DocumentFragment from './documentfragment.js';
-import type DocumentSelection from './documentselection.js';
-import type Item from './item.js';
-import type Node from './node.js';
-import type Selection from './selection.js';
-import type Writer from './writer.js';
-declare const Schema_base: {
+import { ModelElement } from './element.js';
+import { ModelPosition } from './position.js';
+import { ModelRange } from './range.js';
+import { type ModelDocumentFragment } from './documentfragment.js';
+import { type ModelDocumentSelection } from './documentselection.js';
+import { type ModelItem } from './item.js';
+import { type ModelNode } from './node.js';
+import { type ModelSelection } from './selection.js';
+import { type ModelWriter } from './writer.js';
+declare const ModelSchema_base: {
     new (): import("@ckeditor/ckeditor5-utils").Observable;
     prototype: import("@ckeditor/ckeditor5-utils").Observable;
 };
@@ -31,27 +31,28 @@ declare const Schema_base: {
  * {@glink framework/architecture/editing-engine Introduction to the Editing engine architecture} guide.
  * * The {@glink framework/deep-dive/schema Schema deep-dive} guide.
  */
-export default class Schema extends /* #__PURE__ */ Schema_base {
+export declare class ModelSchema extends /* #__PURE__ */ ModelSchema_base {
     private readonly _sourceDefinitions;
     /**
      * A dictionary containing attribute properties.
      */
     private readonly _attributeProperties;
     /**
-     * Stores additional callbacks registered for schema items, which are evaluated when {@link ~Schema#checkChild} is called.
+     * Stores additional callbacks registered for schema items, which are evaluated when {@link ~ModelSchema#checkChild} is called.
      *
      * Keys are schema item names for which the callbacks are registered. Values are arrays with the callbacks.
      *
-     * Some checks are added under {@link ~Schema#_genericCheckSymbol} key, these are evaluated for every {@link ~Schema#checkChild} call.
+     * Some checks are added under {@link ~ModelSchema#_genericCheckSymbol} key, these are
+     * evaluated for every {@link ~ModelSchema#checkChild} call.
      */
     private readonly _customChildChecks;
     /**
-     * Stores additional callbacks registered for attribute names, which are evaluated when {@link ~Schema#checkAttribute} is called.
+     * Stores additional callbacks registered for attribute names, which are evaluated when {@link ~ModelSchema#checkAttribute} is called.
      *
      * Keys are schema attribute names for which the callbacks are registered. Values are arrays with the callbacks.
      *
-     * Some checks are added under {@link ~Schema#_genericCheckSymbol} key, these are evaluated for every
-     * {@link ~Schema#checkAttribute} call.
+     * Some checks are added under {@link ~ModelSchema#_genericCheckSymbol} key, these are evaluated for every
+     * {@link ~ModelSchema#checkAttribute} call.
      */
     private readonly _customAttributeChecks;
     private readonly _genericCheckSymbol;
@@ -69,7 +70,7 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * } );
      * ```
      */
-    register(itemName: string, definition?: SchemaItemDefinition): void;
+    register(itemName: string, definition?: ModelSchemaItemDefinition): void;
     /**
      * Extends a {@link #register registered} item's definition.
      *
@@ -93,7 +94,7 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * //	}
      * ```
      */
-    extend(itemName: string, definition: SchemaItemDefinition): void;
+    extend(itemName: string, definition: ModelSchemaItemDefinition): void;
     /**
      * Returns data of all registered items.
      *
@@ -102,7 +103,7 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * Use specific methods (such as {@link #checkChild `checkChild()`} or {@link #isLimit `isLimit()`})
      * in other cases.
      */
-    getDefinitions(): Record<string, SchemaCompiledItemDefinition>;
+    getDefinitions(): Record<string, ModelSchemaCompiledItemDefinition>;
     /**
      * Returns a definition of the given item or `undefined` if an item is not registered.
      *
@@ -111,7 +112,7 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * Use specific methods (such as {@link #checkChild `checkChild()`} or {@link #isLimit `isLimit()`})
      * in other cases.
      */
-    getDefinition(item: string | Item | DocumentFragment | SchemaContextItem): SchemaCompiledItemDefinition | undefined;
+    getDefinition(item: string | ModelItem | ModelDocumentFragment | ModelSchemaContextItem): ModelSchemaCompiledItemDefinition | undefined;
     /**
      * Returns `true` if the given item is registered in the schema.
      *
@@ -121,10 +122,10 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * schema.isRegistered( 'foo' ); // -> false
      * ```
      */
-    isRegistered(item: string | Item | DocumentFragment | SchemaContextItem): boolean;
+    isRegistered(item: string | ModelItem | ModelDocumentFragment | ModelSchemaContextItem): boolean;
     /**
      * Returns `true` if the given item is defined to be
-     * a block by the {@link module:engine/model/schema~SchemaItemDefinition}'s `isBlock` property.
+     * a block by the {@link module:engine/model/schema~ModelSchemaItemDefinition}'s `isBlock` property.
      *
      * ```ts
      * schema.isBlock( 'paragraph' ); // -> true
@@ -137,14 +138,14 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * See the {@glink framework/deep-dive/schema#block-elements Block elements} section of
      * the {@glink framework/deep-dive/schema Schema deep-dive} guide for more details.
      */
-    isBlock(item: string | Item | DocumentFragment | SchemaContextItem): boolean;
+    isBlock(item: string | ModelItem | ModelDocumentFragment | ModelSchemaContextItem): boolean;
     /**
      * Returns `true` if the given item should be treated as a limit element.
      *
      * It considers an item to be a limit element if its
-     * {@link module:engine/model/schema~SchemaItemDefinition}'s
-     * {@link module:engine/model/schema~SchemaItemDefinition#isLimit `isLimit`} or
-     * {@link module:engine/model/schema~SchemaItemDefinition#isObject `isObject`} property
+     * {@link module:engine/model/schema~ModelSchemaItemDefinition}'s
+     * {@link module:engine/model/schema~ModelSchemaItemDefinition#isLimit `isLimit`} or
+     * {@link module:engine/model/schema~ModelSchemaItemDefinition#isObject `isObject`} property
      * was set to `true`.
      *
      * ```ts
@@ -157,13 +158,13 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * See the {@glink framework/deep-dive/schema#limit-elements Limit elements} section of
      * the {@glink framework/deep-dive/schema Schema deep-dive} guide for more details.
      */
-    isLimit(item: string | Item | DocumentFragment | SchemaContextItem): boolean;
+    isLimit(item: string | ModelItem | ModelDocumentFragment | ModelSchemaContextItem): boolean;
     /**
      * Returns `true` if the given item should be treated as an object element.
      *
      * It considers an item to be an object element if its
-     * {@link module:engine/model/schema~SchemaItemDefinition}'s
-     * {@link module:engine/model/schema~SchemaItemDefinition#isObject `isObject`} property
+     * {@link module:engine/model/schema~ModelSchemaItemDefinition}'s
+     * {@link module:engine/model/schema~ModelSchemaItemDefinition#isObject `isObject`} property
      * was set to `true`.
      *
      * ```ts
@@ -177,10 +178,10 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * See the {@glink framework/deep-dive/schema#object-elements Object elements} section of
      * the {@glink framework/deep-dive/schema Schema deep-dive} guide for more details.
      */
-    isObject(item: string | Item | DocumentFragment | SchemaContextItem): boolean;
+    isObject(item: string | ModelItem | ModelDocumentFragment | ModelSchemaContextItem): boolean;
     /**
      * Returns `true` if the given item is defined to be
-     * an inline element by the {@link module:engine/model/schema~SchemaItemDefinition}'s `isInline` property.
+     * an inline element by the {@link module:engine/model/schema~ModelSchemaItemDefinition}'s `isInline` property.
      *
      * ```ts
      * schema.isInline( 'paragraph' ); // -> false
@@ -193,10 +194,10 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * See the {@glink framework/deep-dive/schema#inline-elements Inline elements} section of
      * the {@glink framework/deep-dive/schema Schema deep-dive} guide for more details.
      */
-    isInline(item: string | Item | DocumentFragment | SchemaContextItem): boolean;
+    isInline(item: string | ModelItem | ModelDocumentFragment | ModelSchemaContextItem): boolean;
     /**
      * Returns `true` if the given item is defined to be
-     * a selectable element by the {@link module:engine/model/schema~SchemaItemDefinition}'s `isSelectable` property.
+     * a selectable element by the {@link module:engine/model/schema~ModelSchemaItemDefinition}'s `isSelectable` property.
      *
      * ```ts
      * schema.isSelectable( 'paragraph' ); // -> false
@@ -211,10 +212,10 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * See the {@glink framework/deep-dive/schema#selectable-elements Selectable elements section} of
      * the {@glink framework/deep-dive/schema Schema deep-dive} guide for more details.
      */
-    isSelectable(item: string | Item | DocumentFragment | SchemaContextItem): boolean;
+    isSelectable(item: string | ModelItem | ModelDocumentFragment | ModelSchemaContextItem): boolean;
     /**
      * Returns `true` if the given item is defined to be
-     * a content by the {@link module:engine/model/schema~SchemaItemDefinition}'s `isContent` property.
+     * a content by the {@link module:engine/model/schema~ModelSchemaItemDefinition}'s `isContent` property.
      *
      * ```ts
      * schema.isContent( 'paragraph' ); // -> false
@@ -229,7 +230,7 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * See the {@glink framework/deep-dive/schema#content-elements Content elements section} of
      * the {@glink framework/deep-dive/schema Schema deep-dive} guide for more details.
      */
-    isContent(item: string | Item | DocumentFragment | SchemaContextItem): boolean;
+    isContent(item: string | ModelItem | ModelDocumentFragment | ModelSchemaContextItem): boolean;
     /**
      * Checks whether the given node can be a child of the given context.
      *
@@ -243,8 +244,9 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * schema.checkChild( model.document.getRoot(), paragraph ); // -> true
      * ```
      *
-     * Both {@link module:engine/model/schema~Schema#addChildCheck callback checks} and declarative rules (added when
-     * {@link module:engine/model/schema~Schema#register registering} and {@link module:engine/model/schema~Schema#extend extending} items)
+     * Both {@link module:engine/model/schema~ModelSchema#addChildCheck callback checks} and declarative rules (added when
+     * {@link module:engine/model/schema~ModelSchema#register registering} and
+     * {@link module:engine/model/schema~ModelSchema#extend extending} items)
      * are evaluated when this method is called.
      *
      * Note that callback checks have bigger priority than declarative rules checks and may overwrite them.
@@ -252,13 +254,13 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * Note that when verifying whether the given node can be a child of the given context, the schema also verifies the entire
      * context &ndash; from its root to its last element. Therefore, it is possible for `checkChild()` to return `false` even though
      * the `context` last element can contain the checked child. It happens if one of the `context` elements does not allow its child.
-     * When `context` is verified, {@link module:engine/model/schema~Schema#addChildCheck custom checks} are considered as well.
+     * When `context` is verified, {@link module:engine/model/schema~ModelSchema#addChildCheck custom checks} are considered as well.
      *
      * @fires checkChild
      * @param context The context in which the child will be checked.
      * @param def The child to check.
      */
-    checkChild(context: SchemaContextDefinition, def: string | Node | DocumentFragment): boolean;
+    checkChild(context: ModelSchemaContextDefinition, def: string | ModelNode | ModelDocumentFragment): boolean;
     /**
      * Checks whether the given attribute can be applied in the given context (on the last item of the context).
      *
@@ -272,8 +274,9 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * schema.checkAttribute( textNode, 'bold' ); // -> true
      * ```
      *
-     * Both {@link module:engine/model/schema~Schema#addAttributeCheck callback checks} and declarative rules (added when
-     * {@link module:engine/model/schema~Schema#register registering} and {@link module:engine/model/schema~Schema#extend extending} items)
+     * Both {@link module:engine/model/schema~ModelSchema#addAttributeCheck callback checks} and declarative rules (added when
+     * {@link module:engine/model/schema~ModelSchema#register registering} and
+     * {@link module:engine/model/schema~ModelSchema#extend extending} items)
      * are evaluated when this method is called.
      *
      * Note that callback checks have bigger priority than declarative rules checks and may overwrite them.
@@ -282,14 +285,14 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * @param context The context in which the attribute will be checked.
      * @param attributeName Name of attribute to check in the given context.
      */
-    checkAttribute(context: SchemaContextDefinition, attributeName: string): boolean;
-    checkMerge(position: Position): boolean;
-    checkMerge(baseElement: Element, elementToMerge: Element): boolean;
+    checkAttribute(context: ModelSchemaContextDefinition, attributeName: string): boolean;
+    checkMerge(position: ModelPosition): boolean;
+    checkMerge(baseElement: ModelElement, elementToMerge: ModelElement): boolean;
     /**
      * Allows registering a callback to the {@link #checkChild} method calls.
      *
      * Callbacks allow you to implement rules which are not otherwise possible to achieve
-     * by using the declarative API of {@link module:engine/model/schema~SchemaItemDefinition}.
+     * by using the declarative API of {@link module:engine/model/schema~ModelSchemaItemDefinition}.
      *
      * Note that callback checks have bigger priority than declarative rules checks and may overwrite them.
      *
@@ -342,19 +345,19 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * Adding callbacks this way can also negatively impact editor performance.
      *
      * @param callback The callback to be called. It is called with two parameters:
-     * {@link module:engine/model/schema~SchemaContext} (context) instance and
-     * {@link module:engine/model/schema~SchemaCompiledItemDefinition} (definition). The callback may return `true/false` to override
-     * `checkChild()`'s return value. If it does not return a boolean value, the default algorithm (or other callbacks) will define
+     * {@link module:engine/model/schema~ModelSchemaContext} (context) instance and
+     * {@link module:engine/model/schema~ModelSchemaCompiledItemDefinition} (definition). The callback may return `true/false` to
+     * override `checkChild()`'s return value. If it does not return a boolean value, the default algorithm (or other callbacks) will define
      * `checkChild()`'s return value.
      * @param itemName Name of the schema item for which the callback is registered. If specified, the callback will be run only for
      * `checkChild()` calls which `def` parameter matches the `itemName`. Otherwise, the callback will run for every `checkChild` call.
      */
-    addChildCheck(callback: SchemaChildCheckCallback, itemName?: string): void;
+    addChildCheck(callback: ModelSchemaChildCheckCallback, itemName?: string): void;
     /**
      * Allows registering a callback to the {@link #checkAttribute} method calls.
      *
      * Callbacks allow you to implement rules which are not otherwise possible to achieve
-     * by using the declarative API of {@link module:engine/model/schema~SchemaItemDefinition}.
+     * by using the declarative API of {@link module:engine/model/schema~ModelSchemaItemDefinition}.
      *
      * Note that callback checks have bigger priority than declarative rules checks and may overwrite them.
      *
@@ -407,16 +410,16 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * Adding callbacks this way can also negatively impact editor performance.
      *
      * @param callback The callback to be called. It is called with two parameters:
-     * {@link module:engine/model/schema~SchemaContext `context`} and attribute name. The callback may return `true` or `false`, to
+     * {@link module:engine/model/schema~ModelSchemaContext `context`} and attribute name. The callback may return `true` or `false`, to
      * override `checkAttribute()`'s return value. If it does not return a boolean value, the default algorithm (or other callbacks)
      * will define `checkAttribute()`'s return value.
      * @param attributeName Name of the attribute for which the callback is registered. If specified, the callback will be run only for
      * `checkAttribute()` calls with matching `attributeName`. Otherwise, the callback will run for every `checkAttribute()` call.
      */
-    addAttributeCheck(callback: SchemaAttributeCheckCallback, attributeName?: string): void;
+    addAttributeCheck(callback: ModelSchemaAttributeCheckCallback, attributeName?: string): void;
     /**
      * This method allows assigning additional metadata to the model attributes. For example,
-     * {@link module:engine/model/schema~AttributeProperties `AttributeProperties#isFormatting` property} is
+     * {@link module:engine/model/schema~ModelAttributeProperties `AttributeProperties#isFormatting` property} is
      * used to mark formatting attributes (like `bold` or `italic`).
      *
      * ```ts
@@ -432,7 +435,7 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * ```
      *
      * Properties are not limited to members defined in the
-     * {@link module:engine/model/schema~AttributeProperties `AttributeProperties` type} and you can also use custom properties:
+     * {@link module:engine/model/schema~ModelAttributeProperties `AttributeProperties` type} and you can also use custom properties:
      *
      * ```ts
      * schema.setAttributeProperties( 'blockQuote', {
@@ -458,21 +461,21 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * @param attributeName A name of the attribute to receive the properties.
      * @param properties A dictionary of properties.
      */
-    setAttributeProperties(attributeName: string, properties: AttributeProperties): void;
+    setAttributeProperties(attributeName: string, properties: ModelAttributeProperties): void;
     /**
      * Returns properties associated with a given model attribute. See {@link #setAttributeProperties `setAttributeProperties()`}.
      *
      * @param attributeName A name of the attribute.
      */
-    getAttributeProperties(attributeName: string): AttributeProperties;
+    getAttributeProperties(attributeName: string): ModelAttributeProperties;
     /**
-     * Returns the lowest {@link module:engine/model/schema~Schema#isLimit limit element} containing the entire
+     * Returns the lowest {@link module:engine/model/schema~ModelSchema#isLimit limit element} containing the entire
      * selection/range/position or the root otherwise.
      *
      * @param selectionOrRangeOrPosition The selection/range/position to check.
      * @returns The lowest limit element containing the entire `selectionOrRangeOrPosition`.
      */
-    getLimitElement(selectionOrRangeOrPosition: Selection | DocumentSelection | Range | Position): Element;
+    getLimitElement(selectionOrRangeOrPosition: ModelSelection | ModelDocumentSelection | ModelRange | ModelPosition): ModelElement;
     /**
      * Checks whether the attribute is allowed in selection:
      *
@@ -483,7 +486,7 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * @param selection Selection which will be checked.
      * @param attribute The name of the attribute to check.
      */
-    checkAttributeInSelection(selection: Selection | DocumentSelection, attribute: string): boolean;
+    checkAttributeInSelection(selection: ModelSelection | ModelDocumentSelection, attribute: string): boolean;
     /**
      * Transforms the given set of ranges into a set of ranges where the given attribute is allowed (and can be applied).
      *
@@ -491,14 +494,14 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * @param attribute The name of the attribute to check.
      * @returns Ranges in which the attribute is allowed.
      */
-    getValidRanges(ranges: Iterable<Range>, attribute: string): IterableIterator<Range>;
+    getValidRanges(ranges: Iterable<ModelRange>, attribute: string): IterableIterator<ModelRange>;
     /**
-     * Basing on given `position`, finds and returns a {@link module:engine/model/range~Range range} which is
+     * Basing on given `position`, finds and returns a {@link module:engine/model/range~ModelRange range} which is
      * nearest to that `position` and is a correct range for selection.
      *
      * The correct selection range might be collapsed when it is located in a position where the text node can be placed.
      * Non-collapsed range is returned when selection can be placed around element marked as an "object" in
-     * the {@link module:engine/model/schema~Schema schema}.
+     * the {@link module:engine/model/schema~ModelSchema schema}.
      *
      * Direction of searching for the nearest correct selection range can be specified as:
      *
@@ -512,18 +515,18 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * @param direction Search direction.
      * @returns Nearest selection range or `null` if one cannot be found.
      */
-    getNearestSelectionRange(position: Position, direction?: 'both' | 'forward' | 'backward'): Range | null;
+    getNearestSelectionRange(position: ModelPosition, direction?: 'both' | 'forward' | 'backward'): ModelRange | null;
     /**
      * Tries to find position ancestors that allow to insert a given node.
      * It starts searching from the given position and goes node by node to the top of the model tree
-     * as long as a {@link module:engine/model/schema~Schema#isLimit limit element}, an
-     * {@link module:engine/model/schema~Schema#isObject object element} or a topmost ancestor is not reached.
+     * as long as a {@link module:engine/model/schema~ModelSchema#isLimit limit element}, an
+     * {@link module:engine/model/schema~ModelSchema#isObject object element} or a topmost ancestor is not reached.
      *
      * @param position The position that the search will start from.
      * @param node The node for which an allowed parent should be found or its name.
      * @returns Allowed parent or null if nothing was found.
      */
-    findAllowedParent(position: Position, node: Node | string): Element | null;
+    findAllowedParent(position: ModelPosition, node: ModelNode | string): ModelElement | null;
     /**
      * Sets attributes allowed by the schema on a given node.
      *
@@ -531,13 +534,13 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * @param attributes Attributes keys and values.
      * @param writer An instance of the model writer.
      */
-    setAllowedAttributes(node: Node, attributes: Record<string, unknown>, writer: Writer): void;
+    setAllowedAttributes(node: ModelNode, attributes: Record<string, unknown>, writer: ModelWriter): void;
     /**
      * Removes attributes disallowed by the schema.
      *
      * @param nodes Nodes that will be filtered.
      */
-    removeDisallowedAttributes(nodes: Iterable<Node>, writer: Writer): void;
+    removeDisallowedAttributes(nodes: Iterable<ModelNode>, writer: ModelWriter): void;
     /**
      * Gets attributes of a node that have a given property.
      *
@@ -548,11 +551,11 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * return attributes which given property's value is equal to this parameter.
      * @returns Object with attributes' names as key and attributes' values as value.
      */
-    getAttributesWithProperty(node: Node, propertyName: string, propertyValue: unknown): Record<string, unknown>;
+    getAttributesWithProperty(node: ModelNode, propertyName: string, propertyValue: unknown): Record<string, unknown>;
     /**
      * Creates an instance of the schema context.
      */
-    createContext(context: SchemaContextDefinition): SchemaContext;
+    createContext(context: ModelSchemaContextDefinition): ModelSchemaContext;
     private _clearCache;
     private _compile;
     private _checkContextMatch;
@@ -576,7 +579,7 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * Takes a flat range and an attribute name. Traverses the range recursively and deeply to find and return all ranges
      * inside the given range on which the attribute can be applied.
      *
-     * This is a helper function for {@link ~Schema#getValidRanges}.
+     * This is a helper function for {@link ~ModelSchema#getValidRanges}.
      *
      * @param range The range to process.
      * @param attribute The name of the attribute to check.
@@ -602,18 +605,18 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
      * The `after` value will try to find a position after selection.
      * @returns The optimal range.
      */
-    findOptimalInsertionRange(selection: Selection | DocumentSelection, place?: 'auto' | 'before' | 'after'): Range;
+    findOptimalInsertionRange(selection: ModelSelection | ModelDocumentSelection, place?: 'auto' | 'before' | 'after'): ModelRange;
 }
 /**
- * Event fired when the {@link ~Schema#checkChild} method is called. It allows plugging in
+ * Event fired when the {@link ~ModelSchema#checkChild} method is called. It allows plugging in
  * additional behavior, for example implementing rules which cannot be defined using the declarative
- * {@link module:engine/model/schema~SchemaItemDefinition} interface.
+ * {@link module:engine/model/schema~ModelSchemaItemDefinition} interface.
  *
- * **Note:** The {@link ~Schema#addChildCheck} method is a more handy way to register callbacks. Internally,
+ * **Note:** The {@link ~ModelSchema#addChildCheck} method is a more handy way to register callbacks. Internally,
  * it registers a listener to this event but comes with a simpler API and it is the recommended choice
  * in most of the cases.
  *
- * The {@link ~Schema#checkChild} method fires an event because it is
+ * The {@link ~ModelSchema#checkChild} method fires an event because it is
  * {@link module:utils/observablemixin~Observable#decorate decorated} with it. Thanks to that you can
  * use this event in various ways, but the most important use case is overriding standard behavior of the
  * `checkChild()` method. Let's see a typical listener template:
@@ -627,8 +630,8 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
  *
  * The listener is added with a `high` priority to be executed before the default method is really called. The `args` callback
  * parameter contains arguments passed to `checkChild( context, child )`. However, the `context` parameter is already
- * normalized to a {@link module:engine/model/schema~SchemaContext} instance and `child` to a
- * {@link module:engine/model/schema~SchemaCompiledItemDefinition} instance, so you do not have to worry about
+ * normalized to a {@link module:engine/model/schema~ModelSchemaContext} instance and `child` to a
+ * {@link module:engine/model/schema~ModelSchemaCompiledItemDefinition} instance, so you do not have to worry about
  * the various ways how `context` and `child` may be passed to `checkChild()`.
  *
  * **Note:** `childDefinition` may be `undefined` if `checkChild()` was called with a non-registered element.
@@ -650,7 +653,7 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
  * ```
  *
  * Allowing elements in specific contexts will be a far less common use case, because it is normally handled by the
- * `allowIn` rule from {@link module:engine/model/schema~SchemaItemDefinition}. But if you have a complex scenario
+ * `allowIn` rule from {@link module:engine/model/schema~ModelSchemaItemDefinition}. But if you have a complex scenario
  * where `listItem` should be allowed only in element `foo` which must be in element `bar`, then this would be the way:
  *
  * ```ts
@@ -667,23 +670,23 @@ export default class Schema extends /* #__PURE__ */ Schema_base {
  * }, { priority: 'high' } );
  * ```
  *
- * @eventName ~Schema#checkChild
+ * @eventName ~ModelSchema#checkChild
  * @param args The `checkChild()`'s arguments.
  */
-export type SchemaCheckChildEvent = {
+export type ModelSchemaCheckChildEvent = {
     name: 'checkChild';
-    args: [[context: SchemaContext, def: SchemaCompiledItemDefinition]];
+    args: [[context: ModelSchemaContext, def: ModelSchemaCompiledItemDefinition]];
 };
 /**
- * Event fired when the {@link ~Schema#checkAttribute} method is called. It allows plugging in
+ * Event fired when the {@link ~ModelSchema#checkAttribute} method is called. It allows plugging in
  * additional behavior, for example implementing rules which cannot be defined using the declarative
- * {@link module:engine/model/schema~SchemaItemDefinition} interface.
+ * {@link module:engine/model/schema~ModelSchemaItemDefinition} interface.
  *
- * **Note:** The {@link ~Schema#addAttributeCheck} method is a more handy way to register callbacks. Internally,
+ * **Note:** The {@link ~ModelSchema#addAttributeCheck} method is a more handy way to register callbacks. Internally,
  * it registers a listener to this event but comes with a simpler API and it is the recommended choice
  * in most of the cases.
  *
- * The {@link ~Schema#checkAttribute} method fires an event because it is
+ * The {@link ~ModelSchema#checkAttribute} method fires an event because it is
  * {@link module:utils/observablemixin~Observable#decorate decorated} with it. Thanks to that you can
  * use this event in various ways, but the most important use case is overriding the standard behavior of the
  * `checkAttribute()` method. Let's see a typical listener template:
@@ -697,7 +700,7 @@ export type SchemaCheckChildEvent = {
  *
  * The listener is added with a `high` priority to be executed before the default method is really called. The `args` callback
  * parameter contains arguments passed to `checkAttribute( context, attributeName )`. However, the `context` parameter is already
- * normalized to a {@link module:engine/model/schema~SchemaContext} instance, so you do not have to worry about
+ * normalized to a {@link module:engine/model/schema~ModelSchemaContext} instance, so you do not have to worry about
  * the various ways how `context` may be passed to `checkAttribute()`.
  *
  * So, in order to implement a rule "disallow `bold` in a text which is in a `heading1`, you can add such a listener:
@@ -717,7 +720,7 @@ export type SchemaCheckChildEvent = {
  * ```
  *
  * Allowing attributes in specific contexts will be a far less common use case, because it is normally handled by the
- * `allowAttributes` rule from {@link module:engine/model/schema~SchemaItemDefinition}. But if you have a complex scenario
+ * `allowAttributes` rule from {@link module:engine/model/schema~ModelSchemaItemDefinition}. But if you have a complex scenario
  * where `bold` should be allowed only in element `foo` which must be in element `bar`, then this would be the way:
  *
  * ```ts
@@ -734,49 +737,50 @@ export type SchemaCheckChildEvent = {
  * }, { priority: 'high' } );
  * ```
  *
- * @eventName ~Schema#checkAttribute
+ * @eventName ~ModelSchema#checkAttribute
  * @param args The `checkAttribute()`'s arguments.
  */
-export type SchemaCheckAttributeEvent = {
+export type ModelSchemaCheckAttributeEvent = {
     name: 'checkAttribute';
-    args: [[context: SchemaContext, attributeName: string]];
+    args: [[context: ModelSchemaContext, attributeName: string]];
 };
 /**
- * A definition of a {@link module:engine/model/schema~Schema schema} item.
+ * A definition of a {@link module:engine/model/schema~ModelSchema schema} item.
  *
  * You can define the following rules:
  *
- * * {@link ~SchemaItemDefinition#allowIn `allowIn`} &ndash; Defines in which other items this item will be allowed.
- * * {@link ~SchemaItemDefinition#allowChildren `allowChildren`} &ndash; Defines which other items are allowed inside this item.
- * * {@link ~SchemaItemDefinition#allowAttributes `allowAttributes`} &ndash; Defines allowed attributes of the given item.
- * * {@link ~SchemaItemDefinition#disallowIn `disallowIn`} &ndash; Defines in which other items this item will be disallowed.
- * * {@link ~SchemaItemDefinition#disallowChildren `disallowChildren`} &ndash; Defines which other items are disallowed inside this item.
- * * {@link ~SchemaItemDefinition#disallowAttributes `disallowAttributes`} &ndash; Defines disallowed attributes of the given item.
- * * {@link ~SchemaItemDefinition#allowContentOf `allowContentOf`} &ndash; Makes this item allow children that are also allowed in the
+ * * {@link ~ModelSchemaItemDefinition#allowIn `allowIn`} &ndash; Defines in which other items this item will be allowed.
+ * * {@link ~ModelSchemaItemDefinition#allowChildren `allowChildren`} &ndash; Defines which other items are allowed inside this item.
+ * * {@link ~ModelSchemaItemDefinition#allowAttributes `allowAttributes`} &ndash; Defines allowed attributes of the given item.
+ * * {@link ~ModelSchemaItemDefinition#disallowIn `disallowIn`} &ndash; Defines in which other items this item will be disallowed.
+ * * {@link ~ModelSchemaItemDefinition#disallowChildren `disallowChildren`} &ndash; Defines which other items are
+ * disallowed inside this item.
+ * * {@link ~ModelSchemaItemDefinition#disallowAttributes `disallowAttributes`} &ndash; Defines disallowed attributes of the given item.
+ * * {@link ~ModelSchemaItemDefinition#allowContentOf `allowContentOf`} &ndash; Makes this item allow children that are also allowed in the
  * specified items. This acknowledges disallow rules.
- * * {@link ~SchemaItemDefinition#allowWhere `allowWhere`} &ndash; Makes this item allowed where the specified items are allowed. This
+ * * {@link ~ModelSchemaItemDefinition#allowWhere `allowWhere`} &ndash; Makes this item allowed where the specified items are allowed. This
  * acknowledges disallow rules.
- * * {@link ~SchemaItemDefinition#allowAttributesOf `allowAttributesOf`} &ndash; Inherits attributes from other items. This acknowledges
- * disallow rules.
- * * {@link ~SchemaItemDefinition#inheritTypesFrom `inheritTypesFrom`} &ndash; Inherits `is*` properties of other items.
- * * {@link ~SchemaItemDefinition#inheritAllFrom `inheritAllFrom`} &ndash;
+ * * {@link ~ModelSchemaItemDefinition#allowAttributesOf `allowAttributesOf`} &ndash; Inherits attributes from other items.
+ * This acknowledges disallow rules.
+ * * {@link ~ModelSchemaItemDefinition#inheritTypesFrom `inheritTypesFrom`} &ndash; Inherits `is*` properties of other items.
+ * * {@link ~ModelSchemaItemDefinition#inheritAllFrom `inheritAllFrom`} &ndash;
  * A shorthand for `allowContentOf`, `allowWhere`, `allowAttributesOf`, `inheritTypesFrom`.
  *
  * # The `is*` properties
  *
  * There are a couple commonly used `is*` properties. Their role is to assign additional semantics to schema items.
  *
- * * {@link ~SchemaItemDefinition#isBlock `isBlock`} &ndash; Whether this item is paragraph-like.
+ * * {@link ~ModelSchemaItemDefinition#isBlock `isBlock`} &ndash; Whether this item is paragraph-like.
  * Generally speaking, content is usually made out of blocks like paragraphs, list items, images, headings, etc.
- * * {@link ~SchemaItemDefinition#isInline `isInline`} &ndash; Whether an item is "text-like" and should be treated as an inline node.
+ * * {@link ~ModelSchemaItemDefinition#isInline `isInline`} &ndash; Whether an item is "text-like" and should be treated as an inline node.
  * Examples of inline elements: `$text`, `softBreak` (`<br>`), etc.
- * * {@link ~SchemaItemDefinition#isLimit `isLimit`} &ndash; It can be understood as whether this element
+ * * {@link ~ModelSchemaItemDefinition#isLimit `isLimit`} &ndash; It can be understood as whether this element
  * should not be split by <kbd>Enter</kbd>. Examples of limit elements: `$root`, table cell, image caption, etc.
  * In other words, all actions that happen inside a limit element are limited to its content.
  * All objects are treated as limit elements, too.
- * * {@link ~SchemaItemDefinition#isObject `isObject`} &ndash; Whether an item is "self-contained" and should be treated as a whole.
+ * * {@link ~ModelSchemaItemDefinition#isObject `isObject`} &ndash; Whether an item is "self-contained" and should be treated as a whole.
  * Examples of object elements: `imageBlock`, `table`, `video`, etc. An object is also a limit, so
- * {@link module:engine/model/schema~Schema#isLimit `isLimit()`} returns `true` for object elements automatically.
+ * {@link module:engine/model/schema~ModelSchema#isLimit `isLimit()`} returns `true` for object elements automatically.
  *
  * Read more about the meaning of these types in the
  * {@glink framework/deep-dive/schema#defining-additional-semantics dedicated section of the Schema deep-dive} guide.
@@ -924,7 +928,7 @@ export type SchemaCheckAttributeEvent = {
  * * Remember about defining the `is*` properties. They do not affect the allowed structures, but they can
  * affect how the editor features treat your elements.
  */
-export interface SchemaItemDefinition {
+export interface ModelSchemaItemDefinition {
     /**
      * Defines in which other items this item will be allowed.
      */
@@ -1013,7 +1017,7 @@ export interface SchemaItemDefinition {
      * `imageBlock`, `table`, `video`, etc.
      *
      * **Note:** An object is also a limit, so
-     * {@link module:engine/model/schema~Schema#isLimit `isLimit()`} returns `true` for object elements automatically.
+     * {@link module:engine/model/schema~ModelSchema#isLimit `isLimit()`} returns `true` for object elements automatically.
      *
      * Read more about the object elements in the
      * {@glink framework/deep-dive/schema#object-elements Object elements section} of the Schema deep-dive guide.
@@ -1024,7 +1028,7 @@ export interface SchemaItemDefinition {
      * Examples of selectable elements: `imageBlock`, `table`, `tableCell`, etc.
      *
      * **Note:** An object is also a selectable element, so
-     * {@link module:engine/model/schema~Schema#isSelectable `isSelectable()`} returns `true` for object elements automatically.
+     * {@link module:engine/model/schema~ModelSchema#isSelectable `isSelectable()`} returns `true` for object elements automatically.
      *
      * Read more about selectable elements in the
      * {@glink framework/deep-dive/schema#selectable-elements Selectable elements section} of
@@ -1036,7 +1040,7 @@ export interface SchemaItemDefinition {
      * Examples of content elements: `$text`, `imageBlock`, `table`, etc. (but not `paragraph`, `heading1` or `tableCell`).
      *
      * **Note:** An object is also a content element, so
-     * {@link module:engine/model/schema~Schema#isContent `isContent()`} returns `true` for object elements automatically.
+     * {@link module:engine/model/schema~ModelSchema#isContent `isContent()`} returns `true` for object elements automatically.
      *
      * Read more about content elements in the
      * {@glink framework/deep-dive/schema#content-elements Content elements section} of
@@ -1045,13 +1049,13 @@ export interface SchemaItemDefinition {
     isContent?: boolean;
 }
 /**
- * A simplified version of {@link module:engine/model/schema~SchemaItemDefinition} after
- * compilation by the {@link module:engine/model/schema~Schema schema}.
- * Rules fed to the schema by {@link module:engine/model/schema~Schema#register}
- * and {@link module:engine/model/schema~Schema#extend} methods are defined in the
- * {@link module:engine/model/schema~SchemaItemDefinition} format.
- * Later on, they are compiled to `SchemaCompiledItemDefinition` so when you use e.g.
- * the {@link module:engine/model/schema~Schema#getDefinition} method you get the compiled version.
+ * A simplified version of {@link module:engine/model/schema~ModelSchemaItemDefinition} after
+ * compilation by the {@link module:engine/model/schema~ModelSchema schema}.
+ * Rules fed to the schema by {@link module:engine/model/schema~ModelSchema#register}
+ * and {@link module:engine/model/schema~ModelSchema#extend} methods are defined in the
+ * {@link module:engine/model/schema~ModelSchemaItemDefinition} format.
+ * Later on, they are compiled to `ModelSchemaCompiledItemDefinition` so when you use e.g.
+ * the {@link module:engine/model/schema~ModelSchema#getDefinition} method you get the compiled version.
  *
  * The compiled version contains only the following properties:
  *
@@ -1061,7 +1065,7 @@ export interface SchemaItemDefinition {
  * * The `allowChildren` array,
  * * The `allowAttributes` array.
  */
-export interface SchemaCompiledItemDefinition {
+export interface ModelSchemaCompiledItemDefinition {
     name: string;
     isBlock: boolean;
     isContent: boolean;
@@ -1088,23 +1092,23 @@ export interface SchemaCompiledItemDefinition {
  * </$root>
  * ```
  *
- * The context of this position is its {@link module:engine/model/position~Position#getAncestors lists of ancestors}:
+ * The context of this position is its {@link module:engine/model/position~ModelPosition#getAncestors lists of ancestors}:
  *
  *		[ rootElement, blockQuoteElement, paragraphElement ]
  *
- * Contexts are used in the {@link module:engine/model/schema~Schema#event:checkChild `Schema#checkChild`} and
- * {@link module:engine/model/schema~Schema#event:checkAttribute `Schema#checkAttribute`} events as a definition
+ * Contexts are used in the {@link module:engine/model/schema~ModelSchema#event:checkChild `Schema#checkChild`} and
+ * {@link module:engine/model/schema~ModelSchema#event:checkAttribute `Schema#checkAttribute`} events as a definition
  * of a place in the document where the check occurs. The context instances are created based on the first arguments
- * of the {@link module:engine/model/schema~Schema#checkChild `Schema#checkChild()`} and
- * {@link module:engine/model/schema~Schema#checkAttribute `Schema#checkAttribute()`} methods so when
- * using these methods you need to use {@link module:engine/model/schema~SchemaContextDefinition}s.
+ * of the {@link module:engine/model/schema~ModelSchema#checkChild `Schema#checkChild()`} and
+ * {@link module:engine/model/schema~ModelSchema#checkAttribute `Schema#checkAttribute()`} methods so when
+ * using these methods you need to use {@link module:engine/model/schema~ModelSchemaContextDefinition}s.
  */
-export declare class SchemaContext implements Iterable<SchemaContextItem> {
+export declare class ModelSchemaContext implements Iterable<ModelSchemaContextItem> {
     private _items;
     /**
      * Creates an instance of the context.
      */
-    constructor(context: SchemaContextDefinition);
+    constructor(context: ModelSchemaContextDefinition);
     /**
      * The number of items.
      */
@@ -1112,20 +1116,20 @@ export declare class SchemaContext implements Iterable<SchemaContextItem> {
     /**
      * The last item (the lowest node).
      */
-    get last(): SchemaContextItem;
+    get last(): ModelSchemaContextItem;
     /**
      * Iterable interface.
      *
      * Iterates over all context items.
      */
-    [Symbol.iterator](): IterableIterator<SchemaContextItem>;
+    [Symbol.iterator](): IterableIterator<ModelSchemaContextItem>;
     /**
      * Returns a new schema context instance with an additional item.
      *
      * Item can be added as:
      *
      * ```ts
-     * const context = new SchemaContext( [ '$root' ] );
+     * const context = new ModelSchemaContext( [ '$root' ] );
      *
      * // An element.
      * const fooElement = writer.createElement( 'fooElement' );
@@ -1139,29 +1143,29 @@ export declare class SchemaContext implements Iterable<SchemaContextItem> {
      * const newContext = context.push( 'barElement' ); // [ '$root', 'barElement' ]
      * ```
      *
-     * **Note** {@link module:engine/model/node~Node} that is already in the model tree will be added as the only item
+     * **Note** {@link module:engine/model/node~ModelNode} that is already in the model tree will be added as the only item
      * (without ancestors).
      *
      * @param item An item that will be added to the current context.
      * @returns A new schema context instance with an additional item.
      */
-    push(item: string | Node): SchemaContext;
+    push(item: string | ModelNode): ModelSchemaContext;
     /**
      * Returns a new schema context that is based on this context but has the last item removed.
      *
      * ```ts
-     * const ctxParagraph = new SchemaContext( [ '$root', 'blockQuote', 'paragraph' ] );
+     * const ctxParagraph = new ModelSchemaContext( [ '$root', 'blockQuote', 'paragraph' ] );
      * const ctxBlockQuote = ctxParagraph.trimLast(); // Items in `ctxBlockQuote` are: `$root` an `blockQuote`.
      * const ctxRoot = ctxBlockQuote.trimLast(); // Items in `ctxRoot` are: `$root`.
      * ```
      *
      * @returns A new reduced schema context instance.
      */
-    trimLast(): SchemaContext;
+    trimLast(): ModelSchemaContext;
     /**
      * Gets an item on the given index.
      */
-    getItem(index: number): SchemaContextItem;
+    getItem(index: number): ModelSchemaContextItem;
     /**
      * Returns the names of items.
      */
@@ -1170,7 +1174,7 @@ export declare class SchemaContext implements Iterable<SchemaContextItem> {
      * Checks whether the context ends with the given nodes.
      *
      * ```ts
-     * const ctx = new SchemaContext( [ rootElement, paragraphElement, textNode ] );
+     * const ctx = new ModelSchemaContext( [ rootElement, paragraphElement, textNode ] );
      *
      * ctx.endsWith( '$text' ); // -> true
      * ctx.endsWith( 'paragraph $text' ); // -> true
@@ -1183,7 +1187,7 @@ export declare class SchemaContext implements Iterable<SchemaContextItem> {
      * Checks whether the context starts with the given nodes.
      *
      * ```ts
-     * const ctx = new SchemaContext( [ rootElement, paragraphElement, textNode ] );
+     * const ctx = new ModelSchemaContext( [ rootElement, paragraphElement, textNode ] );
      *
      * ctx.endsWith( '$root' ); // -> true
      * ctx.endsWith( '$root paragraph' ); // -> true
@@ -1194,7 +1198,7 @@ export declare class SchemaContext implements Iterable<SchemaContextItem> {
     startsWith(query: string): boolean;
 }
 /**
- * The definition of a {@link module:engine/model/schema~SchemaContext schema context}.
+ * The definition of a {@link module:engine/model/schema~ModelSchemaContext schema context}.
  *
  * Contexts can be created in multiple ways:
  *
@@ -1206,10 +1210,10 @@ export declare class SchemaContext implements Iterable<SchemaContextItem> {
  * way to define the context (e.g. when checking some hypothetical situation).
  * * By defining an **array of node names** (potentially, mixed with real nodes) – The same as **name of node**
  * but it is possible to create a path.
- * * By defining a {@link module:engine/model/schema~SchemaContext} instance - in this case the same instance as provided
+ * * By defining a {@link module:engine/model/schema~ModelSchemaContext} instance - in this case the same instance as provided
  * will be returned.
  *
- * Examples of context definitions passed to the {@link module:engine/model/schema~Schema#checkChild `Schema#checkChild()`}
+ * Examples of context definitions passed to the {@link module:engine/model/schema~ModelSchema#checkChild `Schema#checkChild()`}
  * method:
  *
  * ```ts
@@ -1233,7 +1237,7 @@ export declare class SchemaContext implements Iterable<SchemaContextItem> {
  * schema.checkChild( [ '$root', 'bar', paragraphElement ], 'foo' );
  * ```
  *
- * All these `checkChild()` calls will fire {@link module:engine/model/schema~Schema#event:checkChild `Schema#checkChild`}
+ * All these `checkChild()` calls will fire {@link module:engine/model/schema~ModelSchema#event:checkChild `Schema#checkChild`}
  * events in which `args[ 0 ]` is an instance of the context. Therefore, you can write a listener like this:
  *
  * ```ts
@@ -1252,8 +1256,8 @@ export declare class SchemaContext implements Iterable<SchemaContextItem> {
  * [ '$root', 'bar', 'paragraph' ]
  * ```
  *
- * Note: When using the {@link module:engine/model/schema~Schema#checkAttribute `Schema#checkAttribute()`} method
- * you may want to check whether a text node may have an attribute. A {@link module:engine/model/text~Text} is a
+ * Note: When using the {@link module:engine/model/schema~ModelSchema#checkAttribute `Schema#checkAttribute()`} method
+ * you may want to check whether a text node may have an attribute. A {@link module:engine/model/text~ModelText} is a
  * correct way to define a context so you can do this:
  *
  * ```ts
@@ -1268,9 +1272,9 @@ export declare class SchemaContext implements Iterable<SchemaContextItem> {
  * schema.checkChild( [ ...positionInParagraph.getAncestors(), '$text' ], 'bold' );
  * ```
  */
-export type SchemaContextDefinition = Item | Position | SchemaContext | string | Array<string | Item>;
+export type ModelSchemaContextDefinition = ModelItem | ModelPosition | ModelSchemaContext | string | Array<string | ModelItem>;
 /**
- * An item of the {@link module:engine/model/schema~SchemaContext schema context}.
+ * An item of the {@link module:engine/model/schema~ModelSchemaContext schema context}.
  *
  * It contains 3 properties:
  *
@@ -1278,7 +1282,7 @@ export type SchemaContextDefinition = Item | Position | SchemaContext | string |
  * * `* getAttributeKeys()` – a generator of keys of item attributes,
  * * `getAttribute( keyName )` – a method to get attribute values.
  *
- * The context item interface is a highly simplified version of {@link module:engine/model/node~Node} and its role
+ * The context item interface is a highly simplified version of {@link module:engine/model/node~ModelNode} and its role
  * is to expose only the information which schema checks are able to provide (which is the name of the node and
  * node's attributes).
  *
@@ -1293,7 +1297,7 @@ export type SchemaContextDefinition = Item | Position | SchemaContext | string |
  * } );
  * ```
  */
-export interface SchemaContextItem {
+export interface ModelSchemaContextItem {
     name: string;
     getAttributeKeys(): Generator<string>;
     getAttribute(keyName: string): unknown;
@@ -1301,9 +1305,9 @@ export interface SchemaContextItem {
 /**
  * A structure containing additional metadata describing the attribute.
  *
- * See {@link module:engine/model/schema~Schema#setAttributeProperties `Schema#setAttributeProperties()`} for usage examples.
+ * See {@link module:engine/model/schema~ModelSchema#setAttributeProperties `Schema#setAttributeProperties()`} for usage examples.
  */
-export interface AttributeProperties {
+export interface ModelAttributeProperties {
     /**
      * Indicates that the attribute should be considered as a visual formatting, like `bold`, `italic` or
      * `fontSize` rather than semantic attribute (such as `src`, `listType`, etc.). For example, it is used by the "Remove format" feature.
@@ -1325,6 +1329,6 @@ export interface AttributeProperties {
     copyFromObject?: boolean;
     [name: string]: unknown;
 }
-export type SchemaAttributeCheckCallback = (context: SchemaContext, attributeName: string) => boolean | undefined;
-export type SchemaChildCheckCallback = (context: SchemaContext, definition: SchemaCompiledItemDefinition) => boolean | undefined;
+export type ModelSchemaAttributeCheckCallback = (context: ModelSchemaContext, attributeName: string) => boolean | undefined;
+export type ModelSchemaChildCheckCallback = (context: ModelSchemaContext, definition: ModelSchemaCompiledItemDefinition) => boolean | undefined;
 export {};