@univerjs/sheets 0.11.0 → 0.12.0

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

@@ -0,0 +1,270 @@
+import { IUser } from '@univerjs/protocol';
+import { Observable } from 'rxjs';
+import { ICollaborator, IWorkbookPermission, UnsubscribeFn, WorkbookMode, WorkbookPermissionSnapshot, UnitRole, WorkbookPermissionPoint } from './permission-types';
+import { IAuthzIoService, Injector, IPermissionService } from '@univerjs/core';
+/**
+ * Implementation class for WorkbookPermission
+ * Provides workbook-level permission control
+ *
+ * @hideconstructor
+ */
+export declare class FWorkbookPermission implements IWorkbookPermission {
+    private readonly _unitId;
+    private readonly _injector;
+    private readonly _permissionService;
+    private readonly _authzIoService;
+    private readonly _permissionSubject;
+    private readonly _collaboratorChangeSubject;
+    /**
+     * Observable stream of permission snapshot changes (BehaviorSubject)
+     * Emits immediately on subscription with current state, then on any permission point change
+     */
+    readonly permission$: Observable<WorkbookPermissionSnapshot>;
+    /**
+     * Observable stream of individual permission point changes
+     * Emits when a specific permission point value changes
+     */
+    readonly pointChange$: Observable<{
+        point: WorkbookPermissionPoint;
+        value: boolean;
+        oldValue: boolean;
+    }>;
+    /**
+     * Observable stream of collaborator changes
+     * Emits when collaborators are added, updated, or removed
+     */
+    readonly collaboratorChange$: Observable<{
+        type: 'add' | 'update' | 'delete';
+        collaborator: ICollaborator;
+    }>;
+    private _subscriptions;
+    constructor(_unitId: string, _injector: Injector, _permissionService: IPermissionService, _authzIoService: IAuthzIoService);
+    /**
+     * Create permission snapshot stream from IPermissionService
+     * @private
+     */
+    private _createPermissionStream;
+    /**
+     * Create point change stream from IPermissionService
+     * @private
+     */
+    private _createPointChangeStream;
+    /**
+     * Extract WorkbookPermissionPoint type from permission point ID
+     * @private
+     */
+    private _extractWorkbookPointType;
+    /**
+     * Build permission snapshot
+     */
+    private _buildSnapshot;
+    /**
+     * Listen to permission point changes
+    /**
+     * Set permission mode for the workbook.
+     * @param {WorkbookMode} mode The permission mode to set ('owner' | 'editor' | 'viewer' | 'commenter').
+     * @returns {Promise<void>} A promise that resolves when the mode is set.
+     * @example
+     * ```ts
+     * const workbook = univerAPI.getActiveWorkbook();
+     * const permission = workbook?.getWorkbookPermission();
+     * await permission?.setMode('editor');
+     * ```
+     */
+    setMode(mode: WorkbookMode): Promise<void>;
+    /**
+     * Get permission configuration for a specific mode
+     * @private
+     */
+    private _getModePermissions;
+    /**
+     * Batch set multiple permission points efficiently
+     * @private
+     */
+    private _batchSetPermissionPoints;
+    /**
+     * Set the workbook to read-only mode (viewer mode).
+     * @returns {Promise<void>} A promise that resolves when the mode is set.
+     * @example
+     * ```ts
+     * const workbook = univerAPI.getActiveWorkbook();
+     * const permission = workbook?.getWorkbookPermission();
+     * await permission?.setReadOnly();
+     * ```
+     */
+    setReadOnly(): Promise<void>;
+    /**
+     * Set the workbook to editable mode (editor mode).
+     * @returns {Promise<void>} A promise that resolves when the mode is set.
+     * @example
+     * ```ts
+     * const workbook = univerAPI.getActiveWorkbook();
+     * const permission = workbook?.getWorkbookPermission();
+     * await permission?.setEditable();
+     * ```
+     */
+    setEditable(): Promise<void>;
+    /**
+     * Check if the workbook is editable.
+     * @returns {boolean} true if the workbook can be edited, false otherwise.
+     * @example
+     * ```ts
+     * const workbook = univerAPI.getActiveWorkbook();
+     * const permission = workbook?.getWorkbookPermission();
+     * if (permission?.canEdit()) {
+     *   console.log('Workbook is editable');
+     * }
+     * ```
+     */
+    canEdit(): boolean;
+    /**
+     * Set a specific permission point.
+     * @param {WorkbookPermissionPoint} 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 workbook = univerAPI.getActiveWorkbook();
+     * const permission = workbook?.getWorkbookPermission();
+     * await permission?.setPoint(WorkbookPermissionPoint.Print, false);
+     * ```
+     */
+    setPoint(point: WorkbookPermissionPoint, value: boolean): Promise<void>;
+    /**
+     * Get the value of a specific permission point.
+     * @param {WorkbookPermissionPoint} point The permission point to query.
+     * @returns {boolean} true if allowed, false if denied.
+     * @example
+     * ```ts
+     * const workbook = univerAPI.getActiveWorkbook();
+     * const permission = workbook?.getWorkbookPermission();
+     * const canPrint = permission?.getPoint(WorkbookPermissionPoint.Print);
+     * console.log(canPrint);
+     * ```
+     */
+    getPoint(point: WorkbookPermissionPoint): boolean;
+    /**
+     * Get a snapshot of all permission points.
+     * @returns {WorkbookPermissionSnapshot} An object containing all permission point values.
+     * @example
+     * ```ts
+     * const workbook = univerAPI.getActiveWorkbook();
+     * const permission = workbook?.getWorkbookPermission();
+     * const snapshot = permission?.getSnapshot();
+     * console.log(snapshot);
+     * ```
+     */
+    getSnapshot(): WorkbookPermissionSnapshot;
+    /**
+     * Set multiple collaborators at once (replaces existing collaborators).
+     * @param {Array<{ user: IUser; role: UnitRole }>} collaborators Array of collaborators with user information and role.
+     * @returns {Promise<void>} A promise that resolves when the collaborators are set.
+     * @example
+     * ```ts
+     * const workbook = univerAPI.getActiveWorkbook();
+     * const permission = workbook?.getWorkbookPermission();
+     * await permission?.setCollaborators([
+     *   {
+     *     user: { userID: 'user1', name: 'John Doe', avatar: 'https://...' },
+     *     role: UnitRole.Editor
+     *   },
+     *   {
+     *     user: { userID: 'user2', name: 'Jane Smith', avatar: '' },
+     *     role: UnitRole.Reader
+     *   }
+     * ]);
+     * ```
+     */
+    setCollaborators(collaborators: Array<{
+        user: IUser;
+        role: UnitRole;
+    }>): Promise<void>;
+    /**
+     * Add a single collaborator.
+     * @param {IUser} user The user information (userID, name, avatar).
+     * @param {UnitRole} role The role to assign.
+     * @returns {Promise<void>} A promise that resolves when the collaborator is added.
+     * @example
+     * ```ts
+     * const workbook = univerAPI.getActiveWorkbook();
+     * const permission = workbook?.getWorkbookPermission();
+     * await permission?.addCollaborator(
+     *   { userID: 'user1', name: 'John Doe', avatar: 'https://...' },
+     *   UnitRole.Editor
+     * );
+     * ```
+     */
+    addCollaborator(user: IUser, role: UnitRole): Promise<void>;
+    /**
+     * Update an existing collaborator's role and information.
+     * @param {IUser} user The updated user information (userID, name, avatar).
+     * @param {UnitRole} role The new role to assign.
+     * @returns {Promise<void>} A promise that resolves when the collaborator is updated.
+     * @example
+     * ```ts
+     * const workbook = univerAPI.getActiveWorkbook();
+     * const permission = workbook?.getWorkbookPermission();
+     * await permission?.updateCollaborator(
+     *   { userID: 'user1', name: 'John Doe Updated', avatar: 'https://...' },
+     *   UnitRole.Reader
+     * );
+     * ```
+     */
+    updateCollaborator(user: IUser, role: UnitRole): Promise<void>;
+    /**
+     * Remove a collaborator from the workbook.
+     * @param {string} userId The user ID to remove.
+     * @returns {Promise<void>} A promise that resolves when the collaborator is removed.
+     * @example
+     * ```ts
+     * const workbook = univerAPI.getActiveWorkbook();
+     * const permission = workbook?.getWorkbookPermission();
+     * await permission?.removeCollaborator('user1');
+     * ```
+     */
+    removeCollaborator(userId: string): Promise<void>;
+    /**
+     * Remove multiple collaborators at once.
+     * @param {string[]} userIds Array of user IDs to remove.
+     * @returns {Promise<void>} A promise that resolves when the collaborators are removed.
+     * @example
+     * ```ts
+     * const workbook = univerAPI.getActiveWorkbook();
+     * const permission = workbook?.getWorkbookPermission();
+     * await permission?.removeCollaborators(['user1', 'user2']);
+     * ```
+     */
+    removeCollaborators(userIds: string[]): Promise<void>;
+    /**
+     * List all collaborators of the workbook.
+     * @returns {Promise<ICollaborator[]>} Array of collaborators with their roles.
+     * @example
+     * ```ts
+     * const workbook = univerAPI.getActiveWorkbook();
+     * const permission = workbook?.getWorkbookPermission();
+     * const collaborators = await permission?.listCollaborators();
+     * console.log(collaborators);
+     * ```
+     */
+    listCollaborators(): Promise<ICollaborator[]>;
+    /**
+     * Subscribe to permission changes (simplified interface for users not familiar with RxJS).
+     * @param {Function} listener Callback function to be called when permissions change.
+     * @returns {UnsubscribeFn} Unsubscribe function.
+     * @example
+     * ```ts
+     * const workbook = univerAPI.getActiveWorkbook();
+     * const permission = workbook?.getWorkbookPermission();
+     * const unsubscribe = permission?.subscribe((snapshot) => {
+     *   console.log('Permission changed:', snapshot);
+     * });
+     * // Later, to stop listening:
+     * unsubscribe?.();
+     * ```
+     */
+    subscribe(listener: (snapshot: WorkbookPermissionSnapshot) => void): UnsubscribeFn;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}

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

