roosterjs 9.3.0 → 9.4.0

package/dist/rooster-amd.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for roosterjs (Version 9.3.0)
+// Type definitions for roosterjs (Version 9.4.0)
 // Generated by dts tool from roosterjs
 // Project: https://github.com/Microsoft/roosterjs
 
@@ -27,6 +27,16 @@ export interface ContentModelWithFormat<T extends ContentModelFormatBase> {
     format: T;
 }
 
+/**
+ * Represent a content model with format (Readonly)
+ */
+export interface ReadonlyContentModelWithFormat<T extends ContentModelFormatBase> {
+    /**
+     * Format of this model
+     */
+    readonly format: Readonly<T>;
+}
+
 /**
  * Format of Table
  */
@@ -35,12 +45,32 @@ export type ContentModelTableFormat = ContentModelBlockFormat & IdFormat & Borde
 /**
  * Represents base format of an element that supports dataset and/or metadata
  */
-export interface ContentModelWithDataset<T> {
+export type ContentModelWithDataset<T> = MutableMark & {
     /**
      * dataset of this element
      */
     dataset: DatasetFormat;
-}
+};
+
+/**
+ * Represents base format of an element that supports dataset and/or metadata (Readonly)
+ */
+export type ReadonlyContentModelWithDataset<T> = ReadonlyMark & {
+    /**
+     * dataset of this element
+     */
+    readonly dataset: ReadonlyDatasetFormat;
+};
+
+/**
+ * Represents base format of an element that supports dataset and/or metadata (Readonly)
+ */
+export type ShallowMutableContentModelWithDataset<T> = ShallowMutableMark & {
+    /**
+     * dataset of this element
+     */
+    dataset: DatasetFormat;
+};
 
 /**
  * The format object for a paragraph in Content Model
@@ -832,6 +862,11 @@ export type EntityInfoFormat = {
  */
 export type DatasetFormat = Record<string, string>;
 
+/**
+ * Represents dataset format of Content Model (Readonly)
+ */
+export type ReadonlyDatasetFormat = Readonly<Record<string, string>>;
+
 /**
  * Format of table that stored as metadata
  */
@@ -1376,10 +1411,20 @@ export type ExportContentMode = /**
  */
 export type ContentModelBlock = ContentModelFormatContainer | ContentModelListItem | ContentModelGeneralBlock | ContentModelTable | ContentModelParagraph | ContentModelEntity | ContentModelDivider;
 
+/**
+ * A union type of Content Model Block (Readonly)
+ */
+export type ReadonlyContentModelBlock = ReadonlyContentModelFormatContainer | ReadonlyContentModelListItem | ReadonlyContentModelGeneralBlock | ReadonlyContentModelTable | ReadonlyContentModelParagraph | ContentModelEntity | ReadonlyContentModelDivider;
+
+/**
+ * A union type of Content Model Block (Shallow mutable)
+ */
+export type ShallowMutableContentModelBlock = ShallowMutableContentModelFormatContainer | ShallowMutableContentModelListItem | ShallowMutableContentModelGeneralBlock | ShallowMutableContentModelTable | ShallowMutableContentModelParagraph | ContentModelEntity | ContentModelDivider;
+
 /**
  * Content Model of Paragraph
  */
