@univerjs/sheets-ui 0.5.3 → 0.5.4

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

@@ -0,0 +1,389 @@
+import { DeviceInputEventType } from '@univerjs/engine-render';
+import { FRange, FWorkbook, FWorksheet } from '@univerjs/sheets/facade';
+import { KeyCode } from '@univerjs/ui';
+import { FEventName, IEventBase, RichTextValue } from '@univerjs/core';
+/**
+ * Event interface triggered when cell editing starts
+ * @interface ISheetEditStartedEventParams
+ * @augments {IEventBase}
+ */
+export interface ISheetEditStartedEventParams extends IEventBase {
+    /** The workbook instance */
+    workbook: FWorkbook;
+    /** The worksheet being edited */
+    worksheet: FWorksheet;
+    /** Row index of the editing cell */
+    row: number;
+    /** Column index of the editing cell */
+    column: number;
+    /** Type of input device event that triggered the edit */
+    eventType: DeviceInputEventType;
+    /** Optional keycode that triggered the edit */
+    keycode?: KeyCode;
+    /** Whether the edit is happening in zen editor mode */
+    isZenEditor: boolean;
+}
+/**
+ * Event interface triggered when cell editing ends
+ * @interface ISheetEditEndedEventParams
+ * @augments {IEventBase}
+ */
+export interface ISheetEditEndedEventParams extends IEventBase {
+    /** The workbook instance */
+    workbook: FWorkbook;
+    /** The worksheet being edited */
+    worksheet: FWorksheet;
+    /** Row index of the edited cell */
+    row: number;
+    /** Column index of the edited cell */
+    column: number;
+    /** Type of input device event that triggered the edit end */
+    eventType: DeviceInputEventType;
+    /** Optional keycode that triggered the edit end */
+    keycode?: KeyCode;
+    /** Whether the edit happened in zen editor mode */
+    isZenEditor: boolean;
+    /** Whether the edit was confirmed or cancelled */
+    isConfirm: boolean;
+}
+/**
+ * Event interface triggered while cell content is being changed
+ * @interface ISheetEditChangingEventParams
+ * @augments {IEventBase}
+ */
+export interface ISheetEditChangingEventParams extends IEventBase {
+    /** The workbook instance */
+    workbook: FWorkbook;
+    /** The worksheet being edited */
+    worksheet: FWorksheet;
+    /** Row index of the editing cell */
+    row: number;
+    /** Column index of the editing cell */
+    column: number;
+    /** Current value being edited */
+    value: RichTextValue;
+    /** Whether the edit is happening in zen editor mode */
+    isZenEditor: boolean;
+}
+/**
+ * Event interface triggered before cell editing starts
+ * @interface IBeforeSheetEditStartEventParams
+ * @augments {IEventBase}
+ */
+export interface IBeforeSheetEditStartEventParams extends IEventBase {
+    /** The workbook instance */
+    workbook: FWorkbook;
+    /** The worksheet to be edited */
+    worksheet: FWorksheet;
+    /** Row index of the cell to be edited */
+    row: number;
+    /** Column index of the cell to be edited */
+    column: number;
+    /** Type of input device event triggering the edit */
+    eventType: DeviceInputEventType;
+    /** Optional keycode triggering the edit */
+    keycode?: KeyCode;
+    /** Whether the edit will happen in zen editor mode */
+    isZenEditor: boolean;
+}
+/**
+ * Event interface triggered before cell editing ends
+ * @interface IBeforeSheetEditEndEventParams
+ * @augments {IEventBase}
+ */
+export interface IBeforeSheetEditEndEventParams extends IEventBase {
+    /** The workbook instance */
+    workbook: FWorkbook;
+    /** The worksheet being edited */
+    worksheet: FWorksheet;
+    /** Row index of the editing cell */
+    row: number;
+    /** Column index of the editing cell */
+    column: number;
+    /** Current value being edited */
+    value: RichTextValue;
+    /** Type of input device event triggering the edit end */
+    eventType: DeviceInputEventType;
+    /** Optional keycode triggering the edit end */
+    keycode?: KeyCode;
+    /** Whether the edit is happening in zen editor mode */
+    isZenEditor: boolean;
+    /** Whether the edit will be confirmed or cancelled */
+    isConfirm: boolean;
+}
+export declare const CellFEventName: {
+    readonly CellClicked: "CellClicked";
+    readonly CellPointerDown: "CellPointerDown";
+    readonly CellPointerUp: "CellPointerUp";
+    readonly CellPointerMove: "CellPointerMove";
+    readonly CellHover: "CellHover";
+    readonly DragOver: "DragOver";
+    readonly Drop: "Drop";
+};
+export interface IFSheetsUIEventNameMixin {
+    /**
+     * Trigger this event before the clipboard content changes.
+     * Type of the event parameter is {@link IBeforeClipboardChangeParam}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.BeforeClipboardChange, (param) => {
+     *   const {text, html} = param;
+     *   console.log('debugger', text, html); // {text: '...', html: '...'}
+     *   // if want to cancel the clipboard change
+     *   param.cancel = true;
+     * })
+     * ```
+     */
+    readonly BeforeClipboardChange: 'BeforeClipboardChange';
+    /**
+     * Trigger this event after the clipboard content changes.
+     * Type of the event parameter is {@link IClipboardChangedParam}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.ClipboardChanged, (param) => {
+     *  const {text, html} = param;
+     *  console.log('debugger', text, html); // {text: '...', html: '...'}
+     * })
+     * ```
+     */
+    readonly ClipboardChanged: 'ClipboardChanged';
+    /**
+     * Trigger this event before pasting.
+     * Type of the event parameter is {@link IBeforeClipboardPasteParam}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.BeforeClipboardPaste, (param) => {
+     *  const {text, html} = param;
+     *  console.log('debugger', text, html);
+     *  // if want to cancel the clipboard paste
+     *  param.cancel = true;
+     * })
+     * ```
+     */
+    readonly BeforeClipboardPaste: 'BeforeClipboardPaste';
+    /**
+     * Trigger this event after pasting.
+     * Type of the event parameter is {@link IClipboardPastedParam}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.ClipboardPasted, (param) => {
+     *  const {text, html} = param;
+     *  console.log('debugger', text, html); // {text: '...', html: '...'}
+     * })
+     * ```
+     */
+    readonly ClipboardPasted: 'ClipboardPasted';
+    /**
+     * Event fired before a cell is edited
+     * @see {@link IBeforeSheetEditStartEventParams}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.BeforeSheetEditStart, (params) => {
+     *      const { worksheet, workbook, row, column, eventType, keycode, isZenEditor } = params;
+     * });
+     * ```
+     */
+    readonly BeforeSheetEditStart: 'BeforeSheetEditStart';
+    /**
+     * Event fired after a cell is edited
+     * @see {@link ISheetEditEndedEventParams}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.SheetEditStarted, (params) => {
+     *      const { worksheet, workbook, row, column, eventType, keycode, isZenEditor } = params;
+     * });
+     * ```
+     */
+    readonly SheetEditStarted: 'SheetEditStarted';
+    /**
+     * Event fired when a cell is being edited
+     * @see {@link ISheetEditChangingEventParams}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.SheetEditChanging, (params) => {
+     *      const { worksheet, workbook, row, column, value, isZenEditor } = params;
+     * });
+     * ```
+     */
+    readonly SheetEditChanging: 'SheetEditChanging';
+    /**
+     * Event fired before a cell edit ends
+     * @see {@link IBeforeSheetEditEndEventParams}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.BeforeSheetEditEnd, (params) => {
+     *      const { worksheet, workbook, row, column, value, eventType, keycode, isZenEditor } = params;
+     * });
+     * ```
+     */
+    readonly BeforeSheetEditEnd: 'BeforeSheetEditEnd';
+    /**
+     * Event fired after a cell edit ends
+     * @see {@link ISheetEditEndedEventParams}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.SheetEditEnded, (params) => {
+     *      const { worksheet, workbook, row, column, eventType, keycode, isZenEditor } = params;
+     * });
+     * ```
+     */
+    readonly SheetEditEnded: 'SheetEditEnded';
+    /**
+     * Event fired when a cell is clicked
+     * @example
+     * ```ts
+     * univerAPI.getActiveWorkbook().addEvent('CellClicked', (p)=> console.log(p));
+     * ```
+     */
+    readonly CellClicked: 'CellClicked';
+    /**
+     * Event fired when a cell is pointer down
+     * @example
+     * ```ts
+     * univerAPI.getActiveWorkbook().addEvent('CellPointerDown', (p)=> console.log(p));
+     * ```
+     */
+    readonly CellPointerDown: 'CellPointerDown';
+    /**
+     * Event fired when a cell is pointer up
+     * @example
+     * ```ts
+     * univerAPI.getActiveWorkbook().addEvent('CellPointerUp', (p)=> console.log(p));
+     * ```
+     */
+    readonly CellPointerUp: 'CellPointerUp';
+    /**
+     * Event fired when a cell is hovered
+     * @example
+     * ```ts
+     * univerAPI.getActiveWorkbook().addEvent('CellHover', (p)=> console.log(p));
+     * ```
+     */
+    readonly CellHover: 'CellHover';
+    /**
+     * Event fired when move on spreadsheet cells
+     * @example
+     * ```ts
+     * univerAPI.getActiveWorkbook().addEvent('CellPointerMove', (p)=> console.log(p));
+     * ```
+     */
+    readonly CellPointerMove: 'CellPointerMove';
+    /**
+     * Event fired when drag over spreadsheet cells
+     * @example
+     * ```ts
+     * univerAPI.getActiveWorkbook().addEvent('DragOver', (p)=> console.log(p));
+     * ```
+     */
+    readonly DragOver: 'DragOver';
+    /**
+     * Event fired when drop on spreadsheet cells
+     * @example
+     * ```ts
+     * univerAPI.getActiveWorkbook().addEvent('Drop', (p)=> console.log(p));
+     * ```
+     */
+    readonly Drop: 'Drop';
+}
+export declare class FSheetsUIEventName extends FEventName implements IFSheetsUIEventNameMixin {
+    get BeforeClipboardChange(): 'BeforeClipboardChange';
+    get ClipboardChanged(): 'ClipboardChanged';
+    get BeforeClipboardPaste(): 'BeforeClipboardPaste';
+    get ClipboardPasted(): 'ClipboardPasted';
+    get BeforeSheetEditStart(): 'BeforeSheetEditStart';
+    get SheetEditStarted(): 'SheetEditStarted';
+    get SheetEditChanging(): 'SheetEditChanging';
+    get BeforeSheetEditEnd(): 'BeforeSheetEditEnd';
+    get SheetEditEnded(): 'SheetEditEnded';
+    get CellClicked(): 'CellClicked';
+    get CellHover(): 'CellHover';
+    get CellPointerDown(): 'CellPointerDown';
+    get CellPointerUp(): 'CellPointerUp';
+    get CellPointerMove(): 'CellPointerMove';
+    get DragOver(): 'DragOver';
+    get Drop(): 'Drop';
+}
+export interface IUIEventBase extends IEventBase {
+    /**
+     * The workbook instance currently being operated on. {@link FWorkbook}
+     */
+    workbook: FWorkbook;
+    /**
+     * The worksheet instance currently being operated on. {@link FWorksheet}
+     */
+    worksheet: FWorksheet;
+}
+export interface IBeforeClipboardChangeParam extends IEventBase {
+    /**
+     * The workbook instance currently being operated on. {@link FWorkbook}
+     */
+    workbook: FWorkbook;
+    /**
+     * The worksheet instance currently being operated on. {@link FWorksheet}
+     */
+    worksheet: FWorksheet;
+    /**
+     * Clipboard Text String
+     */
+    text: string;
+    /**
+     * Clipboard HTML String
+     */
+    html: string;
+    /**
+     * The sheet containing the content that was (copied/cut)
+     */
+    fromSheet: FWorksheet;
+    /**
+     * The range containing the content that was (copied/cut)
+     */
+    fromRange: FRange;
+}
+export type IClipboardChangedParam = IBeforeClipboardChangeParam;
+export interface IBeforeClipboardPasteParam extends IEventBase {
+    /**
+     * The workbook instance currently being operated on. {@link FWorkbook}
+     */
+    workbook: FWorkbook;
+    /**
+     * The worksheet instance currently being operated on. {@link FWorkbook}
+     */
+    worksheet: FWorksheet;
+    /**
+     * Clipboard Text String
+     */
+    text?: string;
+    /**
+     * Clipboard HTML String
+     */
+    html?: string;
+}
+export type IClipboardPastedParam = IBeforeClipboardPasteParam;
+export interface ICellEventParam extends IUIEventBase {
+    row: number;
+    column: number;
+}
+export interface IFSheetsUIEventParamConfig {
+    BeforeClipboardChange: IBeforeClipboardChangeParam;
+    ClipboardChanged: IClipboardChangedParam;
+    BeforeClipboardPaste: IBeforeClipboardPasteParam;
+    ClipboardPasted: IClipboardPastedParam;
+    BeforeSheetEditStart: IBeforeSheetEditStartEventParams;
+    SheetEditStarted: ISheetEditStartedEventParams;
+    SheetEditChanging: ISheetEditChangingEventParams;
+    BeforeSheetEditEnd: IBeforeSheetEditEndEventParams;
+    SheetEditEnded: ISheetEditEndedEventParams;
+    CellClicked: ICellEventParam;
+    CellHover: ICellEventParam;
+    CellPointerDown: ICellEventParam;
+    CellPointerUp: ICellEventParam;
+    CellPointerMove: ICellEventParam;
+    Drop: ICellEventParam;
+    DragOver: ICellEventParam;
+}
+declare module '@univerjs/core' {
+    interface FEventName extends IFSheetsUIEventNameMixin {
+    }
+    interface IEventParamConfig extends IFSheetsUIEventParamConfig {
+    }
+}

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

