@univerjs/sheets 0.4.2 → 0.5.0-alpha.0

package/lib/es/locale/en-US.js

@@ -0,0 +1,17 @@
+const e = {
+  sheets: {
+    tabs: {
+      sheetCopy: "(Copy{0})",
+      sheet: "Sheet"
+    },
+    info: {
+      overlappingSelections: "Cannot use that command on overlapping selections",
+      acrossMergedCell: "Across a merged cell",
+      partOfCell: "Only part of a merged cell is selected",
+      hideSheet: "No visible sheet after you hide this"
+    }
+  }
+};
+export {
+  e as default
+};

package/lib/es/locale/fa-IR.js

@@ -0,0 +1,17 @@
+const e = {
+  sheets: {
+    tabs: {
+      sheetCopy: "(کپی{0})",
+      sheet: "برگ"
+    },
+    info: {
+      overlappingSelections: "نمی‌توان از این دستور روی انتخاب‌های همپوشانی استفاده کرد",
+      acrossMergedCell: "در سراسر سلول ادغام شده",
+      partOfCell: "فقط بخشی از سلول ادغام شده انتخاب شده است",
+      hideSheet: "پس از پنهان کردن این برگ، هیچ برگی قابل مشاهده نخواهد بود"
+    }
+  }
+};
+export {
+  e as default
+};

package/lib/es/locale/ru-RU.js

@@ -0,0 +1,17 @@
+const e = {
+  sheets: {
+    tabs: {
+      sheetCopy: "(Копия{0})",
+      sheet: "Лист"
+    },
+    info: {
+      overlappingSelections: "Невозможно использовать эту команду на пересекающихся выделениях",
+      acrossMergedCell: "Через объединенную ячейку",
+      partOfCell: "Выделена только часть объединенной ячейки",
+      hideSheet: "После скрытия этого листа не будет видно ни одного листа"
+    }
+  }
+};
+export {
+  e as default
+};

package/lib/es/locale/vi-VN.js

@@ -0,0 +1,17 @@
+const h = {
+  sheets: {
+    tabs: {
+      sheetCopy: "（Bản sao {0}）",
+      sheet: "Bảng tính"
+    },
+    info: {
+      overlappingSelections: "Không thể sử dụng lệnh này trên các vùng chọn chồng chéo nhau",
+      acrossMergedCell: "Không thể vượt qua các ô đã hợp nhất",
+      partOfCell: "Chỉ chọn một phần của ô đã hợp nhất",
+      hideSheet: "Không có bảng tính nào hiển thị sau khi ẩn"
+    }
+  }
+};
+export {
+  h as default
+};

package/lib/es/locale/zh-CN.js

@@ -0,0 +1,17 @@
+const e = {
+  sheets: {
+    tabs: {
+      sheetCopy: "（副本{0}）",
+      sheet: "工作表"
+    },
+    info: {
+      overlappingSelections: "无法对重叠选区使用该命令",
+      acrossMergedCell: "无法跨越合并单元格",
+      partOfCell: "仅选择了合并单元格的一部分",
+      hideSheet: "隐藏后无可见工作表"
+    }
+  }
+};
+export {
+  e as default
+};

package/lib/es/locale/zh-TW.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/add-worksheet-protection.command.d.ts

@@ -0,0 +1,7 @@
+import { ICommand } from '@univerjs/core';
+import { IWorksheetProtectionRule } from '../../services/permission/type';
+export interface IAddWorksheetProtectionParams {
+    unitId: string;
+    rule: IWorksheetProtectionRule;
+}
+export declare const AddWorksheetProtectionCommand: ICommand<IAddWorksheetProtectionParams>;

package/lib/types/commands/commands/delete-worksheet-protection.command.d.ts

