@sheetxl/sdk 0.8.0-beta.1 → 0.8.0-beta.10

package/types/src/sheetHeader/SheetHeader.d.ts

@@ -35,14 +35,14 @@ export declare class SheetHeader implements ISheetHeader {
     protected _headerRunCoords: RunCoords | null;
     protected _hasHidden: boolean;
     protected _hiddenSignature: number;
+    protected _outlineSignature: number;
     protected _lastHeaderRead: {
         offset: number;
         header: ICellHeader;
     } | null;
     protected _readCache: RunUtils.CacheSearchRunData<_Utils.CellHeaderState> | null;
     protected _lastHeaders: ITypes.RunCoordValue<_Utils.CellHeaderState>[] | null;
-    protected _lastVisibleRunsRead: number | null;
-    protected _lastVisibleRunCoords: RunCoords | null;
+    protected _metrics: ISheetHeader.IMetrics | null;
     protected _entireRunMax: number;
     protected _entireHeaderRange: ICellHeaderRange;
     protected _entireRunCoords: RunCoords;
@@ -53,8 +53,22 @@ export declare class SheetHeader implements ISheetHeader {
     constructor(options: SheetHeader.ConstructorOptions);
     /** {@inheritDoc IListener.ISource.addListeners} */
     addListeners(listeners: ISheetHeader.IListeners, options?: IListener.Options): IListener.Remove;
-    protected _invalidateMaxIndex(): void;
-    protected _invalidSizes(force?: boolean): void;
+    /**
+     * Re-derive what is cached from the sheet's extent: the indexed sizes and the maximum index.
+     *
+     * @remarks
+     * The `onViewChange` listener above does this when it hears the sheet's extent change. An
+     * operation that changes the extent and then writes against it - `Sheet.setEntireSize` grows
+     * the sheet and then inserts into the new band, which is bounds-checked against the maximum
+     * index - cannot wait to be told, so it calls this.
+     *
+     * @internal
+     */
+    _invalidateExtent(): void;
+    /** Returns `true` if the maximum index changed. */
+    protected _invalidateMaxIndex(): boolean;
+    /** Returns `true` if the sizes were re-indexed. */
+    protected _invalidSizes(force?: boolean): boolean;
     /**
      * Force the header to re-read configurations.
      *
@@ -76,6 +90,8 @@ export declare class SheetHeader implements ISheetHeader {
     } | void;
     /** {@inheritDoc ISheetHeader.getRange} */
     getRange(address: ICellHeaderRange.Address, options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
+    /** {@inheritDoc ISheetHeader.getFilteredRanges} */
+    getFilteredRanges(coords?: Readonly<RunCoords>): readonly ICellHeaderRange[];
     /** {@inheritDoc ISheetHeader.getRanges} */
     getRanges(address: ICellHeaderRanges.Address, options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
     /** {@inheritDoc ISheetHeader.getSelectedRange} */
@@ -98,38 +114,31 @@ export declare class SheetHeader implements ISheetHeader {
     protected _getSnapshot(coordsFrom: RunCoords, optionsMark?: ICellHeaderRange.CopyOptions): ICellHeaderRange.ISnapshot;
     /** {@inheritDoc ISheetHeader.isProtected} */
     isProtected(): boolean;
-    /** {@inheritDoc ISheetHeader.getScaleFactor} */
-    getScaleFactor(): number;
     protected get _headers(): ITypes.RunCoordValue<_Utils.CellHeaderState>[];
     protected _updatePairsInternal(setters: ICellHeaderRange.AddressUpdatePair[], options?: ICellHeaderRange.UpdateHeadersOptions): RunCoords[] | null;
-    /** {@inheritDoc ISheetHeader.hasHidden} */
-    hasHidden(): boolean;
-    /** {@inheritDoc ISheetHeader.getDefaultSize} */
-    getDefaultSize(): number;
+    /**
+     * The header runs as stored: ordered, non-overlapping, gaps are default headers.
+     *
+     * @remarks
+     * The array is replaced, never mutated, when the headers change, so its identity can key a cache.
+     *
+     * @internal
+     */
+    _getHeaderRuns(): readonly ITypes.RunCoordValue<_Utils.CellHeaderState>[];
     /** {@inheritDoc ISheetHeader.getDefaultSizeNative} */
     getDefaultSizeNative(): number;
     /** {@inheritDoc ISheetHeader.getMaxSize} */
     getMaxSize(): number;
     /** {@inheritDoc ISheetHeader.getMinSize} */
     getMinSize(): number;
-    /** {@inheritDoc ISheetHeader.getOffset} */
-    getOffset(index: number): number;
-    /** {@inheritDoc ISheetHeader.getIndex} */
-    getIndex(offset: number): number;
-    /** {@inheritDoc ISheetHeader.getVisibleIndex} */
-    getVisibleIndex(index: number): RunCoords;
-    /** {@inheritDoc ISheetHeader.getSpanSize} */
-    getSpanSize(indexFrom: number, indexTo?: number): number;
-    /** {@inheritDoc ISheetHeader.getVisibleCount} */
-    getVisibleCount(indexFrom: number, indexTo: number): number;
+    /** {@inheritDoc ISheetHeader.getMetrics} */
+    getMetrics(): ISheetHeader.IMetrics;
     /** {@inheritDoc ISheetHeader.isSelectedAll} */
     isSelectedAll(index: number): boolean;
     /** {@inheritDoc ISheetHeader.isSelected} */
     isSelected(index: number): boolean;
     /** {@inheritDoc ISheetHeader.getSelectedRuns} */
     getSelectedRuns(): readonly ITypes.RunCoordValue<boolean>[];
-    /** {@inheritDoc ISheetHeader.hiddenHeadersAt} */
-    hiddenHeadersAt(index: number, reverse?: boolean): number;
     protected _insertHeaders(index: number, amount: number): void;
     protected _deleteHeaders(index: number, amount: number): void;
     /** {@inheritDoc ITransaction.ITransactional.beginCommit} */
@@ -153,6 +162,8 @@ export declare class SheetHeader implements ISheetHeader {
     toJSON(): ISheetHeader.JSON | null;
     get [Symbol.toStringTag](): string;
     toString(): string;
+    /** {@inheritDoc ISheetHeader.isISheetHeader} */
+    get isISheetHeader(): true;
 }
 /**
  * {@inheritDoc SheetHeader}
@@ -231,6 +242,15 @@ export declare namespace SheetHeader {
          * @param amount
          */
         setContainerShiftedCallback?: (callback: ShiftCallback) => void;
+        /**
+         * Called when the set of hidden headers changes, as it changes: inside the operation that
+         * changed it, or with none open for an undo or a redo.
+         *
+         * @remarks
+         * The `onHiddenChange` listener hears of the same change once the operation has closed. This
+         * is for an owner that has to act within the operation.
+         */
+        hiddenChanged?: () => void;
         /**
          * JSON state to load.
          */

package/types/src/sheetHeader/_HeaderMetrics.d.ts

@@ -0,0 +1,37 @@
+import { RunCoords } from '@sheetxl/utils';
+import { ISheetHeader } from './ISheetHeader';
+import * as _Utils from './_HeaderUtils';
+/**
+ * One version of a header's measurements. Everything it reads is captured at construction: the
+ * running-size index is rebuilt (never edited) whenever a size changes, so holding the references is
+ * enough to keep answering for this version.
+ */
+export declare class HeaderMetrics implements ISheetHeader.IMetrics {
+    private readonly _indexedSizes;
+    private readonly _defaultPxSize;
+    private readonly _scaleFactor;
+    private readonly _maxIndex;
+    private readonly _hasHidden;
+    private _lastVisibleIndex;
+    private _lastVisibleRun;
+    constructor(indexedSizes: readonly _Utils.RunningHeaderSize[], defaultPxSize: number, scaleFactor: number, maxIndex: number, hasHidden: boolean);
+    /** {@inheritDoc ISheetHeader.IMetrics.getScaleFactor} */
+    getScaleFactor(): number;
+    /** {@inheritDoc ISheetHeader.IMetrics.getDefaultSize} */
+    getDefaultSize(): number;
+    /** {@inheritDoc ISheetHeader.IMetrics.getOffset} */
+    getOffset(index: number): number;
+    /** {@inheritDoc ISheetHeader.IMetrics.getIndex} */
+    getIndex(offset: number): number;
+    /** {@inheritDoc ISheetHeader.IMetrics.getSpanSize} */
+    getSpanSize(indexFrom: number, indexTo?: number): number;
+    /** {@inheritDoc ISheetHeader.IMetrics.getVisibleIndex} */
+    getVisibleIndex(index: number): Readonly<RunCoords>;
+    /** {@inheritDoc ISheetHeader.IMetrics.getVisibleCount} */
+    getVisibleCount(indexFrom: number, indexTo: number): number;
+    /** {@inheritDoc ISheetHeader.IMetrics.hiddenHeadersAt} */
+    hiddenHeadersAt(index: number, reverse?: boolean): number;
+    /** {@inheritDoc ISheetHeader.IMetrics.hasHidden} */
+    hasHidden(): boolean;
+}
+//# sourceMappingURL=_HeaderMetrics.d.ts.map

package/types/src/sheetHeader/_HeaderUtils.d.ts

@@ -2,7 +2,7 @@ import { RunCoords } from '@sheetxl/utils';
 import { IRange } from '@sheetxl/primitives';
 import { ITypes } from '../type';
 import { CacheSearchRunData } from '../collections/_RunUtils';
-import { IStyle } from '../style';
+import { ICellStyle } from '../style';
 import { ICellHeaderRange, ICellHeaderRanges } from '../cellRange';
 /**
  * Note - By using optional keys as a way to detect default values we are creating mono polymorphic objects. (perform issue in V8).
@@ -14,10 +14,12 @@ export interface CellHeaderState {
     sz?: number;
     csz?: boolean;
     h?: boolean;
-    s?: IStyle;
+    s?: ICellStyle;
     cs?: boolean;
-    /** outline level */
+    /** outline level, 1-7; absent when not grouped */
     l?: number;
+    /** collapsed; set on a group's summary header */
+    cl?: boolean;
 }
 /**
  * Use for tracking the accumulated sizes from the beginning of the headers.

package/types/src/sheetProtection/ISheetProtection.d.ts

@@ -7,8 +7,8 @@ export interface ISheetProtection extends IProtection<ISheetProtection, ISheetPr
     /**
      * Retrieves the protection properties for the sheet.
      *
-     * @returns The {@link ISheetProtection.Properties} object representing the current protection settings,
-     * or `null` if the sheet is not locked.
+     * @returns The {@link ISheetProtection.Properties} the sheet protects with, kept while it is
+     * unprotected, or `null` when it has none.
      */
     getProperties(): Partial<ISheetProtection.Properties> | null;
     /**
@@ -90,17 +90,36 @@ export interface ISheetProtection extends IProtection<ISheetProtection, ISheetPr
      */
     isSortAllowed(): boolean;
     /**
-     * Checks if selecting locked cells is protected on the sheet.
+     * Checks if formulas may be shown on the protected sheet.
      *
-     * @returns `true` if selecting locked cells is locked, `false` otherwise.
+     * @returns `false` if the sheet hides its formulas while protected.
+     *
+     * @remarks
+     * * While this is `false`, a cell's formula shows only when its style grants it
+     *   (`ICellProtection.isShowFormulas`) — an exception, the way an always-unlocked cell is one.
+     * * Defaults to `true`, and is always `true` while the sheet is not locked (including paused).
+     */
+    isShowFormulasAllowed(): boolean;
+    /**
+     * Checks if locked cells may be selected on the protected sheet.
+     *
+     * @returns `false` if the sheet refuses selection of its locked cells while protected.
+     *
+     * @remarks
+     * Defaults to `true`, and is always `true` while the sheet is not locked (including paused).
      */
     isSelectLockedCellsAllowed(): boolean;
     /**
-     * Checks if selecting unlocked cells is protected on the sheet.
+     * Checks if unlocked cells may be selected on the protected sheet.
      *
-     * @returns `true` if selecting unlocked cells is locked, `false` otherwise.
+     * @returns `false` if the sheet refuses selection of its unlocked cells while protected.
+     *
+     * @remarks
+     * Defaults to `true`, and is always `true` while the sheet is not locked (including paused).
      */
     isSelectUnlockedCellsAllowed(): boolean;
+    /** For runtime type checking. */
+    readonly isISheetProtection: true;
 }
 /**
  * {@inheritDoc ISheetProtection}
@@ -110,6 +129,12 @@ export interface ISheetProtection extends IProtection<ISheetProtection, ISheetPr
  * {@link ISheetProtection}
  */
 export declare namespace ISheetProtection {
+    /**
+     * @remarks
+     * There is no whole-sheet flag here: changing it is {@link IProtection.lock} and
+     * {@link IProtection.unlock}, reading it {@link ISheetProtection.isLocked}. It is saved as
+     * {@link ISheetProtection.JSON.sheet}.
+     */
     interface Properties extends IProtection.Properties {
         /** {@inheritDoc ISheetProtection.isAutoTableAllowed} */
         autoTable?: boolean;
@@ -141,9 +166,18 @@ export declare namespace ISheetProtection {
         selectUnlockedCells?: boolean;
         /** {@inheritDoc ISheetProtection.isSortAllowed} */
         sort?: boolean;
-        sheet?: boolean;
+        /** {@inheritDoc ISheetProtection.isShowFormulasAllowed} */
+        showFormulas?: boolean;
     }
     interface JSON extends ISheetProtection.Properties, IProtection.JSON {
+        /**
+         * `true` when the whole sheet stays allowed: it is not protected, and keeps its options for the
+         * next lock. Absent, the sheet is protected.
+         *
+         * @remarks
+         * Like every allowance here, the inverse of its OOXML attribute (`sheet="1"` is protected).
+         */
+        sheet?: boolean;
     }
     type PropertyKeys = (keyof ISheetProtection.Properties);
 }

package/types/src/sheetProtection/SheetProtection.d.ts

@@ -27,13 +27,25 @@ export declare class SheetProtection extends DefaultProtection<ISheetProtection,
     isScenariosAllowed(): boolean;
     /** {@inheritDoc ISheetProtection.isSortAllowed} */
     isSortAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isShowFormulasAllowed} */
+    isShowFormulasAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isSelectLockedCellsAllowed} */
     isSelectLockedCellsAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isSelectUnlockedCellsAllowed} */
     isSelectUnlockedCellsAllowed(): boolean;
+    /**
+     * A property that a locked sheet must deny explicitly: unset is allowed, and read-only does not
+     * deny it. The opposite of {@link _isPropertyAllowed}, which a locked sheet must grant explicitly.
+     */
+    protected _isPropertyAllowedByDefault(property: ISheetProtection.PropertyKeys): boolean;
+    protected _getAllowedKey(): string;
     protected _updateProperties(properties: ISheetProtection.Properties | null): void;
     protected _clearProperties(): void;
     protected _fromJSON(json: ISheetProtection.JSON | null): void;
     protected _toJSON(json: ISheetProtection.JSON): ISheetProtection.JSON;
     get [Symbol.toStringTag](): string;
     toString(): string;
+    /** {@inheritDoc ISheetProtection.isISheetProtection} */
+    get isISheetProtection(): true;
 }
 //# sourceMappingURL=SheetProtection.d.ts.map

