@univerjs/sheets 0.11.0 → 0.12.0

package/lib/locale/ja-JP.js

@@ -0,0 +1,17 @@
+const e = {
+  sheets: {
+    tabs: {
+      sheetCopy: "(복사본{0})",
+      sheet: "시트"
+    },
+    info: {
+      overlappingSelections: "겹치는 영역에서는 해당 명령을 사용할 수 없습니다.",
+      acrossMergedCell: "병합된 셀을 가로지름",
+      partOfCell: "병합된 셀의 일부만 선택됨",
+      hideSheet: "이 시트를 숨기면 표시되는 시트가 없습니다."
+    }
+  }
+};
+export {
+  e as default
+};

package/lib/types/commands/commands/clear-selection-content.command.d.ts

@@ -1,4 +1,9 @@
-import { ICommand } from '@univerjs/core';
+import { ICommand, IRange } from '@univerjs/core';
+export interface IClearSelectionContentCommandParams {
+    unitId?: string;
+    subUnitId?: string;
+    ranges?: IRange[];
+}
 /**
  * The command to clear content in current selected ranges.
  */

package/lib/types/controllers/permission/sheet-permission-init.controller.d.ts

@@ -1,12 +1,7 @@
-import { IDeleteWorksheetProtectionParams } from '../../commands/mutations/delete-worksheet-protection.mutation';
 import { Disposable, IAuthzIoService, ICommandService, IPermissionService, IUndoRedoService, IUniverInstanceService, UserManagerService } from '@univerjs/core';
 import { RangeProtectionRuleModel } from '../../model/range-protection-rule.model';
 import { WorkbookPermissionService } from '../../services/permission/workbook-permission/workbook-permission.service';
 import { WorksheetProtectionPointModel, WorksheetProtectionRuleModel } from '../../services/permission/worksheet-permission';