@@ -0,0 +1,335 @@
+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 { IAuthzIoService, ICommandService, Injector, IPermissionService } from '@univerjs/core';
+import { RangeProtectionRuleModel, WorksheetProtectionPointModel } from '@univerjs/sheets';
+/**
+ * Implementation class for WorksheetPermission
+ * Provides worksheet-level permission control
+ *
+ * @hideconstructor
+ */
+export declare class FWorksheetPermission implements IWorksheetPermission {
+    private readonly _worksheet;
+    private readonly _injector;
+    private readonly _permissionService;
+    private readonly _authzIoService;
+    private readonly _commandService;
+    private readonly _rangeProtectionRuleModel;
+    private readonly _worksheetProtectionPointModel;
+    private readonly _permissionSubject;
+    private readonly _rangeRulesSubject;
+    /**
+     * Observable stream of permission snapshot changes (BehaviorSubject)
+     * Emits immediately on subscription with current state, then on any permission point change
+     */
+    readonly permission$: Observable<WorksheetPermissionSnapshot>;
+    /**
+     * Observable stream of individual permission point changes
+     * Emits when a specific permission point value changes
+     */
+    readonly pointChange$: Observable<{
+        point: WorksheetPermissionPoint;
+        value: boolean;
+        oldValue: boolean;
+    }>;
+    /**
+     * Observable stream of range protection rule changes
+     * Emits when protection rules are added, updated, or deleted
+     */
+    readonly rangeProtectionChange$: Observable<{
+        type: 'add' | 'update' | 'delete';
+        rules: IRangeProtectionRule[];
+    }>;
+    /**
+     * 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[]>;
+    private readonly _unitId;
+    private readonly _subUnitId;
+    private readonly _subscriptions;
+    constructor(_worksheet: FWorksheet, _injector: Injector, _permissionService: IPermissionService, _authzIoService: IAuthzIoService, _commandService: ICommandService, _rangeProtectionRuleModel: RangeProtectionRuleModel, _worksheetProtectionPointModel: WorksheetProtectionPointModel);
+    /**
+     * Create permission snapshot stream from IPermissionService
+     * @private
+     */
+    private _createPermissionStream;
+    /**
+     * Create point change stream from IPermissionService
+     * @private
+     */
+    private _createPointChangeStream;
+    /**
+     * Create range protection change stream from RangeProtectionRuleModel
+     * @private
+     */
+    private _createRangeProtectionChangeStream;
+    /**
+     * Create range protection rules list stream from RangeProtectionRuleModel
+     * @private
+     */
+    private _createRangeProtectionRulesStream;
+    /**
+     * Extract WorksheetPermissionPoint type from permission point ID
+     * @private
+     */
+    private _extractWorksheetPointType;
+    /**
+     * Read the actual edit permission from a rule's permissionId
+     */
+    private _getRuleEditPermission;
+    /**
+     * Build permission snapshot
+     */
+    private _buildSnapshot;
+    /**
+     * Build range protection rules list
+     */
+    private _buildRangeProtectionRules;
+    /**
+     * Set permission mode for the worksheet.
+     * @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
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * await permission?.setMode('readOnly');
+     * ```
+     */
+    setMode(mode: WorksheetMode): Promise<void>;
+    /**
+     * Get permission configuration for a specific mode
+     * @private
+     */
+    private _getModePermissions;
+    /**
+     * Batch set multiple permission points efficiently
+     * @private
+     */
+    private _batchSetPermissionPoints;
+    /**
+     * Set the worksheet to read-only mode.
+     * @returns {Promise<void>} A promise that resolves when the mode is set.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * await permission?.setReadOnly();
+     * ```
+     */
+    setReadOnly(): Promise<void>;
+    /**
+     * Set the worksheet to editable mode.
+     * @returns {Promise<void>} A promise that resolves when the mode is set.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * await permission?.setEditable();
+     * ```
+     */
+    setEditable(): Promise<void>;
+    /**
+     * Check if the worksheet is editable.
+     * @returns {boolean} true if the worksheet can be edited, false otherwise.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * if (permission?.canEdit()) {
+     *   console.log('Worksheet is editable');
+     * }
+     * ```
+     */
+    canEdit(): boolean;
+    /**
+     * Check if a specific cell can be edited.
+     * @param {number} row Row index.
+     * @param {number} col Column index.
+     * @returns {boolean} true if the cell can be edited, false otherwise.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * const canEdit = permission?.canEditCell(0, 0);
+     * console.log(canEdit);
+     * ```
+     */
+    canEditCell(row: number, col: number): boolean;
+    /**
+     * Check if a specific cell can be viewed.
+     * @param {number} _row Row index (unused, for API consistency).
+     * @param {number} _col Column index (unused, for API consistency).
+     * @returns {boolean} true if the cell can be viewed, false otherwise.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * const canView = permission?.canViewCell(0, 0);
+     * console.log(canView);
+     * ```
+     */
+    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.
+     * @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.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * await permission?.setPoint(WorksheetPermissionPoint.InsertRow, false);
+     * ```
+     */
+    setPoint(point: WorksheetPermissionPoint, value: boolean): Promise<void>;
+    /**
+     * Get the value of a specific permission point.
+     * @param {WorksheetPermissionPoint} point The permission point to query.
+     * @returns {boolean} true if allowed, false if denied.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * const canInsertRow = permission?.getPoint(WorksheetPermissionPoint.InsertRow);
+     * console.log(canInsertRow);
+     * ```
+     */
+    getPoint(point: WorksheetPermissionPoint): boolean;
+    /**
+     * Get a snapshot of all permission points.
+     * @returns {WorksheetPermissionSnapshot} An object containing all permission point values.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * const snapshot = permission?.getSnapshot();
+     * console.log(snapshot);
+     * ```
+     */
+    getSnapshot(): WorksheetPermissionSnapshot;
+    /**
+     * Apply a permission configuration to the worksheet.
+     * @param {IWorksheetPermissionConfig} config The configuration to apply.
+     * @returns {Promise<void>} A promise that resolves when the configuration is applied.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * await permission?.applyConfig({
+     *   mode: 'readOnly',
+     *   points: {
+     *     [WorksheetPermissionPoint.View]: true,
+     *     [WorksheetPermissionPoint.Edit]: false
+     *   }
+     * });
+     * ```
+     */
+    applyConfig(config: IWorksheetPermissionConfig): Promise<void>;
+    /**
+     * 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.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * const rules = await permission?.protectRanges([
+     *   {
+     *     ranges: [worksheet.getRange('A1:B2')],
+     *     options: { name: 'Protected Area 1', allowEdit: false, allowView: true }
+     *   },
+     *   {
+     *     ranges: [worksheet.getRange('C3:D4')],
+     *     options: { name: 'Protected Area 2', allowEdit: true, allowView: false }
+     *   }
+     * ]);
+     * console.log(rules);
+     * ```
+     */
+    protectRanges(configs: Array<{
+        ranges: FRange[];
+        options?: IRangeProtectionOptions;
+    }>): Promise<IRangeProtectionRule[]>;
+    /**
+     * 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;
+    /**
+     * Remove multiple protection rules at once.
+     * @param {string[]} ruleIds Array of rule IDs to remove.
+     * @returns {Promise<void>} A promise that resolves when the rules are removed.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * await permission?.unprotectRules(['rule1', 'rule2']);
+     * ```
+     */
+    unprotectRules(ruleIds: string[]): Promise<void>;
+    /**
+     * List all range protection rules for the worksheet.
+     * @returns {Promise<IRangeProtectionRule[]>} Array of protection rules.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * const rules = await permission?.listRangeProtectionRules();
+     * console.log(rules);
+     * ```
+     */
+    listRangeProtectionRules(): Promise<IRangeProtectionRule[]>;
+    /**
+     * Subscribe to permission changes (simplified interface for users not familiar with RxJS).
+     * @param {Function} listener Callback function to be called when permissions change.
+     * @returns {UnsubscribeFn} Unsubscribe function.
+     * @example
+     * ```ts
+     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
+     * const permission = worksheet?.getWorksheetPermission();
+     * const unsubscribe = permission?.subscribe((snapshot) => {
+     *   console.log('Permission changed:', snapshot);
+     * });
+     * // Later, to stop listening:
+     * unsubscribe?.();
+     * ```
+     */
+    subscribe(listener: (snapshot: WorksheetPermissionSnapshot) => void): UnsubscribeFn;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export { FRangePermission } from './f-range-permission';
+export { FRangeProtectionRule } from './f-range-protection-rule';
+export { FWorkbookPermission } from './f-workbook-permission';
+export { FWorksheetPermission } from './f-worksheet-permission';
+export * from './permission-point-map';
+export * from './permission-types';

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

@@ -0,0 +1,14 @@
+import { RangePermissionPointConstructor, WorkbookPermissionPointConstructor, WorkSheetPermissionPointConstructor } from '@univerjs/core';
+import { RangePermissionPoint, WorkbookPermissionPoint, WorksheetPermissionPoint } from './permission-types';
+/**
+ * Mapping table from Workbook permission point enum to class constructors
+ */
+export declare const WORKBOOK_PERMISSION_POINT_MAP: Record<WorkbookPermissionPoint, WorkbookPermissionPointConstructor>;
+/**
+ * Mapping table from Worksheet permission point enum to class constructors
+ */
+export declare const WORKSHEET_PERMISSION_POINT_MAP: Record<WorksheetPermissionPoint, WorkSheetPermissionPointConstructor>;
+/**
+ * Mapping table from Range permission point enum to class constructors
+ */
+export declare const RANGE_PERMISSION_POINT_MAP: Record<RangePermissionPoint, RangePermissionPointConstructor>;