declare module "@univerjs/core/facade" {
  import { TableColumnFilterTypeEnum, TableConditionTypeEnum, TableDateCompareTypeEnum, TableNumberCompareTypeEnum, TableStringCompareTypeEnum } from "@univerjs/sheets-table";

  interface IFSheetsTableEnumMixin {
      TableColumnFilterTypeEnum: typeof TableColumnFilterTypeEnum;
      TableConditionTypeEnum: typeof TableConditionTypeEnum;
      TableNumberCompareTypeEnum: typeof TableNumberCompareTypeEnum;
      TableStringCompareTypeEnum: typeof TableStringCompareTypeEnum;
      TableDateCompareTypeEnum: typeof TableDateCompareTypeEnum;
  }
}

declare module "@univerjs/sheets-table" {
  import type { IStyleData } from "@univerjs/core";

  enum TableColumnDataTypeEnum {
      None = "none",
      String = "string",
      Number = "number",
      Date = "date",
      Bool = "bool",
      Checkbox = "checkbox",
      List = "list"
  }

  enum TableColumnFilterTypeEnum {
      manual = "manual",
      condition = "condition"
  }

  enum TableConditionTypeEnum {
      Date = "date",
      Number = "number",
      String = "string",
      Logic = "logic"
  }

  enum TableNumberCompareTypeEnum {
      Equal = "equal",
      NotEqual = "notEqual",
      GreaterThan = "greaterThan",
      GreaterThanOrEqual = "greaterThanOrEqual",
      LessThan = "lessThan",
      LessThanOrEqual = "lessThanOrEqual",
      Between = "between",
      NotBetween = "notBetween",
      Above = "above",
      Below = "below",
      TopN = "topN"
  }

  enum TableStringCompareTypeEnum {
      Equal = "equal",
      NotEqual = "notEqual",
      Contains = "contains",
      NotContains = "notContains",
      StartsWith = "startsWith",
      EndsWith = "endsWith"
  }

  enum TableDateCompareTypeEnum {
      Equal = "equal",
      NotEqual = "notEqual",
      After = "after",
      AfterOrEqual = "afterOrEqual",
      Before = "before",
      BeforeOrEqual = "beforeOrEqual",
      Between = "between",
      NotBetween = "notBetween",
      Today = "today",
      Yesterday = "yesterday",
      Tomorrow = "tomorrow",
      ThisWeek = "thisWeek",
      LastWeek = "lastWeek",
      NextWeek = "nextWeek",
      ThisMonth = "thisMonth",
      LastMonth = "lastMonth",
      NextMonth = "nextMonth",
      ThisQuarter = "thisQuarter",
      LastQuarter = "lastQuarter",
      NextQuarter = "nextQuarter",
      ThisYear = "thisYear",
      LastYear = "lastYear",
      NextYear = "nextYear",
      YearToDate = "yearToDate",
      Quarter = "quarter",
      Month = "month",
      M1 = "m1",
      M2 = "m2",
      M3 = "m3",
      M4 = "m4",
      M5 = "m5",
      M6 = "m6",
      M7 = "m7",
      M8 = "m8",
      M9 = "m9",
      M10 = "m10",
      M11 = "m11",
      M12 = "m12",
      Q1 = "q1",
      Q2 = "q2",
      Q3 = "q3",
      Q4 = "q4"
  }

  enum SheetsTableSortStateEnum {
      Asc = "asc",
      Desc = "desc",
      None = "none"
  }

  interface ITableRange {
      startRow: number;
      startColumn: number;
      endRow: number;
      endColumn: number;
  }

  interface ITableOptions {
      /**
       * Whether to show the header row.
       * @todo not support yet
       */
      showHeader?: boolean;
      /**
       * Whether to show the footer row.
       * @todo not support yet
       */
      showFooter?: boolean;
      /**
       * The table style id. If the property is empty, the default style will be used.
       * @default: table-default-0 ~ table-default-5
       */
      tableStyleId?: string;
      /**
       * The total number of rows in the table.
       * @todo not support yet
       */
      hasTotalRow?: boolean;
      /**
       * The columns of the table. If not provided, default columns will be generated based on the range.
       */
      columns?: ITableColumnJson[];
      /**
       * The column filters of the table.
       */
      filters?: ITableFilterItem[];
  }

