@univerjs-pro/bases 0.25.0-insiders.20260608-e4336f7

package/lib/types/locale/vi-VN.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/zh-CN.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/zh-HK.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/zh-TW.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/models/base-cell-data.d.ts

@@ -0,0 +1,14 @@
+import type { BaseCellValue as CellValue, IBaseCellData, IFieldSnapshot, ITableSnapshot, RecordId } from '@univerjs/core';
+export declare function ensureBaseTableCellLayout(table: ITableSnapshot): ITableSnapshot;
+export declare function syncBaseRecordValuesFromCellData(table: ITableSnapshot): ITableSnapshot;
+export declare function getBaseCell(table: ITableSnapshot, recordId: RecordId, fieldId: string): IBaseCellData | undefined;
+export declare function getBaseCellValue(table: ITableSnapshot, recordId: RecordId, fieldId: string): CellValue;
+export declare function getBaseCellFormulaValue(table: ITableSnapshot, recordId: RecordId, fieldId: string): IBaseCellData['v'];
+export declare function setBaseCell(table: ITableSnapshot, recordId: RecordId, fieldId: string, value: CellValue | IBaseCellData): void;
+export declare function toBaseCellData(value: CellValue | IBaseCellData, field?: IFieldSnapshot): IBaseCellData;
+export declare function fromBaseCellData(cell: IBaseCellData | undefined, field?: IFieldSnapshot, table?: ITableSnapshot, recordId?: RecordId): CellValue;
+export declare function toBaseRecordValue(value: CellValue | IBaseCellData, cell: IBaseCellData, field?: IFieldSnapshot, table?: ITableSnapshot, recordId?: RecordId): CellValue;
+export declare function getBaseAttachmentResourceKey(fieldId: string, recordId: RecordId): string;
+export declare function writeAttachmentResources(table: ITableSnapshot, recordId: RecordId, fieldId: string, value: unknown): void;
+export declare function readAttachmentResources(table: ITableSnapshot, recordId: RecordId, fieldId: string): Record<string, unknown>[] | null;
+export declare function normalizeAttachmentValue(value: unknown): Record<string, unknown>[];

package/lib/types/models/base-snapshot.d.ts

@@ -0,0 +1 @@
+export type { IBaseSnapshot } from '@univerjs/core';

package/lib/types/models/default-table.d.ts

@@ -0,0 +1,12 @@
+import type { ITableSnapshot } from '@univerjs/core';
+export interface ICreateDefaultBaseTableSnapshotOptions {
+    id: string;
+    name: string;
+    primaryFieldId?: string;
+    primaryFieldName?: string;
+    gridViewId?: string;
+    recordCount?: number;
+    now?: number;
+}
+export declare function createDefaultBaseTableSnapshot(options: ICreateDefaultBaseTableSnapshotOptions): ITableSnapshot;
+export type CreateDefaultBaseTableSnapshotOptions = ICreateDefaultBaseTableSnapshotOptions;

package/lib/types/models/field-snapshot.d.ts

@@ -0,0 +1 @@
+export type { IFieldSnapshot } from '@univerjs/core';

package/lib/types/models/record-snapshot.d.ts

@@ -0,0 +1 @@
+export type { IRecordSnapshot } from '@univerjs/core';

package/lib/types/models/table-snapshot.d.ts

@@ -0,0 +1 @@
+export type { ITableSnapshot } from '@univerjs/core';

package/lib/types/models/value.d.ts

@@ -0,0 +1 @@
+export type { BaseCellValue as CellValue } from '@univerjs/core';

package/lib/types/models/view-snapshot.d.ts

@@ -0,0 +1 @@
+export type { IViewSnapshot } from '@univerjs/core';

package/lib/types/mutations/json1.mutation.d.ts

@@ -0,0 +1,7 @@
+import type { IMutation, JSONXActions } from '@univerjs/core';
+export interface IApplyBaseJson1MutationParams {
+    unitId: string;
+    op: JSONXActions;
+    trigger?: string;
+}
+export declare const ApplyBaseJson1Mutation: IMutation<IApplyBaseJson1MutationParams>;

package/lib/types/mutations/utils.d.ts

@@ -0,0 +1,2 @@
+import type { IAccessor, JSONXActions } from '@univerjs/core';
+export declare function applyBaseMutation(accessor: IAccessor, unitId: string, op: JSONXActions): boolean;

package/lib/types/ot/json1-adapter.d.ts

