@univerjs/sheets 0.12.2 → 0.12.3-experimental.20251205-e439e48

package/lib/types/facade/permission/f-worksheet-permission.d.ts

@@ -1,16 +1,17 @@
 import { Observable } from 'rxjs';
 import { FRange } from '../f-range';
 import { FWorksheet } from '../f-worksheet';
-import { ICellPermissionDebugInfo, IRangeProtectionOptions, IRangeProtectionRule, IWorksheetPermission, IWorksheetPermissionConfig, UnsubscribeFn, WorksheetMode, WorksheetPermissionSnapshot, WorksheetPermissionPoint } from './permission-types';
+import { IRangeProtectionOptions, IWorksheetPermissionConfig, IWorksheetProtectionOptions, UnsubscribeFn, WorksheetMode, WorksheetPermissionSnapshot, WorksheetPermissionPoint } from './permission-types';
 import { IAuthzIoService, ICommandService, Injector, IPermissionService } from '@univerjs/core';
-import { RangeProtectionRuleModel, WorksheetProtectionPointModel } from '@univerjs/sheets';
+import { RangeProtectionRuleModel, WorksheetProtectionPointModel, WorksheetProtectionRuleModel } from '@univerjs/sheets';
+import { FRangeProtectionRule } from './f-range-protection-rule';
 /**
  * Implementation class for WorksheetPermission
  * Provides worksheet-level permission control
  *
  * @hideconstructor
  */