-interface ISheetPermissionCmdBufferListItemType {
-    id: string;
-    params: IDeleteWorksheetProtectionParams;
-}
 export declare class SheetPermissionInitController extends Disposable {
     private readonly _univerInstanceService;
     private _permissionService;
@@ -18,16 +13,9 @@ export declare class SheetPermissionInitController extends Disposable {
     private _workbookPermissionService;
     private _undoRedoService;
     private _commandService;
-    private _cmdBufferList;
-    private _isRangePermissionInitFinish;
-    private _isWorksheetPermissionInitFinish;
-    private _isWorkbookPermissionInitFinish;
     constructor(_univerInstanceService: IUniverInstanceService, _permissionService: IPermissionService, _authzIoService: IAuthzIoService, _rangeProtectionRuleModel: RangeProtectionRuleModel, _worksheetProtectionRuleModel: WorksheetProtectionRuleModel, _userManagerService: UserManagerService, _worksheetProtectionPointRuleModel: WorksheetProtectionPointModel, _workbookPermissionService: WorkbookPermissionService, _undoRedoService: IUndoRedoService, _commandService: ICommandService);
     initPermission(): void;
     refreshRangeProtectPermission(): void;
-    getIsPermissionInitFinish(): boolean;
-    addCmdToBufferList(item: ISheetPermissionCmdBufferListItemType): void;
-    private _processCmdBufferList;
     private _initRangePermissionFromSnapshot;
     private _initRangePermissionChange;
     initWorkbookPermissionChange(_unitId?: string): Promise<void>;
@@ -39,4 +27,3 @@ export declare class SheetPermissionInitController extends Disposable {
     refreshPermission(unitId: string, permissionId: string): void;
     private _refreshPermissionByCollaCreate;
 }
-export {};

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

@@ -5,6 +5,29 @@ import { FBase } from '@univerjs/core/facade';
 import { RangeProtectionRuleModel, WorkbookEditablePermission, WorkbookPermissionService, WorksheetEditPermission, WorksheetProtectionPointModel, WorksheetProtectionRuleModel, WorksheetViewPermission } from '@univerjs/sheets';
 /**
  * @description Used to generate permission instances to control permissions for the entire workbook
+ * @deprecated This class is deprecated. Use the new permission API instead:
+ * - For workbook-level permissions, use `workbook.getWorkbookPermission()`
+ * - For worksheet-level permissions, use `worksheet.getWorksheetPermission()`
+ * - For range-level permissions, use `range.getRangePermission()`
+ *
+ * The new API provides:
+ * - More intuitive and type-safe interfaces
+ * - Better support for RxJS Observable streams
+ * - Enum-based permission points instead of class constructors
+ * - Simplified collaborator management
+ * - Mode-based permission settings (viewer, editor, owner, etc.)
+ *
+ * Migration examples:
+ * ```ts
+ * // Old API
+ * const permission = workbook.getPermission();
+ * await permission.addRangeBaseProtection(unitId, subUnitId, ranges);
+ *
+ * // New API
+ * const worksheet = workbook.getSheetBySheetId(subUnitId);
+ * const permission = worksheet.getWorksheetPermission();
+ * await permission.protectRanges([{ ranges, options: { name: 'Protected', allowEdit: false } }]);
+ * ```
  * @hideconstructor
  */
 export declare class FPermission extends FBase {
@@ -205,6 +228,7 @@ export declare class FPermission extends FBase {
      * Adds a range protection to the worksheet.
      * Note that after adding, only the background mask of the permission module will be rendered. If you want to modify the function permissions,
      * you need to modify the permission points with the permissionId returned by this function.
+     * @deprecated Use `worksheet.getWorksheetPermission().protectRanges()` instead
      * @param {string} unitId - The unique identifier of the workbook.
      * @param {string} subUnitId - The unique identifier of the worksheet.
      * @param {FRange[]} ranges - The ranges to be protected.
@@ -212,6 +236,7 @@ export declare class FPermission extends FBase {
      *
      * @example
      * ```typescript
+     * // Old API
      * const workbook = univerAPI.getActiveWorkbook();
      * const permission = workbook.getPermission();
      * const unitId = workbook.getId();
@@ -220,11 +245,18 @@ export declare class FPermission extends FBase {
      * const range = worksheet.getRange('A1:B2');
      * const ranges = [];
      * ranges.push(range);
-     * // Note that there will be no permission changes after this step is completed. It only returns an ID for subsequent permission changes.
-     * // For details, please see the example of the **`setRangeProtectionPermissionPoint`** API.
      * const res = await permission.addRangeBaseProtection(unitId, subUnitId, ranges);
      * const {permissionId, ruleId} = res;
      * console.log('debugger', permissionId, ruleId);
+     *
+     * // New API (recommended)
+     * const worksheet = univerAPI.getActiveWorkbook().getActiveSheet();
+     * const permission = worksheet.getWorksheetPermission();
+     * const range = worksheet.getRange('A1:B2');
+     * await permission.protectRanges([{
+     *   ranges: [range],
+     *   options: { name: 'Protected Area', allowEdit: false }
+     * }]);
      * ```
      */
     addRangeBaseProtection(unitId: string, subUnitId: string, ranges: FRange[]): Promise<{
@@ -233,12 +265,14 @@ export declare class FPermission extends FBase {
     } | undefined>;
     /**
      * Removes the range protection from the worksheet.
+     * @deprecated Use `worksheet.getWorksheetPermission().unprotectRules()` instead
      * @param {string} unitId - The unique identifier of the workbook.
      * @param {string} subUnitId - The unique identifier of the worksheet.
      * @param {string[]} ruleIds - The rule IDs of the range protection to be removed.
      *
      * @example
      * ```typescript
+     * // Old API
      * const workbook = univerAPI.getActiveWorkbook();
      * const permission = workbook.getPermission();
      * const unitId = workbook.getId();
@@ -250,6 +284,11 @@ export declare class FPermission extends FBase {
      * const res = await permission.addRangeBaseProtection(unitId, subUnitId, ranges);
      * const ruleId = res.ruleId;
      * permission.removeRangeProtection(unitId, subUnitId, [ruleId]);
+     *
+     * // New API (recommended)
+     * const worksheet = univerAPI.getActiveWorkbook().getActiveSheet();
+     * const permission = worksheet.getWorksheetPermission();
+     * await permission.unprotectRules([ruleId]);
      * ```
      */
     removeRangeProtection(unitId: string, subUnitId: string, ruleIds: string[]): void;

package/lib/types/facade/f-range.d.ts

@@ -4,6 +4,7 @@ import { IFacadeClearOptions } from './f-worksheet';
 import { FHorizontalAlignment, FVerticalAlignment } from './utils';
 import { FBaseInitialable } from '@univerjs/core/facade';
 import { FormulaDataModel } from '@univerjs/engine-formula';
+import { FRangePermission } from './permission/f-range-permission';
 export type FontLine = 'none' | 'underline' | 'line-through';
 export type FontStyle = 'normal' | 'italic';
 export type FontWeight = 'normal' | 'bold';
@@ -1531,4 +1532,33 @@ export declare class FRange extends FBaseInitialable {
      * ```
      */
     setFormulas(formulas: string[][]): FRange;
+    /**
+     * Get the RangePermission instance for managing range-level permissions.
+     * This is the new permission API that provides range-specific permission control.
+     * @returns {FRangePermission} - The RangePermission instance.
+     * @example
+     * ```ts
+     * const fWorksheet = univerAPI.getActiveWorkbook().getActiveSheet();
+     * const fRange = fWorksheet.getRange('A1:B10');
+     * const permission = fRange.getRangePermission();
+     *
+     * // Protect the range
+     * await permission.protect({ name: 'Protected Area', allowEdit: false });
+     *
+     * // Check if range is protected
+     * const isProtected = permission.isProtected();
+     *
+     * // Check if current user can edit
+     * const canEdit = permission.canEdit();
+     *
+     * // Unprotect the range
+     * await permission.unprotect();
+     *
+     * // Subscribe to protection changes
+     * permission.protectionChange$.subscribe(change => {
+     *   console.log('Protection changed:', change);
+     * });
+     * ```
+     */
+    getRangePermission(): FRangePermission;
 }

package/lib/types/facade/f-workbook.d.ts

@@ -6,6 +6,7 @@ import { FBaseInitialable } from '@univerjs/core/facade';
 import { FDefinedName } from './f-defined-name';
 import { FPermission } from './f-permission';
 import { FWorksheet } from './f-worksheet';
+import { FWorkbookPermission } from './permission/f-workbook-permission';
 /**
  * Facade API object bounded to a workbook. It provides a set of methods to interact with the workbook.
  * @hideconstructor
@@ -491,6 +492,7 @@ export declare class FWorkbook extends FBaseInitialable {
     /**
      * Get the PermissionInstance.
      * @returns {FPermission} - The PermissionInstance.
+     * @deprecated Use `getWorkbookPermission()` instead for the new permission API
      * @example
      * ```ts
      * const fWorkbook = univerAPI.getActiveWorkbook();
@@ -499,6 +501,32 @@ export declare class FWorkbook extends FBaseInitialable {
      * ```
      */
     getPermission(): FPermission;
+    /**
+     * Get the WorkbookPermission instance for managing workbook-level permissions.
+     * This is the new permission API that provides a more intuitive and type-safe interface.
+     * @returns {FWorkbookPermission} - The WorkbookPermission instance.
+     * @example
+     * ```ts
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const permission = fWorkbook.getWorkbookPermission();
+     *
+     * // Set workbook to read-only mode
+     * await permission.setMode('viewer');
+     *
+     * // Add a collaborator
+     * await permission.addCollaborator({
+     *   userId: 'user123',
+     *   name: 'John Doe',
+     *   role: 'editor'
+     * });
+     *
+     * // Subscribe to permission changes
+     * permission.permission$.subscribe(snapshot => {
+     *   console.log('Permissions changed:', snapshot);
+     * });
+     * ```
+     */
+    getWorkbookPermission(): FWorkbookPermission;
     /**
      * Get the defined name by name.
      * @param {string} name The name of the defined name to get

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

@@ -5,6 +5,7 @@ import { FBaseInitialable } from '@univerjs/core/facade';
 import { SheetsSelectionsService } from '@univerjs/sheets';
 import { FRange } from './f-range';
 import { FSelection } from './f-selection';
+import { FWorksheetPermission } from './permission/f-worksheet-permission';
 export interface IFacadeClearOptions {
     contentsOnly?: boolean;
     formatOnly?: boolean;
@@ -1449,4 +1450,34 @@ export declare class FWorksheet extends FBaseInitialable {
      * ```
      */
     setColumnCount(columnCount: number): FWorksheet;
+    /**
+     * Get the WorksheetPermission instance for managing worksheet-level permissions.
+     * This is the new permission API that provides worksheet-specific permission control.
+     * @returns {FWorksheetPermission} - The WorksheetPermission instance.
+     * @example
+     * ```ts
+     * const fWorksheet = univerAPI.getActiveWorkbook().getActiveSheet();
+     * const permission = fWorksheet.getWorksheetPermission();
+     *
+     * // Set worksheet to read-only mode
+     * await permission.setMode('readOnly');
+     *
+     * // Check if a specific cell can be edited
+     * const canEdit = permission.canEditCell(0, 0);
+     *
+     * // Protect multiple ranges at once
+     * const range1 = fWorksheet.getRange('A1:B10');
+     * const range2 = fWorksheet.getRange('D1:E10');
+     * await permission.protectRanges([
+     *   { ranges: [range1], options: { name: 'Range 1', allowEdit: false } },
+     *   { ranges: [range2], options: { name: 'Range 2', allowEdit: false } }
+     * ]);
+     *
+     * // Subscribe to permission changes
+     * permission.permission$.subscribe(snapshot => {
+     *   console.log('Worksheet permissions changed:', snapshot);
+     * });
+     * ```
+     */
+    getWorksheetPermission(): FWorksheetPermission;
 }

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

@@ -0,0 +1,270 @@
+import { Observable } from 'rxjs';
+import { FRange } from '../f-range';
+import { FWorksheet } from '../f-worksheet';
+import { IRangeProtectionRule as IFRangeProtectionRule, IRangePermission, IRangeProtectionOptions, RangePermissionSnapshot, RangePermissionPoint } from './permission-types';
+import { IAuthzIoService, ICommandService, Injector, IPermissionService } from '@univerjs/core';
+import { RangeProtectionRuleModel } from '@univerjs/sheets';
+/**
+ * Implementation class for RangePermission
+ * Manages range-level permissions
+ *
+ * @hideconstructor
+ */
+export declare class FRangePermission implements IRangePermission {
+    private readonly _unitId;
+    private readonly _subUnitId;
+    private readonly _range;
+    private readonly _worksheet;
+    private readonly _injector;
+    private readonly _permissionService;
+    private readonly _authzIoService;
+    private readonly _commandService;
+    private readonly _rangeProtectionRuleModel;
+    private readonly _permissionSubject;
+    private readonly _subscriptions;
+    /**
+     * Observable stream of permission snapshot changes
+     * @returns Observable that emits when permission snapshot changes
+     */
+    readonly permission$: Observable<RangePermissionSnapshot>;
+    /**
+     * Observable stream of protection state changes
+     * @returns Observable that emits when protection state changes
+     */
+    readonly protectionChange$: Observable<{
+        type: 'protected';
+        rule: IFRangeProtectionRule;
+    } | {
+        type: 'unprotected';
+        ruleId: string;
+    }>;
+    constructor(_unitId: string, _subUnitId: string, _range: FRange, _worksheet: FWorksheet, _injector: Injector, _permissionService: IPermissionService, _authzIoService: IAuthzIoService, _commandService: ICommandService, _rangeProtectionRuleModel: RangeProtectionRuleModel);
+    /**
+     * Create permission snapshot stream from IPermissionService
+     * @private
+     */
+    private _createPermissionStream;
+    /**
+     * Create protection change stream from RangeProtectionRuleModel
+     * @private
+     */
+    private _createProtectionChangeStream;
+    /**
+     * Check if a protection rule matches this range
+     */
+    private _rangeMatches;
+    /**
+     * Create a Facade rule from internal rule
+     */
+    private _createFacadeRule;
+    /**
+     * Get the value of a specific permission point.
+     * @param {RangePermissionPoint} point The permission point to query.
+     * @returns {boolean} true if allowed, false if denied.
+     * @example
+     * ```ts
+     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
+     * const permission = range?.getRangePermission();
+     * const canEdit = permission?.getPoint(RangePermissionPoint.Edit);
+     * console.log(canEdit);
+     * ```
+     */
+    getPoint(point: RangePermissionPoint): boolean;
+    /**
+     * Get the current permission snapshot.
+     * @returns {RangePermissionSnapshot} Snapshot of all permission points.
+     * @example
+     * ```ts
+     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
+     * const permission = range?.getRangePermission();
+     * const snapshot = permission?.getSnapshot();
+     * console.log(snapshot);
+     * ```
+     */
+    getSnapshot(): RangePermissionSnapshot;
+    /**
+     * Check if the current range is protected.
+     * @returns {boolean} true if protected, false otherwise.
+     * @example
+     * ```ts
+     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
+     * const permission = range?.getRangePermission();
+     * const isProtected = permission?.isProtected();
+     * console.log(isProtected);
+     * ```
+     */
+    isProtected(): boolean;
+    /**
+     * Check if the current user can edit this range.
+     * @returns {boolean} true if editable, false otherwise.
+     * @example
+     * ```ts
+     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
+     * const permission = range?.getRangePermission();
+     * if (permission?.canEdit()) {
+     *   console.log('You can edit this range');
+     * }
+     * ```
+     */
+    canEdit(): boolean;
+    /**
+     * Check if the current user can view this range.
+     * @returns {boolean} true if viewable, false otherwise.
+     * @example
+     * ```ts
+     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
+     * const permission = range?.getRangePermission();
+     * if (permission?.canView()) {
+     *   console.log('You can view this range');
+     * }
+     * ```
+     */
+    canView(): boolean;
+    /**
+     * Check if the current user can manage collaborators for this range.
+     * @returns {boolean} true if can manage collaborators, false otherwise.
+     * @example
+     * ```ts
+     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
+     * const permission = range?.getRangePermission();
+     * if (permission?.canManageCollaborator()) {
+     *   console.log('You can manage collaborators for this range');
+     * }
+     * ```
+     */
+    canManageCollaborator(): boolean;
+    /**
+     * Check if the current user can delete this protection rule.
+     * @returns {boolean} true if can delete rule, false otherwise.
+     * @example
+     * ```ts
+     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
+     * const permission = range?.getRangePermission();
+     * if (permission?.canDelete()) {
+     *   console.log('You can delete this protection rule');
+     * }
+     * ```
+     */
+    canDelete(): boolean;
+    /**
+     * Set a specific permission point for the range (low-level API for local runtime control).
+     * This method directly sets the permission point value for the current range protection rule.
+     * If no protection rule exists, it will create permission points without a rule (local-only mode).
+     * @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();
+     * // Can set permission points without calling protect() first (local-only mode)
+     * await permission?.setPoint(RangePermissionPoint.Edit, false); // Disable edit
+     * await permission?.setPoint(RangePermissionPoint.View, true);  // Enable view
+     * ```
+     */
+    setPoint(point: RangePermissionPoint, value: boolean): Promise<void>;
+    /**
+     * Get a local-only permission ID for this range (used when no protection rule exists)
+     * @private
+     */
+    private _getLocalPermissionId;
+    /**
+     * Protect the current range.
+     * @param {IRangeProtectionOptions} options Protection options.
+     * @returns {Promise<IFRangeProtectionRule>} The created protection rule.
+     * @example
+     * ```ts
+     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
+     * const permission = range?.getRangePermission();
+     * const rule = await permission?.protect({
+     *   name: 'My protected range',
+     *   allowEdit: false,
+     *   allowView: true,
+     *   allowManageCollaborator: false,
+     *   allowDeleteRule: false
+     * });
+     * console.log(rule);
+     * ```
+     */
+    protect(options?: IRangeProtectionOptions): Promise<IFRangeProtectionRule>;
+    /**
+     * Determine view state from options
+     * @private
+     */
+    private _determineViewState;
+    /**
+     * Determine edit state from options
+     * @private
+     */
+    private _determineEditState;
+    /**
+     * Set permission points based on options (for local runtime control)
+     * @private
+     */
+    private _setPermissionPoints;
+    /**
+     * Set a single permission point
+     * @private
+     */
+    private _setPermissionPoint;
+    /**
+     * Unprotect the current range.
+     * @returns {Promise<void>} A promise that resolves when the range is unprotected.
+     * @example
+     * ```ts
+     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
+     * const permission = range?.getRangePermission();
+     * await permission?.unprotect();
+     * ```
+     */
+    unprotect(): Promise<void>;
+    /**
+     * List all protection rules.
+     * @returns {Promise<IFRangeProtectionRule[]>} Array of protection rules.
+     * @example
+     * ```ts
+     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
+     * const permission = range?.getRangePermission();
+     * const rules = await permission?.listRules();
+     * console.log(rules);
+     * ```
+     */
+    listRules(): Promise<IFRangeProtectionRule[]>;
+    /**
+     * Subscribe to permission changes (simplified interface).
+     * @param {Function} listener Callback function to be called when permissions change.
+     * @returns {Function} Unsubscribe function.
+     * @example
+     * ```ts
+     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
+     * const permission = range?.getRangePermission();
+     * const unsubscribe = permission?.subscribe((snapshot) => {
+     *   console.log('Permission changed:', snapshot);
+     * });
+     * // Later, to stop listening:
+     * unsubscribe?.();
+     * ```
+     */
+    subscribe(listener: (snapshot: RangePermissionSnapshot) => void): (() => void);
+    /**
+     * Get the protection rule for the current range
+     */
+    private _getProtectionRule;
+    /**
+     * Build Facade objects for all protection rules
+     */
+    private _buildProtectionRules;
+    /**
+     * Build Facade objects for all protection rules (async version with collaborator data)
+     * @private
+     */
+    private _buildProtectionRulesAsync;
+    /**
+     * Build permission snapshot
+     */
+    private _buildSnapshot;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}

package/lib/types/facade/permission/f-range-protection-rule.d.ts

@@ -0,0 +1,108 @@
+import { FRange } from '../f-range';
+import { IRangeProtectionOptions, IRangeProtectionRule } from './permission-types';
+import { ICommandService, Injector } from '@univerjs/core';
+import { RangeProtectionRuleModel } from '@univerjs/sheets';
+/**
+ * Implementation class for range protection rules
+ * Encapsulates operations on a single protection rule
+ *
+ * @hideconstructor
+ */
+export declare class FRangeProtectionRule implements IRangeProtectionRule {
+    private readonly _unitId;
+    private readonly _subUnitId;
+    private readonly _ruleId;
+    private readonly _permissionId;
+    private readonly _ranges;
+    private readonly _options;
+    private readonly _injector;
+    private readonly _commandService;
+    private readonly _rangeProtectionRuleModel;
+    constructor(_unitId: string, _subUnitId: string, _ruleId: string, _permissionId: string, _ranges: FRange[], _options: IRangeProtectionOptions, _injector: Injector, _commandService: ICommandService, _rangeProtectionRuleModel: RangeProtectionRuleModel);
+    /**
+     * Get the rule ID.
+     * @returns {string} The unique identifier of this protection rule.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.permission();
+     * const rules = await permission?.listRangeProtectionRules();
+     * const ruleId = rules?.[0]?.id;
+     * console.log(ruleId);
+     * ```
+     */
+    get id(): string;
+    /**
+     * Get the protected ranges.
+     * @returns {FRange[]} Array of protected ranges.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.permission();
+     * const rules = await permission?.listRangeProtectionRules();
+     * const ranges = rules?.[0]?.ranges;
+     * console.log(ranges);
+     * ```
+     */
+    get ranges(): FRange[];
+    /**
+     * Get the protection options.
+     * @returns {IRangeProtectionOptions} Copy of the protection options.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.permission();
+     * const rules = await permission?.listRangeProtectionRules();
+     * const options = rules?.[0]?.options;
+     * console.log(options);
+     * ```
+     */
+    get options(): IRangeProtectionOptions;
+    /**
+     * Update the protected ranges.
+     * @param {FRange[]} ranges New ranges to protect.
+     * @returns {Promise<void>} A promise that resolves when the ranges are updated.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.permission();
+     * const rules = await permission?.listRangeProtectionRules();
+     * const rule = rules?.[0];
+     * await rule?.updateRanges([worksheet.getRange('A1:C3')]);
+     * ```
+     */
+    updateRanges(ranges: FRange[]): Promise<void>;
+    /**
+     * Update protection options.
+     * @param {Partial<IRangeProtectionOptions>} options Partial options to update (will be merged with existing options).
+     * @returns {Promise<void>} A promise that resolves when the options are updated.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.permission();
+     * const rules = await permission?.listRangeProtectionRules();
+     * const rule = rules?.[0];
+     * await rule?.updateOptions({ name: 'New Protection Name', allowEdit: true });
+     * ```
+     */
+    updateOptions(options: Partial<IRangeProtectionOptions>): Promise<void>;
+    /**
+     * Delete the current protection rule.
+     * @returns {Promise<void>} A promise that resolves when the rule is removed.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.permission();
+     * const rules = await permission?.listRangeProtectionRules();
+     * const rule = rules?.[0];
+     * await rule?.remove();
+     * ```
+     */
+    remove(): Promise<void>;
+    /**
+     * Check if two ranges intersect
+     * @returns true if ranges intersect, false otherwise
+     * @private
+     */
+    private _rangesIntersect;
+}