@@ -0,0 +1,103 @@
+import type { BaseInvalidation, IBaseSnapshot, IFieldSnapshot, IRecordSnapshot, ITableSnapshot, IViewSnapshot, JSONXActions } from '@univerjs/core';
+export type BaseJson1Command = {
+    type: 'createTable';
+    table: ITableSnapshot;
+    index?: number;
+} | {
+    type: 'renameTable';
+    tableId: string;
+    name: string;
+} | {
+    type: 'deleteTable';
+    tableId: string;
+} | {
+    type: 'createField';
+    tableId: string;
+    field: IFieldSnapshot;
+    index?: number;
+} | {
+    type: 'updateField';
+    tableId: string;
+    fieldId: string;
+    patch: Partial<IFieldSnapshot>;
+} | {
+    type: 'deleteField';
+    tableId: string;
+    fieldId: string;
+} | {
+    type: 'createRecord';
+    tableId: string;
+    record: IRecordSnapshot;
+} | {
+    type: 'deleteRecord';
+    tableId: string;
+    recordId: string;
+} | {
+    type: 'updateRecordOrder';
+    tableId: string;
+    recordId: string;
+    orderKey: string;
+} | {
+    type: 'updateCell';
+    tableId: string;
+    recordId: string;
+    fieldId: string;
+    value: unknown;
+} | {
+    type: 'setRecordValues';
+    tableId: string;
+    patches: Array<{
+        recordId: string;
+        values: Record<string, unknown>;
+    }>;
+} | {
+    type: 'setRangeValues';
+    tableId: string;
+    patches: Array<{
+        row: number;
+        col: number;
+        value: unknown;
+    }>;
+} | {
+    type: 'createView';
+    tableId: string;
+    view: IViewSnapshot;
+    index?: number;
+} | {
+    type: 'deleteView';
+    tableId: string;
+    viewId: string;
+} | {
+    type: 'updateViewConfig';
+    tableId: string;
+    viewId: string;
+    patch: Record<string, unknown>;
+};
+export interface IBaseCollaborativeOp {
+    unitId: string;
+    unitType: 'base';
+    rev: number;
+    op: JSONXActions;
+    meta?: {
+        commandId: string;
+        commandType: string;
+        actorId: string;
+        timestamp: number;
+    };
+}
+export interface IBaseJson1Adapter {
+    createOp(command: BaseJson1Command, snapshot: IBaseSnapshot): JSONXActions;
+    applyOp(snapshot: IBaseSnapshot, op: JSONXActions): IBaseSnapshot;
+    invertOp(snapshot: IBaseSnapshot, op: JSONXActions): JSONXActions;
+    getAffectedRanges(op: JSONXActions): BaseInvalidation[];
+}
+export declare class BaseJson1Adapter implements IBaseJson1Adapter {
+    private readonly _factory;
+    private readonly _applier;
+    createOp(command: BaseJson1Command, snapshot: IBaseSnapshot): JSONXActions;
+    createCollaborativeOp(input: Omit<IBaseCollaborativeOp, 'unitType'>): IBaseCollaborativeOp;
+    applyOp(snapshot: IBaseSnapshot, op: JSONXActions): IBaseSnapshot;
+    invertOp(snapshot: IBaseSnapshot, op: JSONXActions): JSONXActions;
+    getAffectedRanges(op: JSONXActions): BaseInvalidation[];
+}
+export type BaseCollaborativeOp = IBaseCollaborativeOp;

package/lib/types/ot/json1-invalidation.d.ts

@@ -0,0 +1,2 @@
+import type { BaseInvalidation, JSONXActions } from '@univerjs/core';
+export declare function getBaseInvalidationsFromJson1(op: JSONXActions): BaseInvalidation[];

package/lib/types/ot/json1-op-applier.d.ts

@@ -0,0 +1,6 @@
+import type { BaseInvalidation, IBaseSnapshot, JSONXActions } from '@univerjs/core';
+export declare class BaseJson1OpApplier {
+    applyOp(snapshot: IBaseSnapshot, op: JSONXActions): IBaseSnapshot;
+    invertOp(snapshot: IBaseSnapshot, op: JSONXActions): JSONXActions;
+    getAffectedRanges(op: JSONXActions): BaseInvalidation[];
+}

package/lib/types/ot/json1-op-factory.d.ts

