@talrace/ngx-noder 0.0.2

package/lib/+shared/editor/custom-components/table/models/cell-data.model.d.ts

@@ -0,0 +1,11 @@
+import { ComponentRef } from '@angular/core';
+import { NoderTableCellComponent } from '../components/table-cell.component';
+export declare class CellDataModel {
+    cell: HTMLTableCellElement;
+    cellContentHeight: number;
+    componentRef: ComponentRef<NoderTableCellComponent>;
+    constructor(cell: HTMLTableCellElement, cellContentHeight: number, componentRef: ComponentRef<NoderTableCellComponent>);
+    highlightCell(): void;
+    removeHighlightCell(): void;
+    clearSelection(): void;
+}

package/lib/+shared/editor/custom-components/table/models/cell-resizer-parameters.model.d.ts

@@ -0,0 +1,9 @@
+import { ResizerSide } from '../enums/reisizer-side.enum';
+export declare class CellResizerParametersModel {
+    columnIndex: number;
+    rowIndex: number;
+    cellIndex: number;
+    cellSide: ResizerSide;
+    distance: number;
+    constructor(columnIndex: number, rowIndex: number, cellIndex: number, cellSide: ResizerSide);
+}

package/lib/+shared/editor/custom-components/table/models/row-data.model.d.ts

@@ -0,0 +1,7 @@
+import { CellDataModel } from './cell-data.model';
+export declare class RowDataModel {
+    row: HTMLTableRowElement;
+    height: number;
+    cells: CellDataModel[];
+    constructor(row: HTMLTableRowElement, height: number, cells: CellDataModel[]);
+}

package/lib/+shared/editor/custom-components/table/models/selection-range.model.d.ts

@@ -0,0 +1,17 @@
+export declare class SelectionRangeModel {
+    rowIndexes: {
+        startIndex: number;
+        endIndex: number;
+    };
+    cellIndexes: {
+        startIndex: number;
+        endIndex: number;
+    };
+    constructor(rowIndexes: {
+        startIndex: number;
+        endIndex: number;
+    }, cellIndexes: {
+        startIndex: number;
+        endIndex: number;
+    });
+}

package/lib/+shared/editor/custom-components/table/overlay-menu/overlay-menu.component.d.ts