@@ -0,0 +1,8 @@
+import { ICommand } from '@univerjs/core';
+import { IWorksheetProtectionRule } from '../../services/permission/type';
+export interface IDeleteWorksheetProtectionParams {
+    unitId: string;
+    subUnitId: string;
+    rule: IWorksheetProtectionRule;
+}
+export declare const DeleteWorksheetProtectionCommand: ICommand<IDeleteWorksheetProtectionParams>;

package/lib/types/commands/commands/set-frozen.command.d.ts

@@ -1,2 +1,15 @@
 import { ICommand } from '@univerjs/core';
+export interface ISetFrozenCommandParams {
+    startRow: number;
+    startColumn: number;
+    ySplit: number;
+    xSplit: number;
+    unitId?: string;
+    subUnitId?: string;
+}
 export declare const SetFrozenCommand: ICommand;
+export interface ICancelFrozenCommandParams {
+    unitId?: string;
+    subUnitId?: string;
+}
+export declare const CancelFrozenCommand: ICommand<ICancelFrozenCommandParams>;

package/lib/types/commands/commands/set-protection.command.d.ts

@@ -0,0 +1,13 @@
+import { ICommand, IRange } from '@univerjs/core';
+import { IRangeProtectionRule } from '../../model/range-protection-rule.model';
+import { IWorksheetProtectionRule } from '../../services/permission/type';
+type IPermissionRule = (IRangeProtectionRule | IWorksheetProtectionRule) & {
+    ranges: IRange[];
+    id: string;
+};
+interface ISetProtectionParams {
+    rule: IPermissionRule;
+    oldRule: IPermissionRule;
+}
+export declare const SetProtectionCommand: ICommand<ISetProtectionParams>;
+export {};

package/lib/types/commands/commands/set-worksheet-protection.command.d.ts

@@ -0,0 +1,8 @@
+import { ICommand } from '@univerjs/core';
+import { IWorksheetProtectionRule } from '../../services/permission/type';
+export interface ISetWorksheetProtectionParams {
+    permissionId: string;
+    rule: IWorksheetProtectionRule;
+    oldRule: IWorksheetProtectionRule;
+}
+export declare const SetWorksheetProtectionCommand: ICommand<ISetWorksheetProtectionParams>;

package/lib/types/commands/mutations/reorder-range.mutation.d.ts

@@ -1,5 +1,5 @@
 import { IMutation, IRange } from '@univerjs/core';