@@ -0,0 +1,64 @@
+import type { BaseCellValue as CellValue, FilterConfig, GroupConfig, IBaseCellData, IBaseSnapshot, IFieldSnapshot, IRecordSnapshot, ITableSnapshot, IViewSnapshot, JSONXActions, SortConfig, TableId } from '@univerjs/core';
+export interface ICreateFieldOpInput {
+    field: IFieldSnapshot;
+    index?: number;
+}
+export interface ISetRecordValuesPatch {
+    recordId: string;
+    values: Record<string, CellValue>;
+    recordPatch?: Partial<Pick<IRecordSnapshot, 'updatedAt' | 'updatedBy'>>;
+}
+export interface ISetRangeValuesPatch {
+    row: number;
+    col: number;
+    value: CellValue | IBaseCellData | null;
+}
+export declare class BaseJson1OpFactory {
+    createTable(snapshot: IBaseSnapshot, table: ITableSnapshot, index?: number): JSONXActions;
+    renameTable(snapshot: IBaseSnapshot, tableId: TableId, name: string): JSONXActions;
+    deleteTable(snapshot: IBaseSnapshot, tableId: TableId): JSONXActions;
+    createRecord(snapshot: IBaseSnapshot, tableId: TableId, record: IRecordSnapshot): JSONXActions;
+    createRecords(snapshot: IBaseSnapshot, tableId: TableId, records: IRecordSnapshot[]): JSONXActions;
+    deleteRecord(snapshot: IBaseSnapshot, tableId: TableId, recordId: string): JSONXActions;
+    deleteRecords(snapshot: IBaseSnapshot, tableId: TableId, recordIds: string[]): JSONXActions;
+    duplicateRecord(snapshot: IBaseSnapshot, tableId: TableId, sourceRecordId: string, record: IRecordSnapshot): JSONXActions;
+    updateRecordOrder(snapshot: IBaseSnapshot, tableId: TableId, recordId: string, orderKey: string): JSONXActions;
+    updateCell(snapshot: IBaseSnapshot, tableId: TableId, recordId: string, fieldId: string, value: CellValue): JSONXActions;
+    setRecordValues(snapshot: IBaseSnapshot, tableId: TableId, patches: ISetRecordValuesPatch[]): JSONXActions;
+    setRangeValues(snapshot: IBaseSnapshot, tableId: TableId, patches: ISetRangeValuesPatch[]): JSONXActions;
+    createField(snapshot: IBaseSnapshot, tableId: TableId, input: ICreateFieldOpInput): JSONXActions;
+    duplicateField(snapshot: IBaseSnapshot, tableId: TableId, sourceFieldId: string, input: ICreateFieldOpInput): JSONXActions;
+    updateField(snapshot: IBaseSnapshot, tableId: TableId, fieldId: string, patch: Partial<IFieldSnapshot>): JSONXActions;
+    changeFieldType(snapshot: IBaseSnapshot, tableId: TableId, fieldId: string, input: Pick<IFieldSnapshot, 'type' | 'config'>): JSONXActions;
+    deleteField(snapshot: IBaseSnapshot, tableId: TableId, fieldId: string): JSONXActions;
+    moveField(snapshot: IBaseSnapshot, tableId: TableId, fieldId: string, target: {
+        beforeFieldId?: string;
+        afterFieldId?: string;
+    }): JSONXActions;
+    createView(snapshot: IBaseSnapshot, tableId: TableId, view: IViewSnapshot, index?: number): JSONXActions;
+    renameView(snapshot: IBaseSnapshot, tableId: TableId, viewId: string, name: string): JSONXActions;
+    deleteView(snapshot: IBaseSnapshot, tableId: TableId, viewId: string): JSONXActions;
+    moveView(snapshot: IBaseSnapshot, tableId: TableId, viewId: string, target: {
+        beforeViewId?: string;
+        afterViewId?: string;
+    }): JSONXActions;
+    updateViewConfig(snapshot: IBaseSnapshot, tableId: TableId, viewId: string, patch: Record<string, unknown>): JSONXActions;
+    setViewFilter(snapshot: IBaseSnapshot, tableId: TableId, viewId: string, filter: FilterConfig | null): JSONXActions;
+    setViewSort(snapshot: IBaseSnapshot, tableId: TableId, viewId: string, sort: SortConfig[]): JSONXActions;
+    setViewGroup(snapshot: IBaseSnapshot, tableId: TableId, viewId: string, group: GroupConfig[]): JSONXActions;
+    setViewFieldVisible(snapshot: IBaseSnapshot, tableId: TableId, viewId: string, fieldId: string, visible: boolean): JSONXActions;
+    setViewFieldWidth(snapshot: IBaseSnapshot, tableId: TableId, viewId: string, fieldId: string, width: number): JSONXActions;
+    setViewFieldOrder(snapshot: IBaseSnapshot, tableId: TableId, viewId: string, fieldId: string, target: {
+        beforeFieldId?: string;
+        afterFieldId?: string;
+    }): JSONXActions;
+    private _setViewFieldSetting;
+    private _setDeleted;
+    private _createRecordOrderOp;
+    private _setFormulaFieldCells;
+    private _setAttachmentResources;
+    private _replaceOptional;
+}
+export type CreateFieldOpInput = ICreateFieldOpInput;
+export type SetRecordValuesPatch = ISetRecordValuesPatch;
+export type SetRangeValuesPatch = ISetRangeValuesPatch;