  interface ITableFilterJSON {
      tableColumnFilterList?: (ITableFilterItem | undefined)[];
      tableSortInfo?: {
          columnIndex: number;
          sortState: SheetsTableSortStateEnum;
      };
  }

  type ITableFilterItem = ITableManualFilterItem | ITableConditionFilterItem;

  type TableMetaType = Record<string, any>;

  /**
   * Represents the table filter item, filter data by provided values.
   */
  interface ITableManualFilterItem {
      filterType: TableColumnFilterTypeEnum.manual;
      values: string[];
      isAllSelected?: boolean;
  }

  /**
   * Represents the table filter item, filter data by provided condition rules.
   */
  interface ITableConditionFilterItem {
      filterType: TableColumnFilterTypeEnum.condition;
      filterInfo: ITableDateFilterInfo | ITableStringFilterInfo | ITableNumberFilterInfo | ITableLogicFilterInfo;
  }

  interface ITableDateFilterInfo {
      conditionType: TableConditionTypeEnum.Date;
      compareType: TableDateCompareTypeEnum;
      expectedValue?: string | [
          string,
          string
      ] | Date | [
          Date,
          Date
      ];
      anchorTime?: number;
  }

  interface ITableStringFilterInfo {
      conditionType: TableConditionTypeEnum.String;
      compareType: TableStringCompareTypeEnum;
      expectedValue: string;
  }

  interface ITableNumberFilterInfo {
      conditionType: TableConditionTypeEnum.Number;
      compareType: TableNumberCompareTypeEnum;
      expectedValue: number | [
          number,
          number
      ];
  }

  interface ITableLogicFilterInfo {
      conditionType: TableConditionTypeEnum.Logic;
      compareType: TableNumberCompareTypeEnum;
      expectedValue: (ITableDateFilterInfo | ITableStringFilterInfo | ITableNumberFilterInfo)[];
  }

  interface ITableColumnJson {
      dataType: TableColumnDataTypeEnum;
      id: string;
      displayName: string;
      formula: string;
      meta: TableMetaType;
      style: IStyleData;
  }

  interface ITableJson {
      id: string;
      name: string;
      range: ITableRange;
      options: ITableOptions;
      filters: ITableFilterJSON;
      columns: ITableColumnJson[];
      meta: TableMetaType;
  }

  interface ITableInfo {
      id: string;
      name: string;
      subUnitId: string;
      range: ITableRange;
      meta: TableMetaType;
      columns: ITableColumnJson[];
      showHeader: boolean;
  }

  interface ITableInfoWithUnitId extends ITableInfo {
      unitId: string;
  }
}

declare module "@univerjs/sheets-table/facade" {
  import type { IRangeThemeStyleJSON } from "@univerjs/sheets";

  import type { ITableFilterItem, ITableInfo, ITableInfoWithUnitId, ITableOptions, ITableRange } from "@univerjs/sheets-table";

