@sheetxl/sdk 0.7.27 → 0.7.28-beta.1

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

@@ -0,0 +1,257 @@
+import { IRange } from '@sheetxl/primitives';
+import { RunCoords } from '@sheetxl/utils';
+import { ITypes } from '../type';
+import { ITransaction } from '../transaction';
+import { IListener } from '../listener';
+import { ICellHeader } from '../cell';
+import { ITable } from '../table';
+import { ICellHeaderRange, ICellHeaderRanges } from '../cellRange';
+import { IRangeSelection } from '../selection';
+import { ISheet } from '../sheet';
+import { ISheetHeader } from './ISheetHeader';
+import { ListenerEmitter } from '../listener/ListenerEmitter';
+import { CreateCellHeaderCallback } from './SheetCellHeader';
+import * as RunUtils from '../collections/_RunUtils';
+import * as _Utils from './_HeaderUtils';
+/**
+ * For updating and working with headers (rows/columns).
+ */
+export declare class SheetHeader implements ISheetHeader {
+    protected _emitter: ListenerEmitter<ISheetHeader, ISheetHeader.IListeners>;
+    protected _options: ResolvedConstructorOptions;
+    protected _sheetRemoveListener: IListener.Remove;
+    protected _transactions: ITransaction.IStore;
+    protected _transactionsRemoveListener: IListener.Remove;
+    protected _id: string;
+    protected _closed: boolean;
+    protected _emptyHeader: ICellHeader;
+    protected _scaleFactor: number;
+    protected _defaultSize: number;
+    protected _defaultCustomSize: number;
+    protected _defaultPxSize: number;
+    protected _isColumn: boolean;
+    protected _indexedSizes: readonly _Utils.RunningHeaderSize[];
+    protected _indexedHidden: _Utils.IndexedRun[];
+    protected _headerRunCoords: RunCoords | null;
+    protected _hasHidden: boolean;
+    protected _hiddenSignature: 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 _entireRunMax: number;
+    protected _entireHeaderRange: ICellHeaderRange;
+    protected _entireRunCoords: RunCoords;
+    protected _entireRangeCoords: IRange.Coords;
+    protected _entireSheetCoords: IRange.Coords;
+    protected _selectionRuns: readonly ITypes.RunCoordValue<boolean>[] | null;
+    protected _selection: IRangeSelection.Coords;
+    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;
+    /**
+     * Force the header to re-read configurations.
+     *
+     * @remarks
+     * This exists to support loading after the sheet view.
+     *
+     * @internal
+     */
+    invalidate(): void;
+    protected _onHeaderChange(sizeUpdate: boolean): void;
+    /** {@inheritDoc ISheetHeader.getSheet} */
+    getSheet(): ISheet;
+    /** {@inheritDoc ISheetHeader.getAxis} */
+    getAxis(): IRange.Axis;
+    /** {@inheritDoc ISheetHeader.getTextAt} */
+    getTextAt(index: number): string;
+    protected _scanHeaders<T = any>(callback: ICellHeaderRange.ForEachSpanCallback<T>, headerState: State, createCellHeader: CreateCellHeaderCallback, optionsRange: ICellHeaderRange.GetRangeOptions | null, asRun: RunCoords, options: ICellHeaderRange.IteratorOptions): {
+        break: T;
+    } | void;
+    /** {@inheritDoc ISheetHeader.getRange} */
+    getRange(address: ICellHeaderRange.Address, options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
+    /** {@inheritDoc ISheetHeader.getRanges} */
+    getRanges(address: ICellHeaderRanges.Address, options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
+    /** {@inheritDoc ISheetHeader.getSelectedRange} */
+    getSelectedRange(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
+    /** {@inheritDoc ISheetHeader.getSelectedRanges} */
+    getSelectedRanges(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
+    /** {@inheritDoc ISheetHeader.getUsedRange} */
+    getUsedRange(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
+    /** {@inheritDoc ISheetHeader.getEntireRange} */
+    getEntireRange(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
+    /** {@inheritDoc ISheetHeader.at} */
+    at(index: number): ICellHeader;
+    /** {@inheritDoc ISheetHeader.updateHeaderPairs} */
+    updateHeaderPairs(pairs: ICellHeaderRange.AddressUpdatePair[], options?: ICellHeaderRange.UpdateHeadersOptions): RunCoords[] | null;
+    protected _parseHeaderRangeAddress(address: ICellHeaderRange.Address | undefined, r1c1?: boolean): RunCoords;
+    protected _update(addresses: ICellHeaderRange.Address | ICellHeaderRange.Address[], update: ICellHeader.Update, options?: ICellHeaderRange.UpdateHeadersOptions): this | undefined;
+    protected _setSize(address: ICellHeaderRange.Address | ICellHeaderRange.Address[], size?: number | string | null, options?: ICellHeaderRange.SetSizeOptions): this;
+    protected _setHidden(address: ICellHeaderRange.Address | ICellHeaderRange.Address[], hidden?: boolean | null, options?: ICellHeaderRange.UpdateHeadersOptions): this;
+    protected _clear(coords: RunCoords, options?: ICellHeaderRange.UpdateHeadersOptions): void;
+    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;
+    /** {@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.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} */
+    beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
+    /** {@inheritDoc ITransaction.ITransactional.doBatch} */
+    doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ITransaction.OperationOptions): R | Promise<R>;
+    /** {@inheritDoc ITransaction.ITransactional.getId} */
+    getId(): string;
+    /** {@inheritDoc ITransaction.ITransactional.getVersionId} */
+    getVersionId(): number;
+    /** {@inheritDoc ITransaction.ITransactional.isClosed} */
+    isClosed(): boolean;
+    /** {@inheritDoc ISheetHeader.close} */
+    close(): void;
+    protected _getState(): State;
+    protected _beginCommit(options?: ITransaction.StoreOperationOptions): ITransaction;
+    protected _updateState(updateState: Partial<State>, sizeUpdate?: boolean): void;
+    /** {@inheritDoc ISheetHeader.fromJSON} */
+    fromJSON(json?: ISheetHeader.JSON): void;
+    /** {@inheritDoc ISheetHeader.toJSON} */
+    toJSON(): ISheetHeader.JSON | null;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+}
+/**
+ * {@inheritDoc SheetHeader}
+ * @see
+ * ### **Interface**
+ *
+ * {@link SheetHeader}
+ */
+export declare namespace SheetHeader {
+    /**
+     * Constructor Options for Sheet Header.
+     *
+     * @remarks
+     * Used by `Sheet`.
+     */
+    interface ConstructorOptions {
+        /**
+         * The {@link ISheet} containing the Headers.
+         */
+        sheet: ISheet;
+        /**
+         * The axis of the data.
+         *
+         * @defaultValue IRange.Axis.Column
+         *
+         * @remarks
+         * This is the opposite of the axis of the layout. For examples a header that manages
+         * columns will be visibility orientated as a row.
+         */
+        axis?: IRange.Axis;
+        createCellHeader?: CreateCellHeaderCallback;
+        transactions?: ITransaction.IStore;
+        /**
+         * If true the Header will error if any updates are attempted.
+         */
+        isProtected?: () => boolean;
+        /**
+         * Return the display text at the given index.
+         */
+        getTextAt?: (index: number) => string;
+        /**
+         * The size of the header without any customizations.
+         *
+         * @defaultValue 100
+         *
+         * @remarks
+         * Must be great than 0.
+         */
+        defaultSize?: () => number;
+        /**
+         * The minimum size of the header.
+         *
+         * @defaultValue 0
+         *
+         * @remarks
+         * Must be great than or equal 0.
+         */
+        minSize?: () => number;
+        maxSize?: () => number;
+        /**
+         * A callback to return the maximum index of the header.
+         */
+        getEntireSheetCoords?: () => IRange.Coords | null;
+        /**
+         * A number that represents a scaling factor.
+         */
+        scaleFactor?: () => number;
+        /**
+         * A callback to return the column filter at a given index.
+         */
+        getColumnAt?: (index: number) => ITable.IColumn | null;
+        /**
+         * A callback to tell the headers to shift.
+         *
+         * @param index
+         * @param amount
+         */
+        setContainerShiftedCallback?: (callback: ShiftCallback) => void;
+        /**
+         * JSON state to load.
+         */
+        json?: ISheetHeader.JSON;
+    }
+    /**
+     * `Sheet`s manage the insertion and deletion of headers. To notify that this
+     * should occur the ShiftCallback is used.
+     */
+    interface ShiftCallback {
+        (index: number, amount: number): void;
+    }
+}
+/**
+ * {@link SheetHeader.ConstructorOptions} with the keys that are defaulted in the
+ * constructor guaranteed to be present.
+ */
+type ResolvedConstructorOptions = SheetHeader.ConstructorOptions & Required<Pick<SheetHeader.ConstructorOptions, 'isProtected' | 'scaleFactor' | 'defaultSize' | 'minSize' | 'maxSize' | 'getEntireSheetCoords' | 'axis' | 'createCellHeader'>>;
+interface State {
+    headers: ITypes.RunCoordValue<_Utils.CellHeaderState>[];
+    defaultCustomSize: number;
+}
+export {};
+//# sourceMappingURL=SheetHeader.d.ts.map

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

@@ -0,0 +1,94 @@
+import { RunCoords } from '@sheetxl/utils';
+import { IRange } from '@sheetxl/primitives';
+import { ITypes } from '../type';
+import { CacheSearchRunData } from '../collections/_RunUtils';
+import { IStyle } 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).
+ * Revisit and store all keys as a single type.
+ * 1. Create a 'default' state. We will need an isEmpty method to compare all value for pruning. (Probably just )
+ * 2. Only save values that are different than the default state
+ */
+export interface CellHeaderState {
+    sz?: number;
+    csz?: boolean;
+    h?: boolean;
+    s?: IStyle;
+    cs?: boolean;
+    /** outline level */
+    l?: number;
+}
+/**
+ * Use for tracking the accumulated sizes from the beginning of the headers.
+ * @remarks
+ * This is a run but doesn't conform to the Run interface.
+ */
+export interface RunningHeaderSize {
+    min: number;
+    max: number;
+    spanSize: number;
+    runningOffsetMin: number;
+    runningOffsetMax: number;
+    /**
+     * The running headers up to run.
+     */
+    runningHiddenRuns: number;
+}
+export interface IndexedRun extends ITypes.RunCoordValue<boolean> {
+}
+export interface IndexedHeaders {
+    sizes: RunningHeaderSize[];
+    hidden: IndexedRun[];
+}
+export declare function nocToPx(noc: number, mdw: number): number;
+/**
+ * Builds a list of measurable spans. We don't allow any gaps to make search faster.
+ * Note - These are saved as pixels so that we can render quickly.
+ * We could be even smarter and only re-index from a given offset but optimization for later (if needed).
+ */
+export declare function indexHeaderSizes(runs: ITypes.RunCoordValue<CellHeaderState>[], defaultSize: number, scaleFactor: number): IndexedHeaders;
+/**
+ * These assume a results from {@link indexHeaderSizes} is used. No error handling is performed.
+ * All size runs must be contiguous.
+ *
+ * @param sizes
+ * @param index
+ * @returns The offset for the given index.
+ */
+export declare function getOffset(sizes: readonly RunningHeaderSize[], index: number, defaultSize: number): number;
+export declare function getOffsetCached(cache: CacheSearchRunData<RunningHeaderSize>, index: number, defaultSize: number): number;
+/**
+ * These assume a results from {@link indexHeaderSizes} are used. No error handling is performed.
+ * sizes.length > 0. All values must be contiguous. offset must be >= 0 && offset <= size[size.length].maxOffset.
+ *
+ * @param sizes
+ * @param offset
+ * @returns the index for the given offset.
+ *
+ * @remarks
+ * If the current index is hidden it will return the offset before the value
+ */
+export declare function getIndex(sizes: readonly RunningHeaderSize[], offset: number, defaultSize: number): number;
+/**
+ * Finds the visibleIndex for a given absolute index.
+ * Returns a RunCoords. This can be used to determine if an index is hidden
+ * If it's hidden it will return a range of 1 with a value before the offset and after.
+ * If it's visible then it will return a range of 0 with the min and max that exactly match the offset.
+ *
+ * @param index The absolute index
+ *
+ * @remarks
+ * If this is on the edge of the bounds this will return a +/- 1 the max bounds.
+ */
+export declare function findRunningHiddenRuns(sizes: readonly RunningHeaderSize[], index: number, maxIndex?: number): RunCoords;
+/**
+ * Finds the total length between to points account for hidden spans.
+ * No validation is done.
+ */
+export declare function findRunningSpanLength(runs: readonly RunningHeaderSize[], from: number, to: number): number;
+/** @internal */
+export declare function parseHeaderRangesAddress(address: ICellHeaderRanges.Address, isColumn: boolean, defaultRange?: IRange.FixableCoords): RunCoords[];
+/** @internal */
+export declare function parseHeaderRangeAddress(address: ICellHeaderRange.Address, isColumn: boolean, defaultRange?: IRange.FixableCoords, r1c1?: boolean): RunCoords | null;
+//# sourceMappingURL=_HeaderUtils.d.ts.map

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

@@ -0,0 +1,7 @@
+import { ICellHeaderRange } from '../cellRange';
+import { ISheetHeader } from './ISheetHeader';
+/**
+ * Create an invalid range.
+ */
+export declare function createInvalidRange(header: ISheetHeader): ICellHeaderRange;
+//# sourceMappingURL=_InvalidSheetHeaderRange.d.ts.map

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

@@ -0,0 +1,2 @@
+export * from './ISheetHeader';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,150 @@
+import { IProtection } from '../protection/IProtection';
+/**
+ * Interface representing the protection settings for a sheet.
+ * Extends the base `IProtection` interface with additional sheet-specific protection options.
+ */
+export interface ISheetProtection extends IProtection<ISheetProtection, ISheetProtection.Properties, ISheetProtection.JSON> {
+    /**
+     * 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.
+     */
+    getProperties(): Partial<ISheetProtection.Properties> | null;
+    /**
+     * Checks if the AutoTable functionality is protected on the sheet.
+     *
+     * @returns `true` if AutoTable is locked, `false` otherwise.
+     */
+    isAutoTableAllowed(): boolean;
+    /**
+     * Checks if deleting columns is protected on the sheet.
+     *
+     * @returns `true` if deleting columns is locked, `false` otherwise.
+     */
+    isDeleteColumnsAllowed(): boolean;
+    /**
+     * Checks if deleting rows is protected on the sheet.
+     *
+     * @returns `true` if deleting rows is locked, `false` otherwise.
+     */
+    isDeleteRowsAllowed(): boolean;
+    /**
+     * Checks if formatting cells is protected on the sheet.
+     *
+     * @returns `true` if formatting cells is locked, `false` otherwise.
+     */
+    isFormatCellsAllowed(): boolean;
+    /**
+     * Checks if formatting columns is protected on the sheet.
+     *
+     * @returns `true` if formatting columns is locked, `false` otherwise.
+     */
+    isFormatColumnsAllowed(): boolean;
+    /**
+     * Checks if formatting rows is protected on the sheet.
+     *
+     * @returns `true` if formatting rows is locked, `false` otherwise.
+     */
+    isFormatRowsAllowed(): boolean;
+    /**
+     * Checks if inserting columns is protected on the sheet.
+     *
+     * @returns `true` if inserting columns is locked, `false` otherwise.
+     */
+    isInsertColumnsAllowed(): boolean;
+    /**
+     * Checks if inserting hyperlinks is protected on the sheet.
+     *
+     * @returns `true` if inserting hyperlinks is locked, `false` otherwise.
+     */
+    isInsertHyperlinksAllowed(): boolean;
+    /**
+     * Checks if inserting rows is protected on the sheet.
+     *
+     * @returns `true` if inserting rows is locked, `false` otherwise.
+     */
+    isInsertRowsAllowed(): boolean;
+    /**
+     * Checks if objects (e.g., charts, shapes) are protected on the sheet.
+     *
+     * @returns `true` if objects are locked, `false` otherwise.
+     */
+    isObjectsAllowed(): boolean;
+    /**
+     * Checks if pivot tables are protected on the sheet.
+     *
+     * @returns `true` if pivot tables are locked, `false` otherwise.
+     */
+    isPivotTablesAllowed(): boolean;
+    /**
+     * Checks if scenarios are protected on the sheet.
+     *
+     * @returns `true` if scenarios are locked, `false` otherwise.
+     */
+    isScenariosAllowed(): boolean;
+    /**
+     * Checks if sorting is protected on the sheet.
+     *
+     * @returns `true` if sorting is locked, `false` otherwise.
+     */
+    isSortAllowed(): boolean;
+    /**
+     * Checks if selecting locked cells is protected on the sheet.
+     *
+     * @returns `true` if selecting locked cells is locked, `false` otherwise.
+     */
+    isSelectLockedCellsAllowed(): boolean;
+    /**
+     * Checks if selecting unlocked cells is protected on the sheet.
+     *
+     * @returns `true` if selecting unlocked cells is locked, `false` otherwise.
+     */
+    isSelectUnlockedCellsAllowed(): boolean;
+}
+/**
+ * {@inheritDoc ISheetProtection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link ISheetProtection}
+ */
+export declare namespace ISheetProtection {
+    interface Properties extends IProtection.Properties {
+        /** {@inheritDoc ISheetProtection.isAutoTableAllowed} */
+        autoTable?: boolean;
+        /** {@inheritDoc ISheetProtection.isDeleteColumnsAllowed} */
+        deleteColumns?: boolean;
+        /** {@inheritDoc ISheetProtection.isDeleteRowsAllowed} */
+        deleteRows?: boolean;
+        /** {@inheritDoc ISheetProtection.isFormatCellsAllowed} */
+        formatCells?: boolean;
+        /** {@inheritDoc ISheetProtection.isFormatColumnsAllowed} */
+        formatColumns?: boolean;
+        /** {@inheritDoc ISheetProtection.isFormatRowsAllowed} */
+        formatRows?: boolean;
+        /** {@inheritDoc ISheetProtection.isInsertColumnsAllowed} */
+        insertColumns?: boolean;
+        /** {@inheritDoc ISheetProtection.isInsertHyperlinksAllowed} */
+        insertHyperlinks?: boolean;
+        /** {@inheritDoc ISheetProtection.isInsertRowsAllowed} */
+        insertRows?: boolean;
+        /** {@inheritDoc ISheetProtection.isObjectsAllowed} */
+        objects?: boolean;
+        /** {@inheritDoc ISheetProtection.isPivotTablesAllowed} */
+        pivotTables?: boolean;
+        /** {@inheritDoc ISheetProtection.isScenariosAllowed} */
+        scenarios?: boolean;
+        /** {@inheritDoc ISheetProtection.isSelectLockedCellsAllowed} */
+        selectLockedCells?: boolean;
+        /** {@inheritDoc ISheetProtection.isSelectUnlockedCellsAllowed} */
+        selectUnlockedCells?: boolean;
+        /** {@inheritDoc ISheetProtection.isSortAllowed} */
+        sort?: boolean;
+        sheet?: boolean;
+    }
+    interface JSON extends ISheetProtection.Properties, IProtection.JSON {
+    }
+    type PropertyKeys = (keyof ISheetProtection.Properties);
+}
+//# sourceMappingURL=ISheetProtection.d.ts.map

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

@@ -0,0 +1,39 @@
+import { DefaultProtection } from '../protection/DefaultProtection';
+import { ISheetProtection } from './ISheetProtection';
+export declare class SheetProtection extends DefaultProtection<ISheetProtection, ISheetProtection.Properties, ISheetProtection.JSON> implements ISheetProtection {
+    /** {@inheritDoc ISheetProtection.isAutoTableAllowed} */
+    isAutoTableAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isDeleteColumnsAllowed} */
+    isDeleteColumnsAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isDeleteRowsAllowed} */
+    isDeleteRowsAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isFormatCellsAllowed} */
+    isFormatCellsAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isFormatColumnsAllowed} */
+    isFormatColumnsAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isFormatRowsAllowed} */
+    isFormatRowsAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isInsertColumnsAllowed} */
+    isInsertColumnsAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isInsertHyperlinksAllowed} */
+    isInsertHyperlinksAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isInsertRowsAllowed} */
+    isInsertRowsAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isObjectsAllowed} */
+    isObjectsAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isPivotTablesAllowed} */
+    isPivotTablesAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isScenariosAllowed} */
+    isScenariosAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isSortAllowed} */
+    isSortAllowed(): boolean;
+    isSelectLockedCellsAllowed(): boolean;
+    isSelectUnlockedCellsAllowed(): boolean;
+    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;
+}
+//# sourceMappingURL=SheetProtection.d.ts.map

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

@@ -0,0 +1,2 @@
+export * from './ISheetProtection';
+//# sourceMappingURL=index.d.ts.map