package/lib/types/ot/json1-path.d.ts

@@ -0,0 +1,13 @@
+import type { FieldId, RecordId, TableId, ViewId } from '@univerjs/core';
+export declare const baseJson1Path: {
+    table: (tableId: TableId) => string[];
+    field: (tableId: TableId, fieldId: FieldId) => string[];
+    fieldOrder: (tableId: TableId, index: number) => (string | number)[];
+    record: (tableId: TableId, recordId: RecordId) => string[];
+    cell: (tableId: TableId, recordId: RecordId, fieldId: FieldId) => string[];
+    cellData: (tableId: TableId, row: number, col: number) => string[];
+    attachmentSet: (tableId: TableId, key: string) => string[];
+    attachment: (tableId: TableId, attachmentId: string) => string[];
+    view: (tableId: TableId, viewId: ViewId) => string[];
+    viewFieldHidden: (tableId: TableId, viewId: ViewId, fieldId: FieldId) => string[];
+};

package/lib/types/plugin.d.ts

@@ -0,0 +1,35 @@
+import { ICommandService, Injector, IUniverInstanceService, Plugin, UniverInstanceType } from '@univerjs/core';
+import { DataSyncPrimaryController } from '@univerjs/rpc';
+export declare const BASES_PLUGIN_NAME = "BASES_PLUGIN";
+export declare const BASE_SYNC_MUTATIONS: readonly [import("@univerjs/core").IMutation<import(".").IApplyBaseJson1MutationParams, boolean>];
+export declare class UniverBasesPlugin extends Plugin {
+    private readonly _config;
+    protected readonly _injector: Injector;
+    private readonly _commandService;
+    private readonly _univerInstanceService;
+    private readonly _dataSyncPrimaryController?;
+    static pluginName: string;
+    static packageName: string;
+    static version: string;
+    static type: UniverInstanceType;
+    private readonly _baseSyncDisposables;
+    constructor(_config: {} | undefined, _injector: Injector, _commandService: ICommandService, _univerInstanceService: IUniverInstanceService, _dataSyncPrimaryController?: DataSyncPrimaryController | undefined);
+    onReady(): void;
+    private _initDependencies;
+    private _initCommands;
+    private _initDataSync;
+    private _syncBaseUnit;
+    private _initRegistries;
+}
+export declare class UniverRemoteBasesPlugin extends Plugin {
+    private readonly _config;
+    protected readonly _injector: Injector;
+    private readonly _commandService;
+    private readonly _univerInstanceService;
+    static pluginName: string;
+    static packageName: string;
+    static version: string;
+    static type: UniverInstanceType;
+    constructor(_config: {} | undefined, _injector: Injector, _commandService: ICommandService, _univerInstanceService: IUniverInstanceService);
+    onReady(): void;
+}

package/lib/types/search/base-search.d.ts

@@ -0,0 +1,24 @@
+import type { FieldId, FieldType, ITableSnapshot, ProjectedRow, RecordId } from '@univerjs/core';
+export interface IBaseTableSearchRequest {
+    table: ITableSnapshot;
+    rows: ReadonlyArray<Pick<ProjectedRow, 'recordId' | 'values'>>;
+    query: string;
+    fieldIds: ReadonlyArray<FieldId>;
+    limit?: number;
+}
+export interface IBaseTableSearchMatch {
+    recordId: RecordId;
+    fieldId: FieldId;
+    fieldType: FieldType;
+    text: string;
+    score: number;
+}
+export interface IBaseTableSearchResult {
+    query: string;
+    total: number;
+    matches: IBaseTableSearchMatch[];
+}
+export declare function searchBaseTable(request: IBaseTableSearchRequest): IBaseTableSearchResult;
+export type BaseTableSearchRequest = IBaseTableSearchRequest;
+export type BaseTableSearchMatch = IBaseTableSearchMatch;
+export type BaseTableSearchResult = IBaseTableSearchResult;

package/lib/types/services/base-active-dirty.service.d.ts