  interface IFWorkbookSheetsTableMixin {
      /**
       * Get table information
       * @param {string} tableId The table id
       * @returns {ITableInfo} The table information
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const fWorksheet = fWorkbook.getSheetByName('Sheet1');
       * if (!fWorksheet) return;
       *
       * // Insert a table in the range B2:F11
       * const fRange = fWorksheet.getRange('B2:F11');
       * const success = await fWorksheet.addTable(
       *   'name-1',
       *   fRange.getRange(),
       *   'id-1',
       *   {
       *     tableStyleId: 'table-default-4',
       *   }
       * );
       *
       * if (success) {
       *   const tableInfo = fWorkbook.getTableInfo('id-1');
       *   console.log('debugger tableInfo', tableInfo);
       * }
       * ```
       */
      getTableInfo(tableId: string): ITableInfoWithUnitId | undefined;
      /**
       * Get table information by name
       * @param {string} tableName The table name
       * @returns {ITableInfo} The table information
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const fWorksheet = fWorkbook.getSheetByName('Sheet1');
       * if (!fWorksheet) return;
       *
       * // Insert a table in the range B2:F11
       * const fRange = fWorksheet.getRange('B2:F11');
       * const success = await fWorksheet.addTable(
       *   'name-1',
       *   fRange.getRange(),
       *   'id-1',
       *   {
       *     tableStyleId: 'table-default-4',
       *   }
       * );
       *
       * if (success) {
       *   const tableInfo = fWorkbook.getTableInfoByName('name-1');
       *   console.log('debugger tableInfo', tableInfo);
       * }
       * ```
       */
      getTableInfoByName(tableName: string): ITableInfoWithUnitId | undefined;
      /**
       * Get table list
       * @returns {ITableInfo[]} The table list
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const tables = fWorkbook.getTableList();
       * console.log('debugger tables', tables);
       * ```
       */
      getTableList(): ITableInfo[];
      /**
       * Add table
       * @param {string} subUnitId The sub unit id
       * @param {string} tableName The table name
       * @param {ITableRange} rangeInfo The table range information
       * @param {string} [tableId] The table id
       * @param {ITableOptions} [options] The table options
       * @returns {string} The table id
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const fWorksheet = fWorkbook.getSheetByName('Sheet1');
       * if (!fWorksheet) return;
       *
       * // Insert a table in the range B2:F11
       * const fRange = fWorksheet.getRange('B2:F11');
       * const id = await fWorkbook.addTable(
       *   fWorksheet.getSheetId(),
       *   'name-1',
       *   fRange.getRange(),
       *   'id-1',
       *   {
       *     tableStyleId: 'table-default-4',
       *   }
       * );
       *
       * if (id) {
       *   const tableInfo = fWorkbook.getTableInfo(id);
       *   console.log('debugger tableInfo', tableInfo);
       * }
       * ```
       */
      addTable(subUnitId: string, tableName: string, rangeInfo: ITableRange, tableId?: string, options?: ITableOptions): Promise<string | undefined>;
      /**
       * set table filter
       * @param {string} tableId The table id
       * @param {number} column The column index, starting from 0.
       * @param {ITableFilterItem} filter The filter item
       * @returns {Promise<boolean>} The result of set table filter
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const fWorksheet = fWorkbook.getSheetByName('Sheet1');
       * if (!fWorksheet) return;
       *
       * // Insert a table in the range B2:F11
       * const fRange = fWorksheet.getRange('B2:F11');
       * const success = await fWorksheet.addTable(
       *   'name-1',
       *   fRange.getRange(),
       *   'id-1',
       *   {
       *     tableStyleId: 'table-default-4',
       *   }
       * );
       *
       * if (success) {
       *   // Set the filter for the second column
       *   await fWorkbook.setTableFilter('id-1', 1, {
       *     filterType: univerAPI.Enum.TableColumnFilterTypeEnum.condition,
       *     filterInfo: {
       *       conditionType: univerAPI.Enum.TableConditionTypeEnum.Number,
       *       compareType: univerAPI.Enum.TableNumberCompareTypeEnum.GreaterThan,
       *       expectedValue: 10,
       *     },
       *   });
       *
       *   const tableInfo = fWorkbook.getTableInfo('id-1');
       *   console.log('debugger tableInfo', tableInfo);
       * }
       * ```
       */
      setTableFilter(tableId: string, column: number, filter: ITableFilterItem | undefined): void;
      /**
       * Remove table
       * @param {string} tableId The table id
       * @returns {boolean} The result of remove table
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const tableInfo = fWorkbook.getTableInfo('id-1');
       * console.log('debugger tableInfo', tableInfo);
       *
       * if (tableInfo) {
       *   // Remove the table with the specified id
       *   await fWorkbook.removeTable('id-1');
       * }
       * ```
       */
      removeTable(tableId: string): Promise<boolean>;
  }

  class FWorkbookSheetsTableMixin {
      getTableInfo(tableId: string): ITableInfoWithUnitId | undefined;
      getTableList(): ITableInfoWithUnitId[];
      addTable(subUnitId: string, tableName: string, rangeInfo: ITableRange, tableId?: string, options?: ITableOptions): Promise<string | undefined>;
      removeTable(tableId: string): Promise<boolean>;
      getTableInfoByName(tableName: string): ITableInfoWithUnitId | undefined;
      setTableFilter(tableId: string, column: number, filter: ITableFilterItem | undefined): Promise<boolean>;
  }

