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

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

@@ -0,0 +1,769 @@
+import type { BaseCellValue, BaseDataModel, ICommandService, IFieldSnapshot, ITableSnapshot, IViewSnapshot, SortConfig, ViewType } from '@univerjs/core';
+import type { IBasePermissionService } from '../services/base-permission.service';
+import type { IBaseProjectionService } from '../services/base-projection.service';
+import { FField } from './f-field';
+import { FTablePermission } from './f-permission';
+import { FBaseRange } from './f-range';
+import { FRecord } from './f-record';
+import { FView } from './f-view';
+export interface IAddFieldInput {
+    /** Field display name. */
+    name: string;
+    /** Field type, such as `text`, `number`, `singleSelect`, or `formula`. */
+    type: IFieldSnapshot['type'];
+    /** Field type configuration. Formula fields use `config.formula`. */
+    config?: IFieldSnapshot['config'];
+    /** Default value applied to new records when supported by the field type. */
+    defaultValue?: IFieldSnapshot['defaultValue'];
+    /** Optional field description. */
+    description?: string;
+    /** Optional field id. A random id is generated when omitted. */
+    id?: string;
+    /** Optional insertion index in the table field order. */
+    index?: number;
+    /** Whether this field should be readonly. Formula fields are usually readonly. */
+    readonly?: boolean;
+}
+export interface IAddRecordInput {
+    /** Optional record id. A random id is generated when omitted. */
+    id?: string;
+    /** Initial field-id keyed values. */
+    values?: Record<string, BaseCellValue>;
+    /** Optional order key used to position the record. */
+    orderKey?: string;
+    /** Optional creation timestamp. */
+    createdAt?: number;
+    /** Optional update timestamp. */
+    updatedAt?: number;
+    /** Optional creator user id. */
+    createdBy?: string;
+    /** Optional updater user id. */
+    updatedBy?: string;
+}
+export interface ICreateViewInput {
+    /** Optional view id. A random id is generated when omitted. */
+    id?: string;
+    /** View display name. */
+    name: string;
+    /** View type, such as `grid`, `kanban`, `calendar`, `gantt`, or `gallery`. */
+    type: ViewType;
+    /** View-specific configuration. */
+    config?: IViewSnapshot['config'];
+    /** Optional insertion index in the table view order. */
+    index?: number;
+}
+export interface IListRecordOptions {
+    /** Optional view id. When provided, records are returned in the view projection order. */
+    viewId?: string;
+    /** Optional field filter. */
+    filter?: IBaseRecordFilter;
+    /** Optional sort rules applied after view ordering. */
+    sort?: SortConfig[];
+    /** Optional zero-based offset. */
+    offset?: number;
+    /** Optional maximum number of records to return. */
+    limit?: number;
+}
+export interface IBaseRecordFilter {
+    fieldId?: string;
+    operator?: 'is' | 'isNot' | 'contains' | 'doesNotContain' | 'isEmpty' | 'isNotEmpty' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual';
+    value?: BaseCellValue;
+    conjunction?: 'and' | 'or';
+    conditions?: IBaseRecordFilter[];
+}
+export interface IQueryRecordsResult {
+    records: FRecord[];
+    total: number;
+    offset: number;
+    limit: number | null;
+    hasMore: boolean;
+}
+export interface IBaseTableSchemaSnapshot {
+    id: string;
+    name: string;
+    primaryFieldId: string;
+    fieldIds: string[];
+    viewIds: string[];
+    recordCount: number;
+    fields: Array<Pick<IFieldSnapshot, 'id' | 'name' | 'type' | 'config' | 'readonly' | 'description'>>;
+    views: Array<Pick<IViewSnapshot, 'id' | 'name' | 'type'>>;
+}
+/**
+ * Facade API object bound to a Base table.
+ *
+ * A Base table is similar to a worksheet: fields are columns, records are rows,
+ * and ranges address rectangular record-field regions.
+ *
+ * Use table methods for field, record, cell, range, view, schema, and table
+ * permission operations. The table facade always resolves the latest table
+ * snapshot from the Base model, so a previously created `FTable` remains usable
+ * after other facade commands mutate the table.
+ *
+ * @example Create fields, records, a view, and a query
+ * ```ts
+ * const table = await base.createTable({ id: 'tasks', name: 'Tasks', primaryFieldName: 'Title' });
+ * const status = await table.addField({
+ *   id: 'status',
+ *   name: 'Status',
+ *   type: 'singleSelect',
+ *   config: { options: [{ id: 'todo', name: 'Todo', color: 'blue' }, { id: 'done', name: 'Done', color: 'green' }] },
+ * });
+ * const progress = await table.addField({ id: 'progress', name: 'Progress', type: 'progress', config: {} });
+ * await table.addRecords([
+ *   { id: 'task-1', values: { [table.getPrimaryFieldId()]: 'Design protocol', [status.getId()]: 'todo', [progress.getId()]: 20 } },
+ *   { id: 'task-2', values: { [table.getPrimaryFieldId()]: 'Wire server load', [status.getId()]: 'done', [progress.getId()]: 100 } },
+ * ]);
+ * const grid = await table.createView({ id: 'grid-main', name: 'Main Grid', type: 'grid' });
+ * await grid.setSort([{ fieldId: progress.getId(), direction: 'desc' }]);
+ * const done = table.queryRecords({ filter: { fieldId: status.getId(), operator: 'is', value: 'done' } });
+ * ```
+ */
+export declare class FTable {
+    private readonly _base;
+    private readonly _tableId;
+    private readonly _commandService;
+    private readonly _projectionService;
+    private readonly _permissionService;
+    constructor(_base: BaseDataModel, _tableId: string, _commandService: ICommandService, _projectionService: IBaseProjectionService, _permissionService: IBasePermissionService);
+    /**
+     * Get the underlying Base data model.
+     * @returns The Base data model.
+     * @example
+     * ```ts
+     * const baseModel = table.getBase();
+     * ```
+     */
+    getBase(): BaseDataModel;
+    /**
+     * Get the table snapshot.
+     * @returns The table snapshot.
+     * @example
+     * ```ts
+     * const rawTable = table.getTable();
+     * ```
+     */
+    getTable(): ITableSnapshot;
+    /**
+     * Get the table snapshot.
+     * @returns The table snapshot.
+     * @example
+     * ```ts
+     * const snapshot = table.getSnapshot();
+     * ```
+     */
+    getSnapshot(): ITableSnapshot;
+    /**
+     * Get the table id.
+     * @returns The table id.
+     * @example
+     * ```ts
+     * console.log(table.getId());
+     * ```
+     */
+    getId(): string;
+    /**
+     * Get the table name.
+     * @returns The table name.
+     * @example
+     * ```ts
+     * console.log(table.getName());
+     * ```
+     */
+    getName(): string;
+    /**
+     * Get the primary field id.
+     * @returns The primary field id.
+     * @example
+     * ```ts
+     * const primaryFieldId = table.getPrimaryFieldId();
+     * ```
+     */
+    getPrimaryFieldId(): string;
+    /**
+     * Rename this table.
+     * @param name The new table name.
+     * @example
+     * ```ts
+     * await table.setName('Roadmap');
+     * ```
+     */
+    setName(name: string): Promise<void>;
+    /**
+     * Get all non-deleted fields in this table.
+     * @returns Field facades ordered by the table field order.
+     * @example
+     * ```ts
+     * const fields = table.getFields();
+     * fields.forEach((field) => console.log(field.getName()));
+     * ```
+     */
+    getFields(): FField[];
+    /**
+     * List all non-deleted fields in this table.
+     * @returns Field facades ordered by the table field order.
+     * @example
+     * ```ts
+     * const fields = table.listFields();
+     * ```
+     */
+    listFields(): FField[];
+    /**
+     * Get a field by id.
+     * @param fieldId The field id.
+     * @returns The field facade, or null if the field does not exist.
+     * @example
+     * ```ts
+     * const field = table.getField('status');
+     * ```
+     */
+    getField(fieldId: string): FField | null;
+    /**
+     * Get a field by id.
+     * @param fieldId The field id.
+     * @returns The field facade, or null if the field does not exist.
+     * @example
+     * ```ts
+     * const field = table.getFieldById('status');
+     * ```
+     */
+    getFieldById(fieldId: string): FField | null;
+    /**
+     * Get the first field matching a field name.
+     * @param name The field name.
+     * @returns The field facade, or null if no field matches.
+     * @example
+     * ```ts
+     * const field = table.getFieldByName('Status');
+     * ```
+     */
+    getFieldByName(name: string): FField | null;
+    /**
+     * Get the primary field.
+     * @returns The primary field facade.
+     * @example
+     * ```ts
+     * const titleField = table.getPrimaryField();
+     * ```
+     */
+    getPrimaryField(): FField;
+    /**
+     * Add a field to this table.
+     *
+     * Field type belongs to the field snapshot, not to each cell. Cell payloads
+     * may carry typed metadata for compact storage, but formula calculation and
+     * value interpretation should read the field definition from the table.
+     *
+     * @param input Field creation options. `name` and `type` are required.
+     * `config` is type-specific and is where options, attachment settings,
+     * formula expressions, number/date formatting, and view-specific field
+     * metadata should live. `defaultValue` is applied by callers when creating
+     * records. `readonly` is appropriate for calculated fields.
+     * @returns The created field facade.
+     * @example
+     * ```ts
+     * const status = await table.addField({
+     *   id: 'status',
+     *   name: 'Status',
+     *   type: 'singleSelect',
+     *   config: {
+     *     options: [
+     *       { id: 'todo', name: 'Todo', color: 'blue' },
+     *       { id: 'done', name: 'Done', color: 'green' },
+     *     ],
+     *   },
+     * });
+     * ```
+     * @example Formula field
+     * ```ts
+     * const amount = await table.addField({ id: 'amount', name: 'Amount', type: 'number', config: { decimalPlaces: 2 } });
+     * const tax = await table.addField({ id: 'tax', name: 'Tax', type: 'number', config: { decimalPlaces: 2 } });
+     * const total = await table.addField({
+     *   id: 'total',
+     *   name: 'Total',
+     *   type: 'formula',
+     *   readonly: true,
+     *   config: { formula: '=SUM(table[Amount], table[Tax])' },
+     * });
+     * ```
+     * @example
+     * ```ts
+     * const total = await table.addField({
+     *   id: 'total',
+     *   name: 'Total',
+     *   type: 'formula',
+     *   readonly: true,
+     *   config: {
+     *     formula: '=SUM(table[Progress], Pricing[Amount])',
+     *     numberFormat: { type: 'currency', pattern: '"$"#,##0.00' },
+     *   },
+     * });
+     * ```
+     */
+    addField(input: IAddFieldInput): Promise<FField>;
+    /**
+     * Create a field in this table.
+     * @param input Field creation options.
+     * @returns The created field facade.
+     * @example
+     * ```ts
+     * const numberField = await table.createField({
+     *   name: 'Cost',
+     *   type: 'number',
+     *   config: { decimalPlaces: 2 },
+     * });
+     * ```
+     */
+    createField(input: IAddFieldInput): Promise<FField>;
+    /**
+     * Update a field by id.
+     * @param fieldId The field id.
+     * @param patch Partial field snapshot to merge into the field.
+     * @example
+     * ```ts
+     * await table.updateField('total', {
+     *   config: { formula: '=SUM(table[Amount], table[Tax])' },
+     * });
+     * ```
+     */
+    updateField(fieldId: string, patch: Partial<IFieldSnapshot>): Promise<void>;
+    /**
+     * Change a field type.
+     * @param fieldId The field id.
+     * @param input The target type and config.
+     * @example
+     * ```ts
+     * await table.changeFieldType('score', { type: 'number', config: { decimalPlaces: 0 } });
+     * ```
+     */
+    changeFieldType(fieldId: string, input: Pick<IFieldSnapshot, 'type' | 'config'>): Promise<void>;
+    /**
+     * Delete a field by id.
+     * @param fieldId The field id.
+     * @example
+     * ```ts
+     * await table.deleteField('deprecated');
+     * ```
+     */
+    deleteField(fieldId: string): Promise<void>;
+    /**
+     * Move a field relative to another field.
+     * @param fieldId The field id.
+     * @param target Target position descriptor.
+     * @param target.beforeFieldId Optional field id to move this field before.
+     * @param target.afterFieldId Optional field id to move this field after.
+     * @example
+     * ```ts
+     * await table.moveField('status', { afterFieldId: 'title' });
+     * ```
+     */
+    moveField(fieldId: string, target: {
+        beforeFieldId?: string;
+        afterFieldId?: string;
+    }): Promise<void>;
+    /**
+     * Get a record by id.
+     * @param recordId The record id.
+     * @returns The record facade, or null if the record does not exist.
+     * @example
+     * ```ts
+     * const record = table.getRecord('record-1');
+     * ```
+     */
+    getRecord(recordId: string): FRecord | null;
+    /**
+     * Get a record by id.
+     * @param recordId The record id.
+     * @returns The record facade, or null if the record does not exist.
+     * @example
+     * ```ts
+     * const record = table.getRecordById('record-1');
+     * ```
+     */
+    getRecordById(recordId: string): FRecord | null;
+    /**
+     * Get records in this table.
+     *
+     * Records are returned in table order by default. Passing `viewId` first
+     * projects the records through the view, then optional filter, sort,
+     * offset, and limit are applied.
+     *
+     * @param options Optional list options. `viewId` selects a view projection.
+     * `filter` supports simple and nested conditions. `sort` applies field-id
+     * keyed sort rules. `offset` and `limit` page the returned facade objects.
+     * @returns Record facades.
+     * @example
+     * ```ts
+     * const records = table.getRecords();
+     * const visibleRecords = table.getRecords({ viewId: 'grid' });
+     * ```
+     */
+    getRecords(options?: IListRecordOptions): FRecord[];
+    /**
+     * Query records with filter, sort, and pagination metadata.
+     *
+     * Prefer this over `getRecords()` when an API response needs `total`,
+     * `offset`, `limit`, or `hasMore`.
+     *
+     * @param options Query options. `filter` uses field ids and operators such
+     * as `is`, `contains`, `isEmpty`, and numeric comparisons. `sort` is applied
+     * after filtering. `offset` is zero-based and `limit` is nullable.
+     * @returns Records and pagination metadata.
+     * @example
+     * ```ts
+     * const page = table.queryRecords({
+     *   filter: { fieldId: 'status', operator: 'is', value: 'done' },
+     *   sort: [{ fieldId: 'progress', direction: 'desc' }],
+     *   limit: 20,
+     * });
+     * ```
+     */
+    queryRecords(options?: IListRecordOptions): IQueryRecordsResult;
+    private _resolveRecordIds;
+    /**
+     * List records in this table.
+     * @param options Optional list options. Use `viewId` to return records in view projection order.
+     * @returns Record facades.
+     * @example
+     * ```ts
+     * const records = table.listRecords({ viewId: 'grid' });
+     * ```
+     */
+    listRecords(options?: IListRecordOptions): FRecord[];
+    /**
+     * Add a record to this table.
+     *
+     * Values are keyed by field id, not by field name. Use
+     * `table.getPrimaryFieldId()` or field facade ids to avoid name collisions
+     * and localization issues.
+     *
+     * @param input Record creation options. `id` is optional and should be
+     * supplied when the server owns ids. `values` is a field-id keyed map.
+     * `orderKey` controls row order and the command keeps the table
+     * `recordOrder` in sync. `createdAt`, `updatedAt`, `createdBy`, and
+     * `updatedBy` are optional metadata.
+     * @returns The created record facade.
+     * @example
+     * ```ts
+     * const record = await table.addRecord({
+     *   id: 'record-1',
+     *   values: { title: 'Ship beta', status: 'todo' },
+     * });
+     * ```
+     * @example Using field ids from facades
+     * ```ts
+     * const record = await table.addRecord({
+     *   id: 'task-1',
+     *   values: {
+     *     [table.getPrimaryFieldId()]: 'Ship Base adapter',
+     *     [statusField.getId()]: 'todo',
+     *   },
+     * });
+     * ```
+     */
+    addRecord(input?: IAddRecordInput): Promise<FRecord>;
+    /**
+     * Create a record in this table.
+     * @param input Record creation options.
+     * @returns The created record facade.
+     * @example
+     * ```ts
+     * const record = await table.createRecord({ values: { title: 'New task' } });
+     * ```
+     */
+    createRecord(input?: IAddRecordInput): Promise<FRecord>;
+    /**
+     * Add multiple records to this table.
+     *
+     * This executes one batch command, so undo/redo, collaboration,
+     * `recordOrder`, and events see a single multi-record operation.
+     *
+     * @param inputs Record creation options. Each input has the same shape as
+     * `addRecord()`. Empty arrays are ignored and return `[]`.
+     * @returns Created record facades.
+     * @example
+     * ```ts
+     * const records = await table.addRecords([
+     *   { values: { title: 'Task A' } },
+     *   { values: { title: 'Task B' } },
+     * ]);
+     * ```
+     */
+    addRecords(inputs: IAddRecordInput[]): Promise<FRecord[]>;
+    /**
+     * Set values for multiple records.
+     *
+     * This is the preferred API for server-side or agent-side bulk updates
+     * where each record may update different fields.
+     *
+     * @param patches Record value patches. `recordId` identifies the target row
+     * and `values` is a field-id keyed partial value map.
+     * @example
+     * ```ts
+     * await table.setRecordValues([
+     *   { recordId: 'record-1', values: { status: 'done' } },
+     *   { recordId: 'record-2', values: { status: 'todo' } },
+     * ]);
+     * ```
+     */
+    setRecordValues(patches: Array<{
+        recordId: string;
+        values: Record<string, BaseCellValue>;
+    }>): Promise<void>;
+    /**
+     * Update one record by id.
+     * @param recordId The record id.
+     * @param values Field-id keyed values to write.
+     * @example
+     * ```ts
+     * await table.updateRecord('record-1', { title: 'Updated task', status: 'done' });
+     * ```
+     */
+    updateRecord(recordId: string, values: Record<string, BaseCellValue>): Promise<void>;
+    /**
+     * Delete a record by id.
+     * @param recordId The record id.
+     * @example
+     * ```ts
+     * await table.deleteRecord('record-1');
+     * ```
+     */
+    deleteRecord(recordId: string): Promise<void>;
+    /**
+     * Delete multiple records as one undoable command.
+     * @param recordIds Record ids to delete.
+     * @example
+     * ```ts
+     * await table.deleteRecords(['record-1', 'record-2']);
+     * ```
+     */
+    deleteRecords(recordIds: string[]): Promise<void>;
+    /**
+     * Duplicate a record by id.
+     * @param recordId The source record id.
+     * The duplicated record starts with the source record values, then applies
+     * `input.values` as field-id keyed overrides.
+     *
+     * @param input Optional record id, values, and metadata overrides.
+     * @param input.id Optional id for the duplicated record.
+     * @param input.values Optional field-id keyed values for the duplicated record.
+     * @param input.orderKey Optional order key for the duplicated record.
+     * @param input.createdAt Optional creation timestamp override.
+     * @param input.updatedAt Optional update timestamp override.
+     * @param input.createdBy Optional creator user id override.
+     * @param input.updatedBy Optional updater user id override.
+     * @returns The duplicated record facade.
+     * @example
+     * ```ts
+     * const copy = await table.duplicateRecord('record-1', {
+     *   values: { title: 'Copied task' },
+     * });
+     * ```
+     */
+    duplicateRecord(recordId: string, input?: IAddRecordInput): Promise<FRecord>;
+    /**
+     * Update one cell value.
+     * @param recordId The record id.
+     * @param fieldId The field id.
+     * @param value The new cell value.
+     * @example
+     * ```ts
+     * await table.updateCell('record-1', 'status', 'done');
+     * ```
+     */
+    updateCell(recordId: string, fieldId: string, value: BaseCellValue): Promise<void>;
+    /**
+     * Set one cell value.
+     * @param recordId The record id.
+     * @param fieldId The field id.
+     * @param value The new cell value.
+     * @example
+     * ```ts
+     * await table.setCellValue('record-1', 'status', 'done');
+     * ```
+     */
+    setCellValue(recordId: string, fieldId: string, value: BaseCellValue): Promise<void>;
+    /**
+     * Get one cell value.
+     * @param recordId The record id.
+     * @param fieldId The field id.
+     * @returns The cell value, or null when empty.
+     * @example
+     * ```ts
+     * const value = table.getCellValue('record-1', 'status');
+     * ```
+     */
+    getCellValue(recordId: string, fieldId: string): BaseCellValue;
+    /**
+     * Update a record order key.
+     * @param recordId The record id.
+     * @param target The target order key.
+     * @param target.orderKey Optional replacement order key. Existing order key
+     * is kept when omitted.
+     * @example
+     * ```ts
+     * await table.updateRecordOrder('record-1', { orderKey: 'a1' });
+     * ```
+     */
+    updateRecordOrder(recordId: string, target: {
+        orderKey?: string;
+    }): Promise<void>;
+    /**
+     * Get a rectangular range by row and column indexes.
+     *
+     * Range indexes use the table's current `recordOrder` and `fieldOrder`.
+     * This mirrors Sheet-style row/column addressing while still writing Base
+     * record/field values under the hood.
+     *
+     * @param row The zero-based start row index.
+     * @param column The zero-based start column index.
+     * @param numRows Number of rows. Defaults to `1`.
+     * @param numColumns Number of columns. Defaults to `1`.
+     * @returns A Base range facade.
+     * @example
+     * ```ts
+     * const range = table.getRange(0, 0, 2, 3);
+     * const values = range.getValues();
+     * ```
+     * @example Write a 2 by 2 block
+     * ```ts
+     * await table.getRange(0, 0, 2, 2).setValues([
+     *   ['Task A', 'todo'],
+     *   ['Task B', 'done'],
+     * ]);
+     * ```
+     */
+    getRange(row: number, column: number, numRows?: number, numColumns?: number): FBaseRange;
+    /**
+     * Get a range that covers the current table data area.
+     * @returns The data range facade.
+     * @example
+     * ```ts
+     * const values = table.getDataRange().getValues();
+     * ```
+     */
+    getDataRange(): FBaseRange;
+    /**
+     * Get all non-deleted views in this table.
+     * @returns View facades ordered by the table view order.
+     * @example
+     * ```ts
+     * const views = table.getViews();
+     * ```
+     */
+    getViews(): FView[];
+    /**
+     * List all non-deleted views in this table.
+     * @returns View facades ordered by the table view order.
+     * @example
+     * ```ts
+     * const views = table.listViews();
+     * ```
+     */
+    listViews(): FView[];
+    /**
+     * Get a view by id.
+     * @param viewId The view id.
+     * @returns The view facade, or null if the view does not exist.
+     * @example
+     * ```ts
+     * const view = table.getView('grid');
+     * ```
+     */
+    getView(viewId: string): FView | null;
+    /**
+     * Get a view by id.
+     * @param viewId The view id.
+     * @returns The view facade, or null if the view does not exist.
+     * @example
+     * ```ts
+     * const view = table.getViewById('grid');
+     * ```
+     */
+    getViewById(viewId: string): FView | null;
+    /**
+     * Get the first view matching a view name.
+     * @param name The view name.
+     * @returns The view facade, or null if no view matches.
+     * @example
+     * ```ts
+     * const view = table.getViewByName('Grid');
+     * ```
+     */
+    getViewByName(name: string): FView | null;
+    /**
+     * Create a view in this table.
+     *
+     * The view starts with the table's current field order and empty field
+     * settings. Configure filters, sort, grouping, field visibility, and field
+     * widths through the returned `FView`.
+     *
+     * @param input View creation options. `name` and `type` are required.
+     * `config` is view-type specific, for example grid frozen fields, calendar
+     * date fields, or gantt start/end/progress fields. `index` controls view
+     * order.
+     * @returns The created view facade.
+     * @example
+     * ```ts
+     * const view = await table.createView({
+     *   id: 'grid-api',
+     *   name: 'API Grid',
+     *   type: 'grid',
+     *   config: { frozenFieldCount: 1 },
+     * });
+     * ```
+     * @example Calendar and gantt views
+     * ```ts
+     * const calendar = await table.createView({
+     *   id: 'calendar-main',
+     *   name: 'Calendar',
+     *   type: 'calendar',
+     *   config: { startFieldId: 'start', endFieldId: 'end' },
+     * });
+     * const gantt = await table.createView({
+     *   id: 'gantt-main',
+     *   name: 'Gantt',
+     *   type: 'gantt',
+     *   config: { startFieldId: 'start', endFieldId: 'end', progressFieldId: 'progress' },
+     * });
+     * ```
+     */
+    createView(input: ICreateViewInput): Promise<FView>;
+    /**
+     * Delete a view by id.
+     * @param viewId The view id.
+     * @example
+     * ```ts
+     * await table.deleteView('grid-api');
+     * ```
+     */
+    deleteView(viewId: string): Promise<void>;
+    /**
+     * Get a compact schema snapshot for this table.
+     * @returns Table schema without row values.
+     * @example
+     * ```ts
+     * console.log(table.getSchema().fields.map((field) => field.name));
+     * ```
+     */
+    getSchema(): IBaseTableSchemaSnapshot;
+    /**
+     * Get the table permission facade.
+     * @returns Table permission facade.
+     * @example
+     * ```ts
+     * table.getPermission().setPermission({ createRecord: false });
+     * ```
+     */
+    getPermission(): FTablePermission;
+    private _getTable;
+    private _wrapField;
+    private _wrapRecord;
+    private _wrapView;
+}
+export type AddFieldInput = IAddFieldInput;
+export type AddRecordInput = IAddRecordInput;
+export type CreateViewInput = ICreateViewInput;
+export type ListRecordOptions = IListRecordOptions;
+export type BaseRecordFilter = IBaseRecordFilter;
+export type QueryRecordsResult = IQueryRecordsResult;
+export type BaseTableSchemaSnapshot = IBaseTableSchemaSnapshot;