@@ -0,0 +1,24 @@
+import type { BaseCellValue as CellValue, IBaseCellData } from '@univerjs/core';
+export interface IBaseRangeValueDirtyParams {
+    unitId: string;
+    tableId: string;
+    patches: Array<{
+        row: number;
+        col: number;
+        value: CellValue | IBaseCellData | null;
+    }>;
+}
+export interface IBaseFormulaDirtyRange {
+    unitId: string;
+    sheetId: string;
+    range: {
+        startRow: number;
+        endRow: number;
+        startColumn: number;
+        endColumn: number;
+    };
+}
+export type BaseFormulaDirtySuperTableMap = Record<string, Record<string, string>>;
+export declare function setBaseRangeValuesToDirtyRanges(params: IBaseRangeValueDirtyParams): IBaseFormulaDirtyRange[];
+export declare function createBaseStructureDirtySuperTableMap(unitId: string, tableIds: string[]): BaseFormulaDirtySuperTableMap;
+export type BaseFormulaDirtyRange = IBaseFormulaDirtyRange;

package/lib/types/services/base-command.service.d.ts

@@ -0,0 +1,122 @@
+import type { BaseDataModel, BaseCellValue as CellValue, FilterConfig, GroupConfig, IFieldSnapshot, IRecordSnapshot, ITableSnapshot, IViewSnapshot, JSONXActions, SortConfig } from '@univerjs/core';
+import { BaseFieldRegistryService } from './base-field-registry.service';
+import { IBasePermissionService } from './base-permission.service';
+export interface IBaseCommandRuntimeContext {
+    now?: () => number;
+    getCurrentUserId?: () => string | null | undefined;
+    getCurrentUser?: () => {
+        userID: string;
+        name: string;
+        avatar?: string;
+    } | null | undefined;
+}
+export interface IBaseCommandService {
+    createUpdateCellOp(base: BaseDataModel, tableId: string, recordId: string, fieldId: string, value: CellValue): JSONXActions;
+    createSetRecordValuesOp(base: BaseDataModel, tableId: string, patches: Array<{
+        recordId: string;
+        values: Record<string, CellValue>;
+    }>): JSONXActions;
+    createCreateRecordOp(base: BaseDataModel, tableId: string, record: IRecordSnapshot): JSONXActions;
+    createBatchCreateRecordsOp(base: BaseDataModel, tableId: string, records: IRecordSnapshot[]): JSONXActions;
+    createCreateFieldOp(base: BaseDataModel, tableId: string, field: IFieldSnapshot, index?: number): JSONXActions;
+    createTable(base: BaseDataModel, table: ITableSnapshot, index?: number): void;
+    renameTable(base: BaseDataModel, tableId: string, name: string): void;
+    deleteTable(base: BaseDataModel, tableId: string): void;
+    updateCell(base: BaseDataModel, tableId: string, recordId: string, fieldId: string, value: CellValue): void;
+    setRecordValues(base: BaseDataModel, tableId: string, patches: Array<{
+        recordId: string;
+        values: Record<string, CellValue>;
+    }>): void;
+    createRecord(base: BaseDataModel, tableId: string, record: IRecordSnapshot): void;
+    deleteRecord(base: BaseDataModel, tableId: string, recordId: string): void;
+    duplicateRecord(base: BaseDataModel, tableId: string, sourceRecordId: string, record: IRecordSnapshot): void;
+    updateRecordOrder(base: BaseDataModel, tableId: string, recordId: string, orderKey: string): void;
+    createField(base: BaseDataModel, tableId: string, field: IFieldSnapshot, index?: number): void;
+    updateField(base: BaseDataModel, tableId: string, fieldId: string, patch: Partial<IFieldSnapshot>): void;
+    changeFieldType(base: BaseDataModel, tableId: string, fieldId: string, input: Pick<IFieldSnapshot, 'type' | 'config'>): void;
+    deleteField(base: BaseDataModel, tableId: string, fieldId: string): void;
+    moveField(base: BaseDataModel, tableId: string, fieldId: string, target: {
+        beforeFieldId?: string;
+        afterFieldId?: string;
+    }): void;
+    createView(base: BaseDataModel, tableId: string, view: IViewSnapshot, index?: number): void;
+    renameView(base: BaseDataModel, tableId: string, viewId: string, name: string): void;
+    deleteView(base: BaseDataModel, tableId: string, viewId: string): void;
+    moveView(base: BaseDataModel, tableId: string, viewId: string, target: {
+        beforeViewId?: string;
+        afterViewId?: string;
+    }): void;
+    updateViewConfig(base: BaseDataModel, tableId: string, viewId: string, patch: Record<string, unknown>): void;
+    setViewFilter(base: BaseDataModel, tableId: string, viewId: string, filter: FilterConfig | null): void;
+    setViewSort(base: BaseDataModel, tableId: string, viewId: string, sort: SortConfig[]): void;
+    setViewGroup(base: BaseDataModel, tableId: string, viewId: string, group: GroupConfig[]): void;
+    setViewFieldVisible(base: BaseDataModel, tableId: string, viewId: string, fieldId: string, visible: boolean): void;
+    setViewFieldWidth(base: BaseDataModel, tableId: string, viewId: string, fieldId: string, width: number): void;
+    setViewFieldOrder(base: BaseDataModel, tableId: string, viewId: string, fieldId: string, target: {
+        beforeFieldId?: string;
+        afterFieldId?: string;
+    }): void;
+}
+export declare const IBaseCommandService: import("@wendellhu/redi").IdentifierDecorator<IBaseCommandService>;
+export declare class BaseCommandService implements IBaseCommandService {
+    private readonly _permissionService;
+    private readonly _fieldRegistry;
+    private readonly _runtimeContext;
+    private readonly _factory;
+    private readonly _applier;
+    constructor(_permissionService: IBasePermissionService, _fieldRegistry?: BaseFieldRegistryService, _runtimeContext?: IBaseCommandRuntimeContext);
+    createTable(base: BaseDataModel, table: ITableSnapshot, index?: number): void;
+    renameTable(base: BaseDataModel, tableId: string, name: string): void;
+    deleteTable(base: BaseDataModel, tableId: string): void;
+    updateCell(base: BaseDataModel, tableId: string, recordId: string, fieldId: string, value: CellValue): void;
+    setRecordValues(base: BaseDataModel, tableId: string, patches: Array<{
+        recordId: string;
+        values: Record<string, CellValue>;
+    }>): void;
+    createRecord(base: BaseDataModel, tableId: string, record: IRecordSnapshot): void;
+    createUpdateCellOp(base: BaseDataModel, tableId: string, recordId: string, fieldId: string, value: CellValue): JSONXActions;
+    createSetRecordValuesOp(base: BaseDataModel, tableId: string, patches: Array<{
+        recordId: string;
+        values: Record<string, CellValue>;
+    }>): JSONXActions;
+    createCreateRecordOp(base: BaseDataModel, tableId: string, record: IRecordSnapshot): JSONXActions;
+    createBatchCreateRecordsOp(base: BaseDataModel, tableId: string, records: IRecordSnapshot[]): JSONXActions;
+    createCreateFieldOp(base: BaseDataModel, tableId: string, field: IFieldSnapshot, index?: number): JSONXActions;
+    deleteRecord(base: BaseDataModel, tableId: string, recordId: string): void;
+    duplicateRecord(base: BaseDataModel, tableId: string, sourceRecordId: string, record: IRecordSnapshot): void;
+    updateRecordOrder(base: BaseDataModel, tableId: string, recordId: string, orderKey: string): void;
+    createField(base: BaseDataModel, tableId: string, field: IFieldSnapshot, index?: number): void;
+    updateField(base: BaseDataModel, tableId: string, fieldId: string, patch: Partial<IFieldSnapshot>): void;
+    changeFieldType(base: BaseDataModel, tableId: string, fieldId: string, input: Pick<IFieldSnapshot, 'type' | 'config'>): void;
+    deleteField(base: BaseDataModel, tableId: string, fieldId: string): void;
+    moveField(base: BaseDataModel, tableId: string, fieldId: string, target: {
+        beforeFieldId?: string;
+        afterFieldId?: string;
+    }): void;
+    createView(base: BaseDataModel, tableId: string, view: IViewSnapshot, index?: number): void;
+    renameView(base: BaseDataModel, tableId: string, viewId: string, name: string): void;
+    deleteView(base: BaseDataModel, tableId: string, viewId: string): void;
+    moveView(base: BaseDataModel, tableId: string, viewId: string, target: {
+        beforeViewId?: string;
+        afterViewId?: string;
+    }): void;
+    updateViewConfig(base: BaseDataModel, tableId: string, viewId: string, patch: Record<string, unknown>): void;
+    setViewFilter(base: BaseDataModel, tableId: string, viewId: string, filter: FilterConfig | null): void;
+    setViewSort(base: BaseDataModel, tableId: string, viewId: string, sort: SortConfig[]): void;
+    setViewGroup(base: BaseDataModel, tableId: string, viewId: string, group: GroupConfig[]): void;
+    setViewFieldVisible(base: BaseDataModel, tableId: string, viewId: string, fieldId: string, visible: boolean): void;
+    setViewFieldWidth(base: BaseDataModel, tableId: string, viewId: string, fieldId: string, width: number): void;
+    setViewFieldOrder(base: BaseDataModel, tableId: string, viewId: string, fieldId: string, target: {
+        beforeFieldId?: string;
+        afterFieldId?: string;
+    }): void;
+    private _apply;
+    private _createRecordWithDefaults;
+    private _withModifiedSystemValues;
+    private _createSystemFieldValuePatches;
+    private _getSystemFieldValue;
+    private _nextNumberingValue;
+    private _getCurrentUserId;
+    private _normalizeCellValue;
+}
+export type BaseCommandRuntimeContext = IBaseCommandRuntimeContext;