-export declare class FWorksheetPermission implements IWorksheetPermission {
+export declare class FWorksheetPermission {
     private readonly _worksheet;
     private readonly _injector;
     private readonly _permissionService;
@@ -18,6 +19,7 @@ export declare class FWorksheetPermission implements IWorksheetPermission {
     private readonly _commandService;
     private readonly _rangeProtectionRuleModel;
     private readonly _worksheetProtectionPointModel;
+    private readonly _worksheetProtectionRuleModel;
     private readonly _permissionSubject;
     private readonly _rangeRulesSubject;
     /**
@@ -40,17 +42,18 @@ export declare class FWorksheetPermission implements IWorksheetPermission {
      */
     readonly rangeProtectionChange$: Observable<{
         type: 'add' | 'update' | 'delete';
-        rules: IRangeProtectionRule[];
+        rules: FRangeProtectionRule[];
     }>;
     /**
      * Observable stream of current range protection rules list (BehaviorSubject)
      * Emits immediately on subscription with current rules, then auto-updates when rules change
      */
-    readonly rangeProtectionRules$: Observable<IRangeProtectionRule[]>;
+    readonly rangeProtectionRules$: Observable<FRangeProtectionRule[]>;
     private readonly _unitId;
     private readonly _subUnitId;
     private readonly _subscriptions;
-    constructor(_worksheet: FWorksheet, _injector: Injector, _permissionService: IPermissionService, _authzIoService: IAuthzIoService, _commandService: ICommandService, _rangeProtectionRuleModel: RangeProtectionRuleModel, _worksheetProtectionPointModel: WorksheetProtectionPointModel);
+    private readonly _fPermission;
+    constructor(_worksheet: FWorksheet, _injector: Injector, _permissionService: IPermissionService, _authzIoService: IAuthzIoService, _commandService: ICommandService, _rangeProtectionRuleModel: RangeProtectionRuleModel, _worksheetProtectionPointModel: WorksheetProtectionPointModel, _worksheetProtectionRuleModel: WorksheetProtectionRuleModel);
     /**
      * Create permission snapshot stream from IPermissionService
      * @private
@@ -88,8 +91,73 @@ export declare class FWorksheetPermission implements IWorksheetPermission {
      * Build range protection rules list
      */
     private _buildRangeProtectionRules;
+    /**
+     * Build Facade objects for all protection rules
+     */
+    private _buildProtectionRule;
+    /**
+     * Debug cell permission information.
+     * @param {number} row Row index.
+     * @param {number} col Column index.
+     * @returns {ICellPermissionDebugInfo | null} Debug information about which rules affect this cell, or null if no rules apply.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * const debugInfo = permission?.debugCellPermission(0, 0);
+     * console.log(debugInfo);
+     * ```
+     */
+    debugCellPermission(row: number, col: number): FRangeProtectionRule | undefined;
+    /**
+     * Create worksheet protection with collaborators support.
+     * This must be called before setting permission points for collaboration to work.
+     * @param {IWorksheetProtectionOptions} options Protection options including allowed users.
+     * @returns {Promise<string>} The permissionId for the created protection.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     *
+     * // Create worksheet protection with collaborators
+     * const permissionId = await permission?.protect({
+     *   allowedUsers: ['user1', 'user2'],
+     *   name: 'My Worksheet Protection'
+     * });
+     *
+     * // Now set permission points
+     * await permission?.setMode('readOnly');
+     * ```
+     */
+    protect(options?: IWorksheetProtectionOptions): Promise<string>;
+    /**
+     * Remove worksheet protection.
+     * This deletes the protection rule and resets all permission points to allowed.
+     * @returns {Promise<void>} A promise that resolves when protection is removed.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * await permission?.unprotect();
+     * ```
+     */
+    unprotect(): Promise<void>;
+    /**
+     * Check if worksheet is currently protected.
+     * @returns {boolean} true if protected, false otherwise.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * if (permission?.isProtected()) {
+     *   console.log('Worksheet is protected');
+     * }
+     * ```
+     */
+    isProtected(): boolean;
     /**
      * Set permission mode for the worksheet.
+     * Automatically creates worksheet protection if not already protected.
      * @param {WorksheetMode} mode The permission mode to set ('editable' | 'readOnly' | 'filterOnly' | 'commentOnly').
      * @returns {Promise<void>} A promise that resolves when the mode is set.
      * @example
@@ -173,22 +241,9 @@ export declare class FWorksheetPermission implements IWorksheetPermission {
      * ```
      */
     canViewCell(_row: number, _col: number): boolean;
-    /**
-     * Debug cell permission information.
-     * @param {number} row Row index.
-     * @param {number} col Column index.
-     * @returns {ICellPermissionDebugInfo | null} Debug information about which rules affect this cell, or null if no rules apply.
-     * @example
-     * ```ts
-     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
-     * const permission = worksheet?.getWorksheetPermission();
-     * const debugInfo = permission?.debugCellPermission(0, 0);
-     * console.log(debugInfo);
-     * ```
-     */
-    debugCellPermission(row: number, col: number): ICellPermissionDebugInfo | null;
     /**
      * Set a specific permission point for the worksheet.
+     * Automatically creates worksheet protection if not already protected.
      * @param {WorksheetPermissionPoint} point The permission point to set.
      * @param {boolean} value The value to set (true = allowed, false = denied).
      * @returns {Promise<void>} A promise that resolves when the point is set.
@@ -196,7 +251,7 @@ export declare class FWorksheetPermission implements IWorksheetPermission {
      * ```ts
      * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
      * const permission = worksheet?.getWorksheetPermission();
-     * await permission?.setPoint(WorksheetPermissionPoint.InsertRow, false);
+     * await permission?.setPoint(univerAPI.Enum.WorksheetPermissionPoint.InsertRow, false);
      * ```
      */
     setPoint(point: WorksheetPermissionPoint, value: boolean): Promise<void>;
@@ -208,7 +263,7 @@ export declare class FWorksheetPermission implements IWorksheetPermission {
      * ```ts
      * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
      * const permission = worksheet?.getWorksheetPermission();
-     * const canInsertRow = permission?.getPoint(WorksheetPermissionPoint.InsertRow);
+     * const canInsertRow = permission?.getPoint(univerAPI.Enum.WorksheetPermissionPoint.InsertRow);
      * console.log(canInsertRow);
      * ```
      */
@@ -236,8 +291,8 @@ export declare class FWorksheetPermission implements IWorksheetPermission {
      * await permission?.applyConfig({
      *   mode: 'readOnly',
      *   points: {
-     *     [WorksheetPermissionPoint.View]: true,
-     *     [WorksheetPermissionPoint.Edit]: false
+     *     [univerAPI.Enum.WorksheetPermissionPoint.View]: true,
+     *     [univerAPI.Enum.WorksheetPermissionPoint.Edit]: false
      *   }
      * });
      * ```
@@ -246,7 +301,7 @@ export declare class FWorksheetPermission implements IWorksheetPermission {
     /**
      * Protect multiple ranges at once (batch operation).
      * @param {Array<{ ranges: FRange[]; options?: IRangeProtectionOptions }>} configs Array of protection configurations.
-     * @returns {Promise<IRangeProtectionRule[]>} Array of created protection rules.
+     * @returns {Promise<FRangeProtectionRule[]>} Array of created protection rules.
      * @example
      * ```ts
      * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
@@ -254,11 +309,11 @@ export declare class FWorksheetPermission implements IWorksheetPermission {
      * const rules = await permission?.protectRanges([
      *   {
      *     ranges: [worksheet.getRange('A1:B2')],
-     *     options: { name: 'Protected Area 1', allowEdit: false, allowView: true }
+     *     options: { name: 'Protected Area 1', allowEdit: false, allowViewByOthers: true }
      *   },
      *   {
      *     ranges: [worksheet.getRange('C3:D4')],
-     *     options: { name: 'Protected Area 2', allowEdit: true, allowView: false }
+     *     options: { name: 'Protected Area 2', allowEdit: true, allowViewByOthers: false }
      *   }
      * ]);
      * console.log(rules);
@@ -267,7 +322,7 @@ export declare class FWorksheetPermission implements IWorksheetPermission {
     protectRanges(configs: Array<{
         ranges: FRange[];
         options?: IRangeProtectionOptions;
-    }>): Promise<IRangeProtectionRule[]>;
+    }>): Promise<FRangeProtectionRule[]>;
     /**
      * Determine view state from options
      * @private
@@ -302,7 +357,7 @@ export declare class FWorksheetPermission implements IWorksheetPermission {
     unprotectRules(ruleIds: string[]): Promise<void>;
     /**
      * List all range protection rules for the worksheet.
-     * @returns {Promise<IRangeProtectionRule[]>} Array of protection rules.
+     * @returns {Promise<FRangeProtectionRule[]>} Array of protection rules.
      * @example
      * ```ts
      * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
@@ -311,7 +366,7 @@ export declare class FWorksheetPermission implements IWorksheetPermission {
      * console.log(rules);
      * ```
      */
-    listRangeProtectionRules(): Promise<IRangeProtectionRule[]>;
+    listRangeProtectionRules(): Promise<FRangeProtectionRule[]>;
     /**
      * Subscribe to permission changes (simplified interface for users not familiar with RxJS).
      * @param {Function} listener Callback function to be called when permissions change.

package/lib/types/facade/permission/permission-types.d.ts

@@ -1,6 +1,5 @@
 import { IUser } from '@univerjs/protocol';
 import { Observable } from 'rxjs';
-import { FRange } from '../f-range';
 /**
  * ========================
  * Basic Types / Enums
@@ -165,6 +164,22 @@ export type RangePermissionSnapshot = Record<RangePermissionPoint, boolean>;
  * Unsubscribe function type
  */
 export type UnsubscribeFn = () => void;
+/**
+ * ========================
+ * Worksheet Protection Configuration
+ * ========================
+ */
+/**
+ * Worksheet protection options configuration
+ */
+export interface IWorksheetProtectionOptions {
+    /** Whitelist of users allowed to edit; empty means only owner */
+    allowedUsers?: string[];
+    /** Protection name for UI display */
+    name?: string;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
 /**
  * ========================
  * Range Protection Configuration and Rules
@@ -184,24 +199,6 @@ export interface IRangeProtectionOptions {
     /** Custom metadata (logs, tags, etc.) */
     metadata?: Record<string, unknown>;
 }
-/**
- * Range protection rule Facade
- * Encapsulates internal permissionId / ruleId
- */
-export interface IRangeProtectionRule {
-    /** Internal rule id, for debugging/logging, generally not directly used by callers */
-    readonly id: string;
-    /** List of ranges covered by this rule */
-    readonly ranges: FRange[];
-    /** Current rule configuration */
-    readonly options: IRangeProtectionOptions;
-    /** Update protected ranges */
-    updateRanges(ranges: FRange[]): Promise<void>;
-    /** Partially update configuration */
-    updateOptions(options: Partial<IRangeProtectionOptions>): Promise<void>;
-    /** Delete current protection rule */
-    remove(): Promise<void>;
-}
 /**
  * Cell permission debug rule information
  */
@@ -211,15 +208,6 @@ export interface ICellPermissionDebugRuleInfo {
     rangeRefs: string[];
     options: IRangeProtectionOptions;
 }
-/**
- * Cell permission debug information
- */
-export interface ICellPermissionDebugInfo {
-    row: number;
-    col: number;
-    /** List of protection rules that apply */
-    hitRules: ICellPermissionDebugRuleInfo[];
-}
 /**
  * ========================
  * Facade: WorkbookPermission
@@ -317,167 +305,12 @@ export interface IWorksheetPermissionConfig {
         options?: IRangeProtectionOptions;
     }>;
 }
-/**
- * Worksheet-level permission Facade interface
- */
-export interface IWorksheetPermission {
-    /**
-     * Set worksheet overall mode:
-     * - 'readOnly'       → Lock write-related points
-     * - 'filterOnly'     → Only enable Filter/Sort, close other write-related points
-     * - 'commentOnly'    → Close write, keep comment
-     * - 'editable'       → Most write-related points enabled
-     */
-    setMode(mode: WorksheetMode): Promise<void>;
-    /** Shortcut: Read-only */
-    setReadOnly(): Promise<void>;
-    /** Shortcut: Editable */
-    setEditable(): Promise<void>;
-    /** Whether current user can "overall" edit this sheet (not considering local range protection) */
-    canEdit(): boolean;
-    /**
-     * Cell-level high-level check (combines sheet-level & range-level rules)
-     */
-    canEditCell(row: number, col: number): boolean;
-    canViewCell(row: number, col: number): boolean;
-    /**
-     * Debug use: View protection rule information for a specific cell
-     */
-    debugCellPermission(row: number, col: number): ICellPermissionDebugInfo | null;
-    /**
-     * Point operations (low-level)
-     */
-    setPoint(point: WorksheetPermissionPoint, value: boolean): Promise<void>;
-    getPoint(point: WorksheetPermissionPoint): boolean;
-    getSnapshot(): WorksheetPermissionSnapshot;
-    /**
-     * Batch apply permission configuration (for "configuration-driven" scenarios)
-     * Internally uses Command to ensure undo/redo
-     */
-    applyConfig(config: IWorksheetPermissionConfig): Promise<void>;
-    /**
-     * Range protection management
-     */
-    /** Batch create multiple range protection rules (one-time operation, better performance) */
-    protectRanges(configs: Array<{
-        ranges: FRange[];
-        options?: IRangeProtectionOptions;
-    }>): Promise<IRangeProtectionRule[]>;
-    /** Batch delete multiple protection rules */
-    unprotectRules(ruleIds: string[]): Promise<void>;
-    /**
-     * List all range protection rules on current sheet
-     */
-    listRangeProtectionRules(): Promise<IRangeProtectionRule[]>;
-    /**
-     * ========================
-     * RxJS Observable Reactive Interface
-     * ========================
-     */
-    /**
-     * Permission snapshot change stream (BehaviorSubject, immediately provides current state on subscription)
-     * Triggers when any permission point changes
-     */
-    readonly permission$: Observable<WorksheetPermissionSnapshot>;
-    /**
-     * Single permission point change stream
-     * For scenarios that only care about specific permission point changes
-     */
-    readonly pointChange$: Observable<{
-        point: WorksheetPermissionPoint;
-        value: boolean;
-        oldValue: boolean;
-    }>;
-    /**
-     * Range protection rule change stream (add, delete, update)
-     */
-    readonly rangeProtectionChange$: Observable<{
-        type: 'add' | 'update' | 'delete';
-        rules: IRangeProtectionRule[];
-    }>;
-    /**
-     * Current all range protection rules list stream (BehaviorSubject)
-     * Immediately provides current rule list on subscription, auto-updates when rules change
-     */
-    readonly rangeProtectionRules$: Observable<IRangeProtectionRule[]>;
-    /**
-     * Compatibility method: Simplified subscription (for users unfamiliar with RxJS)
-     * Internally implemented based on permission$ Observable
-     */
-    subscribe(listener: (snapshot: WorksheetPermissionSnapshot) => void): UnsubscribeFn;
-}
 /**
  * ========================
  * Facade: RangePermission
  * ========================
  */
-/**
- * Range-level permission Facade interface
- */
-export interface IRangePermission {
-    /**
-     * Create protection rule on current range
-     * - Default options.allowEdit = false → Treated as "locked"
-     */
-    protect(options?: IRangeProtectionOptions): Promise<IRangeProtectionRule>;
-    /**
-     * Remove all protection rules covered by current range
-     * (Internally can calculate range → ruleId mapping)
-     */
-    unprotect(): Promise<void>;
-    /**
-     * Whether current range is in protected state (for current user)
-     */
-    isProtected(): boolean;
-    /** Whether current user can edit this range (combines Worksheet / Workbook / Range levels) */
-    canEdit(): boolean;
-    /** Whether current user can view this range */
-    canView(): boolean;
-    /**
-     * Range-level point reading (generally for debugging / advanced scenarios)
-     * Usually only need Edit/View two points
-     */
-    getPoint(point: RangePermissionPoint): boolean;
-    getSnapshot(): RangePermissionSnapshot;
-    /**
-     * Set a specific permission point for the range (low-level API for local runtime control)
-     * @param {RangePermissionPoint} point The permission point to set
-     * @param {boolean} value The value to set (true = allowed, false = denied)
-     * @returns {Promise<void>} A promise that resolves when the point is set
-     * @example
-     * ```ts
-     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
-     * const permission = range?.getRangePermission();
-     * await permission?.setPoint(RangePermissionPoint.Edit, false); // Disable edit for current user
-     * ```
-     */
-    setPoint(point: RangePermissionPoint, value: boolean): Promise<void>;
-    /**
-     * Get snapshot of all protection rules in current worksheet (can also proxy worksheet interface)
-     */
-    listRules(): Promise<IRangeProtectionRule[]>;
-    /**
-     * ========================
-     * RxJS Observable Reactive Interface
-     * ========================
-     */
-    /**
-     * Permission snapshot change stream (BehaviorSubject, immediately provides current state on subscription)
-     */
-    readonly permission$: Observable<RangePermissionSnapshot>;
-    /**
-     * Protection state change stream
-     */
-    readonly protectionChange$: Observable<{
-        type: 'protected';
-        rule: IRangeProtectionRule;
-    } | {
-        type: 'unprotected';
-        ruleId: string;
-    }>;
-    /**
-     * Compatibility method: Simplified subscription (for users unfamiliar with RxJS)
-     * Internally implemented based on permission$ Observable
-     */
-    subscribe(listener: (snapshot: RangePermissionSnapshot) => void): UnsubscribeFn;
+export interface ICellPermissionDebugInfo {
+    permissionId: string;
+    ruleId: string;
 }

package/lib/types/index.d.ts

@@ -89,6 +89,7 @@ export { type IToggleCellCheckboxCommandParams, ToggleCellCheckboxCommand } from
 export { type IToggleGridlinesCommandParams, ToggleGridlinesCommand } from './commands/commands/toggle-gridlines.command';
 export { UnregisterWorksheetRangeThemeStyleCommand } from './commands/commands/unregister-range-theme.command';
 export type { IUnregisterWorksheetRangeThemeStyleCommandParams } from './commands/commands/unregister-range-theme.command';
+export { countCells } from './commands/commands/util';
 export { alignToMergedCellsBorders, getCellAtRowCol, isSingleCellSelection, setEndForRange } from './commands/commands/utils/selection-utils';
 export { followSelectionOperation, getPrimaryForRange } from './commands/commands/utils/selection-utils';
 export { copyRangeStyles } from './commands/commands/utils/selection-utils';
@@ -99,6 +100,7 @@ export type { IAddRangeThemeMutationParams } from './commands/mutations/add-rang
 export { AddMergeUndoMutationFactory, AddWorksheetMergeMutation } from './commands/mutations/add-worksheet-merge.mutation';
 export { AddWorksheetProtectionMutation, type IAddWorksheetProtectionParams } from './commands/mutations/add-worksheet-protection.mutation';
 export { SetWorksheetRangeThemeStyleMutation, SetWorksheetRangeThemeStyleMutationFactory } from './commands/mutations/add-worksheet-range-theme.mutation';
+export { CopyWorksheetEndMutation, type ICopyWorksheetEndMutationParams } from './commands/mutations/copy-worksheet-end.mutation';
 export { DeleteRangeProtectionMutation, FactoryDeleteRangeProtectionMutation, type IDeleteRangeProtectionMutationParams } from './commands/mutations/delete-range-protection.mutation';
 export { DeleteWorksheetProtectionMutation } from './commands/mutations/delete-worksheet-protection.mutation';
 export type { IDeleteWorksheetProtectionParams } from './commands/mutations/delete-worksheet-protection.mutation';
@@ -153,7 +155,7 @@ export { getInsertRangeMutations, getRemoveRangeMutations } from './commands/uti
 export { handleInsertRangeMutation } from './commands/utils/handle-range-mutation';
 export { type ISheetCommandSharedParams } from './commands/utils/interface';
 export { getSelectionsService } from './commands/utils/selection-command-util';
-export { type IUniverSheetsConfig } from './controllers/config.schema';
+export { defaultLargeSheetOperationConfig, type ILargeSheetOperationConfig, type IUniverSheetsConfig, SHEETS_PLUGIN_CONFIG_KEY } from './controllers/config.schema';
 export { MAX_CELL_PER_SHEET_KEY } from './controllers/config/config';
 export { DefinedNameDataController } from './controllers/defined-name-data.controller';
 export { SCOPE_WORKBOOK_VALUE_DEFINED_NAME } from './controllers/defined-name-data.controller';
@@ -173,6 +175,7 @@ export type { IRangeThemeStyleItem } from './model/range-theme-util';
 export { UniverSheetsPlugin } from './plugin';
 export { BorderStyleManagerService, type IBorderInfo } from './services/border-style-manager.service';
 export { ExclusiveRangeService, IExclusiveRangeService } from './services/exclusive-range/exclusive-range-service';
+export { SheetLazyExecuteScheduleService } from './services/lazy-execute-schedule.service';
 export { NumfmtService } from './services/numfmt/numfmt.service';
 export type { INumfmtItem, INumfmtItemWithCache } from './services/numfmt/type';
 export { INumfmtService } from './services/numfmt/type';

package/lib/types/services/lazy-execute-schedule.service.d.ts

@@ -0,0 +1,47 @@
+import { IMutationInfo, Disposable, ICommandService, IUniverInstanceService } from '@univerjs/core';
+import { ISetRangeValuesMutationParams } from '../commands/mutations/set-range-values.mutation';
+/**
+ * Service to schedule and execute remaining SetRangeValuesMutation tasks
+ * during browser idle time after a sheet copy operation.
+ *
+ * This improves user experience by:
+ * 1. Immediately showing the copied sheet with first chunk of data
+ * 2. Filling remaining data in background during idle time
+ * 3. Automatically canceling tasks if the sheet is deleted
+ * 4. Warning user if they try to close while tasks are pending
+ */
+export declare class SheetLazyExecuteScheduleService extends Disposable {
+    private readonly _commandService;
+    private readonly _univerInstanceService;
+    private _tasks;
+    private _idleCallbackId;
+    private _beforeUnloadHandler;
+    constructor(_commandService: ICommandService, _univerInstanceService: IUniverInstanceService);
+    /**
+     * Check if there are any pending tasks
+     */
+    hasPendingTasks(): boolean;
+    /**
+     * Get the count of pending mutations across all tasks
+     */
+    getPendingMutationsCount(): number;
+    /**
+     * Schedule mutations to be executed during idle time
+     * @param unitId - The workbook unit ID
+     * @param subUnitId - The sheet ID (newly created sheet)
+     * @param mutations - Remaining SetRangeValuesMutation to execute
+     */
+    scheduleMutations(unitId: string, subUnitId: string, mutations: IMutationInfo<ISetRangeValuesMutationParams>[]): void;
+    /**
+     * Cancel scheduled mutations for a specific sheet
+     * Called when the sheet is deleted
+     */
+    cancelScheduledMutations(unitId: string, subUnitId: string): void;
+    private _cancelTask;
+    private _cancelAllTasks;
+    private _scheduleNextIdle;
+    private _processIdleTasks;
+    private _isSheetExist;
+    private _setupBeforeUnloadListener;
+    private _removeBeforeUnloadListener;
+}