-import { ISheetCommandSharedParams } from '@univerjs/sheets';
+import { ISheetCommandSharedParams } from '../../commands/utils/interface';
 export interface IReorderRangeMutationParams extends ISheetCommandSharedParams {
     range: IRange;
     order: {

package/lib/types/facade/__tests__/utils.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * 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 {};

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

@@ -0,0 +1,106 @@
+import { IRange, RangePermissionPointConstructor, WorkbookPermissionPointConstructor, WorkSheetPermissionPointConstructor, FBase, IAuthzIoService, ICommandService, Injector, IPermissionService } from '@univerjs/core';
+import { RangeProtectionRuleModel, WorksheetProtectionPointModel, WorksheetProtectionRuleModel } from '@univerjs/sheets';
+export declare class FPermission extends FBase {
+    protected readonly _injector: Injector;
+    protected readonly _commandService: ICommandService;
+    protected readonly _permissionService: IPermissionService;
+    protected readonly _worksheetProtectionRuleModel: WorksheetProtectionRuleModel;
+    protected readonly _rangeProtectionRuleModel: RangeProtectionRuleModel;
+    protected readonly _worksheetProtectionPointRuleModel: WorksheetProtectionPointModel;
+    protected readonly _authzIoService: IAuthzIoService;
+    constructor(_injector: Injector, _commandService: ICommandService, _permissionService: IPermissionService, _worksheetProtectionRuleModel: WorksheetProtectionRuleModel, _rangeProtectionRuleModel: RangeProtectionRuleModel, _worksheetProtectionPointRuleModel: WorksheetProtectionPointModel, _authzIoService: IAuthzIoService);
+    /**
+     * Configures a specific permission point for a workbook.
+     *
+     * This function sets or updates a permission point for a workbook identified by `unitId`.
+     * It creates a new permission point if it does not already exist, and updates the point with the provided value.
+     *
+     * @param {string} unitId - The unique identifier of the workbook for which the permission is being set.
+     * @param {WorkbookPermissionPointConstructor} FPointClass - The constructor function for creating a permission point instance. Other point constructors can See the [permission-point documentation](https://github.com/dream-num/univer/tree/dev/packages/sheets/src/services/permission/permission-point) for more details.
+     * @param {boolean} value - The boolean value to determine whether the permission point is enabled or disabled.
+     *
+     */
+    setWorkbookPermissionPoint(unitId: string, FPointClass: WorkbookPermissionPointConstructor, value: boolean): void;
+    /**
+     * This function is used to set whether the workbook can be edited
+     *
+     * @param {string} unitId - The unique identifier of the workbook for which the permission is being set.
+     * @param {boolean} value - A value that controls whether the workbook can be edited
+     *
+     */
+    setWorkbookEditPermission(unitId: string, value: boolean): void;
+    /**
+     * This function is used to add a base permission for a worksheet.
+     *
+     * @param {string} unitId - The unique identifier of the workbook for which the permission is being set.
+     * @param {string} subUnitId - The unique identifier of the worksheet for which the permission is being set.
+     *
+     * @returns {Promise<string | undefined>} - Returns the `permissionId` if the permission is successfully added. If the operation fails or no result is returned, it resolves to `undefined`.
+     */
+    addWorksheetBasePermission(unitId: string, subUnitId: string): Promise<string | undefined>;
+    /**
+     * Delete the entire table protection set for the worksheet and reset the point permissions of the worksheet to true
+     *
+     * @param {string} unitId - The unique identifier of the workbook for which the permission is being set.
+     * @param {string} subUnitId - The unique identifier of the worksheet for which the permission is being set.
+     */
+    removeWorksheetPermission(unitId: string, subUnitId: string): void;
+    /**
+     * Sets the worksheet permission point by updating or adding the permission point for the worksheet.
+     * If the worksheet doesn't have a base permission, it creates one to used render
+     *
+     * @param {string} unitId - The unique identifier of the workbook.
+     * @param {string} subUnitId - The unique identifier of the worksheet.
+     * @param {WorkSheetPermissionPointConstructor} FPointClass - The constructor for the permission point class.
+     *    See the [permission-point documentation](https://github.com/dream-num/univer/tree/dev/packages/sheets/src/services/permission/permission-point) for more details.
+     * @param {boolean} value - The new permission value to be set for the worksheet.
+     *
+     * @returns {Promise<string | undefined>} - Returns the `permissionId` if the permission point is successfully set or created. If no permission is set, it resolves to `undefined`.
+     */
+    setWorksheetPermissionPoint(unitId: string, subUnitId: string, FPointClass: WorkSheetPermissionPointConstructor, value: boolean): Promise<string | undefined>;
+    /**
+     * Adds a range protection to the worksheet.
+     *
+     * @param {string} unitId - The unique identifier of the workbook.
+     * @param {string} subUnitId - The unique identifier of the worksheet.
+     * @param {IRange[]} ranges - The ranges to be protected.
+     *
+     * @returns {Promise<{ permissionId: string, ruleId: string } | undefined>} - Returns an object containing the `permissionId` and `ruleId` if the range protection is successfully added. If the operation fails or no result is returned, it resolves to `undefined`. permissionId is used to stitch permission point ID，ruleId is used to store permission rules
+     */
+    addRangeBaseProtection(unitId: string, subUnitId: string, ranges: IRange[]): Promise<{
+        permissionId: string;
+        ruleId: string;
+    } | undefined>;
+    /**
+     * Removes the range protection from the worksheet.
+     *
+     * @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.
+     */
+    removeRangeProtection(unitId: string, subUnitId: string, ruleIds: string[]): void;
+    /**
+     * Modify the permission points of a custom area
+     *
+     * @param {string} unitId - The unique identifier of the workbook.
+     * @param {string} subUnitId - The unique identifier of the worksheet within the workbook.
+     * @param {string} permissionId - The unique identifier of the permission that controls access to the range.
+     * @param {RangePermissionPointConstructor} FPointClass - The constructor for the range permission point class.
+     *    See the [permission-point documentation](https://github.com/dream-num/univer/tree/dev/packages/sheets/src/services/permission/permission-point) for more details.
+     * @param {boolean} value - The new permission value to be set for the range (e.g., true for allowing access, false for restricting access).
+     */
+    setRangeProtectionPermissionPoint(unitId: string, subUnitId: string, permissionId: string, FPointClass: RangePermissionPointConstructor, value: boolean): void;
+    /**
+     * Sets the ranges for range protection in a worksheet.
+     *
+     * This method finds the rule by unitId, subUnitId, and ruleId, and updates the rule with the provided ranges.
+     * It checks for overlaps with existing ranges in the same subunit and shows an error message if any overlap is detected.
+     * If no overlap is found, it executes the command to update the range protection with the new ranges.
+     *
+     * @param {string} unitId - The unique identifier of the workbook.
+     * @param {string} subUnitId - The unique identifier of the worksheet within the workbook.
+     * @param {string} ruleId - The ruleId of the range protection rule that is being updated.
+     * @param {IRange[]} ranges - The array of new ranges to be set for the range protection rule.
+     */
+    setRangeProtectionRanges(unitId: string, subUnitId: string, ruleId: string, ranges: IRange[]): void;
+}

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

@@ -0,0 +1,193 @@
+import { CellValue, ICellData, IObjectMatrixPrimitiveType, IRange, IStyleData, Nullable, Workbook, Worksheet, FBase, ICommandService, Injector, WrapStrategy } from '@univerjs/core';
+import { FHorizontalAlignment, FVerticalAlignment } from './utils';
+import { FormulaDataModel } from '@univerjs/engine-formula';
+export type FontLine = 'none' | 'underline' | 'line-through';
+export type FontStyle = 'normal' | 'italic';
+export type FontWeight = 'normal' | 'bold';
+export declare class FRange extends FBase {
+    protected readonly _workbook: Workbook;
+    protected readonly _worksheet: Worksheet;
+    protected readonly _range: IRange;
+    protected readonly _injector: Injector;
+    protected readonly _commandService: ICommandService;
+    protected readonly _formulaDataModel: FormulaDataModel;
+    constructor(_workbook: Workbook, _worksheet: Worksheet, _range: IRange, _injector: Injector, _commandService: ICommandService, _formulaDataModel: FormulaDataModel);
+    /**
+     * Get the unit ID of the current workbook
+     *
+     * @return The unit ID of the workbook
+     */
+    getUnitId(): string;
+    /**
+     * Gets the name of the worksheet
+     *
+     * @return The name of the worksheet
+     */
+    getSheetName(): string;
+    /**
+     * Gets the area where the statement is applied
+     *
+     * @return The area where the statement is applied
+     */
+    getRange(): IRange;
+    /**
+     * Gets the starting row number of the applied area
+     *
+     * @return The starting row number of the area
+     */
+    getRow(): number;
+    /**
+     * Gets the starting column number of the applied area
+     *
+     * @return The starting column number of the area
+     */
+    getColumn(): number;
+    /**
+     * Gets the width of the applied area
+     *
+     * @return The width of the area
+     */
+    getWidth(): number;
+    /**
+     * Gets the height of the applied area
+     *
+     * @return The height of the area
+     */
+    getHeight(): number;
+    /**
+     * Return first cell model data in this range
+     * @returns The cell model data
+     */
+    getCellData(): ICellData | null;
+    /**
+     * Return range whether this range is merged
+     * @returns if true is merged
+     */
+    isMerged(): boolean;
+    /**
+     * Return first cell style data in this range
+     * @returns The cell style data
+     */
+    getCellStyleData(): IStyleData | null;
+    /**
+     * Returns the value of the cell at the start of this range.
+     * @returns The value of the cell.
+     */
+    getValue(): CellValue | null;
+    /**
+     * Returns the rectangular grid of values for this range.
+     * Returns a two-dimensional array of values, indexed by row, then by column.
+     * @returns A two-dimensional array of values.
+     */
+    getValues(): Nullable<CellValue>[][];
+    /**
+     * Returns the cell data for the cells in the range.
+     * @returns A two-dimensional array of cell data.
+     */
+    getCellDataGrid(): Nullable<ICellData>[][];
+    /**
+     * Returns the formulas (A1 notation) for the cells in the range. Entries in the 2D array are empty strings for cells with no formula.
+     * @returns A two-dimensional array of formulas in string format.
+     */
+    getFormulas(): string[][];
+    getWrap(): boolean;
+    getWrapStrategy(): WrapStrategy;
+    getHorizontalAlignment(): string;
+    getVerticalAlignment(): string;
+    setBackgroundColor(color: string): Promise<boolean>;
+    /**
+     * The value can be a number, string, boolean, or standard cell format. If it begins with `=`, it is interpreted as a formula. The value is tiled to all cells in the range.
+     * @param value
+     */
+    setValue(value: CellValue | ICellData): Promise<boolean>;
+    /**
+     * Set the cell wrap of the given range.
+     * Cells with wrap enabled (the default) resize to display their full content. Cells with wrap disabled display as much as possible in the cell without resizing or running to multiple lines.
+     */
+    setWrap(isWrapEnabled: boolean): Promise<boolean>;
+    /**
+     * Sets the text wrapping strategy for the cells in the range.
+     */
+    setWrapStrategy(strategy: WrapStrategy): Promise<boolean>;
+    /**
+     * Set the vertical (top to bottom) alignment for the given range (top/middle/bottom).
+     */
+    setVerticalAlignment(alignment: FVerticalAlignment): Promise<boolean>;
+    /**
+     * Set the horizontal (left to right) alignment for the given range (left/center/right).
+     */
+    setHorizontalAlignment(alignment: FHorizontalAlignment): Promise<boolean>;
+    /**
+     * Sets a different value for each cell in the range. The value can be a two-dimensional array or a standard range matrix (must match the dimensions of this range), consisting of numbers, strings, Boolean values or Composed of standard cell formats. If a value begins with `=`, it is interpreted as a formula.
+     * @param value
+     */
+    setValues(value: CellValue[][] | IObjectMatrixPrimitiveType<CellValue> | ICellData[][] | IObjectMatrixPrimitiveType<ICellData>): Promise<boolean>;
+    /**
+     * Sets the font weight for the given range (normal/bold),
+     * @param fontWeight The font weight, either 'normal' or 'bold'; a null value resets the font weight.
+     */
+    setFontWeight(fontWeight: FontWeight | null): this;
+    /**
+     * Sets the font style for the given range ('italic' or 'normal').
+     * @param fontStyle The font style, either 'italic' or 'normal'; a null value resets the font style.
+     */
+    setFontStyle(fontStyle: FontStyle | null): this;
+    /**
+     * Sets the font line style of the given range ('underline', 'line-through', or 'none').
+     * @param fontLine The font line style, either 'underline', 'line-through', or 'none'; a null value resets the font line style.
+     */
+    setFontLine(fontLine: FontLine | null): this;
+    /**
+     * Sets the font underline style of the given ITextDecoration
+     */
+    private _setFontUnderline;
+    /**
+     * Sets the font strikethrough style of the given ITextDecoration
+     */
+    private _setFontStrikethrough;
+    /**
+     * Sets the font family, such as "Arial" or "Helvetica".
+     * @param fontFamily The font family to set; a null value resets the font family.
+     */
+    setFontFamily(fontFamily: string | null): this;
+    /**
+     * Sets the font size, with the size being the point size to use.
+     * @param size A font size in point size. A null value resets the font size.
+     */
+    setFontSize(size: number | null): this;
+    /**
+     * Sets the font color in CSS notation (such as '#ffffff' or 'white').
+     * @param color The font color in CSS notation (such as '#ffffff' or 'white'); a null value resets the color.
+     */
+    setFontColor(color: string | null): this;
+    /**
+     * Merge cells in a range into one merged cell
+     * @returns This range, for chaining
+     */
+    merge(): Promise<FRange>;
+    /**
+     * Merges cells in a range horizontally.
+     * @returns This range, for chaining
+     */
+    mergeAcross(): Promise<FRange>;
+    /**
+     * Merges cells in a range vertically.
+     * @returns This range, for chaining
+     */
+    mergeVertically(): Promise<FRange>;
+    /**
+     * Returns true if cells in the current range overlap a merged cell.
+     * @returns {boolean} is overlap with a merged cell
+     */
+    isPartOfMerge(): boolean;
+    /**
+     * Unmerge cells in the range
+     * @returns This range, for chaining
+     */
+    breakApart(): FRange;
+    /**
+     * Iterate cells in this range. Merged cells will be respected.
+     * @param callback
+     */
+    forEach(callback: (row: number, col: number, cell: ICellData) => void): void;
+}

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

@@ -0,0 +1,11 @@
+import { Workbook, Worksheet, Injector } from '@univerjs/core';
+import { ISelectionWithStyle } from '@univerjs/sheets';
+import { FRange } from './f-range';
+export declare class FSelection {
+    private readonly _workbook;
+    private readonly _worksheet;
+    private readonly _selections;
+    private readonly _injector;
+    constructor(_workbook: Workbook, _worksheet: Worksheet, _selections: Readonly<ISelectionWithStyle[]>, _injector: Injector);
+    getActiveRange(): FRange | null;
+}

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

@@ -0,0 +1,36 @@
+import { IWorkbookData } from '@univerjs/core';
+import { FPermission } from './f-permission';
+import { FWorkbook } from './f-workbook';
+interface IFUniverSheetsMixin {
+    /**
+     * Create a new spreadsheet and get the API handler of that spreadsheet.
+     *
+     * @param {Partial<IWorkbookData>} data The snapshot of the spreadsheet.
+     * @returns {FWorkbook} FWorkbook API instance.
+     */
+    createUniverSheet(data: Partial<IWorkbookData>): FWorkbook;
+    /**
+     * Get the currently focused Univer spreadsheet.
+     *
+     * @returns {FWorkbook | null} The currently focused Univer spreadsheet.
+     */
+    getActiveWorkbook(): FWorkbook | null;
+    /**
+     * Get the spreadsheet API handler by the spreadsheet id.
+     *
+     * @param {string} id The spreadsheet id.
+     * @returns {FWorkbook | null} The spreadsheet API instance.
+     */
+    getUniverSheet(id: string): FWorkbook | null;
+    /**
+     * Get the PermissionInstance.
+     *
+     * @returns {FPermission} - The PermissionInstance.
+     */
+    getPermission(): FPermission;
+}
+declare module '@univerjs/core' {
+    interface FUniver extends IFUniverSheetsMixin {
+    }
+}
+export {};

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

@@ -0,0 +1,105 @@
+import { CommandListener, IDisposable, IRange, IWorkbookData, Workbook, FBase, ICommandService, ILogService, Injector, IPermissionService, IResourceLoaderService, IUniverInstanceService } from '@univerjs/core';
+import { SheetsSelectionsService } from '@univerjs/sheets';
+import { FRange } from './f-range';
+import { FWorksheet } from './f-worksheet';
+export declare class FWorkbook extends FBase {
+    protected readonly _workbook: Workbook;
+    protected readonly _injector: Injector;
+    protected readonly _resourceLoaderService: IResourceLoaderService;
+    protected readonly _selectionManagerService: SheetsSelectionsService;
+    protected readonly _univerInstanceService: IUniverInstanceService;
+    protected readonly _commandService: ICommandService;
+    protected readonly _permissionService: IPermissionService;
+    protected readonly _logService: ILogService;
+    readonly id: string;
+    constructor(_workbook: Workbook, _injector: Injector, _resourceLoaderService: IResourceLoaderService, _selectionManagerService: SheetsSelectionsService, _univerInstanceService: IUniverInstanceService, _commandService: ICommandService, _permissionService: IPermissionService, _logService: ILogService);
+    getId(): string;
+    getName(): string;
+    /**
+     * save workbook snapshot data, including conditional formatting, data validation, and other plugin data.
+     */
+    save(): IWorkbookData;
+    /**
+     * @deprecated use 'save' instead.
+     * @return {*}  {IWorkbookData}
+     * @memberof FWorkbook
+     */
+    getSnapshot(): IWorkbookData;
+    /**
+     * Get the active sheet of the workbook.
+     * @returns The active sheet of the workbook
+     */
+    getActiveSheet(): FWorksheet;
+    /**
+     * Gets all the worksheets in this workbook
+     * @returns An array of all the worksheets in the workbook
+     */
+    getSheets(): FWorksheet[];
+    /**
+     * Create a new worksheet and returns a handle to it.
+     * @param name Name of the new sheet
+     * @param rows How may rows would the new sheet have
+     * @param column How many columns would the new sheet have
+     * @returns The new created sheet
+     */
+    create(name: string, rows: number, column: number): FWorksheet;
+    /**
+     * Get a worksheet by sheet id.
+     * @param sheetId The id of the sheet to get.
+     * @return The worksheet with given sheet id
+     */
+    getSheetBySheetId(sheetId: string): FWorksheet | null;
+    /**
+     * Get a worksheet by sheet name.
+     * @param name The name of the sheet to get.
+     * @returns The worksheet with given sheet name
+     */
+    getSheetByName(name: string): FWorksheet | null;
+    /**
+     * Sets the given worksheet to be the active worksheet in the workbook.
+     * @param sheet The worksheet to set as the active worksheet.
+     * @returns The active worksheet
+     */
+    setActiveSheet(sheet: FWorksheet): FWorksheet;
+    /**
+     * Inserts a new worksheet into the workbook.
+     * Using a default sheet name. The new sheet becomes the active sheet
+     * @returns The new sheet
+     */
+    insertSheet(): FWorksheet;
+    /**
+     * Deletes the specified worksheet.
+     * @param sheet The worksheet to delete.
+     */
+    deleteSheet(sheet: FWorksheet): void;
+    undo(): Promise<boolean>;
+    redo(): Promise<boolean>;
+    /**
+     * Register a callback that will be triggered before invoking a command targeting the Univer sheet.
+     * @param callback the callback.
+     * @returns A function to dispose the listening.
+     */
+    onBeforeCommandExecute(callback: CommandListener): IDisposable;
+    /**
+     * Register a callback that will be triggered when a command is invoked targeting the Univer sheet.
+     * @param callback the callback.
+     * @returns A function to dispose the listening.
+     */
+    onCommandExecuted(callback: CommandListener): IDisposable;
+    onSelectionChange(callback: (selections: IRange[]) => void): IDisposable;
+    /**
+     * Used to modify the editing permissions of the workbook. When the value is false, editing is not allowed.
+     * @param {boolean} value  editable value want to set
+     */
+    setEditable(value: boolean): void;
+    /**
+     * Sets the active selection region for this sheet.
+     * @param range The range to set as the active selection.
+     */
+    setActiveRange(range: FRange): void;
+    /**
+     * Returns the selected range in the active sheet, or null if there is no active range.
+     * @returns the active range
+     */
+    getActiveRange(): FRange | null;
+}