package/lib/types/services/base-compression.service.d.ts

@@ -0,0 +1,46 @@
+import type { BaseCellValue as CellValue, IBaseCellData, IBaseSnapshot, ITableSnapshot } from '@univerjs/core';
+export interface IBaseRangeValuesPayload {
+    unitId: string;
+    tableId: string;
+    patches: Array<{
+        row: number;
+        col: number;
+        value: CellValue | IBaseCellData | null;
+    }>;
+    trigger?: string;
+}
+export interface ICompressedBaseRangeValuesPayload {
+    compress: true;
+    kind: 'base-range-values-v1';
+    u: string;
+    t: string;
+    p: Array<[number, number, CompressedBaseRangeValue]>;
+}
+export interface ICompressedBaseCellData {
+    c: 1;
+    v?: IBaseCellData['v'];
+    t?: IBaseCellData['t'];
+    f?: IBaseCellData['f'];
+    si?: IBaseCellData['si'];
+    p?: IBaseCellData['p'];
+}
+export type CompressedBaseRangeValue = CellValue | ICompressedBaseCellData | null;
+export interface ICompressedBaseTableSnapshot extends Omit<ITableSnapshot, 'cellData'> {
+    cd?: Array<[number, number, ICompressedBaseCellData]>;
+}
+export interface ICompressedBaseSnapshot extends Omit<IBaseSnapshot, 'tables'> {
+    compress: true;
+    kind: 'base-snapshot-v1';
+    tables: Record<string, ICompressedBaseTableSnapshot>;
+}
+export declare function compressBaseRangeValuesPayload(payload: IBaseRangeValuesPayload): ICompressedBaseRangeValuesPayload;
+export declare function decompressBaseRangeValuesPayload(payload: ICompressedBaseRangeValuesPayload | IBaseRangeValuesPayload): IBaseRangeValuesPayload;
+export declare function isCompressedBaseRangeValuesPayload(payload: unknown): payload is ICompressedBaseRangeValuesPayload;
+export declare function compressBaseSnapshot(snapshot: IBaseSnapshot): ICompressedBaseSnapshot;
+export declare function decompressBaseSnapshot(snapshot: IBaseSnapshot | ICompressedBaseSnapshot): IBaseSnapshot;
+export declare function isCompressedBaseSnapshot(snapshot: unknown): snapshot is ICompressedBaseSnapshot;
+export type BaseRangeValuesPayload = IBaseRangeValuesPayload;
+export type CompressedBaseRangeValuesPayload = ICompressedBaseRangeValuesPayload;
+export type CompressedBaseCellData = ICompressedBaseCellData;
+export type CompressedBaseTableSnapshot = ICompressedBaseTableSnapshot;
+export type CompressedBaseSnapshot = ICompressedBaseSnapshot;