@@ -2,8 +2,11 @@ import { FPermission } from '@univerjs/sheets/facade';
 export interface IFPermissionSheetsUIMixin {
     /**
      * Set visibility of unauthorized pop-up window
-     *
      * @param {boolean} visible
+     * @example
+     * ```ts
+     * univerAPI.getPermission().setPermissionDialogVisible(false);
+     * ```
      */
     setPermissionDialogVisible(visible: boolean): void;
 }

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

@@ -1,8 +1,8 @@
 import { ICellWithCoord, IDisposable, ISelectionCell, Nullable, DisposableCollection } from '@univerjs/core';
 import { ISelectionStyle } from '@univerjs/sheets';
 import { ComponentType, ComponentManager } from '@univerjs/ui';
-import { FRange } from '@univerjs/sheets/facade';
 import { ICanvasPopup, ICellAlert } from '@univerjs/sheets-ui';
+import { FRange } from '@univerjs/sheets/facade';
 export interface IFComponentKey {
     /**
      * The key of the component to be rendered in the popup.
@@ -20,16 +20,31 @@ export interface IFCanvasPopup extends Omit<ICanvasPopup, 'componentKey'>, IFCom
 interface IFRangeSheetsUIMixin {
     /**
      * Return this cell information, including whether it is merged and cell coordinates
-     * @returns The cell information
+     * @returns {ICellWithCoord} cell location and coordinate.
+     * @example
+     * ``` ts
+     * let sheet = univerAPI.getActiveWorkbook().getActiveSheet();
+     * sheet.getRange(5, 7).getCell();
+     * ```
      */
-    getCell(): ICellWithCoord;
+    getCell(this: FRange): ICellWithCoord;
     /**
      * Returns the coordinates of this cell,does not include units
      * @returns coordinates of the cell， top, right, bottom, left
+     * @example
+     * ``` ts
+     * let sheet = univerAPI.getActiveWorkbook().getActiveSheet();
+     * sheet.getRange(5, 7).getCellRect();
+     * ```
      */
-    getCellRect(): DOMRect;
+    getCellRect(this: FRange): DOMRect;
     /**
      * Generate HTML content for the range.
+     * @example
+     * ``` ts
+     * let sheet = univerAPI.getActiveWorkbook().getActiveSheet();
+     * sheet.getRange(5, 7).generateHTML();
+     * ```
      */
     generateHTML(this: FRange): string;
     /**
@@ -38,16 +53,39 @@ interface IFRangeSheetsUIMixin {
      * Be careful to manager the detach disposable object, if not dispose correctly, it might memory leaks.
      * @param popup The popup to attach
      * @returns The disposable object to detach the popup, if the popup is not attached, return `null`.
+     * @example
+    ```
+        let sheet = univerAPI.getActiveWorkbook().getActiveSheet();
+        let range = sheet.getRange(2, 2, 3, 3);
+        let disposable = range.attachPopup({
+        componentKey: 'univer.sheet.cell-alert',
+        extraProps: { alert: { type: 0, title: 'This is an Info', message: 'This is an info message' } },
+        });
+    ```
      */
     attachPopup(popup: IFCanvasPopup): Nullable<IDisposable>;
     /**
      * Attach an alert popup to the start cell of current range.
      * @param alert The alert to attach
      * @returns The disposable object to detach the alert.
+     * @example
+     * ```ts
+     * let sheet = univerAPI.getActiveWorkbook().getActiveSheet();
+     * let range = sheet.getRange(2, 2, 3, 3);
+     * range.attachAlertPopup({ message: 'This is an alert', type: 'warning' });
+     * ```
      */
     attachAlertPopup(alert: Omit<ICellAlert, 'location'>): IDisposable;
     /**
-     * Highlight this range.
+     *  Highlight the range with the specified style and primary cell.
+     * @param style - style for highlight range.
+     * @param primary - primary cell for highlight range.
+     * @example
+     * ```ts
+     * let sheet = univerAPI.getActiveWorkbook().getActiveSheet();
+     * let range = sheet.getRange(2, 2, 3, 3);
+     * range.highlight({ stroke: 'red' }, { startRow: 2, startColumn: 2 });
+     * ```
      */
     highlight(style?: Nullable<Partial<ISelectionStyle>>, primary?: Nullable<ISelectionCell>): IDisposable;
 }