package/types/src/sheetView/ISheetView.d.ts

@@ -2,8 +2,7 @@ import { IRange } from '@sheetxl/primitives';
 import { TopLeft } from '@sheetxl/utils';
 import { IListener } from '../listener';
 import { IColor } from '../color';
-import { IMovable, IMovableSelection } from '../movable';
-import { IRangeSelection } from '../selection';
+import { IMovableSelection, IRangeSelection } from '../selection';
 import { ISheet } from '../sheet';
 /**
  * The `ISheetView` provides properties and methods for controlling how a sheet is displayed and interacted with,
@@ -16,7 +15,16 @@ import { ISheet } from '../sheet';
  * * Since views only affect the presentation of the data, changes to view settings are typically not included in the undo/redo stack.
  * * Multiple views can be associated to the same collection of data, each providing a different way of viewing and interacting.
  */
-export interface ISheetView extends IMovableSelection, IListener.ISource<IMovableSelection> {
+export interface ISheetView {
+    /**
+     * Identifies this view.
+     *
+     * @remarks
+     * Stable for the life of the view. A sheet can be shown through more than one view — each user
+     * in a shared workbook has their own — so anything recorded against a view (a restored
+     * selection, for example) names it by this id rather than holding the view itself.
+     */
+    getId(): string;
     /**
      * The top left scroll position of the (main) pane.
      *
@@ -31,7 +39,7 @@ export interface ISheetView extends IMovableSelection, IListener.ISource<IMovabl
     getTopLeft(): TopLeft;
     /**
      * The first VISIBLE cell — the cell sitting at the grid's top-left corner right now. `A1` when
-     * unscrolled.
+     * un-scrolled.
      *
      * @remarks
      * The cell-coordinate reading of {@link getTopLeft} (which is base px), resolved against the row /
@@ -157,6 +165,37 @@ export interface ISheetView extends IMovableSelection, IListener.ISource<IMovabl
      * @see {@link setShowFormulas}
      */
     isShowFormulas(): boolean;
+    /**
+     * Indicate whether the cells that sheet protection locks are shaded, leaving the ranges that stay
+     * editable clear.
+     *
+     * @defaultValue `false`
+     *
+     * @remarks
+     * Only meaningful while the sheet is protected: it shades what protection is actually holding
+     * shut, so an unprotected sheet has nothing to shade.
+     */
+    setShowLockedShading(showLockedShading: boolean): this;
+    /**
+     * @see {@link setShowLockedShading}
+     */
+    isShowLockedShading(): boolean;
+    /**
+     * Indicate whether cells whose value fails a data validation are marked.
+     *
+     * @defaultValue `false`
+     *
+     * @remarks
+     * The sheet's counterpart of Excel's *Circle Invalid Data*, except that the marks follow the
+     * values as they change. A cell is marked when its value fails any data validation covering it;
+     * a list cell is marked only when its value is not on the list. Not written to xlsx, where Excel
+     * keeps no such setting.
+     */
+    setShowInvalid(showInvalid: boolean): this;
+    /**
+     * @see {@link setShowInvalid}
+     */
+    isShowInvalid(): boolean;
     /**
      * Indicate whether the sheet is displayed right-to-left (the leftmost column on
      * the right). Persisted per sheet; round-trips through xlsx `sheetView@rightToLeft`.
@@ -181,6 +220,21 @@ export interface ISheetView extends IMovableSelection, IListener.ISource<IMovabl
      * @see {@link setShowZeros}
      */
     isShowZeros(): boolean;
+    /**
+     * Indicate whether the outline symbols (the brackets, the collapse and expand buttons and the
+     * level buttons of the row and column groups) are shown.
+     *
+     * @defaultValue `true`
+     *
+     * @remarks
+     * A view setting, as in Excel (`Window.DisplayOutline`, Ctrl+8): the groups stay on the sheet,
+     * only their symbols are hidden. Round-trips through xlsx `sheetView@showOutlineSymbols`.
+     */
+    setShowOutlineSymbols(showOutlineSymbols: boolean): this;
+    /**
+     * @see {@link setShowOutlineSymbols}
+     */
+    isShowOutlineSymbols(): boolean;
     /**
      * The color of the gridline on the sheet.
      *
@@ -200,18 +254,12 @@ export interface ISheetView extends IMovableSelection, IListener.ISource<IMovabl
      */
     getRangeSelection(): IRangeSelection;
     /**
-     * Add a movable to the selection.
-     * If addToSelection is true then the items will be added to the selection.
+     * Returns the movable selection: the drawings selected on the sheet.
      *
-     * @param movables The movables to select.
-     * @param addToSelection
-     */
-    selectMovables(movables: readonly IMovable[], addToSelection?: boolean): this;
-    /**
-     * Removes the movables from selection (if they were selected)
-     * @param movables
+     * @remarks
+     * Held beside the {@link getRangeSelection | range selection}, independently of it.
      */
-    unselectMovables(movables: readonly IMovable[]): this;
+    getMovableSelection(): IMovableSelection;
     /**
      * Allow for a bulk update of the view properties.
      */
@@ -266,7 +314,7 @@ export declare namespace ISheetView {
     /**
      * A listener for changes to the ISheetView object.
      */
-    interface Events extends IMovableSelection.Events {
+    interface Events {
         /**
          * Called when the sheetView changes.
          */
@@ -329,8 +377,14 @@ export declare namespace ISheetView {
         zoomScale: number;
         /** {@inheritDoc ISheetView.setShowFormulas} */
         showFormulas: boolean;
+        /** {@inheritDoc ISheetView.setShowLockedShading} */
+        showLockedShading: boolean;
+        /** {@inheritDoc ISheetView.setShowInvalid} */
+        showInvalid: boolean;
         /** {@inheritDoc ISheetView.setShowZeros} */
         showZeros: boolean;
+        /** {@inheritDoc ISheetView.setShowOutlineSymbols} */
+        showOutlineSymbols: boolean;
         /** {@inheritDoc ISheetView.setRightToLeft} */
         rightToLeft: boolean;
         /** {@inheritDoc ISheetView.setGridLineColor} */

package/types/src/sheetView/SheetView.d.ts

@@ -2,22 +2,25 @@ import { IRange } from '@sheetxl/primitives';
 import { TopLeft } from '@sheetxl/utils';
 import { IListener } from '../listener';
 import { IColor } from '../color';
-import { IMovable, IMovableSelection } from '../movable';
-import { IRangeSelection } from '../selection';
+import { IMovableSelection, IRangeSelection } from '../selection';
 import { ISheet } from '../sheet';
 import { ListenerEmitter } from '../listener/ListenerEmitter';
 import { ISheetView } from './ISheetView';
 /**
  * Default Sheet View
  */
-export declare class SheetView implements ISheetView, IMovableSelection {
+export declare class SheetView implements ISheetView {
     protected _state: ISheetView.Properties;
     protected _sheet: ISheet;
     protected _rangeSelection: IRangeSelection;
     protected _rangeSelectionRemoveListener: IListener.Remove;
     protected _emitter: ListenerEmitter<ISheetView, ISheetView.IListeners>;
-    protected _movableSelection: readonly IMovable[];
+    protected _movableSelection: IMovableSelection;
+    protected _movableSelectionRemoveListener: IListener.Remove;
+    protected _id: string;
     constructor(options: ISheetView.ConstructorOptions);
+    /** {@inheritDoc ISheetView.getId} */
+    getId(): string;
     /** {@inheritDoc ISheetView.addListeners} */
     addListeners(listeners: ISheetView.IListeners, options?: IListener.Options): IListener.Remove;
     /** {@inheritDoc ISheetView.setTopLeft} */
@@ -74,6 +77,14 @@ export declare class SheetView implements ISheetView, IMovableSelection {
     isShowFormulas(): boolean;
     /** {@inheritDoc ISheetView.setShowFormulas} */
     setShowFormulas(newValue: boolean): this;
+    /** {@inheritDoc ISheetView.isShowLockedShading} */
+    isShowLockedShading(): boolean;
+    /** {@inheritDoc ISheetView.setShowLockedShading} */
+    setShowLockedShading(newValue: boolean): this;
+    /** {@inheritDoc ISheetView.isShowInvalid} */
+    isShowInvalid(): boolean;
+    /** {@inheritDoc ISheetView.setShowInvalid} */
+    setShowInvalid(newValue: boolean): this;
     /** {@inheritDoc ISheetView.isRightToLeft} */
     isRightToLeft(): boolean;
     /** {@inheritDoc ISheetView.setRightToLeft} */
@@ -82,6 +93,10 @@ export declare class SheetView implements ISheetView, IMovableSelection {
     isShowZeros(): boolean;
     /** {@inheritDoc ISheetView.setShowZeros} */
     setShowZeros(newValue: boolean): this;
+    /** {@inheritDoc ISheetView.isShowOutlineSymbols} */
+    isShowOutlineSymbols(): boolean;
+    /** {@inheritDoc ISheetView.setShowOutlineSymbols} */
+    setShowOutlineSymbols(newValue: boolean): this;
     /** {@inheritDoc ISheetView.getGridLineColor} */
     getGridLineColor(): any;
     /** {@inheritDoc ISheetView.setGridLineColor} */
@@ -89,13 +104,7 @@ export declare class SheetView implements ISheetView, IMovableSelection {
     /** {@inheritDoc ISheetView.getRangeSelection} */
     getRangeSelection(): IRangeSelection;
     /** {@inheritDoc ISheetView.getMovableSelection} */
-    getMovableSelection(): readonly IMovable[];
-    /** {@inheritDoc ISheetView.setMovableSelection} */
-    setMovableSelection(newValue: readonly IMovable[] | null): this;
-    /** {@inheritDoc IMovableSelection.selectMovables} */
-    selectMovables(movables: readonly IMovable[], addToSelection?: boolean): this;
-    /** {@inheritDoc IMovableSelection.unselectMovables} */
-    unselectMovables(movables: IMovable[]): this;
+    getMovableSelection(): IMovableSelection;
     protected _update<T extends ISheetView.Properties[K], K extends keyof ISheetView.Properties>(newValue: T, property: K, event: keyof ISheetView.IListeners): T;
     protected _notifyAll(): void;
     /** {@inheritDoc ISheetView.toJSON} */