package/lib/types/services/base-field-registry.service.d.ts

@@ -0,0 +1,17 @@
+import type { FieldType } from '@univerjs/core';
+import type { IFieldCorePlugin, IFieldTypePlugin } from '../fields/field-core-plugin';
+import { Disposable, toDisposable } from '@univerjs/core';
+export interface IBaseFieldRegistryService {
+    register(plugin: IFieldCorePlugin): ReturnType<typeof toDisposable>;
+    get(type: FieldType): IFieldCorePlugin;
+    getTypePlugin(type: FieldType): IFieldTypePlugin | undefined;
+    getAll(): IFieldCorePlugin[];
+}
+export declare const IBaseFieldRegistryService: import("@wendellhu/redi").IdentifierDecorator<IBaseFieldRegistryService>;
+export declare class BaseFieldRegistryService extends Disposable implements IBaseFieldRegistryService {
+    private readonly _plugins;
+    register(plugin: IFieldCorePlugin): import("@wendellhu/redi").IDisposable;
+    get(type: FieldType): IFieldCorePlugin;
+    getTypePlugin(type: FieldType): IFieldTypePlugin | undefined;
+    getAll(): IFieldCorePlugin[];
+}

package/lib/types/services/base-formula.service.d.ts

@@ -0,0 +1,71 @@
+import type { IBaseCellData, IBaseSnapshot, ITableSnapshot } from '@univerjs/core';
+import { ObjectMatrix } from '@univerjs/core';
+export interface IBaseFormulaValidationResult {
+    valid: boolean;
+    reason?: string;
+}
+export interface IBaseFormulaDependency {
+    tableId: string;
+    fieldId: string;
+}
+export interface IBaseFormulaContext {
+    snapshot?: IBaseSnapshot;
+}
+export interface IBaseFormulaSuperTableReference {
+    sheetId: string;
+    titleMap: Map<string, number>;
+    range: {
+        startRow: number;
+        endRow: number;
+        startColumn: number;
+        endColumn: number;
+    };
+}
+export interface IBaseFormulaSuperTableServiceLike {
+    registerTable(unitId: string, tableName: string, reference: IBaseFormulaSuperTableReference): void;
+    remove?(unitId: string, tableName: string): void;
+}
+export interface IBaseFormulaCalculationDataset {
+    formulaData: Record<string, Record<string, Record<number, Record<number, {
+        f: string;
+        si?: string;
+    }>>>>;
+    allUnitData: Record<string, Record<string, {
+        cellData: ObjectMatrix<IBaseCellData | null>;
+        rowCount: number;
+        columnCount: number;
+        rowData: Record<number, unknown>;
+        columnData: Record<number, unknown>;
+    }>>;
+    unitStylesData: Record<string, Record<string, unknown>>;
+    unitSheetNameMap: Record<string, Record<string, string>>;
+}
+export interface IBaseFormulaCalculationResult {
+    unitData?: Record<string, Record<string, Record<number, Record<number, IBaseCellData | null>> | null> | null>;
+    unitOtherData?: unknown;
+}
+export interface IBaseFormulaResultPatchGroup {
+    unitId: string;
+    tableId: string;
+    patches: Array<{
+        row: number;
+        col: number;
+        value: IBaseCellData | null;
+    }>;
+}
+export declare class BaseFormulaService {
+    createSuperTableReference(table: ITableSnapshot, sheetId?: string): IBaseFormulaSuperTableReference;
+    registerSuperTable(superTableService: IBaseFormulaSuperTableServiceLike, unitId: string, table: ITableSnapshot, options?: {
+        tableName?: string;
+        sheetId?: string;
+    }): IBaseFormulaSuperTableReference;
+    registerSuperTables(superTableService: IBaseFormulaSuperTableServiceLike, snapshot: IBaseSnapshot): IBaseFormulaSuperTableReference[];
+    validateFormula(formula: string, table: ITableSnapshot, context?: IBaseFormulaContext): IBaseFormulaValidationResult;
+    getDependencies(formula: string, table: ITableSnapshot, context?: IBaseFormulaContext): string[];
+    getStructuredDependencies(formula: string, table: ITableSnapshot, context?: IBaseFormulaContext): IBaseFormulaDependency[];
+}
+export declare function createBaseFormulaCalculationDataset(snapshot: IBaseSnapshot): IBaseFormulaCalculationDataset;
+export declare function createBaseFormulaResultPatches(snapshot: IBaseSnapshot, result: IBaseFormulaCalculationResult): IBaseFormulaResultPatchGroup[];
+export type BaseFormulaValidationResult = IBaseFormulaValidationResult;
+export type BaseFormulaSuperTableReference = IBaseFormulaSuperTableReference;
+export type BaseFormulaSuperTableServiceLike = IBaseFormulaSuperTableServiceLike;

package/lib/types/services/base-performance.service.d.ts

@@ -0,0 +1,5 @@
+export type BasePerformanceDetails = Record<string, unknown>;
+export declare function isBasePerformanceTracingEnabled(): boolean;
+export declare function traceBasePerformance<T>(label: string, fn: () => T, details?: BasePerformanceDetails): T;
+export declare function traceBasePerformanceAsync<T>(label: string, fn: () => Promise<T>, details?: BasePerformanceDetails): Promise<T>;
+export declare function logBasePerformance(label: string, duration: number, details?: BasePerformanceDetails): void;