@@ -55,6 +93,11 @@ declare module '@univerjs/sheets/facade' {
     interface FRange extends IFRangeSheetsUIMixin {
     }
 }
+/**
+ * Transform component key
+ * @param {IFComponentKey} component - The component key to transform.
+ * @param {ComponentManager} componentManager - The component manager to use for registration.
+ */
 export declare function transformComponentKey(component: IFComponentKey, componentManager: ComponentManager): {
     key: string;
     disposableCollection: DisposableCollection;

package/lib/types/facade/f-sheet-hooks.d.ts

@@ -4,46 +4,84 @@ import { FSheetHooks } from '@univerjs/sheets/facade';
 export interface IFSheetHooksUIMixin {
     /**
      * The onCellPointerMove event is fired when a pointer changes coordinates.
-     * @param callback Callback function that will be called when the event is fired
-     * @returns A disposable object that can be used to unsubscribe from the event
+     * @param {function(Nullable<IHoverCellPosition>): void} callback - function that will be called when the event is fired
+     * @returns {IDisposable} A disposable object that can be used to unsubscribe from the event
+     * @example
+     * ```ts
+     * univerAPI.getSheetHooks().onCellPointerMove((cellPos) => { console.log(cellPos)});
+     * ```
      */
     onCellPointerMove(callback: (cellPos: Nullable<IHoverCellPosition>) => void): IDisposable;
     /**
      * The onCellPointerOver event is fired when a pointer is moved into a cell's hit test boundaries.
-     * @param callback Callback function that will be called when the event is fired
-     * @returns A disposable object that can be used to unsubscribe from the event
+     * @param {function(Nullable<IHoverCellPosition>): void} callback - function that will be called when the event is fired
+     * @returns {IDisposable} A disposable object that can be used to unsubscribe from the event
+     * @example
+     * ```ts
+     * univerAPI.getSheetHooks().onCellPointerOver((cellPos) => { console.log(cellPos)});
+     * ```
      */
     onCellPointerOver(callback: (cellPos: Nullable<IHoverCellPosition>) => void): IDisposable;
     /**
      * The onCellDragOver event is fired when an element or text selection is being dragged into a cell's hit test boundaries.
-     * @param callback Callback function that will be called when the event is fired
-     * @returns A disposable object that can be used to unsubscribe from the event
+     * @param {function (Nullable<IDragCellPosition>): void} callback Callback function that will be called when the event is fired
+     * @returns {IDisposable} A disposable object that can be used to unsubscribe from the event
+     * @example
+     * ```ts
+     * univerAPI.getSheetHooks().onCellDragOver((cellPos) => { console.log(cellPos)});
+     * ```
      */
     onCellDragOver(callback: (cellPos: Nullable<IDragCellPosition>) => void): IDisposable;
     /**
      * The onCellDrop event is fired when an element or text selection is being dropped on the cell.
-     * @param callback Callback function that will be called when the event is fired
-     * @returns A disposable object that can be used to unsubscribe from the event
+     * @param {function(Nullable<IDragCellPosition>): void} callback Callback function that will be called when the event is fired
+     * @returns {IDisposable} A disposable object that can be used to unsubscribe from the event
+     * @example
+     * ```ts
+     * univerAPI.getSheetHooks().onCellDrop((cellPos) => { console.log(cellPos)});
+     * ```
      */
     onCellDrop(callback: (cellPos: Nullable<IDragCellPosition>) => void): IDisposable;
     /**
      * The onCellRender event is fired when a cell is rendered.
-     * @param customRender Custom render function
-     * @param effect The effect of the interceptor
-     * @param priority The priority of the interceptor
-     * @returns A disposable object that can be used to unsubscribe from the event
+     * @param {Nullable<ICellCustomRender[]>} customRender Custom render function
+     * @param {InterceptorEffectEnum} [effect] The effect of the interceptor
+     * @param {number} priority The priority of the interceptor
+     * @returns {IDisposable} A disposable object that can be used to unsubscribe from the event
+     * @example
+     * ```ts
+        univerAPI.getSheetHooks().onCellRender([{
+            drawWith: (ctx, info) => {
+                const { row, col } = info;
+                // Update to any cell location you want
+                if (row === 1 && col === 2) {
+                    const { primaryWithCoord } = info;
+                    const { startX, startY } = primaryWithCoord;
+                    ctx.fillText('Univer', startX, startY + 10);
+                }
+            },
+        }])
+     * ```
      */
     onCellRender(customRender: Nullable<ICellCustomRender[]>, effect?: InterceptorEffectEnum, priority?: number): IDisposable;
     /**
      * The onBeforeCellEdit event is fired before a cell is edited.
      * @param callback Callback function that will be called when the event is fired
      * @returns A disposable object that can be used to unsubscribe from the event
+     * @example
+     * ```ts
+     * univerAPI.getSheetHooks().onBeforeCellEdit((params) => {console.log(params)})
+     * ```
      */
     onBeforeCellEdit(callback: (params: IEditorBridgeServiceVisibleParam) => void): IDisposable;
     /**
      * The onAfterCellEdit event is fired after a cell is edited.
      * @param callback Callback function that will be called when the event is fired
      * @returns A disposable object that can be used to unsubscribe from the event
+     * @example
+     * ```ts
+     * univerAPI.getSheetHooks().onAfterCellEdit((params) => {console.log(params)})
+     * ```
      */
     onAfterCellEdit(callback: (params: IEditorBridgeServiceVisibleParam) => void): IDisposable;
 }

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

@@ -1,32 +1,27 @@
-import { IDisposable, FUniver } from '@univerjs/core';
+import { IDisposable, Injector, FUniver } from '@univerjs/core';
 import { IColumnsHeaderCfgParam, IRowsHeaderCfgParam, SheetExtension } from '@univerjs/engine-render';
 import { FSheetHooks } from '@univerjs/sheets/facade';
 export interface IFUniverSheetsUIMixin {
     /**
      * Customize the column header of the spreadsheet.
-     *
      * @param {IColumnsHeaderCfgParam} cfg The configuration of the column header.
-     *
      * @example
      * ```typescript
-     * customizeColumnHeader({ headerStyle: { backgroundColor: 'pink', fontSize: 9 }, columnsCfg: ['MokaII', undefined, null, { text: 'Size', textAlign: 'left' }] });
+     * univerAPI.customizeColumnHeader({ headerStyle: { backgroundColor: 'pink', fontSize: 9 }, columnsCfg: ['MokaII', undefined, null, { text: 'Size', textAlign: 'left' }] });
      * ```
      */
     customizeColumnHeader(cfg: IColumnsHeaderCfgParam): void;
     /**
      * Customize the row header of the spreadsheet.
-     *
      * @param {IRowsHeaderCfgParam} cfg The configuration of the row header.
-     *
      * @example
      * ```typescript
-     * customizeRowHeader({ headerStyle: { backgroundColor: 'pink', fontSize: 9 }, rowsCfg: ['MokaII', undefined, null, { text: 'Size', textAlign: 'left' }] });
+     * univerAPI.customizeRowHeader({ headerStyle: { backgroundColor: 'pink', fontSize: 9 }, rowsCfg: ['MokaII', undefined, null, { text: 'Size', textAlign: 'left' }] });
      * ```
      */
     customizeRowHeader(cfg: IRowsHeaderCfgParam): void;
     /**
      * Register sheet row header render extensions.
-     *
      * @param {string} unitId The unit id of the spreadsheet.
      * @param {SheetExtension[]} extensions The extensions to register.
      * @returns {IDisposable} The disposable instance.
@@ -34,7 +29,6 @@ export interface IFUniverSheetsUIMixin {
     registerSheetRowHeaderExtension(unitId: string, ...extensions: SheetExtension[]): IDisposable;
     /**
      * Register sheet column header render extensions.
-     *
      * @param {string} unitId The unit id of the spreadsheet.
      * @param {SheetExtension[]} extensions The extensions to register.
      * @returns {IDisposable} The disposable instance.
@@ -42,20 +36,28 @@ export interface IFUniverSheetsUIMixin {
     registerSheetColumnHeaderExtension(unitId: string, ...extensions: SheetExtension[]): IDisposable;
     /**
      * Register sheet main render extensions.
-     *
      * @param {string} unitId The unit id of the spreadsheet.
      * @param {SheetExtension[]} extensions The extensions to register.
      * @returns {IDisposable} The disposable instance.
      */
     registerSheetMainExtension(unitId: string, ...extensions: SheetExtension[]): IDisposable;
     /**
-     * Get sheet hooks.
-     *
-     * @returns {FSheetHooks} FSheetHooks instance
+     * @deprecated use `univerAPI.addEvent` as instead.
      */
     getSheetHooks(): FSheetHooks;
 }
 export declare class FUniverSheetsUIMixin extends FUniver implements IFUniverSheetsUIMixin {
+    private _initSheetUIEvent;
+    _initialize(injector: Injector): void;
+    private _generateClipboardCopyParam;
+    private _beforeClipboardChange;
+    private _clipboardChanged;
+    private _generateClipboardPasteParam;
+    private _generateClipboardPasteParamAsync;
+    private _beforeClipboardPaste;
+    private _clipboardPaste;
+    private _beforeClipboardPasteAsync;
+    private _clipboardPasteAsync;
     customizeColumnHeader(cfg: IColumnsHeaderCfgParam): void;
     customizeRowHeader(cfg: IRowsHeaderCfgParam): void;
     registerSheetRowHeaderExtension(unitId: string, ...extensions: SheetExtension[]): IDisposable;
@@ -63,9 +65,7 @@ export declare class FUniverSheetsUIMixin extends FUniver implements IFUniverShe
     registerSheetMainExtension(unitId: string, ...extensions: SheetExtension[]): IDisposable;
     /**
      * Get sheet render component from render by unitId and view key.
-     *
      * @private
-     *
      * @param {string} unitId The unit id of the spreadsheet.
      * @param {SHEET_VIEW_KEY} viewKey The view key of the spreadsheet.
      * @returns {Nullable<RenderComponentType>} The render component.
@@ -73,7 +73,6 @@ export declare class FUniverSheetsUIMixin extends FUniver implements IFUniverShe
     private _getSheetRenderComponent;
     /**
      * Get sheet hooks.
-     *
      * @returns {FSheetHooks} FSheetHooks instance
      */
     getSheetHooks(): FSheetHooks;