devexpress-richedit 24.1.1-alpha-24085-0102 → 24.1.2-beta

package/lib/common/model/document-model.js

@@ -34,10 +34,12 @@ import { FindReplaceHelper, FindReplaceState, SearchDirection } from './find-rep
 import { AnchoredPictureRun } from './runs/anchored-picture-run';
 import { InlinePictureRun } from './runs/inline-picture-run';
 import { SubDocumentCollection } from './sub-document-collection';
+import { NotePosition, NoteSeparators } from './footnotes/footnote';
 export class DocumentModel {
     constructor(modelOptions, subDocumentsIdCounter = 1) {
         this.mirrorMargins = false;
         this.aspxIsDocumentProtectionEnabled = false;
+        this.documentEndNotePosition = NotePosition.EndOfDocument;
         this.sections = [];
         this.headers = [];
         this.footers = [];
@@ -52,6 +54,8 @@ export class DocumentModel {
         this.numberingLists = [];
         this.abstractNumberingListsIdProvider = new AbstractNumberingListIdProvider(this);
         this.numberingListsIdProvider = new NumberingListIdProvider(this);
+        this.footNoteSeparators = new NoteSeparators(this);
+        this.endNoteSeparators = new NoteSeparators(this);
         this.repositoryBorderItem = new BorderInfo();
         this.compatSettings = [];
         this.subDocumentsIdCounter = -1;
@@ -69,7 +73,6 @@ export class DocumentModel {
         this.compatibilitySettings = new CompatibilitySettings();
         this.docVariables = new DocumentVariables();
     }
-    ;
     get subDocuments() {
         return this.subDocumentsCollection.filteredCollection;
     }

package/lib/common/model/enums.d.ts

@@ -2,5 +2,7 @@ export declare enum SubDocumentInfoType {
     Main = 0,
     Header = 1,
     Footer = 2,
-    TextBox = 3
+    TextBox = 3,
+    FootNote = 4,
+    EndNote = 5
 }

package/lib/common/model/enums.js

@@ -4,4 +4,6 @@ export var SubDocumentInfoType;
     SubDocumentInfoType[SubDocumentInfoType["Header"] = 1] = "Header";
     SubDocumentInfoType[SubDocumentInfoType["Footer"] = 2] = "Footer";
     SubDocumentInfoType[SubDocumentInfoType["TextBox"] = 3] = "TextBox";
+    SubDocumentInfoType[SubDocumentInfoType["FootNote"] = 4] = "FootNote";
+    SubDocumentInfoType[SubDocumentInfoType["EndNote"] = 5] = "EndNote";
 })(SubDocumentInfoType || (SubDocumentInfoType = {}));

package/lib/common/model/footnotes/footnote.d.ts

@@ -0,0 +1,46 @@
+import { ICloneable, ISupportCopyFrom } from "@devexpress/utils/lib/types";
+import { NumberingFormat } from "../numbering-lists/list-level-properties";
+import { DocumentModel } from "../document-model";
+import { SubDocument } from "../sub-document";
+export declare enum NotePosition {
+    BottomOfPage = 0,
+    BelowText = 1,
+    EndOfDocument = 2,
+    EndOfSection = 3
+}
+export declare enum NoteType {
+    Separator = 0,
+    ContinuationSeparator = 1,
+    ContinuationNotice = 2,
+    Normal = 3
+}
+export declare type NoteSeparatorTypes = NoteType.Separator | NoteType.ContinuationSeparator | NoteType.ContinuationNotice;
+export declare enum NoteNumberingRestartType {
+    Continuous = 0,
+    NewPage = 1,
+    NewSection = 2
+}
+export declare class NoteProperties implements ICloneable<NoteProperties>, ISupportCopyFrom<NoteProperties> {
+    static createDefault(): NoteProperties;
+    position: NotePosition;
+    numberingFormat: NumberingFormat;
+    numberingRestartType: NoteNumberingRestartType;
+    startingNumber: number;
+    columnCount: number;
+    copyFrom(obj: NoteProperties): void;
+    clone(): NoteProperties;
+    equals(other: NoteProperties): boolean;
+}
+export declare class NoteSeparators {
+    private model;
+    separatorId: number;
+    continuationSeparatorId: number;
+    continuationNoticeId: number;
+    constructor(model: DocumentModel);
+    get separator(): SubDocument;
+    get continuationSeparator(): SubDocument;
+    get continuationNotice(): SubDocument;
+    setSeparator(sudDocId: number, type: NoteSeparatorTypes): void;
+    getSeparator(type: NoteSeparatorTypes): SubDocument | never;
+    getSeparatos(): IterableIterator<SubDocument>;
+}

package/lib/common/model/footnotes/footnote.js

@@ -0,0 +1,100 @@
+import { NumberingFormat } from "../numbering-lists/list-level-properties";
+export var NotePosition;
+(function (NotePosition) {
+    NotePosition[NotePosition["BottomOfPage"] = 0] = "BottomOfPage";
+    NotePosition[NotePosition["BelowText"] = 1] = "BelowText";
+    NotePosition[NotePosition["EndOfDocument"] = 2] = "EndOfDocument";
+    NotePosition[NotePosition["EndOfSection"] = 3] = "EndOfSection";
+})(NotePosition || (NotePosition = {}));
+export var NoteType;
+(function (NoteType) {
+    NoteType[NoteType["Separator"] = 0] = "Separator";
+    NoteType[NoteType["ContinuationSeparator"] = 1] = "ContinuationSeparator";
+    NoteType[NoteType["ContinuationNotice"] = 2] = "ContinuationNotice";
+    NoteType[NoteType["Normal"] = 3] = "Normal";
+})(NoteType || (NoteType = {}));
+export var NoteNumberingRestartType;
+(function (NoteNumberingRestartType) {
+    NoteNumberingRestartType[NoteNumberingRestartType["Continuous"] = 0] = "Continuous";
+    NoteNumberingRestartType[NoteNumberingRestartType["NewPage"] = 1] = "NewPage";
+    NoteNumberingRestartType[NoteNumberingRestartType["NewSection"] = 2] = "NewSection";
+})(NoteNumberingRestartType || (NoteNumberingRestartType = {}));
+export class NoteProperties {
+    static createDefault() {
+        const result = new NoteProperties();
+        result.position = NotePosition.BottomOfPage;
+        result.numberingFormat = NumberingFormat.Decimal;
+        result.numberingRestartType = NoteNumberingRestartType.Continuous;
+        result.startingNumber = 1;
+        result.columnCount = 0;
+        return result;
+    }
+    copyFrom(obj) {
+        this.position = obj.position;
+        this.numberingFormat = obj.numberingFormat;
+        this.numberingRestartType = obj.numberingRestartType;
+        this.startingNumber = obj.startingNumber;
+        this.columnCount = obj.columnCount;
+    }
+    clone() {
+        const result = new NoteProperties();
+        result.copyFrom(this);
+        return result;
+    }
+    equals(other) {
+        return this.position === other.position &&
+            this.numberingFormat === other.numberingFormat &&
+            this.numberingRestartType === other.numberingRestartType &&
+            this.startingNumber === other.startingNumber &&
+            this.columnCount === other.columnCount;
+    }
+}
+export class NoteSeparators {
+    constructor(model) {
+        this.model = model;
+    }
+    get separator() {
+        return this.model.subDocuments[this.separatorId];
+    }
+    get continuationSeparator() {
+        return this.model.subDocuments[this.continuationSeparatorId];
+    }
+    get continuationNotice() {
+        return this.model.subDocuments[this.continuationNoticeId];
+    }
+    setSeparator(sudDocId, type) {
+        switch (type) {
+            case NoteType.Separator:
+                this.separatorId = sudDocId;
+                break;
+            case NoteType.ContinuationSeparator:
+                this.continuationSeparatorId = sudDocId;
+                break;
+            case NoteType.ContinuationNotice:
+                this.continuationNoticeId = sudDocId;
+                break;
+            default:
+                throw Error("Invalid separator type.");
+        }
+    }
+    getSeparator(type) {
+        switch (type) {
+            case NoteType.Separator:
+                return this.separator;
+            case NoteType.ContinuationSeparator:
+                return this.continuationSeparator;
+            case NoteType.ContinuationNotice:
+                return this.continuationNotice;
+            default:
+                throw Error("Invalid separator type.");
+        }
+    }
+    *getSeparatos() {
+        if (this.separator)
+            yield this.separator;
+        if (this.continuationSeparator)
+            yield this.continuationSeparator;
+        if (this.continuationNotice)
+            yield this.continuationNotice;
+    }
+}

package/lib/common/model/json/importers/sub-document/json-sub-document-importer.js

@@ -15,7 +15,7 @@ import { JSONRunBaseProperty } from '../../enums/json-run-enums';
 import { JSONBookmarkProperty, JSONChunkProperty, JSONEnumLoadPieceTable, JSONRangePermissionProperty } from '../../enums/json-sub-document-enums';
 import { JSONTabConverter } from '../json-tab-converter';
 import { JSONTableImporter } from '../table/json-table-importer';
-import { AnchoredPictureRunImporter, AnchoredTextBoxRunImporter, InlinePictureRunImporter, InlineTextBoxRunImporter, SimpleRunImporter, TextRunImporter } from './run-importers';
+import { AnchoredPictureRunImporter, AnchoredTextBoxRunImporter, InlinePictureRunImporter, InlineTextBoxRunImporter, NoteRunImporter, SimpleRunImporter, TextRunImporter } from './run-importers';
 export class JSONSubDocumentImporter {
     static importSubDocument(subDocument, documentProtectionSettings, content, imageCorrespondence) {
         JSONTableImporter.importTables(subDocument, content[JSONEnumLoadPieceTable.Tables]);
@@ -119,8 +119,8 @@ JSONSubDocumentImporter.runTypeToRunImporter = {
     [RunType.InlinePictureRun]: new InlinePictureRunImporter(),
     [RunType.InlineTextBoxRun]: new InlineTextBoxRunImporter(),
     [RunType.LayoutDependentRun]: new SimpleRunImporter(LayoutDependentRun),
-    [RunType.FootNoteRun]: new SimpleRunImporter(FootNoteRun),
-    [RunType.EndNoteRun]: new SimpleRunImporter(EndNoteRun),
+    [RunType.FootNoteRun]: new NoteRunImporter(FootNoteRun),
+    [RunType.EndNoteRun]: new NoteRunImporter(EndNoteRun),
     [RunType.NoteSeparatorRun]: new SimpleRunImporter(NoteSeparatorRun),
     [RunType.NoteContinuationSeparatorRun]: new SimpleRunImporter(NoteContinuationSeparatorRun),
 };

package/lib/common/model/json/importers/sub-document/run-importers.d.ts

@@ -5,6 +5,7 @@ import { CharacterStyle } from '../../../character/character-style';
 import { Paragraph } from '../../../paragraph/paragraph';
 import { RunBase } from '../../../runs/run-base';
 export declare type SimpleRunConstructor = new (startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle) => RunBase;
+export declare type NoteRunConstructor = new (startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle, noteDocumentId: number) => RunBase;
 export declare abstract class BaseRunImporter {
     private maskedCharacterPropertiesCache;
     private charStyles;
@@ -19,6 +20,11 @@ export declare class SimpleRunImporter extends BaseRunImporter {
     constructor(runConstructor: SimpleRunConstructor);
     protected makeRun(_jsonRun: any, startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle): RunBase;
 }
+export declare class NoteRunImporter extends BaseRunImporter {
+    runConstructor: NoteRunConstructor;
+    constructor(runConstructor: NoteRunConstructor);
+    protected makeRun(_jsonRun: any, startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle): RunBase;
+}
 export declare class TextRunImporter extends BaseRunImporter {
     protected makeRun(jsonRun: any, startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle): RunBase;
 }

package/lib/common/model/json/importers/sub-document/run-importers.js

@@ -34,6 +34,15 @@ export class SimpleRunImporter extends BaseRunImporter {
         return new this.runConstructor(startOffset, paragraph, charPropsBundle);
     }
 }
+export class NoteRunImporter extends BaseRunImporter {
+    constructor(runConstructor) {
+        super();
+        this.runConstructor = runConstructor;
+    }
+    makeRun(_jsonRun, startOffset, paragraph, charPropsBundle) {
+        return new this.runConstructor(startOffset, paragraph, charPropsBundle, -1);
+    }
+}
 export class TextRunImporter extends BaseRunImporter {
     makeRun(jsonRun, startOffset, paragraph, charPropsBundle) {
         return new TextRun(startOffset, jsonRun[JSONRunBaseProperty.Length], paragraph, charPropsBundle);

package/lib/common/model/model-checks/position.d.ts

@@ -7,7 +7,8 @@ export declare class PositionChecker {
     check(): boolean;
     compare(poss: Position[], registered: Position[]): boolean;
     private getNewRegInterval;
-    private checkValue;
+    private isGreater;
+    private isEqual;
     private sort;
     private addSections;
     private addParagraphs;

package/lib/common/model/model-checks/position.js

@@ -27,7 +27,9 @@ export class PositionChecker {
         for (let currPos of poss) {
             if (prevPos.value != currPos.value)
                 regInterval = this.getNewRegInterval(registered, regInterval);
-            if (!this.checkValue(currPos, registered, regInterval))
+            while (this.isGreater(currPos, registered, regInterval))
+                regInterval = this.getNewRegInterval(registered, regInterval);
+            if (!this.isEqual(currPos, registered, regInterval))
                 return false;
             prevPos = currPos;
         }
@@ -43,7 +45,14 @@ export class PositionChecker {
         }
         return regInterval;
     }
-    checkValue(currPos, registered, regInterval) {
+    isGreater(currPos, registered, regInterval) {
+        for (let i = regInterval.start; i < regInterval.end; i++) {
+            if (registered[i] && currPos.value > registered[i].value)
+                return true;
+        }
+        return false;
+    }
+    isEqual(currPos, registered, regInterval) {
         for (let i = regInterval.start; i < regInterval.end; i++) {
             if (currPos === registered[i])
                 return true;

package/lib/common/model/numbering-lists/numbering-helper.d.ts

@@ -1,13 +1,14 @@
 import { IModelManager } from '../../model-manager';
 import { DocumentModel } from '../document-model';
 import { SubDocument } from '../sub-document';
-import { NumberingType } from './numbering-list';
+import { AbstractNumberingList, NumberingType } from './numbering-list';
 export declare class NumberingHelper {
     static templateCodeStart: number;
     static templateCodeEnd: number;
     static generateNewTemplateCode(documentModel: DocumentModel): number;
     static isNewTemplateCode(documentModel: DocumentModel, templateCode: number): boolean;
     static getNumberingListTemplateIndex(documentModel: DocumentModel, type: NumberingType): number;
+    static getNumberingListTemplate(documentModel: DocumentModel, type: NumberingType): AbstractNumberingList;
     static deleteNumberingList(modelManager: IModelManager, subDocument: SubDocument, paragraphIndices: number[]): void;
     private static resetParagraphLeftIndent;
     private static deleteNumberingListCore;

package/lib/common/model/numbering-lists/numbering-helper.js

@@ -26,6 +26,9 @@ export class NumberingHelper {
         }
         return -1;
     }
+    static getNumberingListTemplate(documentModel, type) {
+        return documentModel.abstractNumberingListTemplates.find(list => list.getListType() === type);
+    }
     static deleteNumberingList(modelManager, subDocument, paragraphIndices) {
         for (let i = paragraphIndices.length - 1; i >= 0; i--) {
             let paragraphIndex = paragraphIndices[i];

package/lib/common/model/paragraph/paragraph-style.d.ts

@@ -24,6 +24,7 @@ export declare class ParagraphStyle extends StyleBase<ParagraphStyle> implements
     getResultTabs(): TabProperties;
     getMergedParagraphProperties(): ParagraphProperties;
     isInOwnList(): boolean;
+    isInList(): boolean;
     getListLevel(model: DocumentModel): IOverrideListLevel;
     getNumberingList(model: DocumentModel): NumberingList;
     getNumberingListIndex(): number;

package/lib/common/model/paragraph/paragraph-style.js

@@ -29,6 +29,9 @@ export class ParagraphStyle extends StyleBase {
     isInOwnList() {
         return this.numberingListIndex >= 0;
     }
+    isInList() {
+        return this.getNumberingListIndex() >= 0;
+    }
     getListLevel(model) {
         return this.getNumberingList(model).levels[this.getListLevelIndex()];
     }
@@ -42,10 +45,11 @@ export class ParagraphStyle extends StyleBase {
             return this.parent.getNumberingListIndex();
     }
     getListLevelIndex() {
-        if (this.listLevelIndex >= 0 || this.listLevelIndex === NumberingList.NoNumberingListIndex || !this.parent)
+        var _a, _b;
+        if (this.listLevelIndex >= 0)
             return this.listLevelIndex;
         else
-            return this.parent.getListLevelIndex();
+            return (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getListLevelIndex()) !== null && _b !== void 0 ? _b : 0;
     }
     clone() {
         const style = new ParagraphStyle(this.styleName, this.localizedName, this.deleted, this.hidden, this.semihidden, this.isDefault, this.maskedCharacterProperties, this.maskedParagraphProperties, this.tabs.clone(), this.autoUpdate, this.numberingListIndex, this.listLevelIndex, this.base64EncodedImage, this.id);

package/lib/common/model/properties-merger/paragraph-properties-merger.js

@@ -38,7 +38,7 @@ export class ParagraphPropertiesMerger extends PropertiesMergerBase {
         let currentParagraphStyle = paragraphStyle;
         while (currentParagraphStyle) {
             this.merge(currentParagraphStyle.maskedParagraphProperties);
-            if (currentParagraphStyle.isInOwnList())
+            if (currentParagraphStyle.isInList())
                 this.merge(currentParagraphStyle.getListLevel(model).getParagraphProperties());
             currentParagraphStyle = currentParagraphStyle.parent;
         }

package/lib/common/model/runs/run-base.d.ts

@@ -23,6 +23,7 @@ export declare abstract class RunBase implements ICharacterPropertiesContainer,
     paragraph: Paragraph;
     characterStyle: CharacterStyle;
     maskedCharacterProperties: MaskedCharacterProperties;
+    noteDocumentId: number;
     private mergedCharacterProperties;
     constructor(startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle);
     abstract getLength(): number;

package/lib/common/model/runs/simple-runs.d.ts

@@ -1,7 +1,9 @@
 import { ICloneable } from '@devexpress/utils/lib/types';
+import { MaskedCharacterPropertiesBundle } from '../../rich-utils/properties-bundle';
 import { SubDocument } from '../sub-document';
 import { OneCharRun } from './run-base';
 import { RunType } from './run-type';
+import { Paragraph } from '../paragraph/paragraph';
 export declare class SectionRun extends OneCharRun implements ICloneable<SectionRun> {
     getType(): RunType;
     isParagraphOrSectionRun(): boolean;
@@ -34,12 +36,15 @@ export declare class LayoutDependentRun extends OneCharRun implements ICloneable
     clone(): LayoutDependentRun;
     cloneToNewSubDocument(subDocument: SubDocument): LayoutDependentRun;
 }
-export declare class FootNoteRun extends OneCharRun implements ICloneable<FootNoteRun> {
+declare abstract class NoteRun extends OneCharRun {
+    constructor(startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle, noteDocumentId?: number);
+}
+export declare class FootNoteRun extends NoteRun implements ICloneable<FootNoteRun> {
     getType(): RunType;
     clone(): FootNoteRun;
     cloneToNewSubDocument(subDocument: SubDocument): FootNoteRun;
 }
-export declare class EndNoteRun extends OneCharRun implements ICloneable<EndNoteRun> {
+export declare class EndNoteRun extends NoteRun implements ICloneable<EndNoteRun> {
     getType(): RunType;
     clone(): EndNoteRun;
     cloneToNewSubDocument(subDocument: SubDocument): EndNoteRun;
@@ -54,3 +59,4 @@ export declare class NoteContinuationSeparatorRun extends OneCharRun implements
     clone(): NoteContinuationSeparatorRun;
     cloneToNewSubDocument(subDocument: SubDocument): NoteContinuationSeparatorRun;
 }
+export {};

package/lib/common/model/runs/simple-runs.js

@@ -73,26 +73,32 @@ export class LayoutDependentRun extends OneCharRun {
         return new LayoutDependentRun(this.startOffset, subDocument.getParagraphByPosition(this.paragraph.startLogPosition.value), new MaskedCharacterPropertiesBundle(subDocument.documentModel.cache.maskedCharacterPropertiesCache.getItem(this.maskedCharacterProperties), subDocument.documentModel.stylesManager.getCharacterStyleByName(this.characterStyle.styleName)));
     }
 }
-export class FootNoteRun extends OneCharRun {
+class NoteRun extends OneCharRun {
+    constructor(startOffset, paragraph, charPropsBundle, noteDocumentId = -1) {
+        super(startOffset, paragraph, charPropsBundle);
+        this.noteDocumentId = noteDocumentId;
+    }
+}
+export class FootNoteRun extends NoteRun {
     getType() {
         return RunType.FootNoteRun;
     }
     clone() {
-        return new FootNoteRun(this.startOffset, this.paragraph, new MaskedCharacterPropertiesBundle(this.maskedCharacterProperties, this.characterStyle));
+        return new FootNoteRun(this.startOffset, this.paragraph, new MaskedCharacterPropertiesBundle(this.maskedCharacterProperties, this.characterStyle), this.noteDocumentId);
     }
     cloneToNewSubDocument(subDocument) {
-        return new FootNoteRun(this.startOffset, subDocument.getParagraphByPosition(this.paragraph.startLogPosition.value), new MaskedCharacterPropertiesBundle(subDocument.documentModel.cache.maskedCharacterPropertiesCache.getItem(this.maskedCharacterProperties), subDocument.documentModel.stylesManager.getCharacterStyleByName(this.characterStyle.styleName)));
+        return new FootNoteRun(this.startOffset, subDocument.getParagraphByPosition(this.paragraph.startLogPosition.value), new MaskedCharacterPropertiesBundle(subDocument.documentModel.cache.maskedCharacterPropertiesCache.getItem(this.maskedCharacterProperties), subDocument.documentModel.stylesManager.getCharacterStyleByName(this.characterStyle.styleName)), this.noteDocumentId);
     }
 }
-export class EndNoteRun extends OneCharRun {
+export class EndNoteRun extends NoteRun {
     getType() {
         return RunType.EndNoteRun;
     }
     clone() {
-        return new EndNoteRun(this.startOffset, this.paragraph, new MaskedCharacterPropertiesBundle(this.maskedCharacterProperties, this.characterStyle));
+        return new EndNoteRun(this.startOffset, this.paragraph, new MaskedCharacterPropertiesBundle(this.maskedCharacterProperties, this.characterStyle), this.noteDocumentId);
     }
     cloneToNewSubDocument(subDocument) {
-        return new EndNoteRun(this.startOffset, subDocument.getParagraphByPosition(this.paragraph.startLogPosition.value), new MaskedCharacterPropertiesBundle(subDocument.documentModel.cache.maskedCharacterPropertiesCache.getItem(this.maskedCharacterProperties), subDocument.documentModel.stylesManager.getCharacterStyleByName(this.characterStyle.styleName)));
+        return new EndNoteRun(this.startOffset, subDocument.getParagraphByPosition(this.paragraph.startLogPosition.value), new MaskedCharacterPropertiesBundle(subDocument.documentModel.cache.maskedCharacterPropertiesCache.getItem(this.maskedCharacterProperties), subDocument.documentModel.stylesManager.getCharacterStyleByName(this.characterStyle.styleName)), this.noteDocumentId);
     }
 }
 export class NoteSeparatorRun extends OneCharRun {

package/lib/common/model/section/section-properties.d.ts

@@ -5,6 +5,7 @@ import { SectionStartType } from './enums';
 import { SectionColumnProperties } from './section-column-properties';
 import { PaperKind } from './paper-kind';
 import { LineNumberingProperties } from './line-numbering-properties';
+import { NoteProperties } from '../footnotes/footnote';
 export declare class SectionProperties implements ICloneable<SectionProperties>, ISupportCopyFrom<SectionProperties> {
     static createSimpleSectionProperties(width: number, height: number): SectionProperties;
     margins: Margins;
@@ -22,6 +23,8 @@ export declare class SectionProperties implements ICloneable<SectionProperties>,
     firstPageNumber: number;
     continueNumbering: boolean;
     lineNumbering: LineNumberingProperties;
+    footNote: NoteProperties;
+    endNote: NoteProperties;
     get marginLeft(): number;
     get marginTop(): number;
     get marginRight(): number;

package/lib/common/model/special-characters.d.ts

@@ -39,6 +39,7 @@ export declare class SpecialCharacters {
     OpeningDoubleQuotationMark: string;
     ClosingDoubleQuotationMark: string;
     SeparatorMark: string;
+    MSWordBulletMark: string;
     HiddenLineBreak: string;
     HiddenParagraphMark: string;
     HiddenSpace: string;
@@ -47,5 +48,7 @@ export declare class SpecialCharacters {
     FieldCodeEndRun: string;
     FieldResultEndRun: string;
     LayoutDependentText: string;
+    ETX: string;
+    EOT: string;
     DEBUG_CONVERTER(str: string): string;
 }

package/lib/common/model/special-characters.js

@@ -40,6 +40,7 @@ export class SpecialCharacters {
         this.OpeningDoubleQuotationMark = '\u201C';
         this.ClosingDoubleQuotationMark = '\u201D';
         this.SeparatorMark = '|';
+        this.MSWordBulletMark = String.fromCharCode(0xF0B7);
         this.HiddenLineBreak = String.fromCharCode(0x21B2);
         this.HiddenParagraphMark = String.fromCharCode(0x00B6);
         this.HiddenSpace = String.fromCharCode(0x00B7);
@@ -48,6 +49,8 @@ export class SpecialCharacters {
         this.FieldCodeEndRun = "}";
         this.FieldResultEndRun = ">";
         this.LayoutDependentText = "#";
+        this.ETX = '\u0003';
+        this.EOT = '\u0004';
     }
     DEBUG_CONVERTER(str) {
         let result = [];

package/lib/common/model/sub-document-infos.d.ts

@@ -1,6 +1,7 @@
 import { DocumentModel } from './document-model';
 import { SubDocumentInfoType } from './enums';
 import { HeaderFooterType } from './section/enums';
+import { NoteType } from './footnotes/footnote';
 export declare abstract class SubDocumentInfoBase {
     subDocumentId: number;
     isMain: boolean;
@@ -28,6 +29,23 @@ export declare class TextBoxSubDocumentInfoBase extends SubDocumentInfoBase {
     getType(): SubDocumentInfoType;
     clone(): TextBoxSubDocumentInfoBase;
 }
+export declare abstract class NoteSubDocumentInfo extends SubDocumentInfoBase {
+    isMain: boolean;
+    isNote: boolean;
+    noteType: NoteType;
+}
+export declare class FootNoteSubDocumentInfo extends NoteSubDocumentInfo {
+    isMain: boolean;
+    isFootNote: boolean;
+    getType(): SubDocumentInfoType;
+    clone(): FootNoteSubDocumentInfo;
+}
+export declare class EndNoteSubDocumentInfo extends NoteSubDocumentInfo {
+    isMain: boolean;
+    isEndNote: boolean;
+    getType(): SubDocumentInfoType;
+    clone(): EndNoteSubDocumentInfo;
+}
 export declare class MainSubDocumentInfo extends SubDocumentInfoBase {
     constructor();
     getType(): SubDocumentInfoType;

package/lib/common/model/sub-document-infos.js

@@ -1,6 +1,7 @@
 import { Errors } from '@devexpress/utils/lib/errors';
 import { SubDocumentInfoType } from './enums';
 import { HeaderFooterType } from './section/enums';
+import { NoteType } from './footnotes/footnote';
 export class SubDocumentInfoBase {
     constructor(subDocumentId) {
         this.isMain = true;
@@ -31,6 +32,10 @@ export class SubDocumentInfoBase {
                 return new FooterSubDocumentInfo(subDocumentId);
             case SubDocumentInfoType.TextBox:
                 return new TextBoxSubDocumentInfoBase(subDocumentId, parentSubDocumentId);
+            case SubDocumentInfoType.FootNote:
+                return new FootNoteSubDocumentInfo(subDocumentId);
+            case SubDocumentInfoType.EndNote:
+                return new EndNoteSubDocumentInfo(subDocumentId);
         }
         throw new Error(Errors.NotImplemented);
     }
@@ -49,6 +54,40 @@ export class TextBoxSubDocumentInfoBase extends SubDocumentInfoBase {
         return new TextBoxSubDocumentInfoBase(this.subDocumentId, this.parentSubDocumentId);
     }
 }
+export class NoteSubDocumentInfo extends SubDocumentInfoBase {
+    constructor() {
+        super(...arguments);
+        this.isMain = false;
+        this.isNote = true;
+        this.noteType = NoteType.Normal;
+    }
+}
+export class FootNoteSubDocumentInfo extends NoteSubDocumentInfo {
+    constructor() {
+        super(...arguments);
+        this.isMain = false;
+        this.isFootNote = true;
+    }
+    getType() {
+        return SubDocumentInfoType.FootNote;
+    }
+    clone() {
+        return new FootNoteSubDocumentInfo(this.subDocumentId);
+    }
+}
+export class EndNoteSubDocumentInfo extends NoteSubDocumentInfo {
+    constructor() {
+        super(...arguments);
+        this.isMain = false;
+        this.isEndNote = true;
+    }
+    getType() {
+        return SubDocumentInfoType.EndNote;
+    }
+    clone() {
+        return new EndNoteSubDocumentInfo(this.subDocumentId);
+    }
+}
 export class MainSubDocumentInfo extends SubDocumentInfoBase {
     constructor() {
         super(0);

package/lib/common/model/sub-document.d.ts

@@ -40,6 +40,8 @@ export declare class SubDocument {
     get interval(): FixedInterval;
     getLastChunk(): Chunk;
     getFirstChunk(): Chunk;
+    getLastParagraph(): Paragraph;
+    getFirstParagraph(): Paragraph;
     getText(interval?: FixedInterval): string;
     getSimpleText(interval: ConstInterval): string;
     splitRun(position: number): void;