@@ -0,0 +1,37 @@
+import { EditorService } from '../../../interaction/editor.service';
+import { OverlayService } from '../../shared/services/overlay/overlay.service';
+import { SelectionRangeModel } from '../models/selection-range.model';
+import * as i0 from "@angular/core";
+export declare class TableOverlayMenuComponent {
+    private editorService;
+    private overlayService;
+    selectionRange: SelectionRangeModel;
+    targets: SelectionRangeModel;
+    canRemoveRows: boolean;
+    canRemoveColumns: boolean;
+    tableInsertIndex: number;
+    sessionId: number;
+    selectedRowsCount: number;
+    selectedColumnsCount: number;
+    insertMessages: {
+        insertRowsAboveMessage: string;
+        insertRowsBelowMessage: string;
+        insertColumnsLeftMessage: string;
+        insertColumnsRightMessage: string;
+    };
+    removeMessages: {
+        removeRowsMessage: string;
+        removeColumnsMessage: string;
+    };
+    constructor(editorService: EditorService, overlayService: OverlayService);
+    ngOnInit(): void;
+    processInsertMenuItems(): void;
+    onInsertRowsAbove(): void;
+    onInsertRowsBelow(): void;
+    onInsertColumnsLeft(): void;
+    onInsertColumnsRight(): void;
+    onRemoveRows(): void;
+    onRemoveColumns(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableOverlayMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableOverlayMenuComponent, "app-table-overlay-menu", never, { "selectionRange": { "alias": "selectionRange"; "required": false; }; "targets": { "alias": "targets"; "required": false; }; "canRemoveRows": { "alias": "canRemoveRows"; "required": false; }; "canRemoveColumns": { "alias": "canRemoveColumns"; "required": false; }; "tableInsertIndex": { "alias": "tableInsertIndex"; "required": false; }; "sessionId": { "alias": "sessionId"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/+shared/editor/custom-components/table/selection/table-selection.d.ts

@@ -0,0 +1,74 @@
+import { Subscription } from 'rxjs';
+import { EditorService } from '../../../interaction/editor.service';
+import { OverlayService } from '../../shared/services/overlay/overlay.service';
+import { RowDataModel } from '../models/row-data.model';
+import { SelectionRangeModel } from '../models/selection-range.model';
+import { TableModel } from '../../../../../models/generated/table.model';
+export declare class TableSelection {
+    private editorService;
+    private overlayService;
+    private rowMatrix;
+    private table;
+    private tableEl;
+    private sessionId;
+    originSelectedCell: {
+        rowIndex: number;
+        cellIndex: number;
+        isFocused: boolean;
+    };
+    tableContextMenu$: Subscription;
+    tableMouseDown$: Subscription;
+    documentMouseDown$: Subscription;
+    documentMouseMove$: Subscription;
+    documentMouseUp$: Subscription;
+    selectionRange: SelectionRangeModel | null;
+    readonly editorTagName = "APP-EDITOR";
+    readonly cellTagName = "TD";
+    readonly draggableCellContent: string[];
+    constructor(editorService: EditorService, overlayService: OverlayService, rowMatrix: RowDataModel[], table: TableModel, tableEl: HTMLTableElement, sessionId: number);
+    destroy(): void;
+    addTableContextMenuSubscriptions(): void;
+    addTableMouseDownSubscriptions(): void;
+    addDocumentMouseMovementSubscriptions(): void;
+    addDocumentMouseDownSubscriptions(): void;
+    removeMouseSubscriptions(): void;
+    processMouseMove(event: MouseEvent): void;
+    selectAllCellsInBetween(event: MouseEvent): void;
+    getCellIndexes(element: HTMLElement): {
+        rowIndex: number;
+        cellIndex: number;
+    } | null;
+    getSelectedCell(el: HTMLElement): {
+        rowIndex: number;
+        cellIndex: number;
+    } | null;
+    getCellIndexesOutsideTable(event: MouseEvent): {
+        rowIndex: number;
+        cellIndex: number;
+    } | null;
+    getCellIndexesOutsideTableLeft(event: MouseEvent): {
+        rowIndex: number;
+        cellIndex: number;
+    };
+    getCellIndexesOutsideTableRights(event: MouseEvent): {
+        rowIndex: number;
+        cellIndex: number;
+    };
+    getNearestRowIndex(event: MouseEvent): number;
+    addSelectionInAllCells(): void;
+    clearSelectionInAllCells(): void;
+    getStartAndEndIndexes(originIndex: number, currentIndex: number): {
+        startIndex: number;
+        endIndex: number;
+    };
+    isOriginCell(event: MouseEvent): boolean;
+    isOnEditorClick(element: HTMLElement): boolean;
+    isOnTableClick(element: HTMLElement): boolean;
+    canStartSelection(element: HTMLElement): boolean;
+    getSelectionRangeForMenuOverlay(element: HTMLElement): SelectionRangeModel;
+    getTargetsForMenuOverlay(selectionRange: SelectionRangeModel): SelectionRangeModel;
+    getTargetRowStartIndex(startIndex: number): number;
+    getTargetRowEndIndex(endIndex: number): number;
+    getTargetColumnStartIndex(rowStartIndex: number, rowEndIndex: number, cellStartIndex: number): number;
+    getTargetColumnEndIndex(rowStartIndex: number, rowEndIndex: number, cellEndIndex: number): number;
+}

package/lib/+shared/editor/editor.component.d.ts

@@ -0,0 +1,43 @@
+import { ChangeDetectorRef, ElementRef, Injector, OnDestroy } from '@angular/core';
+import { Clipboard } from '@angular/cdk/clipboard';
+import { MatDrawer } from '@angular/material/sidenav';
+import { Observable, Subscription } from 'rxjs';
+import { CommandsService } from '../services/commands.service';
+import { ComponentService } from './custom-components/shared/services/component/component.service';
+import { DocxModel } from '../../models/generated/docx.model';
+import { Editor } from './core/editor';
+import { EditorService } from './interaction/editor.service';
+import { ElementDataModel } from './custom-components/external-element/models/element-data.model';
+import { ExternalElementModel } from './custom-components/external-element/models/external-element.model';
+import { ExternalSidenavModel } from './custom-components/external-element/models/external-sidenav.model';
+import { RegulatorService } from './execution/regulator.service';
+import * as i0 from "@angular/core";
+export declare class EditorComponent implements OnDestroy {
+    private cdr;
+    private componentService;
+    private editorService;
+    private injector;
+    private regulatorService;
+    private commandsService;
+    private clipboard;
+    get isViewOnly$(): Observable<boolean>;
+    set content(model: DocxModel);
+    get content(): DocxModel;
+    private _content;
+    container: ElementRef<HTMLElement>;
+    sidenavContainer: ElementRef<HTMLElement>;
+    sidenav: MatDrawer;
+    class: string;
+    editor: Editor;
+    elements: ExternalElementModel[];
+    sidenavProperties: ExternalSidenavModel;
+    readonly subscriptions: Subscription[];
+    private sidenavComponentRef;
+    constructor(cdr: ChangeDetectorRef, componentService: ComponentService, editorService: EditorService, injector: Injector, regulatorService: RegulatorService, commandsService: CommandsService, clipboard: Clipboard);
+    ngOnDestroy(): void;
+    initEditor(content: DocxModel): void;
+    createElement(model: ElementDataModel): void;
+    toggleSidenavSubscription(): Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditorComponent, "app-editor", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/+shared/editor/editor.module.d.ts

@@ -0,0 +1,30 @@
+import { ModuleWithProviders, Type } from '@angular/core';
+import { ExternalElementInterface } from './custom-components/external-element/external-element.service';
+import { ExternalSidenavModel } from './custom-components/external-element/models/external-sidenav.model';
+import * as i0 from "@angular/core";
+import * as i1 from "./editor.component";
+import * as i2 from "./custom-components/external-element/element-toolbar/element-toolbar.component";
+import * as i3 from "./core/components/edges/edge.component";
+import * as i4 from "./custom-components/image/components/image.component";
+import * as i5 from "./custom-components/tab/tab.component";
+import * as i6 from "./custom-components/table/components/table-cell.component";
+import * as i7 from "./custom-components/table/components/table.component";
+import * as i8 from "./custom-components/image/resizer/resizer.component";
+import * as i9 from "./custom-components/table/overlay-menu/overlay-menu.component";
+import * as i10 from "@angular/common";
+import * as i11 from "@angular/material/button";
+import * as i12 from "@angular/material/dialog";
+import * as i13 from "@angular/material/icon";
+import * as i14 from "@angular/material/sidenav";
+import * as i15 from "@angular/material/tooltip";
+import * as i16 from "@angular/forms";
+export interface INoderOptions {
+    sidenav?: Partial<ExternalSidenavModel>;
+    elementService: Type<ExternalElementInterface>;
+}
+export declare class EditorModule {
+    static forRoot(options?: INoderOptions): ModuleWithProviders<EditorModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EditorModule, [typeof i1.EditorComponent, typeof i2.ElementToolbarComponent, typeof i3.NoderEdgeComponent, typeof i4.NoderImageComponent, typeof i5.NoderTabComponent, typeof i6.NoderTableCellComponent, typeof i7.NoderTableComponent, typeof i8.ResizerComponent, typeof i9.TableOverlayMenuComponent], [typeof i10.CommonModule, typeof i11.MatButtonModule, typeof i12.MatDialogModule, typeof i13.MatIconModule, typeof i14.MatSidenavModule, typeof i15.MatTooltipModule, typeof i16.ReactiveFormsModule], [typeof i1.EditorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EditorModule>;
+}

package/lib/+shared/editor/execution/models/cell-session-source.model.d.ts

@@ -0,0 +1,11 @@
+import { NoderTableCellComponent } from '../../custom-components/table/components/table-cell.component';
+import { SessionSourceModel } from './session-source.model';
+import { TableModel } from '../../../../models/generated/table.model';
+import { TargetModel } from '../../../../models/generated/target.model';
+export declare class CellSessionSourceModel implements SessionSourceModel {
+    private table;
+    private cellComponent;
+    edgeEditPage?: number;
+    constructor(table: TableModel, cellComponent: NoderTableCellComponent);
+    getTarget(): TargetModel;
+}

package/lib/+shared/editor/execution/models/edge-session-source.model.d.ts

@@ -0,0 +1,11 @@
+import { EdgeType } from '../../core/components/edges/edge-type.enum';
+import { PageType } from '../../core/enums/page-type.enum';
+import { SessionSourceModel } from './session-source.model';
+import { TargetModel } from '../../../../models/generated/target.model';
+export declare class EdgeSessionSourceModel implements SessionSourceModel {
+    private pageType;
+    private type;
+    edgeEditPage?: number;
+    constructor(pageType: PageType, type: EdgeType);
+    getTarget(): TargetModel;
+}

package/lib/+shared/editor/execution/models/general-properties.model.d.ts

@@ -0,0 +1,7 @@
+import { NumberingModel } from '../../../../models/generated/numbering.model';
+export declare class GeneralPropertiesModel {
+    defaultTabWidth: number;
+    numberings: NumberingModel[];
+    maxEdgeHeight: number;
+    constructor(fields?: Partial<GeneralPropertiesModel>);
+}

package/lib/+shared/editor/execution/models/main-session-source.model.d.ts

@@ -0,0 +1,5 @@
+import { SessionSourceModel } from './session-source.model';
+import { TargetModel } from '../../../../models/generated/target.model';
+export declare class MainSessionSourceModel implements SessionSourceModel {
+    getTarget(): TargetModel;
+}

package/lib/+shared/editor/execution/models/session-source.model.d.ts

@@ -0,0 +1,5 @@
+import { TargetModel } from '../../../../models/generated/target.model';
+export declare abstract class SessionSourceModel {
+    edgeEditPage?: number;
+    abstract getTarget(): TargetModel;
+}

package/lib/+shared/editor/execution/models/session.model.d.ts

@@ -0,0 +1,12 @@
+import { EditSession } from '../../core/edit.session';
+import { Renderer } from '../../core/renderer';
+import { SessionSourceModel } from './session-source.model';
+import { VirtualRenderer } from '../../core/virtual.renderer';
+export declare class SessionModel {
+    session: EditSession;
+    renderer: Renderer | VirtualRenderer;
+    sessionId: number;
+    parentSessionId: number | null;
+    source: SessionSourceModel;
+    constructor(session: EditSession, renderer: Renderer | VirtualRenderer, sessionId: number, parentSessionId: number | null, source: SessionSourceModel);
+}

package/lib/+shared/editor/execution/regulator.service.d.ts

@@ -0,0 +1,45 @@
+import { ElementRef } from '@angular/core';
+import { CustomContentService } from '../custom-components/shared/services/custom-content/custom-content.service';
+import { DocxModel } from '../../../models/generated/docx.model';
+import { EditorService } from '../interaction/editor.service';
+import { EditSession } from '../core/edit.session';
+import { GeneralPropertiesModel } from './models/general-properties.model';
+import { MarginModel } from '../core/models/margin.model';
+import { NoderEdgeComponent } from '../core/components/edges/edge.component';
+import { NoderTableCellComponent } from '../custom-components/table/components/table-cell.component';
+import { Selection } from '../positioning/selection';
+import { SessionModel } from './models/session.model';
+import { TableModel } from '../../../models/generated/table.model';
+import { TargetModel } from '../../../models/generated/target.model';
+import * as i0 from "@angular/core";
+export declare class RegulatorService {
+    private customContentService;
+    private editorService;
+    mainSession: SessionModel;
+    sessions: SessionModel[];
+    currentSession: SessionModel;
+    selection: Selection;
+    sessionIdIncrement: number;
+    edgeEditingPage: number | null;
+    constructor(customContentService: CustomContentService, editorService: EditorService);
+    addMainSession(model: DocxModel, margins: MarginModel, container: ElementRef<HTMLElement>): void;
+    addCellSession(table: TableModel, margins: MarginModel, component: NoderTableCellComponent, properties: GeneralPropertiesModel): SessionModel;
+    addEdgeSession(component: NoderEdgeComponent): SessionModel;
+    removeSession(sessionId: number): void;
+    setMainSessionAsCurrent(): void;
+    setCustomSessionAsCurrent(sessionId: number): void;
+    setEdgeSessionAsCurrent(sessionId: number, clickedPage: number): void;
+    setTargetedSessionAsCurrent(targets: TargetModel[]): void;
+    setCurrentSessionById(sessionId: number): void;
+    setCurrentSession(session: SessionModel): void;
+    getSession(sessionId: number): EditSession;
+    setSelection(selection: Selection): void;
+    clearAllSessions(): void;
+    getCurrentSessionTargets(): TargetModel[];
+    getTargets(session: SessionModel): TargetModel[];
+    getEdgeTarget(sessionId: number): TargetModel | null;
+    getTargetedSession(targets: TargetModel[]): EditSession;
+    toggleEdgeEditMode(clickedPage?: number | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegulatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RegulatorService>;
+}

package/lib/+shared/editor/helpers/break.helper.d.ts

@@ -0,0 +1,7 @@
+import { BreakModel } from '../../../models/generated/break.model';
+import { BreakTypes } from '../core/enums/break-types.enum';
+import { ContentsInterface } from '../interfaces/contents.interface';
+export declare class BreakHelper {
+    static getBreakType(model: ContentsInterface, char: string, insertIndex: number): BreakTypes | null;
+    static removeBreakMarker(breaks: BreakModel[], text: string, fragmentStartIndex: number): string;
+}

package/lib/+shared/editor/helpers/content.helper.d.ts

@@ -0,0 +1,9 @@
+import { InsertIndexInterface } from '../interfaces/insert-index.interface';
+import { Point } from '../core/point';
+export declare class ContentHelper {
+    static documentIndexToParagraphIndex(wrapParagraphIndex: number[], indexInDocument: number): Point;
+    static documentIndexToParagraphWithOffset(wrapParagraphIndex: number[], lines: string[], indexInDocument: number): Point;
+    static paragraphPositionToDocumentIndex(wrapParagraphIndex: number[], paragraph: Point): number;
+    static paragraphToDocumentIndex(wrapParagraphIndex: number[], paragraph: number, index: number): number;
+    static setIndexesElementsInInterval<T extends InsertIndexInterface>(elements: T[], elementIndexes: number[], startIndex: number, endIndex: number): void;
+}

package/lib/+shared/editor/helpers/format.helper.d.ts

@@ -0,0 +1,4 @@
+import { FormatModel } from '../../../models/generated/format.model';
+export declare class FormatHelper {
+    static sliceSection(formats: FormatModel[], startIndex: number, endIndex: number): FormatModel[];
+}

package/lib/+shared/editor/helpers/indexed-element.helper.d.ts

@@ -0,0 +1,4 @@
+import { InsertIndexInterface } from '../interfaces/insert-index.interface';
+export declare class IndexedElementHelper {
+    static sliceSection<T extends InsertIndexInterface>(elements: T[], startIndex: number, endIndex: number): T[];
+}

package/lib/+shared/editor/helpers/tab.helper.d.ts

@@ -0,0 +1,3 @@
+export declare class TabHelper {
+    static calculateTabWidth(rowWidth: number, defaultTabWidth: number): number;
+}

package/lib/+shared/editor/interaction/editor.service.d.ts

@@ -0,0 +1,194 @@
+import { Observable } from 'rxjs';
+import { Type } from '@angular/core';
+import { BreakTypes } from '../core/enums/break-types.enum';
+import { EdgeType } from '../core/components/edges/edge-type.enum';
+import { ElementDataModel } from '../custom-components/external-element/models/element-data.model';
+import { ElementModel } from '../../../models/generated/element.model';
+import { ImageDataModel } from '../../../models/generated/image-data.model';
+import { ImageModel } from '../../../models/generated/image.model';
+import { IToolbarStyles } from '../core/interfaces/toolbar-styles.interface';
+import { NumberingLevelModel } from '../../../models/generated/numbering-level.model';
+import { OperationsHistoryInfoModel } from '../operation-history/operations-history-info.model';
+import { ParagraphStyleModel } from '../../../models/generated/paragraph-style.model';
+import { Replace } from '../core/interfaces/replace.interface';
+import { ResizeTableColumnsModel } from '../../../models/generated/resize-table-columns.model';
+import { SearchIteration } from '../core/interfaces/search-iteration.interface';
+import { SearchOptions } from '../core/search';
+import { TextStyleModel } from '../../../models/generated/text-style.model';
+import * as i0 from "@angular/core";
+export declare class EditorService {
+    set styles(value: IToolbarStyles);
+    get styles$(): Observable<IToolbarStyles>;
+    private _styles$;
+    get isViewOnly$(): Observable<boolean>;
+    get isViewOnly(): boolean;
+    private _isViewOnly$;
+    private _isViewOnly;
+    get clipboardData$(): Observable<string>;
+    private _clipboardData$;
+    get hasSelection$(): Observable<boolean>;
+    private _hasSelection$;
+    set historyInfo(value: OperationsHistoryInfoModel);
+    get historyInfo$(): Observable<OperationsHistoryInfoModel>;
+    private _historyInfo$;
+    get toggleSidenav$(): Observable<{
+        open: boolean;
+        component: Type<any>;
+        model: ElementModel;
+        contentWidth: number;
+    }>;
+    private _toggleSidenav$;
+    set openSearchDialog(value: boolean);
+    get openSearchDialog$(): Observable<boolean>;
+    private _openSearchDialog$;
+    set searchOptions(value: SearchOptions);
+    get searchOptions$(): Observable<SearchOptions>;
+    private _searchOptions$;
+    set searchIteration(value: SearchIteration);
+    get searchIteration$(): Observable<SearchIteration>;
+    private _searchIteration$;
+    set replace(value: Replace);
+    get replace$(): Observable<Replace>;
+    private _replace$;
+    get setTextStyles$(): Observable<TextStyleModel>;
+    private _setTextStyles$;
+    get setParagraphStyles$(): Observable<ParagraphStyleModel>;
+    private _setParagraphStyles$;
+    get setNumberingTemplateType$(): Observable<NumberingLevelModel[]>;
+    private _setNumberingTemplateType$;
+    get removeNumberings$(): Observable<void>;
+    private _removeNumberings$;
+    get setImageStyle$(): Observable<ImageModel>;
+    private _changeImageStyle$;
+    get changeElementStyle$(): Observable<ElementModel>;
+    private _changeElementStyle$;
+    get createCustomComponent$(): Observable<ElementDataModel>;
+    private _createCustomComponent$;
+    get insertBreak$(): Observable<BreakTypes>;
+    private _insertBreak$;
+    get insertImage$(): Observable<ImageDataModel>;
+    private _insertImage$;
+    get insertLink$(): Observable<{
+        text: string;
+        link: string;
+    }>;
+    private _insertLink$;
+    get endMousePress$(): Observable<void>;
+    private _endMousePress$;
+    get clearSelection$(): Observable<void>;
+    private _clearSelection$;
+    get changedTableSize$(): Observable<{
+        insertIndex: number;
+        sessionId: number;
+    }>;
+    private _changedTableSize$;
+    get insertTableRows$(): Observable<{
+        insertIndex: number;
+        rowsCount: number;
+        targetIndex: number;
+        inheritIndex: number;
+        sessionId: number;
+    }>;
+    private _insertTableRows$;
+    get insertTableColumns$(): Observable<{
+        insertIndex: number;
+        columnsCount: number;
+        targetIndex: number;
+        inheritIndex: number;
+        sessionId: number;
+    }>;
+    private _insertTableColumns$;
+    get removeTableRows$(): Observable<{
+        insertIndex: number;
+        startIndex: number;
+        endIndex: number;
+        sessionId: number;
+    }>;
+    private _removeTableRows$;
+    get removeTableColumns$(): Observable<{
+        insertIndex: number;
+        startIndex: number;
+        endIndex: number;
+        sessionId: number;
+    }>;
+    private _removeTableColumns$;
+    get removeImage$(): Observable<{
+        insertIndex: number;
+    }>;
+    private _removeImage$;
+    get resizeTableColumns$(): Observable<{
+        resizeTableColumns: ResizeTableColumnsModel;
+        sessionId: number;
+    }>;
+    private _resizeTableColumns$;
+    get insertTable$(): Observable<{
+        rows: number;
+        columns: number;
+    }>;
+    private _insertTable$;
+    get rendererUpdated$(): Observable<number>;
+    private _rendererUpdated$;
+    get edgeElementCopyUpdated$(): Observable<{
+        newElementCopy: HTMLElement;
+        page: number;
+    }>;
+    private _edgeElementCopyUpdated$;
+    get changedEdgeHeight$(): Observable<EdgeType>;
+    private _changedEdgeHeight$;
+    get redo$(): Observable<void>;
+    private _redo$;
+    get undo$(): Observable<void>;
+    private _undo$;
+    get print$(): Observable<void>;
+    private _print$;
+    get cutSelected$(): Observable<void>;
+    private _cutSelected$;
+    get copySelected$(): Observable<void>;
+    private _copySelected$;
+    get pasteFromClipboard$(): Observable<void>;
+    private _pasteFromClipboard$;
+    get selectAll$(): Observable<void>;
+    private _selectAll$;
+    get removeSelected$(): Observable<void>;
+    private _removeSelected$;
+    setIsViewOnly(value: boolean): void;
+    setHasSelection(value: boolean): void;
+    setClipboardData(value: string): void;
+    setTextStyles(value: TextStyleModel): void;
+    setParagraphStyles(value: ParagraphStyleModel): void;
+    setNumberingTemplateType(value: NumberingLevelModel[]): void;
+    removeNumberings(): void;
+    changeImageStyle(value: ImageModel): void;
+    changeElementStyle(value: ElementModel): void;
+    createCustomComponent(model: ElementDataModel): void;
+    insertBreak(value: BreakTypes): void;
+    insertImage(imageData: ImageDataModel): void;
+    insertLink(text: string, link: string): void;
+    endMousePress(): void;
+    clearSelection(): void;
+    toggleSidenav(open: boolean, component: Type<any>, model: ElementModel, contentWidth: number): void;
+    changedTableSize(insertIndex: number, sessionId: number): void;
+    insertTableRows(insertIndex: number, rowsCount: number, targetIndex: number, inheritIndex: number, sessionId: number): void;
+    insertTableColumns(insertIndex: number, columnsCount: number, targetIndex: number, inheritIndex: number, sessionId: number): void;
+    removeTableRows(insertIndex: number, startIndex: number, endIndex: number, sessionId: number): void;
+    removeTableColumns(insertIndex: number, startIndex: number, endIndex: number, sessionId: number): void;
+    removeImage(insertIndex: number): void;
+    resizeTableColumns(resizeTableColumns: ResizeTableColumnsModel, sessionId: number): void;
+    insertTable(tableData: {
+        rows: number;
+        columns: number;
+    }): void;
+    rendererUpdated(sessionId: number): void;
+    edgeElementCopyUpdated(newElementCopy: any, page: any): void;
+    changedEdgeHeight(type: EdgeType): void;
+    undo(): void;
+    redo(): void;
+    print(): void;
+    cutSelected(): void;
+    copySelected(): void;
+    pasteFromClipboard(): void;
+    selectAll(): void;
+    removeSelected(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EditorService>;
+}

package/lib/+shared/editor/interaction/input.handler.d.ts

@@ -0,0 +1,25 @@
+import { Subscription } from 'rxjs';
+import { Editor } from '../core/editor';
+export declare class InputHandler {
+    readonly textareaKeyDown$: Subscription;
+    readonly textareaBlur$: Subscription;
+    readonly textareaFocus$: Subscription;
+    readonly textareaInput$: Subscription;
+    readonly textareaCut$: Subscription;
+    readonly textareaCopy$: Subscription;
+    readonly textareaPaste$: Subscription;
+    private readonly actions;
+    private readonly actionsWithScroll;
+    private readonly actionsWithSelection;
+    constructor(textarea: Node, editor: Editor);
+    destroy(): void;
+    private onInput;
+    private onCut;
+    private onPaste;
+    private onKeyDown;
+    private getKeyCombination;
+    private selectAll;
+    private fillActions;
+    private fillActionsWithScroll;
+    private fillActionsWithSelection;
+}

package/lib/+shared/editor/interaction/mouse.handler.d.ts

@@ -0,0 +1,14 @@
+import { Subscription } from 'rxjs';
+import { Editor } from '../core/editor';
+export declare class MouseHandler {
+    private clicks;
+    documentMouseMove$: Subscription;
+    documentMouseUp$: Subscription;
+    containerWheel$: Subscription;
+    containerMouseDown$: Subscription;
+    constructor(container: Node, editor: Editor);
+    destroy(): void;
+    startMousePress(editor: Editor): void;
+    endMousePress(): void;
+    private onMultiMouseDown;
+}

package/lib/+shared/editor/interfaces/contents.interface.d.ts

@@ -0,0 +1,22 @@
+import { BreakModel } from '../../../models/generated/break.model';
+import { ColumnSectionModel } from '../../../models/generated/column-section.model';
+import { ElementModel } from '../../../models/generated/element.model';
+import { FormatModel } from '../../../models/generated/format.model';
+import { ImageModel } from '../../../models/generated/image.model';
+import { LinkModel } from '../../../models/generated/link.model';
+import { ParagraphModel } from '../../../models/generated/paragraph.model';
+import { TableModel } from '../../../models/generated/table.model';
+import { TabModel } from '../../../models/generated/tab.model';
+export interface ContentsInterface {
+    content: string;
+    contentLength: number;
+    paragraphs: ParagraphModel[];
+    formats: FormatModel[];
+    images: ImageModel[];
+    links: LinkModel[];
+    tables: TableModel[];
+    elements: ElementModel[];
+    breaks: BreakModel[];
+    columnSections: ColumnSectionModel[];
+    tabs: TabModel[];
+}

package/lib/+shared/editor/interfaces/insert-index.interface.d.ts

@@ -0,0 +1,3 @@
+export interface InsertIndexInterface {
+    insertIndex: number;
+}