  interface IFWorksheetTableMixin {
      /**
       * Add a table to the worksheet
       * @param {string} tableName The table name
       * @param {ITableRange} rangeInfo The table range information
       * @param {string} [tableId] The table id
       * @param {ITableOptions} [options] The table options
       * @returns {Promise<boolean>} Whether the table was added successfully
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const fWorksheet = fWorkbook.getSheetByName('Sheet1');
       * if (!fWorksheet) return;
       *
       * // Insert a table in the range B2:F11
       * const fRange = fWorksheet.getRange('B2:F11');
       * const success = await fWorksheet.addTable(
       *   'name-1',
       *   fRange.getRange(),
       *   'id-1',
       *   {
       *     tableStyleId: 'table-default-4',
       *     columns: [
       *       { id: 'col-1', displayName: 'Column 1' }
       *     ],
       *     filters: [
       *       {
       *         filterType: univerAPI.Enum.TableColumnFilterTypeEnum.condition,
       *         filterInfo: {
       *           conditionType: univerAPI.Enum.TableConditionTypeEnum.Number,
       *           compareType: univerAPI.Enum.TableNumberCompareTypeEnum.GreaterThan,
       *           expectedValue: 2,
       *         }
       *       }
       *     ]
       *   }
       * );
       *
       * if (success) {
       *   const tableInfo = fWorkbook.getTableInfo('id-1');
       *   console.log('debugger tableInfo', tableInfo);
       * }
       * ```
       */
      addTable(tableName: string, rangeInfo: ITableRange, tableId?: string, options?: ITableOptions): Promise<boolean> | boolean;
      /**
       * Set the filter for a table column
       * @param {string} tableId The table id
       * @param {number} column The table column index, starting from 0. For example, the first column is 0, the second column is 1, and so on.
       * @param {ITableFilterItem} filter The filter item
       * @returns {Promise<boolean>} Whether the table filter was set successfully
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const fWorksheet = fWorkbook.getSheetByName('Sheet1');
       * if (!fWorksheet) return;
       *
       * // Insert a table in the range B2:F11
       * const fRange = fWorksheet.getRange('B2:F11');
       * const success = await fWorksheet.addTable(
       *   'name-1',
       *   fRange.getRange(),
       *   'id-1',
       *   {
       *     tableStyleId: 'table-default-4',
       *   }
       * );
       *
       * if (success) {
       *   // Set the filter for the second column
       *   await fWorksheet.setTableFilter('id-1', 1, {
       *     filterType: univerAPI.Enum.TableColumnFilterTypeEnum.condition,
       *     filterInfo: {
       *       conditionType: univerAPI.Enum.TableConditionTypeEnum.Number,
       *       compareType: univerAPI.Enum.TableNumberCompareTypeEnum.GreaterThan,
       *       expectedValue: 10,
       *     },
       *   });
       *
       *   const tableInfo = fWorkbook.getTableInfo('id-1');
       *   console.log('debugger tableInfo', tableInfo);
       * }
       * ```
       */
      setTableFilter(tableId: string, column: number, filter: ITableFilterItem): Promise<boolean>;
      /**
       * Remove a table from the worksheet
       * @param {string} tableId The table id
       * @returns {Promise<boolean>} Whether the table was removed successfully
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const fWorksheet = fWorkbook.getSheetByName('Sheet1');
       * if (!fWorksheet) return;
       * const tableInfo = fWorkbook.getTableInfo('id-1');
       * console.log('debugger tableInfo', tableInfo);
       *
       * if (tableInfo) {
       *   // Remove the table with the specified id
       *   await fWorksheet.removeTable('id-1');
       * }
       * ```
       */
      removeTable(tableId: string): Promise<boolean>;
      /**
       * Set the range of a table
       * @param {string} tableId The table id
       * @param {ITableRange} rangeInfo The new range information
       * @returns {Promise<boolean>} Whether the table range was set successfully
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const fWorksheet = fWorkbook.getSheetByName('Sheet1');
       * if (!fWorksheet) return;
       *
       * // Insert a table in the range B2:F11
       * const fRange = fWorksheet.getRange('B2:F11');
       * const success = await fWorksheet.addTable(
       *   'name-1',
       *   fRange.getRange(),
       *   'id-1',
       *   {
       *     tableStyleId: 'table-default-4',
       *   }
       * );
       *
       * if (success) {
       *   // Update the table range to B2:F21 after 3 seconds
       *   setTimeout(async () => {
       *     const newRange = fWorksheet.getRange('B2:F21');
       *     await fWorksheet.setTableRange('id-1', newRange.getRange());
       *
       *     const tableInfo = fWorkbook.getTableInfo('id-1');
       *     console.log('debugger tableInfo', tableInfo);
       *   }, 3000);
       * }
       * ```
       */
      setTableRange(tableId: string, rangeInfo: ITableRange): Promise<boolean>;
      /**
       * Set the name of a table
       * @param {string} tableId The table id
       * @param {string} tableName The new table name
       * @returns {Promise<boolean>} Whether the table name was set successfully
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const fWorksheet = fWorkbook.getSheetByName('Sheet1');
       * if (!fWorksheet) return;
       *
       * // Insert a table in the range B2:F11
       * const fRange = fWorksheet.getRange('B2:F11');
       * const success = await fWorksheet.addTable(
       *   'name-1',
       *   fRange.getRange(),
       *   'id-1',
       *   {
       *     tableStyleId: 'table-default-4',
       *   }
       * );
       *
       * if (success) {
       *   // Update the table name after 3 seconds
       *   setTimeout(async () => {
       *     await fWorksheet.setTableName('id-1', 'new-name');
       *
       *     const tableInfo = fWorkbook.getTableInfo('id-1');
       *     console.log('debugger tableInfo', tableInfo);
       *   }, 3000);
       * }
       * ```
       */
      setTableName(tableId: string, tableName: string): Promise<boolean> | boolean;
      /**
       * Get the list of tables in the worksheet
       * @returns {ITableInfoWithUnitId[]} The list of tables
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const fWorksheet = fWorkbook.getSheetByName('Sheet1');
       * if (!fWorksheet) return;
       * const tables = fWorksheet.getSubTableInfos();
       * console.log('debugger tables', tables);
       * ```
       */
      getSubTableInfos(): ITableInfoWithUnitId[];
      /**
       * Reset the column filter of a table
       * @param {string} tableId The table id
       * @param {number} column The column index, starting from 0. For example, the first column is 0, the second column is 1, and so on.
       * @returns {Promise<boolean>} Whether the table filter was reset successfully
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const fWorksheet = fWorkbook.getSheetByName('Sheet1');
       * if (!fWorksheet) return;
       *
       * // Insert a table in the range B2:F11
       * const fRange = fWorksheet.getRange('B2:F11');
       * const success = await fWorksheet.addTable(
       *   'name-1',
       *   fRange.getRange(),
       *   'id-1',
       *   {
       *     tableStyleId: 'table-default-4',
       *   }
       * );
       *
       * if (success) {
       *   // Set the filter for the second column
       *   await fWorksheet.setTableFilter('id-1', 1, {
       *     filterType: univerAPI.Enum.TableColumnFilterTypeEnum.condition,
       *     filterInfo: {
       *       conditionType: univerAPI.Enum.TableConditionTypeEnum.Number,
       *       compareType: univerAPI.Enum.TableNumberCompareTypeEnum.GreaterThan,
       *       expectedValue: 10,
       *     },
       *   });
       *
       *   // Reset the filter for the second column after 3 seconds
       *   setTimeout(async () => {
       *     await fWorksheet.resetFilter('id-1', 1);
       *   }, 3000);
       *
       *   const tableInfo = fWorkbook.getTableInfo('id-1');
       *   console.log('debugger tableInfo', tableInfo);
       * }
       * ```
       */
      resetFilter(tableId: string, column: number): Promise<boolean>;
      /**
       * Get the table information by cell position
       * @param {number} row The cell row index, starting from 0.
       * @param {number} column The cell column index, starting from 0.
       * @returns {ITableInfoWithUnitId | undefined} The table information or undefined if not found
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const fWorksheet = fWorkbook.getSheetByName('Sheet1');
       * if (!fWorksheet) return;
       *
       * const cellB2 = fWorksheet.getRange('B2');
       * const row = cellB2.getRow();
       * const column = cellB2.getColumn();
       * console.log('debugger tableInfo', fWorksheet.getTableByCell(row, column));
       *
       * // Insert a table in the range B2:F11
       * const fRange = fWorksheet.getRange('B2:F11');
       * const success = await fWorksheet.addTable(
       *   'name-1',
       *   fRange.getRange(),
       *   'id-1',
       *   {
       *     tableStyleId: 'table-default-4',
       *   }
       * );
       * console.log('debugger tableInfo2', fWorksheet.getTableByCell(row, column));
       * ```
       */
      getTableByCell(row: number, column: number): ITableInfoWithUnitId | undefined;
      /**
       * Add a theme to the table
       * @param {string} tableId The table id
       * @param {IRangeThemeStyleJSON} themeStyleJSON The theme style JSON
       * @returns {Promise<boolean>} Whether the theme was added successfully
       * @example
       * ```typescript
       * const fWorkbook = univerAPI.getActiveWorkbook();
       * const fWorksheet = fWorkbook.getSheetByName('Sheet1');
       * if (!fWorksheet) return;
       *
       * // Insert a table in the range B2:F11
       * const fRange = fWorksheet.getRange('B2:F11');
       * const success = await fWorksheet.addTable(
       *   'name-1',
       *   fRange.getRange(),
       *   'id-1',
       *   {
       *     tableStyleId: 'table-default-4',
       *   }
       * );
       *
       * if (success) {
       *   await fWorksheet.addTableTheme('id-1', {
       *     name: 'table-custom-1',
       *     headerRowStyle: {
       *       bg: {
       *         rgb: '#145f82',
       *       },
       *     },
       *     firstRowStyle: {
       *       bg: {
       *         rgb: '#c0e4f5',
       *       },
       *     },
       *   });
       *
       *   const tableInfo = fWorkbook.getTableInfo('id-1');
       *   console.log('debugger tableInfo', tableInfo);
       * }
       * ```
       */
      addTableTheme(tableId: string, themeStyleJSON: IRangeThemeStyleJSON): Promise<boolean>;
  }