-export interface ContentModelParagraph extends ContentModelBlockWithCache, ContentModelBlockBase<'Paragraph'> {
+export interface ContentModelParagraph extends ContentModelParagraphCommon, ContentModelBlockBase<'Paragraph'> {
     /**
      * Segments within this paragraph
      */
@@ -1392,6 +1437,12 @@ export interface ContentModelParagraph extends ContentModelBlockWithCache, Conte
      * Decorator info for this paragraph, used by heading and P tags
      */
     decorator?: ContentModelParagraphDecorator;
+}
+
+/**
+ * Common part of Content Model of Paragraph
+ */
+export interface ContentModelParagraphCommon {
     /**
      * Whether this block was created from a block HTML element or just some simple segment between other block elements.
      * True means it doesn't have a related block element, false means it was from a block element
@@ -1399,10 +1450,46 @@ export interface ContentModelParagraph extends ContentModelBlockWithCache, Conte
     isImplicit?: boolean;
 }
 
+/**
+ * Content Model of Paragraph (Readonly)
+ */
+export interface ReadonlyContentModelParagraph extends ReadonlyContentModelBlockBase<'Paragraph'>, Readonly<ContentModelParagraphCommon> {
+    /**
+     * Segments within this paragraph
+     */
+    readonly segments: ReadonlyArray<ReadonlyContentModelSegment>;
+    /**
+     * Segment format on this paragraph. This is mostly used for default format
+     */
+    readonly segmentFormat?: Readonly<ContentModelSegmentFormat>;
+    /**
+     * Decorator info for this paragraph, used by heading and P tags
+     */
+    readonly decorator?: ReadonlyContentModelParagraphDecorator;
+}
+
+/**
+ * Content Model of Paragraph (Shallow mutable)
+ */
+export interface ShallowMutableContentModelParagraph extends ContentModelParagraphCommon, ContentModelBlockBase<'Paragraph'> {
+    /**
+     * Segments within this paragraph
+     */
+    segments: ShallowMutableContentModelSegment[];
+    /**
+     * Segment format on this paragraph. This is mostly used for default format
+     */
+    segmentFormat?: ContentModelSegmentFormat;
+    /**
+     * Decorator info for this paragraph, used by heading and P tags
+     */
+    decorator?: ContentModelParagraphDecorator;
+}
+
 /**
  * Content Model of Table
  */
-export interface ContentModelTable extends ContentModelBlockBase<'Table', ContentModelTableFormat>, ContentModelWithDataset<TableMetadataFormat>, ContentModelBlockWithCache<HTMLTableElement> {
+export interface ContentModelTable extends ContentModelBlockBase<'Table', ContentModelTableFormat, HTMLTableElement>, ContentModelWithDataset<TableMetadataFormat> {
     /**
      * Widths of each column
      */
@@ -1413,10 +1500,44 @@ export interface ContentModelTable extends ContentModelBlockBase<'Table', Conten
     rows: ContentModelTableRow[];
 }
 
+/**
+ * Content Model of Table (Readonly)
+ */
+export interface ReadonlyContentModelTable extends ReadonlyContentModelBlockBase<'Table', ContentModelTableFormat, HTMLTableElement>, ReadonlyContentModelWithDataset<TableMetadataFormat> {
+    /**
+     * Widths of each column
+     */
+    readonly widths: ReadonlyArray<number>;
+    /**
+     * Cells of this table
+     */
+    readonly rows: ReadonlyArray<ReadonlyContentModelTableRow>;
+}
+
+/**
+ * Content Model of Table (Shallow mutable)
+ */
+export interface ShallowMutableContentModelTable extends ShallowMutableContentModelBlockBase<'Table', ContentModelTableFormat, HTMLTableElement>, ShallowMutableContentModelWithDataset<TableMetadataFormat> {
+    /**
+     * Widths of each column
+     */
+    widths: number[];
+    /**
+     * Cells of this table
+     */
+    rows: ShallowMutableContentModelTableRow[];
+}
+
 /**
  * Content Model of horizontal divider
  */
-export interface ContentModelDivider extends Selectable, ContentModelBlockWithCache, ContentModelBlockBase<'Divider', ContentModelDividerFormat> {
+export interface ContentModelDivider extends Selectable, ContentModelDividerCommon, ContentModelBlockBase<'Divider', ContentModelDividerFormat> {
+}
+
+/**
+ * Common part of Content Model of horizontal divider
+ */
+export interface ContentModelDividerCommon {
     /**
      * Tag name of this element, either HR or DIV
      */
@@ -1427,14 +1548,38 @@ export interface ContentModelDivider extends Selectable, ContentModelBlockWithCa
     size?: string;
 }
 
+/**
+ * Content Model of horizontal divider (Readonly)
+ */
+export interface ReadonlyContentModelDivider extends ReadonlySelectable, ReadonlyContentModelBlockBase<'Divider', ContentModelDividerFormat>, Readonly<ContentModelDividerCommon> {
+}
+
 /**
  * Base type of a block
  */
-export interface ContentModelBlockBase<T extends ContentModelBlockType, TFormat extends ContentModelBlockFormat = ContentModelBlockFormat> extends ContentModelWithFormat<TFormat> {
+export interface ContentModelBlockBase<T extends ContentModelBlockType, TFormat extends ContentModelBlockFormat = ContentModelBlockFormat, TCacheElement extends HTMLElement = HTMLElement> extends MutableMark, ContentModelBlockBaseCommon<T>, ContentModelWithFormat<TFormat>, ContentModelBlockWithCache<TCacheElement> {
+}
+
+/**
+ * Common part of base type of a block
+ */
+export interface ContentModelBlockBaseCommon<T extends ContentModelBlockType> {
     /**
      * Type of this block
      */
-    blockType: T;
+    readonly blockType: T;
+}
+
+/**
+ * Base type of a block (Readonly)
+ */
+export interface ReadonlyContentModelBlockBase<T extends ContentModelBlockType, TFormat extends ContentModelBlockFormat = ContentModelBlockFormat, TCacheElement extends HTMLElement = HTMLElement> extends ReadonlyMark, ContentModelBlockBaseCommon<T>, ReadonlyContentModelWithFormat<TFormat>, ContentModelBlockWithCache<TCacheElement> {
+}
+
+/**
+ * Base type of a block (Shallow mutable)
+ */
+export interface ShallowMutableContentModelBlockBase<T extends ContentModelBlockType, TFormat extends ContentModelBlockFormat = ContentModelBlockFormat, TCacheElement extends HTMLElement = HTMLElement> extends ShallowMutableMark, ContentModelBlockBaseCommon<T>, ContentModelWithFormat<TFormat>, ContentModelBlockWithCache<TCacheElement> {
 }
 
 /**
@@ -1450,15 +1595,41 @@ export interface ContentModelBlockWithCache<TElement extends HTMLElement = HTMLE
 /**
  * Content Model of Table
  */
-export interface ContentModelTableRow extends ContentModelBlockWithCache<HTMLTableRowElement>, ContentModelWithFormat<ContentModelBlockFormat> {
+export interface ContentModelTableRow extends MutableMark, ContentModelTableRowCommon, ContentModelBlockWithCache<HTMLTableRowElement>, ContentModelWithFormat<ContentModelBlockFormat> {
+    /**
+     * Cells of this table
+     */
+    cells: ContentModelTableCell[];
+}
+
+/**
+ * Common part of Content Model of Table
+ */
+export interface ContentModelTableRowCommon {
     /**
      * Heights of each row
      */
     height: number;
+}
+
+/**
+ * Content Model of Table (Readonly)
+ */
+export interface ReadonlyContentModelTableRow extends ReadonlyMark, Readonly<ContentModelTableRowCommon>, ContentModelBlockWithCache<HTMLTableRowElement>, ReadonlyContentModelWithFormat<ContentModelBlockFormat> {
     /**
      * Cells of this table
      */
-    cells: ContentModelTableCell[];
+    readonly cells: ReadonlyArray<ReadonlyContentModelTableCell>;
+}
+
+/**
+ * Content Model of Table (Readonly)
+ */
+export interface ShallowMutableContentModelTableRow extends ShallowMutableMark, ContentModelTableRowCommon, ContentModelBlockWithCache<HTMLTableRowElement>, ContentModelWithFormat<ContentModelBlockFormat> {
+    /**
+     * Cells of this table
+     */
+    cells: ReadonlyContentModelTableCell[];
 }
 
 /**
@@ -1478,31 +1649,81 @@ export interface ContentModelEntity extends ContentModelBlockBase<'Entity', Cont
 /**
  * Content Model document entry point
  */
-export interface ContentModelDocument extends ContentModelBlockGroupBase<'Document'>, Partial<ContentModelWithFormat<ContentModelSegmentFormat>> {
+export interface ContentModelDocument extends ContentModelDocumentCommon, ContentModelBlockGroupBase<'Document'>, Partial<ContentModelWithFormat<ContentModelSegmentFormat>> {
+}
+
+/**
+ * Common part of Content Model document entry point
+ */
+export interface ContentModelDocumentCommon {
     /**
      * Whether the selection in model (if any) is a revert selection (end is before start)
      */
     hasRevertedRangeSelection?: boolean;
 }
 
+/**
+ * Content Model document entry point (Readonly)
+ */
+export interface ReadonlyContentModelDocument extends Readonly<ContentModelDocumentCommon>, ReadonlyContentModelBlockGroupBase<'Document'>, Partial<ReadonlyContentModelWithFormat<ContentModelSegmentFormat>> {
+}
+
+/**
+ * Content Model document entry point (Shallow mutable)
+ */
+export interface ShallowMutableContentModelDocument extends ContentModelDocumentCommon, ShallowMutableContentModelBlockGroupBase<'Document'>, Partial<ContentModelWithFormat<ContentModelSegmentFormat>> {
+}
+
 /**
  * Base type of Content Model Block Group
  */
-export interface ContentModelBlockGroupBase<T extends ContentModelBlockGroupType> {
+export interface ContentModelBlockGroupBase<T extends ContentModelBlockGroupType, TElement extends HTMLElement = HTMLElement> extends MutableMark, ContentModelBlockGroupBaseCommon<T, TElement> {
+    /**
+     * Blocks under this group
+     */
+    blocks: ContentModelBlock[];
+}
+
+/**
+ * Common part of base type of Content Model Block Group
+ */
+export interface ContentModelBlockGroupBaseCommon<T extends ContentModelBlockGroupType, TElement extends HTMLElement = HTMLElement> extends ContentModelBlockWithCache<TElement> {
     /**
      * Type of this block group
      */
-    blockGroupType: T;
+    readonly blockGroupType: T;
+}
+
+/**
+ * Base type of Content Model Block Group (Readonly)
+ */
+export interface ReadonlyContentModelBlockGroupBase<T extends ContentModelBlockGroupType, TElement extends HTMLElement = HTMLElement> extends ReadonlyMark, ContentModelBlockGroupBaseCommon<T, TElement> {
+    /**
+     * Blocks under this group
+     */
+    readonly blocks: ReadonlyArray<ReadonlyContentModelBlock>;
+}
+
+/**
+ * Base type of Content Model Block Group (Shallow mutable)
+ */
+export interface ShallowMutableContentModelBlockGroupBase<T extends ContentModelBlockGroupType, TElement extends HTMLElement = HTMLElement> extends ShallowMutableMark, ContentModelBlockGroupBaseCommon<T, TElement> {
     /**
      * Blocks under this group
      */
-    blocks: ContentModelBlock[];
+    blocks: ReadonlyContentModelBlock[];
 }
 
 /**
  * Content Model of Format Container
  */
-export interface ContentModelFormatContainer extends ContentModelBlockWithCache, ContentModelBlockGroupBase<'FormatContainer'>, ContentModelBlockBase<'BlockGroup', ContentModelFormatContainerFormat> {
+export interface ContentModelFormatContainer extends ContentModelFormatContainerCommon, ContentModelBlockGroupBase<'FormatContainer'>, ContentModelBlockBase<'BlockGroup', ContentModelFormatContainerFormat, HTMLElement> {
+}
+
+/**
+ * Common part of Content Model of Format Container
+ */
+export interface ContentModelFormatContainerCommon {
     /**
      * Tag name of this container
      */
@@ -1514,20 +1735,78 @@ export interface ContentModelFormatContainer extends ContentModelBlockWithCache,
     zeroFontSize?: boolean;
 }
 
+/**
+ * Content Model of Format Container (Readonly)
+ */
+export interface ReadonlyContentModelFormatContainer extends Readonly<ContentModelFormatContainerCommon>, ReadonlyContentModelBlockGroupBase<'FormatContainer'>, ReadonlyContentModelBlockBase<'BlockGroup', ContentModelFormatContainerFormat, HTMLElement> {
+}
+
+/**
+ * Content Model of Format Container (Shallow mutable)
+ */
+export interface ShallowMutableContentModelFormatContainer extends ContentModelFormatContainerCommon, ShallowMutableContentModelBlockGroupBase<'FormatContainer'>, ShallowMutableContentModelBlockBase<'BlockGroup', ContentModelFormatContainerFormat, HTMLElement> {
+}
+
 /**
  * Content Model for general Block element
  */
-export interface ContentModelGeneralBlock extends Selectable, ContentModelBlockGroupBase<'General'>, ContentModelBlockBase<'BlockGroup', ContentModelBlockFormat & ContentModelSegmentFormat> {
+export interface ContentModelGeneralBlock extends Selectable, ContentModelGeneralBlockCommon, ContentModelBlockGroupBase<'General'>, ContentModelBlockBase<'BlockGroup', ContentModelBlockFormat & ContentModelSegmentFormat> {
+}
+
+/**
+ * Common part of Content Model for general Block element
+ */
+export interface ContentModelGeneralBlockCommon {
     /**
      * A reference to original HTML node that this model was created from
      */
     element: HTMLElement;
 }
 
+/**
+ * Content Model for general Block element (Readonly)
+ */
+export interface ReadonlyContentModelGeneralBlock extends ReadonlySelectable, Readonly<ContentModelGeneralBlockCommon>, ReadonlyContentModelBlockGroupBase<'General'>, ReadonlyContentModelBlockBase<'BlockGroup', ContentModelBlockFormat & ContentModelSegmentFormat> {
+}
+
+/**
+ * Content Model for general Block element (Shallow mutable)
+ */
+export interface ShallowMutableContentModelGeneralBlock extends ShallowMutableSelectable, ContentModelGeneralBlockCommon, ShallowMutableContentModelBlockGroupBase<'General'>, ShallowMutableContentModelBlockBase<'BlockGroup', ContentModelBlockFormat & ContentModelSegmentFormat> {
+}
+
 /**
  * Content Model of List Item
  */
-export interface ContentModelListItem extends ContentModelBlockGroupBase<'ListItem'>, ContentModelBlockBase<'BlockGroup', ContentModelListItemFormat> {
+export interface ContentModelListItem extends ContentModelBlockGroupBase<'ListItem', HTMLLIElement>, ContentModelBlockBase<'BlockGroup', ContentModelListItemFormat, HTMLLIElement> {
+    /**
+     * Type of this list, either ordered or unordered
+     */
+    levels: ContentModelListLevel[];
+    /**
+     * A dummy segment to hold format of this list item
+     */
+    formatHolder: ContentModelSelectionMarker;
+}
+
+/**
+ * Content Model of List Item (Readonly)
+ */
+export interface ReadonlyContentModelListItem extends ReadonlyContentModelBlockGroupBase<'ListItem', HTMLLIElement>, ReadonlyContentModelBlockBase<'BlockGroup', ContentModelListItemFormat, HTMLLIElement> {
+    /**
+     * Type of this list, either ordered or unordered
+     */
+    readonly levels: ReadonlyArray<ReadonlyContentModelListLevel>;
+    /**
+     * A dummy segment to hold format of this list item
+     */
+    readonly formatHolder: ReadonlyContentModelSelectionMarker;
+}
+
+/**
+ * Content Model of List Item (Shallow mutable)
+ */
+export interface ShallowMutableContentModelListItem extends ShallowMutableContentModelBlockGroupBase<'ListItem', HTMLLIElement>, ShallowMutableContentModelBlockBase<'BlockGroup', ContentModelListItemFormat, HTMLLIElement> {
     /**
      * Type of this list, either ordered or unordered
      */
@@ -1541,7 +1820,13 @@ export interface ContentModelListItem extends ContentModelBlockGroupBase<'ListIt
 /**
  * Content Model of Table Cell
  */
-export interface ContentModelTableCell extends Selectable, ContentModelBlockGroupBase<'TableCell'>, ContentModelWithFormat<ContentModelTableCellFormat>, ContentModelWithDataset<TableCellMetadataFormat>, ContentModelBlockWithCache<HTMLTableCellElement> {
+export interface ContentModelTableCell extends Selectable, ContentModelTableCellCommon, ContentModelBlockGroupBase<'TableCell', HTMLTableCellElement>, ContentModelWithFormat<ContentModelTableCellFormat>, ContentModelWithDataset<TableCellMetadataFormat> {
+}
+
+/**
+ * Common part of Content Model of Table Cell
+ */
+export interface ContentModelTableCellCommon {
     /**
      * Whether this cell is spanned from left cell
      */
@@ -1556,27 +1841,73 @@ export interface ContentModelTableCell extends Selectable, ContentModelBlockGrou
     isHeader?: boolean;
 }
 
+/**
+ * Content Model of Table Cell (Readonly)
+ */
+export interface ReadonlyContentModelTableCell extends ReadonlySelectable, Readonly<ContentModelTableCellCommon>, ReadonlyContentModelBlockGroupBase<'TableCell', HTMLTableCellElement>, ReadonlyContentModelWithFormat<ContentModelTableCellFormat>, ReadonlyContentModelWithDataset<TableCellMetadataFormat> {
+}
+
+/**
+ * Content Model of Table Cell (Shallow mutable)
+ */
+export interface ShallowMutableContentModelTableCell extends ShallowMutableSelectable, ContentModelTableCellCommon, ShallowMutableContentModelBlockGroupBase<'TableCell', HTMLTableCellElement>, ContentModelWithFormat<ContentModelTableCellFormat>, ShallowMutableContentModelWithDataset<TableCellMetadataFormat> {
+}
+
 /**
  * The union type of Content Model Block Group
  */
 export type ContentModelBlockGroup = ContentModelDocument | ContentModelFormatContainer | ContentModelListItem | ContentModelTableCell | ContentModelGeneralBlock;
 
+/**
+ * The union type of Content Model Block Group (Readonly)
+ */
+export type ReadonlyContentModelBlockGroup = ReadonlyContentModelDocument | ReadonlyContentModelFormatContainer | ReadonlyContentModelListItem | ReadonlyContentModelTableCell | ReadonlyContentModelGeneralBlock;
+
+/**
+ * The union type of Content Model Block Group (Shallow mutable)
+ */
+export type ShallowMutableContentModelBlockGroup = ShallowMutableContentModelDocument | ShallowMutableContentModelFormatContainer | ShallowMutableContentModelListItem | ShallowMutableContentModelTableCell | ShallowMutableContentModelGeneralBlock;
+
 /**
  * Content Model of BR
  */
 export interface ContentModelBr extends ContentModelSegmentBase<'Br'> {
 }
 
+/**
+ * Content Model of BR (Readonly)
+ */
+export interface ReadonlyContentModelBr extends ReadonlyContentModelSegmentBase<'Br'> {
+}
+
 /**
  * Content Model of general Segment
  */
 export interface ContentModelGeneralSegment extends ContentModelGeneralBlock, ContentModelSegmentBase<'General', ContentModelBlockFormat & ContentModelSegmentFormat> {
 }
 
+/**
+ * Content Model of general Segment (Readonly)
+ */
+export interface ReadonlyContentModelGeneralSegment extends ReadonlyContentModelGeneralBlock, ReadonlyContentModelSegmentBase<'General', ContentModelBlockFormat & ContentModelSegmentFormat> {
+}
+
+/**
+ * Content Model of general Segment (Shallow mutable)
+ */
+export interface ShallowMutableContentModelGeneralSegment extends ShallowMutableContentModelGeneralBlock, ShallowMutableContentModelSegmentBase<'General', ContentModelBlockFormat & ContentModelSegmentFormat> {
+}
+
 /**
  * Content Model of IMG
  */
-export interface ContentModelImage extends ContentModelSegmentBase<'Image', ContentModelImageFormat>, ContentModelWithDataset<ImageMetadataFormat> {
+export interface ContentModelImage extends ContentModelImageCommon, ContentModelSegmentBase<'Image', ContentModelImageFormat>, ContentModelWithDataset<ImageMetadataFormat> {
+}
+
+/**
+ * Common part of Content Model of IMG
+ */
+export interface ContentModelImageCommon {
     /**
      * Image source of this IMG element
      */
@@ -1595,30 +1926,88 @@ export interface ContentModelImage extends ContentModelSegmentBase<'Image', Cont
     isSelectedAsImageSelection?: boolean;
 }
 
+/**
+ * Content Model of IMG (Readonly)
+ */
+export interface ReadonlyContentModelImage extends ReadonlyContentModelSegmentBase<'Image', ContentModelImageFormat>, ReadonlyContentModelWithDataset<ImageMetadataFormat>, Readonly<ContentModelImageCommon> {
+}
+
 /**
  * Content Model for Text
  */
-export interface ContentModelText extends ContentModelSegmentBase<'Text'> {
+export interface ContentModelText extends ContentModelTextCommon, ContentModelSegmentBase<'Text'> {
+}
+
+/**
+ * Common port of Content Model for Text
+ */
+export interface ContentModelTextCommon {
+    /**
+     * Text content of this segment
+     */
+    text: string;
+}
+
+/**
+ * Content Model for Text (Readonly)
+ */
+export interface ReadonlyContentModelText extends ReadonlyContentModelSegmentBase<'Text'>, Readonly<ContentModelTextCommon> {
+}
+
+/**
+ * Content Model of Selection Marker
+ */
+export interface ContentModelSelectionMarker extends ContentModelSegmentBase<'SelectionMarker'> {
+}
+
+/**
+ * Content Model of Selection Marker (Readonly)
+ */
+export interface ReadonlyContentModelSelectionMarker extends ReadonlyContentModelSegmentBase<'SelectionMarker'> {
+}
+
+/**
+ * Base type of Content Model Segment
+ */
+export interface ContentModelSegmentBase<T extends ContentModelSegmentType, TFormat extends ContentModelSegmentFormat = ContentModelSegmentFormat> extends MutableMark, Selectable, ContentModelWithFormat<TFormat>, ContentModelSegmentBaseCommon<T> {
+    /**
+     * Hyperlink info
+     */
+    link?: ContentModelLink;
+    /**
+     * Code info
+     */
+    code?: ContentModelCode;
+}
+
+/**
+ * Common part of base type of Content Model Segment
+ */
+export interface ContentModelSegmentBaseCommon<T extends ContentModelSegmentType> {
     /**
-     * Text content of this segment
+     * Type of this segment
      */
-    text: string;
+    readonly segmentType: T;
 }
 
 /**
- * Content Model of Selection Marker
+ * Base type of Content Model Segment (Readonly)
  */
-export interface ContentModelSelectionMarker extends ContentModelSegmentBase<'SelectionMarker'> {
+export interface ReadonlyContentModelSegmentBase<T extends ContentModelSegmentType, TFormat extends ContentModelSegmentFormat = ContentModelSegmentFormat> extends ReadonlyMark, ReadonlySelectable, ReadonlyContentModelWithFormat<TFormat>, Readonly<ContentModelSegmentBaseCommon<T>> {
+    /**
+     * Hyperlink info
+     */
+    readonly link?: ReadonlyContentModelLink;
+    /**
+     * Code info
+     */
+    readonly code?: ReadonlyContentModelCode;
 }
 
 /**
- * Base type of Content Model Segment
+ * Base type of Content Model Segment (Shallow mutable)
  */
-export interface ContentModelSegmentBase<T extends ContentModelSegmentType, TFormat extends ContentModelSegmentFormat = ContentModelSegmentFormat> extends Selectable, ContentModelWithFormat<TFormat> {
-    /**
-     * Type of this segment
-     */
-    segmentType: T;
+export interface ShallowMutableContentModelSegmentBase<T extends ContentModelSegmentType, TFormat extends ContentModelSegmentFormat = ContentModelSegmentFormat> extends ShallowMutableMark, ShallowMutableSelectable, ContentModelWithFormat<TFormat>, ContentModelSegmentBaseCommon<T> {
     /**
      * Hyperlink info
      */
@@ -1634,12 +2023,30 @@ export interface ContentModelSegmentBase<T extends ContentModelSegmentType, TFor
  */
 export type ContentModelSegment = ContentModelSelectionMarker | ContentModelText | ContentModelBr | ContentModelGeneralSegment | ContentModelEntity | ContentModelImage;
 
+/**
+ * Union type of Content Model Segment (Readonly)
+ */
+export type ReadonlyContentModelSegment = ReadonlyContentModelSelectionMarker | ReadonlyContentModelText | ReadonlyContentModelBr | ReadonlyContentModelGeneralSegment | ContentModelEntity | ReadonlyContentModelImage;
+
+/**
+ * Union type of Content Model Segment (Shallow mutable)
+ */
+export type ShallowMutableContentModelSegment = ContentModelSelectionMarker | ContentModelText | ContentModelBr | ShallowMutableContentModelGeneralSegment | ContentModelEntity | ContentModelImage;
+
 /**
  * Represent code info of Content Model.
  * ContentModelCode is a decorator but not a standalone model type, instead it need to be put inside a ContentModelSegment
  * since code is also a kind of segment, with some extra information
  */
-export interface ContentModelCode extends ContentModelWithFormat<ContentModelCodeFormat> {
+export interface ContentModelCode extends MutableMark, ContentModelWithFormat<ContentModelCodeFormat> {
+}
+
+/**
+ * Represent code info of Content Model. (Readonly)
+ * ContentModelCode is a decorator but not a standalone model type, instead it need to be put inside a ContentModelSegment
+ * since code is also a kind of segment, with some extra information
+ */
+export interface ReadonlyContentModelCode extends ReadonlyMark, ReadonlyContentModelWithFormat<ContentModelCodeFormat> {
 }
 
 /**
@@ -1647,7 +2054,15 @@ export interface ContentModelCode extends ContentModelWithFormat<ContentModelCod
  * ContentModelLink is not a standalone model type, instead it need to be put inside a ContentModelSegment
  * since link is also a kind of segment, with some extra information
  */
-export interface ContentModelLink extends ContentModelWithFormat<ContentModelHyperLinkFormat>, ContentModelWithDataset<null> {
+export interface ContentModelLink extends MutableMark, ContentModelWithFormat<ContentModelHyperLinkFormat>, ContentModelWithDataset<null> {
+}
+
+/**
+ * Represent link info of Content Model (Readonly).
+ * ContentModelLink is not a standalone model type, instead it need to be put inside a ContentModelSegment
+ * since link is also a kind of segment, with some extra information
+ */
+export interface ReadonlyContentModelLink extends ReadonlyMark, ReadonlyContentModelWithFormat<ContentModelHyperLinkFormat>, ReadonlyContentModelWithDataset<null> {
 }
 
 /**
@@ -1655,38 +2070,144 @@ export interface ContentModelLink extends ContentModelWithFormat<ContentModelHyp
  * A decorator of paragraph can represent a heading, or a P tag that act likes a paragraph but with some extra format info
  * since heading is also a kind of paragraph, with some extra information
  */
-export interface ContentModelParagraphDecorator extends ContentModelWithFormat<ContentModelSegmentFormat> {
+export interface ContentModelParagraphDecorator extends MutableMark, ContentModelParagraphDecoratorCommon, ContentModelWithFormat<ContentModelSegmentFormat> {
+}
+
+/**
+ * Common part of decorator for a paragraph in Content Model
+ */
+export interface ContentModelParagraphDecoratorCommon {
     /**
      * Tag name of this paragraph
      */
     tagName: string;
 }
 
+/**
+ * Represent decorator for a paragraph in Content Model (Readonly)
+ * A decorator of paragraph can represent a heading, or a P tag that act likes a paragraph but with some extra format info
+ * since heading is also a kind of paragraph, with some extra information
+ */
+export interface ReadonlyContentModelParagraphDecorator extends ReadonlyMark, ReadonlyContentModelWithFormat<ContentModelSegmentFormat>, Readonly<ContentModelParagraphDecoratorCommon> {
+}
+
 /**
  * Union type for segment decorators
  */
 export type ContentModelDecorator = ContentModelLink | ContentModelCode | ContentModelListLevel;
 
+/**
+ * Union type for segment decorators (Readonly)
+ */
+export type ReadonlyContentModelDecorator = ReadonlyContentModelLink | ReadonlyContentModelCode | ReadonlyContentModelListLevel;
+
 /**
  * Content Model of List Level
  */
-export interface ContentModelListLevel extends ContentModelWithFormat<ContentModelListItemLevelFormat>, ContentModelWithDataset<ListMetadataFormat> {
+export interface ContentModelListLevel extends MutableMark, ContentModelBlockWithCache<HTMLOListElement | HTMLUListElement>, ContentModelListLevelCommon, ContentModelWithFormat<ContentModelListItemLevelFormat>, ContentModelWithDataset<ListMetadataFormat> {
+}
+
+/**
+ * Common part of Content Model of List Level
+ */
+export interface ContentModelListLevelCommon {
     /**
      * Type of a list, order (OL) or unordered (UL)
      */
     listType: 'OL' | 'UL';
 }
 
+/**
+ * Content Model of List Level (Readonly)
+ */
+export interface ReadonlyContentModelListLevel extends ReadonlyMark, ContentModelBlockWithCache<HTMLOListElement | HTMLUListElement>, ReadonlyContentModelWithFormat<ContentModelListItemLevelFormat>, ReadonlyContentModelWithDataset<ListMetadataFormat>, Readonly<ContentModelListLevelCommon> {
+}
+
 /**
  * Represents a selectable Content Model object
  */
-export interface Selectable {
+export interface Selectable extends MutableMark  {
+    /**
+     * Whether this model object is selected
+     */
+    isSelected?: boolean;
+}
+
+/**
+ * Represents a selectable Content Model object (Readonly)
+ */
+export interface ReadonlySelectable extends ReadonlyMark  {
+    /**
+     * Whether this model object is selected
+     */
+    readonly isSelected?: boolean;
+}
+
+/**
+ * Represents a selectable Content Model object (Shallow mutable)
+ */
+export interface ShallowMutableSelectable extends ShallowMutableMark  {
     /**
      * Whether this model object is selected
      */
     isSelected?: boolean;
 }
 
+/**
+ * Mark an object as mutable
+ */
+export type MutableMark = {
+    /**
+     * The mutable marker to mark an object as mutable. When assign readonly object to a mutable type, compile will fail to build
+     * due to this member does not exist from source type.
+     */
+    readonly dummy1?: never[];
+    /**
+     * The mutable marker to mark an object as mutable. When assign readonly object to a mutable type, compile will fail to build
+     * due to this member does not exist from source type.
+     */
+    readonly dummy2?: never[];
+};
+
+/**
+ * Mark an object as single level mutable (child models are still readonly)
+ */
+export type ShallowMutableMark = {
+    /**
+     * The mutable marker to mark an object as mutable. When assign readonly object to a mutable type, compile will fail to build
+     * due to this member does not exist from source type.
+     */
+    readonly dummy1?: never[];
+    /**
+     * The mutable marker to mark an object as mutable. When assign readonly object to a mutable type, compile will fail to build
+     * due to this member does not exist from source type.
+     * This is used for preventing assigning ShallowMutableMark to MutableMark
+     */
+    readonly dummy2?: ReadonlyArray<never>;
+};
+
+/**
+ * Mark an object as readonly
+ */
+export type ReadonlyMark = {
+    /**
+     * The mutable marker to mark an object as mutable. When assign readonly object to a mutable type, compile will fail to build
+     * due to this member does not exist from source type.
+     * This is used for preventing assigning ReadonlyMark to ShallowMutableMark or MutableMark
+     */
+    readonly dummy1?: ReadonlyArray<never>;
+    /**
+     * The mutable marker to mark an object as mutable. When assign readonly object to a mutable type, compile will fail to build
+     * due to this member does not exist from source type.
+     */
+    readonly dummy2?: ReadonlyArray<never>;
+};
+
+/**
+ * Get mutable type from its related readonly type
+ */
+export type MutableType<T> = T extends ReadonlyContentModelGeneralSegment ? ShallowMutableContentModelGeneralSegment : T extends ReadonlyContentModelSelectionMarker ? ContentModelSelectionMarker : T extends ReadonlyContentModelImage ? ContentModelImage : T extends ContentModelEntity ? ContentModelEntity : T extends ReadonlyContentModelText ? ContentModelText : T extends ReadonlyContentModelBr ? ContentModelBr : T extends ReadonlyContentModelParagraph ? ShallowMutableContentModelParagraph : T extends ReadonlyContentModelTable ? ShallowMutableContentModelTable : T extends ReadonlyContentModelTableRow ? ContentModelTableRow : T extends ReadonlyContentModelTableCell ? ShallowMutableContentModelTableCell : T extends ReadonlyContentModelFormatContainer ? ShallowMutableContentModelFormatContainer : T extends ReadonlyContentModelListItem ? ShallowMutableContentModelListItem : T extends ReadonlyContentModelListLevel ? ContentModelListLevel : T extends ReadonlyContentModelDivider ? ContentModelDivider : T extends ReadonlyContentModelDocument ? ShallowMutableContentModelDocument : T extends ReadonlyContentModelGeneralBlock ? ShallowMutableContentModelGeneralBlock : T extends ReadonlyContentModelParagraphDecorator ? ContentModelParagraphDecorator : T extends ReadonlyContentModelLink ? ContentModelLink : T extends ReadonlyContentModelCode ? ContentModelCode : never;
+
 /**
  * The union type of 3 selection types
  */
@@ -1774,15 +2295,15 @@ export interface InsertPoint {
     /**
      * The paragraph that contains this insert point
      */
-    paragraph: ContentModelParagraph;
+    paragraph: ShallowMutableContentModelParagraph;
     /**
      * Block group path of this insert point, from direct parent group to the root group
      */
-    path: ContentModelBlockGroup[];
+    path: ReadonlyContentModelBlockGroup[];
     /**
      * Table context of this insert point
      */
-    tableContext?: TableSelectionContext;
+    tableContext?: ReadonlyTableSelectionContext;
 }
 
 /**
@@ -1807,6 +2328,28 @@ export interface TableSelectionContext {
     isWholeTableSelected: boolean;
 }
 
+/**
+ * Context object for table in a selection (Readonly)
+ */
+export interface ReadonlyTableSelectionContext {
+    /**
+     * The table that contains the selection
+     */
+    table: ReadonlyContentModelTable;
+    /**
+     * Row Index of the selected table cell
+     */
+    rowIndex: number;
+    /**
+     * Column Index of the selected table cell
+     */
+    colIndex: number;
+    /**
+     * Whether the whole table is selected
+     */
+    isWholeTableSelected: boolean;
+}
+
 /**
  * Coordinates of table selection
  */
@@ -2940,6 +3483,10 @@ export interface EditorOptions {
      * Color of the border of a selectedImage. Default color: '#DB626C'
      */
     imageSelectionBorderColor?: string;
+    /**
+     * Background color of a selected table cell. Default color: '#C6C6C6'
+     */
+    tableCellSelectionBackgroundColor?: string;
     /**
      * Initial Content Model
      */
@@ -3573,6 +4120,18 @@ export interface SelectionPluginState {
      * Color of the border of a selectedImage. Default color: '#DB626C'
      */
     imageSelectionBorderColor?: string;
+    /**
+     * Color of the border of a selectedImage in dark mode. Default color: '#DB626C'
+     */
+    imageSelectionBorderColorDark?: string;
+    /**
+     * Background color of a selected table cell. Default color: '#C6C6C6'
+     */
+    tableCellSelectionBackgroundColor?: string;
+    /**
+     * Background color of a selected table cell in dark mode. Default color: '#C6C6C6'
+     */
+    tableCellSelectionBackgroundColorDark?: string;
 }
 
 /**
@@ -4088,11 +4647,11 @@ export interface DeleteSelectionContext extends DeleteSelectionResult  {
     /**
      * Last paragraph after previous step
      */
-    lastParagraph?: ContentModelParagraph;
+    lastParagraph?: ShallowMutableContentModelParagraph;
     /**
      * Last table context after previous step
      */
-    lastTableContext?: TableSelectionContext;
+    lastTableContext?: ReadonlyTableSelectionContext;
     /**
      * Format context provided by formatContentModel API
      */
@@ -4691,6 +5250,16 @@ export interface IterateSelectionsOption {
     includeListFormatHolder?: 'anySegment' | 'allSegments' | 'never';
 }
 
+/**
+ * The callback function type for iterateSelections (Readonly)
+ * @param path The block group path of current selection
+ * @param tableContext Table context of current selection
+ * @param block Block of current selection
+ * @param segments Segments of current selection
+ * @returns True to stop iterating, otherwise keep going
+ */
+export type ReadonlyIterateSelectionsCallback = (path: ReadonlyContentModelBlockGroup[], tableContext?: ReadonlyTableSelectionContext, block?: ReadonlyContentModelBlock, segments?: ReadonlyContentModelSegment[]) => void | boolean;
+
 /**
  * A type map from node type number to its type declaration. This is used by utility function isNodeOfType()
  */
@@ -4732,7 +5301,7 @@ export interface NodeTypeMap {
 /**
  * Retrieve block group type string from a given block group
  */
-export type TypeOfBlockGroup<T extends ContentModelBlockGroup> = T extends ContentModelBlockGroupBase<infer U> ? U : never;
+export type TypeOfBlockGroup<T extends ContentModelBlockGroup | ReadonlyContentModelBlockGroup> = T extends ContentModelBlockGroupBase<infer U> | ReadonlyContentModelBlockGroupBase<infer U> ? U : never;
 
 /**
  * Represent a pair of parent block group and child block
@@ -4752,6 +5321,24 @@ export type OperationalBlocks<T extends ContentModelBlockGroup> = {
     path: ContentModelBlockGroup[];
 };
 
+/**
+ * Represent a pair of parent block group and child block (Readonly)
+ */
+export type ReadonlyOperationalBlocks<T extends ReadonlyContentModelBlockGroup> = {
+    /**
+     * The parent block group
+     */
+    parent: ReadonlyContentModelBlockGroup;
+    /**
+     * The child block
+     */
+    block: ReadonlyContentModelBlock | T;
+    /**
+     * Selection path of this block
+     */
+    path: ReadonlyContentModelBlockGroup[];
+};
+
 /**
  * Represents a parsed table with its table cells
  */
@@ -5471,13 +6058,21 @@ export function buildSelectionMarker(group: ContentModelBlockGroup, context: Dom
  * @param definition @optional Metadata definition used for verify the metadata object
  * @returns The metadata object if any, or null
  */
-export function updateMetadata<T>(model: ContentModelWithDataset<T>, callback?: (metadata: T | null) => T | null, definition?: Definition<T>): T | null;
+export function updateMetadata<T>(model: ShallowMutableContentModelWithDataset<T>, callback?: (metadata: T | null) => T | null, definition?: Definition<T>): T | null;
+
+/**
+ * Retrieve metadata from the given model.
+ * @param model The Content Model to retrieve metadata from
+ * @param definition Definition of this metadata type, used for validate the metadata object
+ * @returns Metadata of the model, or null if it does not contain a valid metadata
+ */
+export function getMetadata<T>(model: ReadonlyContentModelWithDataset<T>, definition?: Definition<T>): T | null;
 
 /**
  * Check if the given model has metadata
  * @param model The content model to check
  */
-export function hasMetadata<T>(model: ContentModelWithDataset<T> | HTMLElement): boolean;
+export function hasMetadata<T>(model: ReadonlyContentModelWithDataset<T> | HTMLElement): boolean;
 
 /**
  * Type checker for Node. Return true if it of the specified node type
@@ -5651,21 +6246,21 @@ export function normalizeRect(clientRect: DOMRect): Rect | null;
  * Create a ContentModelBr model
  * @param format @optional The format of this model
  */
-export function createBr(format?: ContentModelSegmentFormat): ContentModelBr;
+export function createBr(format?: Readonly<ContentModelSegmentFormat>): ContentModelBr;
 
 /**
  * Create a ContentModelListItem model
  * @param levels Existing list levels
  * @param format @optional The format of this model
  */
-export function createListItem(levels: ContentModelListLevel[], format?: ContentModelSegmentFormat): ContentModelListItem;
+export function createListItem(levels: ReadonlyArray<ReadonlyContentModelListLevel>, format?: Readonly<ContentModelSegmentFormat>): ContentModelListItem;
 
 /**
  * Create a ContentModelFormatContainer model
  * @param tag Tag name of this format container, in lower case
  * @param format @optional The format of this model
  */
-export function createFormatContainer(tag: Lowercase<string>, format?: ContentModelFormatContainerFormat): ContentModelFormatContainer;
+export function createFormatContainer(tag: Lowercase<string>, format?: Readonly<ContentModelFormatContainerFormat>): ContentModelFormatContainer;
 
 /**
  * Create a ContentModelParagraph model
@@ -5674,20 +6269,20 @@ export function createFormatContainer(tag: Lowercase<string>, format?: ContentMo
  * @param segmentFormat @optional Segment format applied to this block
  * @param decorator @optional Decorator of this paragraph
  */
-export function createParagraph(isImplicit?: boolean, blockFormat?: ContentModelBlockFormat, segmentFormat?: ContentModelSegmentFormat, decorator?: ContentModelParagraphDecorator): ContentModelParagraph;
+export function createParagraph(isImplicit?: boolean, blockFormat?: Readonly<ContentModelBlockFormat>, segmentFormat?: Readonly<ContentModelSegmentFormat>, decorator?: ReadonlyContentModelParagraphDecorator): ContentModelParagraph;
 
 /**
  * Create a ContentModelSelectionMarker model
  * @param format @optional The format of this model
  */
-export function createSelectionMarker(format?: ContentModelSegmentFormat): ContentModelSelectionMarker;
+export function createSelectionMarker(format?: Readonly<ContentModelSegmentFormat>): ContentModelSelectionMarker;
 
 /**
  * Create a ContentModelTable model
  * @param rowCount Count of rows of this table
  * @param format @optional The format of this model
  */
-export function createTable(rowCount: number, format?: ContentModelTableFormat): ContentModelTable;
+export function createTable(rowCount: number, format?: Readonly<ContentModelTableFormat>): ContentModelTable;
 
 /**
  * Create a ContentModelTableCell model
@@ -5696,7 +6291,7 @@ export function createTable(rowCount: number, format?: ContentModelTableFormat):
  * @param isHeader @optional Whether this is a header cell @default false
  * @param format @optional The format of this model
  */
-export function createTableCell(spanLeftOrColSpan?: boolean | number, spanAboveOrRowSpan?: boolean | number, isHeader?: boolean, format?: ContentModelTableCellFormat, dataset?: DatasetFormat): ContentModelTableCell;
+export function createTableCell(spanLeftOrColSpan?: boolean | number, spanAboveOrRowSpan?: boolean | number, isHeader?: boolean, format?: Readonly<ContentModelTableCellFormat>, dataset?: ReadonlyDatasetFormat): ContentModelTableCell;
 
 /**
  * Create a ContentModelText model
@@ -5705,34 +6300,34 @@ export function createTableCell(spanLeftOrColSpan?: boolean | number, spanAboveO
  * @param link @optional The link decorator
  * @param code @option The code decorator
  */
-export function createText(text: string, format?: ContentModelSegmentFormat, link?: ContentModelLink, code?: ContentModelCode): ContentModelText;
+export function createText(text: string, format?: Readonly<ContentModelSegmentFormat>, link?: ReadonlyContentModelLink, code?: ReadonlyContentModelCode): ContentModelText;
 
 /**
  * Create a ContentModelImage model
  * @param src Image source
  * @param format @optional The format of this model
  */
-export function createImage(src: string, format?: ContentModelImageFormat): ContentModelImage;
+export function createImage(src: string, format?: Readonly<ContentModelImageFormat>): ContentModelImage;
 
 /**
  * Create a ContentModelDocument model
  * @param defaultFormat @optional Default format of this model
  */
-export function createContentModelDocument(defaultFormat?: ContentModelSegmentFormat): ContentModelDocument;
+export function createContentModelDocument(defaultFormat?: Readonly<ContentModelSegmentFormat>): ContentModelDocument;
 
 /**
  * Create a ContentModelParagraphDecorator model
  * @param tagName Tag name of this decorator
  * @param format @optional The format of this model
  */
-export function createParagraphDecorator(tagName: string, format?: ContentModelSegmentFormat): ContentModelParagraphDecorator;
+export function createParagraphDecorator(tagName: string, format?: Readonly<ContentModelSegmentFormat>): ContentModelParagraphDecorator;
 
 /**
  * Create a ContentModelGeneralSegment model
  * @param element The original DOM element
  * @param format @optional The format of this model
  */
-export function createGeneralSegment(element: HTMLElement, format?: ContentModelSegmentFormat): ContentModelGeneralSegment;
+export function createGeneralSegment(element: HTMLElement, format?: Readonly<ContentModelSegmentFormat>): ContentModelGeneralSegment;
 
 /**
  * Create a ContentModelGeneralBlock model
@@ -5748,14 +6343,14 @@ export function createGeneralBlock(element: HTMLElement): ContentModelGeneralBlo
  * @param type @optional Type of this entity
  * @param id @optional Id of this entity
  */
-export function createEntity(wrapper: HTMLElement, isReadonly?: boolean, segmentFormat?: ContentModelSegmentFormat, type?: string, id?: string): ContentModelEntity;
+export function createEntity(wrapper: HTMLElement, isReadonly?: boolean, segmentFormat?: Readonly<ContentModelSegmentFormat>, type?: string, id?: string): ContentModelEntity;
 
 /**
  * Create a ContentModelDivider model
  * @param tagName Tag name of this divider. Currently only hr and div are supported
  * @param format @optional The format of this model
  */
-export function createDivider(tagName: 'hr' | 'div', format?: ContentModelBlockFormat): ContentModelDivider;
+export function createDivider(tagName: 'hr' | 'div', format?: Readonly<ContentModelBlockFormat>): ContentModelDivider;
 
 /**
  * Create a ContentModelListLevel model
@@ -5763,27 +6358,56 @@ export function createDivider(tagName: 'hr' | 'div', format?: ContentModelBlockF
  * @param format @optional The format of this model
  * @param dataset @optional The dataset of this model
  */
-export function createListLevel(listType: 'OL' | 'UL', format?: ContentModelListItemLevelFormat, dataset?: DatasetFormat): ContentModelListLevel;
+export function createListLevel(listType: 'OL' | 'UL', format?: Readonly<ContentModelListItemLevelFormat>, dataset?: ReadonlyDatasetFormat): ContentModelListLevel;
 
 /**
  * Create an empty Content Model Document with initial empty line and insert point with default format
  * @param format @optional The default format to be applied to this Content Model
  */
-export function createEmptyModel(format?: ContentModelSegmentFormat): ContentModelDocument;
+export function createEmptyModel(format?: Readonly<ContentModelSegmentFormat>): ContentModelDocument;
+
+/**
+ * Create a ContentModelTableRow model
+ * @param format @optional The format of this model
+ */
+export function createTableRow(format?: Readonly<ContentModelBlockFormat>, height?: number): ContentModelTableRow;
+
+/**
+ * Convert a readonly block to mutable block, clear cached element if exist
+ * @param block The block to convert from
+ * @returns The same block object of its related mutable type
+ */
+export function mutateBlock<T extends ReadonlyContentModelBlockGroup | ReadonlyContentModelBlock>(block: T): MutableType<T>;
+
+/**
+ * Convert segments of a readonly paragraph to be mutable.
+ * Segments that are not belong to the given paragraph will be skipped
+ * @param paragraph The readonly paragraph to convert from
+ * @param segments The segments to convert from
+ */
+export function mutateSegments(paragraph: ReadonlyContentModelParagraph, segments: ReadonlyContentModelSegment[]): [ShallowMutableContentModelParagraph, ShallowMutableContentModelSegment[], number[]];
+
+/**
+ * Convert a readonly segment to be mutable, together with its owner paragraph
+ * If the segment does not belong to the given paragraph, return null for the segment
+ * @param paragraph The readonly paragraph to convert from
+ * @param segment The segment to convert from
+ */
+export function mutateSegment<T extends ReadonlyContentModelSegment>(paragraph: ReadonlyContentModelParagraph, segment: T, callback?: (segment: MutableType<T>, paragraph: ShallowMutableContentModelParagraph, index: number) => void): [ShallowMutableContentModelParagraph, MutableType<T> | null, number];
 
 /**
  * Add a given block to block group
  * @param group The block group to add block into
  * @param block The block to add
  */
-export function addBlock(group: ContentModelBlockGroup, block: ContentModelBlock): void;
+export function addBlock(group: ShallowMutableContentModelBlockGroup, block: ShallowMutableContentModelBlock): void;
 
 /**
  * Add a code decorator into segment if any
  * @param segment The segment to add decorator to
  * @param code The code decorator to add
  */
-export function addCode(segment: ContentModelSegment, code: ContentModelCode): void;
+export function addCode(segment: ShallowMutableContentModelSegment, code: ReadonlyContentModelCode): void;
 
 /**
  * Add a new text segment to current paragraph
@@ -5798,7 +6422,7 @@ export function addTextSegment(group: ContentModelBlockGroup, text: string, cont
  * @param paragraph The paragraph to normalize
  * Normalize a paragraph. If it is empty, add a BR segment to make sure it can insert content
  */
-export function normalizeParagraph(paragraph: ContentModelParagraph): void;
+export function normalizeParagraph(paragraph: ReadonlyContentModelParagraph): void;
 
 /**
  * For a given content model, normalize it to make the model be consistent.
@@ -5809,7 +6433,7 @@ export function normalizeParagraph(paragraph: ContentModelParagraph): void;
  * - For an empty block, remove it
  * @param group The root level block group of content model to normalize
  */
-export function normalizeContentModel(group: ContentModelBlockGroup): void;
+export function normalizeContentModel(group: ReadonlyContentModelBlockGroup): void;
 
 /**
  * Check if the given block group is a general segment
@@ -5817,12 +6441,24 @@ export function normalizeContentModel(group: ContentModelBlockGroup): void;
  */
 export function isGeneralSegment(group: ContentModelBlockGroup | ContentModelGeneralSegment): group is ContentModelGeneralSegment;
 
+/**
+ * Check if the given block group is a general segment (Shallow mutable)
+ * @param group The group to check
+ */
+export function isGeneralSegment(group: ShallowMutableContentModelBlockGroup | ShallowMutableContentModelGeneralSegment): group is ShallowMutableContentModelGeneralSegment;
+
+/**
+ * Check if the given block group is a general segment (Readonly)
+ * @param group The group to check
+ */
+export function isGeneralSegment(group: ReadonlyContentModelBlockGroup | ReadonlyContentModelGeneralSegment): group is ReadonlyContentModelGeneralSegment;
+
 /**
  * Unwrap a given block group, move its child blocks to be under its parent group
  * @param parent Parent block group of the unwrapping group
  * @param groupToUnwrap  The block group to unwrap
  */
-export function unwrapBlock(parent: ContentModelBlockGroup | null, groupToUnwrap: ContentModelBlockGroup & ContentModelBlock): void;
+export function unwrapBlock(parent: ReadonlyContentModelBlockGroup | null, groupToUnwrap: ReadonlyContentModelBlockGroup & ReadonlyContentModelBlock): void;
 
 /**
  * Add a given segment into a paragraph from its parent group. If the last block of the given group is not paragraph, create a new paragraph.
@@ -5833,24 +6469,33 @@ export function unwrapBlock(parent: ContentModelBlockGroup | null, groupToUnwrap
  */
 export function addSegment(group: ContentModelBlockGroup, newSegment: ContentModelSegment, blockFormat?: ContentModelBlockFormat, segmentFormat?: ContentModelSegmentFormat): ContentModelParagraph;
 
+/**
+ * Add a given segment into a paragraph from its parent group. If the last block of the given group is not paragraph, create a new paragraph. (Shallow mutable)
+ * @param group The parent block group of the paragraph to add segment into
+ * @param newSegment The segment to add
+ * @param blockFormat The block format used for creating a new paragraph when need
+ * @returns The parent paragraph where the segment is added to
+ */
+export function addSegment(group: ShallowMutableContentModelBlockGroup, newSegment: ContentModelSegment, blockFormat?: ContentModelBlockFormat, segmentFormat?: ContentModelSegmentFormat): ShallowMutableContentModelParagraph;
+
 /**
  * Get whether the model is empty.
  * @returns true if the model is empty.
  */
-export function isEmpty(model: ContentModelBlock | ContentModelBlockGroup | ContentModelSegment): boolean;
+export function isEmpty(model: ReadonlyContentModelBlock | ReadonlyContentModelBlockGroup | ReadonlyContentModelSegment): boolean;
 
 /**
  * Normalize a given segment, make sure its spaces are correctly represented by space and non-break space
  * @param segment The segment to normalize
  * @param ignoreTrailingSpaces Whether we should ignore the trailing space of the text segment @default false
  */
-export function normalizeSingleSegment(segment: ContentModelSegment, ignoreTrailingSpaces?: boolean): void;
+export function normalizeSingleSegment(paragraph: ReadonlyContentModelParagraph, segment: ReadonlyContentModelSegment, ignoreTrailingSpaces?: boolean): void;
 
 /**
  * For a given block, if it is a paragraph, set it to be not-implicit
  * @param block The block to check
  */
-export function setParagraphNotImplicit(block: ContentModelBlock): void;
+export function setParagraphNotImplicit(block: ReadonlyContentModelBlock): void;
 
 /**
  * Get the list number for a list item according to list style type and its index number
@@ -6080,13 +6725,20 @@ export function cacheGetEventData<T, E extends PluginEvent>(event: E, key: strin
  */
 export function isBlockGroupOfType<T extends ContentModelBlockGroup>(input: ContentModelBlock | ContentModelBlockGroup | null | undefined, type: TypeOfBlockGroup<T>): input is T;
 
+/**
+ * Check if the given content model block or block group is of the expected block group type (Readonly)
+ * @param input The object to check
+ * @param type The expected type
+ */
+export function isBlockGroupOfType<T extends ReadonlyContentModelBlockGroup>(input: ReadonlyContentModelBlock | ReadonlyContentModelBlockGroup | null | undefined, type: TypeOfBlockGroup<T>): input is T;
+
 /**
  * Get index of closest ancestor block group of the expected block group type. If not found, return -1
  * @param path The block group path, from the closest one to root
  * @param blockGroupTypes The expected block group types
  * @param stopTypes @optional Block group types that will cause stop searching
  */
-export function getClosestAncestorBlockGroupIndex<T extends ContentModelBlockGroup>(path: ContentModelBlockGroup[], blockGroupTypes: TypeOfBlockGroup<T>[], stopTypes?: ContentModelBlockGroupType[]): number;
+export function getClosestAncestorBlockGroupIndex<T extends ContentModelBlockGroup>(path: ReadonlyContentModelBlockGroup[], blockGroupTypes: TypeOfBlockGroup<T>[], stopTypes?: ContentModelBlockGroupType[]): number;
 
 /**
  * Iterate all selected elements in a given model
@@ -6096,18 +6748,38 @@ export function getClosestAncestorBlockGroupIndex<T extends ContentModelBlockGro
  */
 export function iterateSelections(group: ContentModelBlockGroup, callback: IterateSelectionsCallback, option?: IterateSelectionsOption): void;
 
+/**
+ * Iterate all selected elements in a given model (Readonly)
+ * @param group The given Content Model to iterate selection from
+ * @param callback The callback function to access the selected element
+ * @param option Option to determine how to iterate
+ */
+export function iterateSelections(group: ReadonlyContentModelBlockGroup, callback: ReadonlyIterateSelectionsCallback, option?: IterateSelectionsOption): void;
+
 /**
  * Get the first selected list item from content model
  * @param model The Content Model to get selection from
  */
 export function getFirstSelectedListItem(model: ContentModelDocument): ContentModelListItem | undefined;
 
+/**
+ * Get the first selected list item from content model (Readonly)
+ * @param model The Content Model to get selection from
+ */
+export function getFirstSelectedListItem(model: ReadonlyContentModelDocument): ReadonlyContentModelListItem | undefined;
+
 /**
  * Get the first selected table from content model
  * @param model The Content Model to get selection from
  */
 export function getFirstSelectedTable(model: ContentModelDocument): [ContentModelTable | undefined, ContentModelBlockGroup[]];
 
+/**
+ * Get the first selected table from content model (Readonly)
+ * @param model The Content Model to get selection from
+ */
+export function getFirstSelectedTable(model: ReadonlyContentModelDocument): [ReadonlyContentModelTable | undefined, ReadonlyContentModelBlockGroup[]];
+
 /**
  * Get an array of block group - block pair that is of the expected block group type from selection
  * @param group The root block group to search
@@ -6117,12 +6789,34 @@ export function getFirstSelectedTable(model: ContentModelDocument): [ContentMode
  */
 export function getOperationalBlocks<T extends ContentModelBlockGroup>(group: ContentModelBlockGroup, blockGroupTypes: TypeOfBlockGroup<T>[], stopTypes: ContentModelBlockGroupType[], deepFirst?: boolean): OperationalBlocks<T>[];
 
+/**
+ * Get an array of block group - block pair that is of the expected block group type from selection (Readonly)
+ * @param group The root block group to search
+ * @param blockGroupTypes The expected block group types
+ * @param stopTypes Block group types that will stop searching when hit
+ * @param deepFirst True means search in deep first, otherwise wide first
+ */
+export function getOperationalBlocks<T extends ReadonlyContentModelBlockGroup>(group: ReadonlyContentModelBlockGroup, blockGroupTypes: TypeOfBlockGroup<T>[], stopTypes: ContentModelBlockGroupType[], deepFirst?: boolean): ReadonlyOperationalBlocks<T>[];
+
 /**
  * Get any array of selected paragraphs from a content model
  * @param model The Content Model to get selection from
  */
 export function getSelectedParagraphs(model: ContentModelDocument): ContentModelParagraph[];
 
+/**
+ * Get any array of selected paragraphs from a content model, return mutable paragraphs
+ * @param model The Content Model to get selection from
+ * @param mutate Set to true to indicate we will mutate the selected paragraphs
+ */
+export function getSelectedParagraphs(model: ReadonlyContentModelDocument, mutate: true): ShallowMutableContentModelParagraph[];
+
+/**
+ * Get any array of selected paragraphs from a content model (Readonly)
+ * @param model The Content Model to get selection from
+ */
+export function getSelectedParagraphs(model: ReadonlyContentModelDocument): ReadonlyContentModelParagraph[];
+
 /**
  * Get an array of selected segments from a content model
  * @param model The Content Model to get selection from
@@ -6130,36 +6824,77 @@ export function getSelectedParagraphs(model: ContentModelDocument): ContentModel
  */
 export function getSelectedSegments(model: ContentModelDocument, includingFormatHolder: boolean): ContentModelSegment[];
 
+/**
+ * Get an array of selected segments from a content model, return mutable segments
+ * @param model The Content Model to get selection from
+ * @param includingFormatHolder True means also include format holder as segment from list item
+ * @param mutate Set to true to indicate we will mutate the selected paragraphs
+ */
+export function getSelectedSegments(model: ReadonlyContentModelDocument, includingFormatHolder: boolean, mutate: true): ShallowMutableContentModelSegment[];
+
+/**
+ * Get an array of selected segments from a content model (Readonly)
+ * @param model The Content Model to get selection from
+ * @param includingFormatHolder True means also include format holder as segment from list item
+ */
+export function getSelectedSegments(model: ReadonlyContentModelDocument, includingFormatHolder: boolean): ReadonlyContentModelSegment[];
+
 /**
  * Get an array of selected parent paragraph and child segment pair
  * @param model The Content Model to get selection from
  * @param includingFormatHolder True means also include format holder as segment from list item, in that case paragraph will be null
+ * @param includingEntity True to include entity in result as well
  */
 export function getSelectedSegmentsAndParagraphs(model: ContentModelDocument, includingFormatHolder: boolean, includingEntity?: boolean): [ContentModelSegment, ContentModelParagraph | null, ContentModelBlockGroup[]][];
 
+/**
+ * Get an array of selected parent paragraph and child segment pair, return mutable paragraph and segments
+ * @param model The Content Model to get selection from
+ * @param includingFormatHolder True means also include format holder as segment from list item, in that case paragraph will be null
+ * @param includingEntity True to include entity in result as well
+ * @param mutate Set to true to indicate we will mutate the selected paragraphs
+ */
+export function getSelectedSegmentsAndParagraphs(model: ReadonlyContentModelDocument, includingFormatHolder: boolean, includingEntity: boolean, mutate: true): [
+    ShallowMutableContentModelSegment,
+    ContentModelParagraph | null,
+    ReadonlyContentModelBlockGroup[]
+][];
+
+/**
+ * Get an array of selected parent paragraph and child segment pair (Readonly)
+ * @param model The Content Model to get selection from
+ * @param includingFormatHolder True means also include format holder as segment from list item, in that case paragraph will be null
+ * @param includingEntity True to include entity in result as well
+ */
+export function getSelectedSegmentsAndParagraphs(model: ReadonlyContentModelDocument, includingFormatHolder: boolean, includingEntity?: boolean): [
+    ReadonlyContentModelSegment,
+    ReadonlyContentModelParagraph | null,
+    ReadonlyContentModelBlockGroup[]
+][];
+
 /**
  * Get selection coordinates of a table. If there is no selection, return null
  * @param table The table model to get selection from
  */
-export function getSelectedCells(table: ContentModelTable): TableSelectionCoordinates | null;
+export function getSelectedCells(table: ReadonlyContentModelTable): TableSelectionCoordinates | null;
 
 /**
  * Check if there is selection within the given block
  * @param block The block to check
  */
-export function hasSelectionInBlock(block: ContentModelBlock): boolean;
+export function hasSelectionInBlock(block: ReadonlyContentModelBlock): boolean;
 
 /**
  * Check if there is selection within the given segment
  * @param segment The segment to check
  */
-export function hasSelectionInSegment(segment: ContentModelSegment): boolean;
+export function hasSelectionInSegment(segment: ReadonlyContentModelSegment): boolean;
 
 /**
  * Check if there is selection within the given block
  * @param block The block to check
  */
-export function hasSelectionInBlockGroup(group: ContentModelBlockGroup): boolean;
+export function hasSelectionInBlockGroup(group: ReadonlyContentModelBlockGroup): boolean;
 
 /**
  * Set selection into Content Model. If the Content Model already has selection, existing selection will be overwritten by the new one.
@@ -6167,14 +6902,14 @@ export function hasSelectionInBlockGroup(group: ContentModelBlockGroup): boolean
  * @param start The start selected element. If not passed, existing selection of content model will be cleared
  * @param end The end selected element. If not passed, only the start element will be selected. If passed, all elements between start and end elements will be selected
  */
-export function setSelection(group: ContentModelBlockGroup, start?: Selectable, end?: Selectable): void;
+export function setSelection(group: ReadonlyContentModelBlockGroup, start?: ReadonlySelectable, end?: ReadonlySelectable): void;
 
 /**
  * Clone a content model
  * @param model The content model to clone
  * @param options @optional Options to specify customize the clone behavior
  */
-export function cloneModel(model: ContentModelDocument, options?: CloneModelOptions): ContentModelDocument;
+export function cloneModel(model: ReadonlyContentModelDocument, options?: CloneModelOptions): ContentModelDocument;
 
 /**
  * Merge source model into target mode
@@ -6184,7 +6919,7 @@ export function cloneModel(model: ContentModelDocument, options?: CloneModelOpti
  * @param options More options, see MergeModelOption
  * @returns Insert point after merge, or null if there is no insert point
  */
-export function mergeModel(target: ContentModelDocument, source: ContentModelDocument, context?: FormatContentModelContext, options?: MergeModelOption): InsertPoint | null;
+export function mergeModel(target: ReadonlyContentModelDocument, source: ContentModelDocument, context?: FormatContentModelContext, options?: MergeModelOption): InsertPoint | null;
 
 /**
  * Delete selected content from Content Model
@@ -6193,17 +6928,17 @@ export function mergeModel(target: ContentModelDocument, source: ContentModelDoc
  * @param formatContext @optional A context object provided by formatContentModel API
  * @returns A DeleteSelectionResult object to specify the deletion result
  */
-export function deleteSelection(model: ContentModelDocument, additionalSteps?: (DeleteSelectionStep | null)[], formatContext?: FormatContentModelContext): DeleteSelectionResult;
+export function deleteSelection(model: ReadonlyContentModelDocument, additionalSteps?: (DeleteSelectionStep | null)[], formatContext?: FormatContentModelContext): DeleteSelectionResult;
 
 /**
  * Delete a content model segment from current selection
- * @param paragraph Parent paragraph of the segment to delete
- * @param segmentToDelete The segment to delete
+ * @param readonlyParagraph Parent paragraph of the segment to delete
+ * @param readonlySegmentToDelete The segment to delete
  * @param context @optional Context object provided by formatContentModel API
  * @param direction @optional Whether this is deleting forward or backward. This is only used for deleting entity.
  * If not specified, only selected entity will be deleted
  */
-export function deleteSegment(paragraph: ContentModelParagraph, segmentToDelete: ContentModelSegment, context?: FormatContentModelContext, direction?: 'forward' | 'backward'): boolean;
+export function deleteSegment(readonlyParagraph: ReadonlyContentModelParagraph, readonlySegmentToDelete: ReadonlyContentModelSegment, context?: FormatContentModelContext, direction?: 'forward' | 'backward'): boolean;
 
 /**
  * Delete a content model block from current selection
@@ -6214,7 +6949,7 @@ export function deleteSegment(paragraph: ContentModelParagraph, segmentToDelete:
  * @param direction @optional Whether this is deleting forward or backward. This is only used for deleting entity.
  * If not specified, only selected entity will be deleted
  */
-export function deleteBlock(blocks: ContentModelBlock[], blockToDelete: ContentModelBlock, replacement?: ContentModelBlock, context?: FormatContentModelContext, direction?: 'forward' | 'backward'): boolean;
+export function deleteBlock(blocks: ReadonlyContentModelBlock[], blockToDelete: ReadonlyContentModelBlock, replacement?: ReadonlyContentModelBlock, context?: FormatContentModelContext, direction?: 'forward' | 'backward'): boolean;
 
 /**
  * Apply table format from table metadata and the passed in new format
@@ -6222,20 +6957,27 @@ export function deleteBlock(blocks: ContentModelBlock[], blockToDelete: ContentM
  * @param newFormat @optional New format to apply. When passed, this value will be merged into existing metadata format and default format
  * @param keepCellShade @optional When pass true, table cells with customized shade color will not be overwritten. @default false
  */
-export function applyTableFormat(table: ContentModelTable, newFormat?: TableMetadataFormat, keepCellShade?: boolean): void;
+export function applyTableFormat(table: ReadonlyContentModelTable, newFormat?: TableMetadataFormat, keepCellShade?: boolean): void;
+
+/**
+ * Set the first column format borders for the table as well as header property
+ * @param rows The rows of the table
+ * @param format The table metadata format
+ */
+export function setFirstColumnFormatBorders(rows: ShallowMutableContentModelTableRow[], format: Partial<TableMetadataFormat>): void;
 
 /**
  * Normalize a Content Model table, make sure:
  * 1. Fist cells are not spanned
- * 2. Inner cells are not header
+ * 2. Only first column and row can have headers
  * 3. All cells have content and width
  * 4. Table and table row have correct width/height
  * 5. Spanned cell has no child blocks
  * 6. default format is correctly applied
- * @param table The table to normalize
+ * @param readonlyTable The table to normalize
  * @param defaultSegmentFormat @optional Default segment format to apply to cell
  */
-export function normalizeTable(table: ContentModelTable, defaultSegmentFormat?: ContentModelSegmentFormat): void;
+export function normalizeTable(readonlyTable: ReadonlyContentModelTable, defaultSegmentFormat?: ContentModelSegmentFormat): void;
 
 /**
  * Minimum width for a table cell
@@ -6249,7 +6991,7 @@ export const MIN_ALLOWED_TABLE_CELL_WIDTH: number;
  * @param isColorOverride @optional When pass true, it means this shade color is not part of table format, so it can be preserved when apply table format
  * @param applyToSegments @optional When pass true, we will also apply text color from table cell to its child blocks and segments
  */
-export function setTableCellBackgroundColor(cell: ContentModelTableCell, color: string | null | undefined, isColorOverride?: boolean, applyToSegments?: boolean): void;
+export function setTableCellBackgroundColor(cell: ShallowMutableContentModelTableCell, color: string | null | undefined, isColorOverride?: boolean, applyToSegments?: boolean): void;
 
 /**
  * Retrieve format state from the given Content Model
@@ -6257,7 +6999,7 @@ export function setTableCellBackgroundColor(cell: ContentModelTableCell, color:
  * @param pendingFormat Existing pending format, if any
  * @param formatState Existing format state object, used for receiving the result
  */
-export function retrieveModelFormatState(model: ContentModelDocument, pendingFormat: ContentModelSegmentFormat | null, formatState: ContentModelFormatState): void;
+export function retrieveModelFormatState(model: ReadonlyContentModelDocument, pendingFormat: ContentModelSegmentFormat | null, formatState: ContentModelFormatState): void;
 
 /**
  * Gets the list style type that the bullet is part of, using the Constant record
@@ -6272,7 +7014,7 @@ export function getListStyleTypeFromString(listType: 'OL' | 'UL', bullet: string
  * @param segment The segment to get format from
  * @returns
  */
-export function getSegmentTextFormat(segment: ContentModelSegment): ContentModelSegmentFormat;
+export function getSegmentTextFormat(segment: ReadonlyContentModelSegment): ContentModelSegmentFormat;
 
 /**
  * Update image metadata with a callback
@@ -6281,26 +7023,50 @@ export function getSegmentTextFormat(segment: ContentModelSegment): ContentModel
  */
 export function updateImageMetadata(image: ContentModelImage, callback?: (format: ImageMetadataFormat | null) => ImageMetadataFormat | null): ImageMetadataFormat | null;
 
+/**
+ * Get image metadata
+ * @param image The image Content Model
+ */
+export function getImageMetadata(image: ReadonlyContentModelImage): ImageMetadataFormat | null;
+
 /**
  * Update table cell metadata with a callback
  * @param cell The table cell Content Model
  * @param callback The callback function used for updating metadata
  */
-export function updateTableCellMetadata(cell: ContentModelTableCell, callback?: (format: TableCellMetadataFormat | null) => TableCellMetadataFormat | null): TableCellMetadataFormat | null;
+export function updateTableCellMetadata(cell: ShallowMutableContentModelTableCell, callback?: (format: TableCellMetadataFormat | null) => TableCellMetadataFormat | null): TableCellMetadataFormat | null;
+
+/**
+ * Get table cell metadata
+ * @param cell The table cell Content Model
+ */
+export function getTableCellMetadata(cell: ReadonlyContentModelTableCell): TableCellMetadataFormat | null;
 
 /**
  * Update table metadata with a callback
  * @param table The table Content Model
  * @param callback The callback function used for updating metadata
  */
-export function updateTableMetadata(table: ContentModelTable, callback?: (format: TableMetadataFormat | null) => TableMetadataFormat | null): TableMetadataFormat | null;
+export function updateTableMetadata(table: ShallowMutableContentModelTable, callback?: (format: TableMetadataFormat | null) => TableMetadataFormat | null): TableMetadataFormat | null;
+
+/**
+ * Get table metadata
+ * @param table The table Content Model
+ */
+export function getTableMetadata(table: ReadonlyContentModelTable): TableMetadataFormat | null;
 
 /**
  * Update list metadata with a callback
  * @param list The list Content Model (metadata holder)
  * @param callback The callback function used for updating metadata
  */
-export function updateListMetadata(list: ContentModelWithDataset<ListMetadataFormat>, callback?: (format: ListMetadataFormat | null) => ListMetadataFormat | null): ListMetadataFormat | null;
+export function updateListMetadata(list: ShallowMutableContentModelWithDataset<ListMetadataFormat>, callback?: (format: ListMetadataFormat | null) => ListMetadataFormat | null): ListMetadataFormat | null;
+
+/**
+ * Get list metadata
+ * @param list The list Content Model (metadata holder)
+ */
+export function getListMetadata(list: ReadonlyContentModelWithDataset<ListMetadataFormat>): ListMetadataFormat | null;
 
 /**
  * Metadata definition for List
@@ -7266,19 +8032,26 @@ export function setModelListStyle(model: ContentModelDocument, style: ListMetada
 export function setModelListStartNumber(model: ContentModelDocument, value: number): boolean;
 
 /**
+ * Search for all list items in the same thread as the current list item
  * @param model The content model
  * @param currentItem The current list item
- * Search for all list items in the same thread as the current list item
  */
 export function findListItemsInSameThread(group: ContentModelBlockGroup, currentItem: ContentModelListItem): ContentModelListItem[];
 
+/**
+ * Search for all list items in the same thread as the current list item (Readonly)
+ * @param model The content model
+ * @param currentItem The current list item
+ */
+export function findListItemsInSameThread(group: ReadonlyContentModelBlockGroup, currentItem: ReadonlyContentModelListItem): ReadonlyContentModelListItem[];
+
 /**
  * @param model The content model to set indentation
  * @param indentation The indentation type, 'indent' to indent, 'outdent' to outdent
  * @param length The length of indentation in pixel, default value is 40
  * Set indentation for selected list items or paragraphs
  */
-export function setModelIndentation(model: ContentModelDocument, indentation: 'indent' | 'outdent', length?: number, context?: FormatContentModelContext): boolean;
+export function setModelIndentation(model: ReadonlyContentModelDocument, indentation: 'indent' | 'outdent', length?: number, context?: FormatContentModelContext): boolean;
 
 /**
  * Try to match a given string with link match rules, return matched link
@@ -7297,7 +8070,7 @@ export function matchLink(url: string): LinkData | null;
  * @param path Content model path that include the list item
  * @returns Announce data of current list item if any, or null
  */
-export function getListAnnounceData(path: ContentModelBlockGroup[]): AnnounceData | null;
+export function getListAnnounceData(path: ReadonlyContentModelBlockGroup[]): AnnounceData | null;
 
 /**
  * TableEdit plugin, provides the ability to resize a table by drag-and-drop
@@ -7413,6 +8186,7 @@ export class EditPlugin implements EditorPlugin  {
     private editor;
     private disposer;
     private shouldHandleNextInputEvent;
+    private selectionAfterDelete;
     /**
      * Get name of this plugin
      */