  class FWorksheetTableMixin {
      addTable(tableName: string, rangeInfo: ITableRange, tableId?: string, options?: ITableOptions): Promise<boolean> | boolean;
      setTableFilter(tableId: string, column: number, filter: ITableFilterItem): Promise<boolean>;
      removeTable(tableId: string): Promise<boolean>;
      setTableRange(tableId: string, rangeInfo: ITableRange): Promise<boolean>;
      setTableName(tableId: string, tableName: string): Promise<boolean> | boolean;
      getSubTableInfos(): ITableInfoWithUnitId[];
      resetFilter(tableId: string, column: number): Promise<boolean>;
      getTableByCell(row: number, column: number): ITableInfoWithUnitId | undefined;
      addTableTheme(tableId: string, themeStyleJSON: IRangeThemeStyleJSON): Promise<boolean>;
  }
}

declare module "@univerjs/core/facade" {
  import { TableColumnFilterTypeEnum, TableConditionTypeEnum, TableDateCompareTypeEnum, TableNumberCompareTypeEnum, TableStringCompareTypeEnum } from "@univerjs/sheets-table";

  interface FEnum extends IFSheetsTableEnumMixin {
  }
}

declare module "@univerjs/sheets/facade" {
  import type { IFWorkbookSheetsTableMixin, IFWorksheetTableMixin } from "@univerjs/sheets-table/facade";

  interface FWorkbook extends IFWorkbookSheetsTableMixin {
  }
}

declare module "@univerjs/sheets/facade" {
  import type { IFWorkbookSheetsTableMixin, IFWorksheetTableMixin } from "@univerjs/sheets-table/facade";

  interface FWorksheet extends IFWorksheetTableMixin {
  }
}
