@xnetjs/data 0.0.2 → 0.1.0

package/dist/clone-C0Jhk2UN.d.ts

@@ -0,0 +1,2205 @@
+import { ao as NodeQueryMaterializedViewOptions, h as NodeState, B as PropertyType, S as SchemaIRI, a as Schema } from './types-S-BJAKyK.js';
+import { N as NodeStore } from './store-DtIDjk7c.js';
+import { c as ColumnDefinition, C as ColumnType, d as ColumnConfig, f as SelectColor, i as isNodeStoreColumnType, h as isComputedColumnType, j as isAutoColumnType, k as isYDocColumnType, V as ViewType, m as FilterGroup, p as SortConfig, l as ViewConfig, o as FilterOperator, g as RollupAggregation, a as RollupColumnConfig } from './view-types-DSde-uT_.js';
+import * as Y from 'yjs';
+
+/**
+ * Cell value types for database rows.
+ *
+ * Cell values are stored as dynamic properties on DatabaseRow nodes,
+ * keyed by column ID with a `cell_` prefix to avoid collisions with
+ * schema-defined properties.
+ */
+/**
+ * Reference to a file stored in the system.
+ * Same shape as the blob-layer FileRef (schema/properties/file.ts):
+ * content-addressed, resolved to URLs through the BlobService.
+ */
+interface FileRef {
+    /** Content-addressed ID (CID) of the file */
+    cid: string;
+    /** Original file name */
+    name: string;
+    /** MIME type */
+    mimeType: string;
+    /** File size in bytes */
+    size: number;
+}
+/**
+ * A date range with start and end dates.
+ */
+interface DateRange {
+    /** Start date (ISO 8601 string) */
+    start: string;
+    /** End date (ISO 8601 string) */
+    end: string;
+}
+/**
+ * All possible cell value types.
+ *
+ * - string: text, url, email, phone, select (option ID), person (DID)
+ * - number: number
+ * - boolean: checkbox
+ * - string (ISO 8601): date
+ * - DateRange: dateRange
+ * - string[]: multiSelect (option IDs), relation (row IDs)
+ * - FileRef: file
+ * - null: empty cell
+ */
+type CellValue = string | number | boolean | DateRange | string[] | FileRef | null;
+/**
+ * Prefix for cell value property keys.
+ * This prevents collisions with schema-defined properties like 'database' and 'sortKey'.
+ */
+declare const CELL_PREFIX = "cell_";
+/**
+ * Convert a column ID to a cell property key.
+ *
+ * @example
+ * cellKey('name') // 'cell_name'
+ * cellKey('status') // 'cell_status'
+ */
+declare function cellKey(columnId: string): string;
+/**
+ * Check if a property key is a cell value key.
+ *
+ * @example
+ * isCellKey('cell_name') // true
+ * isCellKey('database') // false
+ */
+declare function isCellKey(key: string): boolean;
+/**
+ * Extract the column ID from a cell property key.
+ *
+ * @example
+ * columnIdFromKey('cell_name') // 'name'
+ * columnIdFromKey('cell_status') // 'status'
+ */
+declare function columnIdFromKey(key: string): string;
+/**
+ * Convert a record of column ID -> value to cell key -> value.
+ *
+ * @example
+ * toCellProperties({ name: 'John', age: 30 })
+ * // { cell_name: 'John', cell_age: 30 }
+ */
+declare function toCellProperties(cells: Record<string, CellValue>): Record<string, CellValue>;
+/**
+ * Extract cell values from a node's properties, converting cell keys back to column IDs.
+ *
+ * @example
+ * fromCellProperties({ cell_name: 'John', cell_age: 30, database: 'db1' })
+ * // { name: 'John', age: 30 }
+ */
+declare function fromCellProperties(properties: Record<string, unknown>): Record<string, CellValue>;
+/**
+ * Check if a value is a valid DateRange.
+ */
+declare function isDateRange(value: unknown): value is DateRange;
+/**
+ * Check if a value is a valid FileRef.
+ */
+declare function isFileRef(value: unknown): value is FileRef;
+/**
+ * Check if a value is a valid CellValue.
+ */
+declare function isCellValue(value: unknown): value is CellValue;
+
+/**
+ * Row CRUD operations for database rows.
+ *
+ * These functions provide a high-level API for creating, updating,
+ * and querying database rows. They handle:
+ * - Cell value storage with column ID prefixes
+ * - Sort key generation for row ordering
+ * - Database row count maintenance
+ */
+
+/**
+ * Options for creating a new row.
+ */
+interface CreateRowOptions {
+    /** Parent database ID */
+    databaseId: string;
+    /** Initial cell values (columnId -> value) */
+    cells?: Record<string, CellValue>;
+    /**
+     * Insert position: before this row's sortKey.
+     * If neither before nor after is specified, appends to end.
+     */
+    before?: string;
+    /**
+     * Insert position: after this row's sortKey.
+     * If neither before nor after is specified, appends to end.
+     */
+    after?: string;
+}
+/**
+ * Options for querying rows.
+ */
+interface QueryRowsOptions {
+    /** Maximum number of rows to return */
+    limit?: number;
+    /** Offset for page-based pagination */
+    offset?: number;
+    /** Cursor for pagination (sortKey of last row from previous page) */
+    cursor?: string;
+    /** Property to sort by (default: 'sortKey') */
+    sortBy?: string;
+    /** Sort direction (default: 'asc') */
+    sortDirection?: 'asc' | 'desc';
+    /** Stable materialized row-list cache for persisted database views */
+    materializedView?: string | NodeQueryMaterializedViewOptions;
+}
+/**
+ * Result of a row query.
+ */
+interface QueryRowsResult {
+    /** The rows matching the query */
+    rows: DatabaseRowNode[];
+    /** Cursor for the next page (undefined if no more rows) */
+    cursor?: string;
+    /** Whether there are more rows after this page */
+    hasMore: boolean;
+}
+/**
+ * A database row node with extracted cell values.
+ */
+interface DatabaseRowNode extends NodeState {
+    /** Extracted cell values (columnId -> value) */
+    cells: Record<string, CellValue>;
+}
+/**
+ * Create a new row in a database.
+ *
+ * @example
+ * ```typescript
+ * const rowId = await createRow(store, {
+ *   databaseId: 'db_abc123',
+ *   cells: {
+ *     name: 'John Doe',
+ *     status: 'active',
+ *     priority: 3
+ *   }
+ * })
+ * ```
+ */
+declare function createRow(store: NodeStore, options: CreateRowOptions): Promise<string>;
+/**
+ * Update a single cell value in a row.
+ *
+ * @example
+ * ```typescript
+ * await updateCell(store, rowId, 'status', 'completed')
+ * ```
+ */
+declare function updateCell(store: NodeStore, rowId: string, columnId: string, value: CellValue): Promise<void>;
+/**
+ * Update multiple cell values in a row.
+ *
+ * @example
+ * ```typescript
+ * await updateCells(store, rowId, {
+ *   name: 'Jane Doe',
+ *   status: 'active'
+ * })
+ * ```
+ */
+declare function updateCells(store: NodeStore, rowId: string, cells: Record<string, CellValue>): Promise<void>;
+/**
+ * Delete a row from a database.
+ *
+ * @example
+ * ```typescript
+ * await deleteRow(store, rowId)
+ * ```
+ */
+declare function deleteRow(store: NodeStore, rowId: string): Promise<void>;
+/**
+ * Get a single row by ID with extracted cell values.
+ *
+ * @example
+ * ```typescript
+ * const row = await getRow(store, rowId)
+ * console.log(row.cells.name) // 'John Doe'
+ * ```
+ */
+declare function getRow(store: NodeStore, rowId: string): Promise<DatabaseRowNode | null>;
+/**
+ * Query rows for a database with pagination.
+ *
+ * @example
+ * ```typescript
+ * const { rows, hasMore, cursor } = await queryRows(store, databaseId, {
+ *   limit: 50
+ * })
+ *
+ * // Get next page
+ * if (hasMore) {
+ *   const nextPage = await queryRows(store, databaseId, {
+ *     limit: 50,
+ *     cursor
+ *   })
+ * }
+ * ```
+ */
+declare function queryRows(store: NodeStore, databaseId: string, options?: QueryRowsOptions): Promise<QueryRowsResult>;
+/**
+ * Move a row to a new position.
+ *
+ * @example
+ * ```typescript
+ * // Move row between two other rows
+ * await moveRow(store, rowId, {
+ *   after: 'row_abc',
+ *   before: 'row_xyz'
+ * })
+ * ```
+ */
+declare function moveRow(store: NodeStore, rowId: string, position: {
+    before?: string;
+    after?: string;
+}): Promise<void>;
+/**
+ * Rebalance all rows in a database.
+ * Use this when sort keys get too long (> 10 chars) due to many
+ * insertions at the same position.
+ *
+ * @example
+ * ```typescript
+ * if (await checkNeedsRebalancing(store, databaseId)) {
+ *   await rebalanceDatabase(store, databaseId)
+ * }
+ * ```
+ */
+declare function rebalanceDatabase(store: NodeStore, databaseId: string): Promise<void>;
+/**
+ * Check if a database needs rebalancing.
+ * Returns true if any sort key exceeds the maximum recommended length.
+ *
+ * @param maxKeyLength - Maximum key length before rebalancing (default: 10)
+ */
+declare function checkNeedsRebalancing(store: NodeStore, databaseId: string, maxKeyLength?: number): Promise<boolean>;
+
+/**
+ * Fractional indexing for O(1) row ordering.
+ *
+ * Row order uses fractional indexing instead of array positions. Each row has
+ * a `sortKey` string that can be sorted lexicographically. Inserting between
+ * two rows generates a key that sorts between them, without updating any other rows.
+ *
+ * This approach is used by Figma, Linear, and other collaborative apps because
+ * it enables O(1) insert/reorder operations and works naturally with database
+ * queries (`ORDER BY sort_key`).
+ *
+ * @example
+ * ```typescript
+ * generateSortKey()           // "a0" - first key
+ * generateSortKey("a0")       // "a1" - append
+ * generateSortKey("a0", "a1") // "a0V" - insert between
+ * ```
+ */
+/**
+ * Generate a sort key that orders between `before` and `after`.
+ *
+ * @param before - The key to sort after (or undefined for start)
+ * @param after - The key to sort before (or undefined for end)
+ * @returns A new key that sorts between before and after
+ *
+ * @example
+ * ```typescript
+ * generateSortKey()           // "a0" - first key
+ * generateSortKey("a0")       // "a1" - append
+ * generateSortKey(undefined, "a0") // key before a0
+ * generateSortKey("a0", "a1") // "a0V" - insert between
+ * ```
+ */
+declare function generateSortKey(before?: string, after?: string): string;
+/**
+ * Generate a sort key with random jitter to prevent collisions.
+ * Use this in high-concurrency scenarios where multiple users might
+ * insert at the same position simultaneously.
+ *
+ * @param before - The key to sort after (or undefined for start)
+ * @param after - The key to sort before (or undefined for end)
+ * @returns A new key with random suffix
+ */
+declare function generateSortKeyWithJitter(before?: string, after?: string): string;
+/**
+ * Validate that a key is well-formed.
+ */
+declare function isValidSortKey(key: string): boolean;
+/**
+ * Compare two sort keys.
+ * Returns negative if a < b, positive if a > b, 0 if equal.
+ *
+ * Uses simple string comparison (not locale-aware) to ensure
+ * consistent ordering across all environments.
+ */
+declare function compareSortKeys(a: string, b: string): number;
+/**
+ * Rebalance sort keys for a set of rows.
+ * Generates evenly-spaced keys for all rows.
+ *
+ * Use this when sort keys get too long (> 10 chars) due to many
+ * insertions at the same position.
+ *
+ * @param rowIds - Row IDs in current sorted order
+ * @returns Map of rowId -> new sortKey
+ *
+ * @example
+ * ```typescript
+ * const newKeys = rebalanceSortKeys(['row1', 'row2', 'row3'])
+ * // Map { 'row1' => '0U', 'row2' => '0q', 'row3' => '1C' }
+ * ```
+ */
+declare function rebalanceSortKeys(rowIds: string[]): Map<string, string>;
+/**
+ * Get the maximum recommended key length before rebalancing.
+ */
+declare const MAX_KEY_LENGTH = 10;
+/**
+ * Check if any keys in a list exceed the maximum recommended length.
+ */
+declare function needsRebalancing(sortKeys: string[]): boolean;
+
+/**
+ * Rich text cell support for database rows.
+ *
+ * Rich text cells use the row's Y.Doc for collaborative editing.
+ * Each rich text column gets its own Y.XmlFragment in the doc,
+ * which supports TipTap/ProseMirror content.
+ *
+ * Not every row needs a Y.Doc - only rows with rich text columns.
+ * This is determined by the database's column definitions.
+ */
+
+/**
+ * Prefix for rich text cell fragments in the Y.Doc.
+ */
+declare const RICHTEXT_PREFIX = "richtext_";
+/**
+ * Get or create a rich text cell in the row's Y.Doc.
+ * The XML fragment supports TipTap/ProseMirror content.
+ *
+ * @example
+ * ```typescript
+ * const doc = await store.getOrCreateDoc(rowId)
+ * const fragment = getRichTextCell(doc, 'notes')
+ *
+ * // Use with TipTap editor
+ * const editor = new Editor({
+ *   extensions: [Collaboration.configure({ fragment })]
+ * })
+ * ```
+ */
+declare function getRichTextCell(doc: Y.Doc, columnId: string): Y.XmlFragment;
+/**
+ * Check if a row has any rich text content for a specific column.
+ */
+declare function hasRichTextContent(doc: Y.Doc, columnId: string): boolean;
+/**
+ * Check if any columns in the list are rich text columns.
+ * Used to decide whether to create/sync a Y.Doc for a row.
+ *
+ * @example
+ * ```typescript
+ * const columns = await getColumns(databaseId)
+ * if (hasRichTextColumns(columns)) {
+ *   // Row needs a Y.Doc
+ *   const doc = await store.getOrCreateDoc(rowId)
+ * }
+ * ```
+ */
+declare function hasRichTextColumns(columns: ColumnDefinition[]): boolean;
+/**
+ * Get all rich text column IDs from a list of columns.
+ */
+declare function getRichTextColumnIds(columns: ColumnDefinition[]): string[];
+/**
+ * Delete a rich text cell from the row's Y.Doc.
+ * Used when a rich text column is deleted.
+ */
+declare function deleteRichTextCell(doc: Y.Doc, columnId: string): void;
+/**
+ * Get plain text content from a rich text cell.
+ * Useful for search indexing and previews.
+ */
+declare function getRichTextPlainText(doc: Y.Doc, columnId: string): string;
+
+/**
+ * Field type definitions for the V2 database model.
+ *
+ * V2 stores fields as first-class DatabaseField nodes (see
+ * schema/schemas/database-field.ts) ordered by fractional sortKey, rather
+ * than as Y.Array entries in the database Y.Doc. The type/config unions are
+ * shared with the legacy column model (column-types.ts) so the pure engines
+ * (filter/sort/group/rollup/formula) work unchanged.
+ *
+ * Select/multiSelect options are NOT part of the field config in V2 — they
+ * are DatabaseSelectOption nodes keyed by `field`, so concurrent option
+ * creation merges cleanly. SelectFieldConfig retains only behavioral flags.
+ */
+
+/** All supported field types. */
+type FieldType = ColumnType;
+/** Type-specific field configuration. */
+type FieldConfig = ColumnConfig;
+
+/** Valid field type values, for runtime enforcement in field-operations. */
+declare const FIELD_TYPES: readonly FieldType[];
+declare function isFieldType(value: unknown): value is FieldType;
+/** Valid select option colors. */
+declare const SELECT_COLORS: readonly SelectColor[];
+declare function isSelectColor(value: unknown): value is SelectColor;
+/**
+ * Pick a deterministic color for a new option from its name, so
+ * typeahead-created tags get stable, pleasant colors without a picker.
+ */
+declare function autoColor(name: string): SelectColor;
+declare const isNodeStoreFieldType: typeof isNodeStoreColumnType;
+declare const isComputedFieldType: typeof isComputedColumnType;
+declare const isAutoFieldType: typeof isAutoColumnType;
+declare const isYDocFieldType: typeof isYDocColumnType;
+/** A DatabaseField node narrowed with typed properties access. */
+interface FieldNode {
+    id: string;
+    database: string;
+    name: string;
+    type: FieldType;
+    config: FieldConfig;
+    sortKey: string;
+    width?: number;
+    isTitle?: boolean;
+    hidden?: boolean;
+}
+/** A DatabaseSelectOption node narrowed for picker use. */
+interface SelectOptionNode {
+    id: string;
+    field: string;
+    database: string;
+    name: string;
+    color?: SelectColor;
+    sortKey: string;
+}
+/** Extract a FieldNode from a raw node's properties. */
+declare function toFieldNode(node: {
+    id: string;
+    properties: Record<string, unknown>;
+}): FieldNode;
+/** Extract a SelectOptionNode from a raw node's properties. */
+declare function toSelectOptionNode(node: {
+    id: string;
+    properties: Record<string, unknown>;
+}): SelectOptionNode;
+
+/**
+ * Field CRUD operations for the V2 database model.
+ *
+ * Fields are DatabaseField nodes; select options are DatabaseSelectOption
+ * nodes. Ordering uses the same fractional indexing scheme as rows, so
+ * reorders are O(1) single-property updates that merge under LWW.
+ */
+
+interface CreateFieldOptions {
+    /** Parent database ID */
+    databaseId: string;
+    /** Display name */
+    name: string;
+    /** Field type */
+    type: FieldType;
+    /** Type-specific configuration */
+    config?: FieldConfig;
+    /** Default column width */
+    width?: number;
+    /** Whether this is the title field */
+    isTitle?: boolean;
+    /** Insert position: before this field's sortKey */
+    before?: string;
+    /** Insert position: after this field's sortKey */
+    after?: string;
+}
+interface UpdateFieldOptions {
+    name?: string;
+    type?: FieldType;
+    config?: FieldConfig;
+    width?: number;
+    isTitle?: boolean;
+    hidden?: boolean;
+}
+interface CreateSelectOptionOptions {
+    /** Parent field ID */
+    fieldId: string;
+    /** Option display name */
+    name: string;
+    /** Option color (auto-derived from name when omitted) */
+    color?: SelectColor;
+}
+/**
+ * Get all fields for a database, ordered by sortKey.
+ */
+declare function getFields(store: NodeStore, databaseId: string): Promise<FieldNode[]>;
+/**
+ * Get a single field by ID.
+ */
+declare function getField(store: NodeStore, fieldId: string): Promise<FieldNode | null>;
+/**
+ * Get the title field for a database.
+ */
+declare function getTitleField(store: NodeStore, databaseId: string): Promise<FieldNode | null>;
+/**
+ * Create a new field. Returns the new field's node ID.
+ *
+ * @example
+ * ```typescript
+ * const fieldId = await createField(store, {
+ *   databaseId,
+ *   name: 'Status',
+ *   type: 'select'
+ * })
+ * ```
+ */
+declare function createField(store: NodeStore, options: CreateFieldOptions): Promise<string>;
+/**
+ * Update a field's properties. Only provided keys are written, so
+ * concurrent edits to different aspects (rename vs resize) merge cleanly.
+ */
+declare function updateField(store: NodeStore, fieldId: string, updates: UpdateFieldOptions): Promise<void>;
+/**
+ * Delete a field and its select options.
+ *
+ * Cell values under the field's `cell_<id>` key are left in place on rows
+ * (orphaned data is invisible and avoids a full-table write storm — the
+ * same call Notion makes).
+ */
+declare function deleteField(store: NodeStore, fieldId: string): Promise<void>;
+/**
+ * Move a field to a new position via fractional index.
+ *
+ * @example
+ * ```typescript
+ * await moveField(store, fieldId, { after: fieldA.sortKey, before: fieldB.sortKey })
+ * ```
+ */
+declare function moveField(store: NodeStore, fieldId: string, position: {
+    before?: string;
+    after?: string;
+}): Promise<void>;
+/**
+ * Duplicate a field (its select options included).
+ * Returns the new field's node ID, positioned right after the source.
+ */
+declare function duplicateField(store: NodeStore, fieldId: string, newName?: string): Promise<string | null>;
+/**
+ * Get all options for a select/multiSelect field, ordered by sortKey.
+ */
+declare function getSelectOptions(store: NodeStore, fieldId: string): Promise<SelectOptionNode[]>;
+/**
+ * Create a select option (the typeahead "＋ Create" path).
+ * Returns the new option's node ID.
+ *
+ * Concurrent creates from multiple collaborators are safe by construction:
+ * each create is an independent node.
+ */
+declare function createSelectOption(store: NodeStore, options: CreateSelectOptionOptions): Promise<string>;
+/**
+ * Get all options for every select field of a database in one query.
+ */
+declare function getDatabaseSelectOptions(store: NodeStore, databaseId: string): Promise<SelectOptionNode[]>;
+/**
+ * Rename or recolor an option.
+ */
+declare function updateSelectOption(store: NodeStore, optionId: string, updates: {
+    name?: string;
+    color?: SelectColor;
+}): Promise<void>;
+/**
+ * Delete an option. Cells referencing the option keep the dangling ID;
+ * renderers must drop unknown option IDs (same behavior as deleted rows
+ * in relation cells).
+ */
+declare function deleteSelectOption(store: NodeStore, optionId: string): Promise<void>;
+/**
+ * Reorder an option via fractional index.
+ */
+declare function moveSelectOption(store: NodeStore, optionId: string, position: {
+    before?: string;
+    after?: string;
+}): Promise<void>;
+
+/**
+ * Extension field operations — create / list / reorder / delete the custom
+ * columns a user adds to an existing schema.
+ *
+ * These mirror `field-operations.ts` (which manage `DatabaseField` columns for
+ * free-form databases) but operate on `ExtensionField` nodes keyed to a
+ * `SchemaExtension`. The "+ Add field" affordance on a typed schema's grid
+ * calls `createExtensionField`; core (schema-defined) columns are structurally
+ * locked and routed nowhere — only extension fields are mutable.
+ */
+
+interface EnsureExtensionOptions {
+    /** Versioned (or base) IRI of the schema being extended. */
+    targetSchema: string;
+    /** Namespace authority that owns the overlay (Space id, DID, or domain). */
+    authority: string;
+    /** Human label for the extension set. */
+    label?: string;
+    /** Optional owning Space for the authorization cascade. */
+    space?: string;
+}
+/**
+ * Ensure a `SchemaExtension` exists for `(authority, targetSchema)` and return
+ * its id. Uses the deterministic id so repeated calls upsert rather than fork.
+ */
+declare function ensureSchemaExtension(store: NodeStore, options: EnsureExtensionOptions): Promise<string>;
+interface CreateExtensionFieldOptions {
+    targetSchema: string;
+    authority: string;
+    /** Field token — the `<field>` segment; must be a valid extension field name. */
+    name: string;
+    /** Field type (FieldType union). */
+    type: string;
+    config?: Record<string, unknown>;
+    width?: number;
+    space?: string;
+}
+/**
+ * Add a custom column to a schema. Returns the new `ExtensionField` node id.
+ * The resulting overlay property key on target nodes is
+ * `ext:<authority>/<name>`.
+ *
+ * @throws if `type` is not a valid field type, or `name` is not a valid
+ *   extension field token.
+ */
+declare function createExtensionField(store: NodeStore, options: CreateExtensionFieldOptions): Promise<{
+    fieldId: string;
+    key: string;
+}>;
+/** Rename an extension field's display token (does not change the stored key). */
+declare function renameExtensionField(store: NodeStore, fieldId: string, name: string): Promise<void>;
+/** Delete (soft) an extension field. Does not remove overlay values on nodes. */
+declare function deleteExtensionField(store: NodeStore, fieldId: string): Promise<void>;
+
+/**
+ * View CRUD operations for the V2 database model.
+ *
+ * Views are DatabaseView nodes. Each concern (filters, sorts, grouping,
+ * per-view layout overrides) is a separate property, so concurrent edits
+ * to different concerns merge cleanly under per-property LWW.
+ */
+
+/**
+ * A database view, read from a DatabaseView node.
+ *
+ * This is the single ViewConfig shape for V2 — the `@xnetjs/views` dialect
+ * (visibleProperties/propertyWidths) is retired.
+ */
+interface ViewNode {
+    id: string;
+    database: string;
+    name: string;
+    type: ViewType;
+    filters?: FilterGroup | null;
+    sorts?: SortConfig[];
+    groupBy?: string | null;
+    groupSort?: 'asc' | 'desc';
+    collapsedGroups?: string[];
+    /** Per-view field order overrides: fieldId -> fractional sortKey */
+    fieldOrder?: Record<string, string>;
+    /** Per-view width overrides: fieldId -> px */
+    fieldWidths?: Record<string, number>;
+    /** Per-view hidden fields */
+    hiddenFields?: string[];
+    /** View tab order */
+    sortKey: string;
+    coverField?: string;
+    cardSize?: 'small' | 'medium' | 'large';
+    dateField?: string;
+    endDateField?: string;
+}
+interface CreateViewOptions {
+    databaseId: string;
+    name: string;
+    type: ViewType;
+    /** Insert position among view tabs */
+    before?: string;
+    after?: string;
+}
+type UpdateViewOptions = Partial<Omit<ViewNode, 'id' | 'database' | 'sortKey'>>;
+/**
+ * Get all views for a database, ordered by tab sortKey.
+ */
+declare function getViews$1(store: NodeStore, databaseId: string): Promise<ViewNode[]>;
+/**
+ * Get a single view by ID.
+ */
+declare function getView$1(store: NodeStore, viewId: string): Promise<ViewNode | null>;
+/**
+ * Create a view. Returns the new view's node ID.
+ */
+declare function createView$1(store: NodeStore, options: CreateViewOptions): Promise<string>;
+/**
+ * Update view properties. Only provided keys are written.
+ */
+declare function updateView$1(store: NodeStore, viewId: string, updates: UpdateViewOptions): Promise<void>;
+/**
+ * Delete a view.
+ */
+declare function deleteView$1(store: NodeStore, viewId: string): Promise<void>;
+/**
+ * Duplicate a view (all configuration copied), positioned after the source.
+ * Returns the new view's node ID.
+ */
+declare function duplicateView$1(store: NodeStore, viewId: string, newName?: string): Promise<string | null>;
+/**
+ * Move a view tab via fractional index.
+ */
+declare function moveView(store: NodeStore, viewId: string, position: {
+    before?: string;
+    after?: string;
+}): Promise<void>;
+declare function setViewFilters$1(store: NodeStore, viewId: string, filters: FilterGroup | null): Promise<void>;
+declare function setViewSorts$1(store: NodeStore, viewId: string, sorts: SortConfig[]): Promise<void>;
+declare function setViewGroupBy$1(store: NodeStore, viewId: string, groupBy: string | null, groupSort?: 'asc' | 'desc'): Promise<void>;
+declare function toggleViewGroupCollapsed(store: NodeStore, viewId: string, groupKey: string): Promise<void>;
+/**
+ * Hide/show a field in this view.
+ */
+declare function setFieldHidden(store: NodeStore, viewId: string, fieldId: string, hidden: boolean): Promise<void>;
+/**
+ * Set a per-view column width override.
+ */
+declare function setViewFieldWidth(store: NodeStore, viewId: string, fieldId: string, width: number): Promise<void>;
+/**
+ * Set a per-view field order override (fractional key among the view's
+ * effective field order).
+ */
+declare function setViewFieldOrder(store: NodeStore, viewId: string, fieldId: string, sortKey: string): Promise<void>;
+/**
+ * Compute the effective field order for a view: per-view fieldOrder
+ * overrides win, otherwise the field's own sortKey.
+ */
+declare function effectiveFieldSortKey(view: Pick<ViewNode, 'fieldOrder'>, field: {
+    id: string;
+    sortKey: string;
+}): string;
+
+/**
+ * Cell value conversion for field type changes (exploration 0159,
+ * spreadsheet-UX follow-up).
+ *
+ * When a field is retyped, existing cell values convert rather than
+ * orphan: numeric strings become numbers, comma-separated text becomes
+ * multi-select names, option IDs stringify back to their names, etc.
+ *
+ * Pure: select/multiSelect targets return the *names* to resolve —
+ * the caller creates/looks up SelectOption nodes and maps names to IDs.
+ */
+
+interface ConvertContext {
+    /** Resolve an option ID to its display name (source select fields) */
+    optionName?: (id: string) => string | undefined;
+}
+interface ConvertedCell {
+    /** The converted value (null clears the cell) */
+    value: CellValue;
+    /**
+     * For select/multiSelect targets: display names that need resolving to
+     * option IDs (create-if-missing). The caller replaces `value` with the
+     * resolved ID(s).
+     */
+    optionNames?: string[];
+}
+/** Render any cell value as plain text (the universal intermediate). */
+declare function cellValueToText(value: CellValue, sourceType: FieldType, ctx?: ConvertContext): string;
+/**
+ * Convert a cell value from one field type to another.
+ * Unconvertible values become null (never garbage).
+ */
+declare function convertCellValue(value: CellValue, sourceType: FieldType, targetType: FieldType, ctx?: ConvertContext): ConvertedCell;
+
+/**
+ * New-database setup for the V2 node model.
+ *
+ * Replaces the Y.Doc-based setupNewDatabase (database-doc.ts): a fresh
+ * database gets a title field and a default table view as nodes.
+ */
+
+interface SetupDatabaseResult {
+    titleFieldId: string;
+    defaultViewId: string;
+}
+/**
+ * Initialize a freshly created database with its default structure:
+ * a "Name" title field and a "Table" view.
+ *
+ * Idempotent: skips creation when a title field / view already exists
+ * (e.g. when two clients race to initialize a synced database).
+ */
+declare function setupDatabase(store: NodeStore, databaseId: string): Promise<SetupDatabaseResult>;
+
+/**
+ * Database Schema Utilities
+ *
+ * Utilities for generating unique, versioned schema IRIs for databases
+ * and managing schema metadata stored in Y.Doc.
+ */
+
+/**
+ * Schema metadata stored in a database's Y.Doc.
+ */
+interface DatabaseSchemaMetadata {
+    /** User-editable schema name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Semver version (auto-incremented) */
+    version: string;
+    /** When the database was created */
+    createdAt: number;
+    /** Last column modification time */
+    updatedAt: number;
+}
+/**
+ * A stored column in a database's Y.Doc.
+ */
+interface StoredColumn {
+    id: string;
+    name: string;
+    type: PropertyType;
+    config?: Record<string, unknown>;
+}
+/**
+ * Schema version history entry.
+ */
+interface SchemaVersionEntry {
+    version: string;
+    timestamp: number;
+    columns: StoredColumn[];
+    changeType: 'initial' | 'add' | 'update' | 'delete';
+    changeDescription?: string;
+}
+/**
+ * Type of version bump.
+ */
+type VersionBumpType = 'patch' | 'minor';
+/**
+ * Default namespace for database-defined schemas.
+ */
+declare const DATABASE_SCHEMA_NAMESPACE = "xnet://xnet.fyi/";
+/**
+ * Prefix for database schema IRIs.
+ */
+declare const DATABASE_SCHEMA_PREFIX = "xnet://xnet.fyi/db/";
+/**
+ * Generate a schema IRI from a database ID and version.
+ *
+ * @example
+ * buildSchemaIRI('abc123', '1.0.0') // => 'xnet://xnet.fyi/db/abc123@1.0.0'
+ */
+declare function buildSchemaIRI(databaseId: string, version: string): SchemaIRI;
+/**
+ * Parse a database schema IRI to extract the database ID and version.
+ *
+ * @returns { databaseId, version } or null if the IRI doesn't match the pattern
+ *
+ * @example
+ * parseSchemaIRI('xnet://xnet.fyi/db/abc123@1.0.0')
+ * // => { databaseId: 'abc123', version: '1.0.0' }
+ */
+declare function parseDatabaseSchemaIRI(iri: string): {
+    databaseId: string;
+    version: string;
+} | null;
+/**
+ * Check if an IRI is a database-defined schema IRI.
+ */
+declare function isDatabaseSchemaIRI(iri: string): boolean;
+/**
+ * Parse a semver version string.
+ *
+ * @returns { major, minor, patch } or null if invalid
+ */
+declare function parseVersion(version: string): {
+    major: number;
+    minor: number;
+    patch: number;
+} | null;
+/**
+ * Bump a schema version.
+ *
+ * - patch: 1.0.0 -> 1.0.1 (add column, update column, rename)
+ * - minor: 1.0.0 -> 1.1.0 (delete column, change column type)
+ *
+ * @example
+ * bumpSchemaVersion('1.0.0', 'patch') // => '1.0.1'
+ * bumpSchemaVersion('1.0.5', 'minor') // => '1.1.0'
+ */
+declare function bumpSchemaVersion(current: string, type: VersionBumpType): string;
+/**
+ * Create initial schema metadata for a new database.
+ */
+declare function createInitialSchemaMetadata(name: string): DatabaseSchemaMetadata;
+/**
+ * Build a Schema object from database metadata and columns.
+ *
+ * This creates a unique, versioned schema for the database.
+ *
+ * @example
+ * const schema = buildDatabaseSchema('db123', metadata, columns)
+ * // schema['@id'] === 'xnet://xnet.fyi/db/db123@1.0.0'
+ */
+declare function buildDatabaseSchema(databaseId: string, metadata: DatabaseSchemaMetadata, columns: StoredColumn[]): Schema;
+/**
+ * Create a schema version history entry.
+ */
+declare function createVersionEntry(version: string, columns: StoredColumn[], changeType: SchemaVersionEntry['changeType'], changeDescription?: string): SchemaVersionEntry;
+/**
+ * Maximum number of version history entries to keep.
+ */
+declare const MAX_VERSION_HISTORY = 50;
+/**
+ * Prune version history to stay within limits.
+ */
+declare function pruneVersionHistory(history: SchemaVersionEntry[]): SchemaVersionEntry[];
+/**
+ * Determine the version bump type for a column operation.
+ */
+declare function getVersionBumpType(operation: 'add' | 'update' | 'rename' | 'delete' | 'changeType'): VersionBumpType;
+
+/**
+ * Database-defined schemas from DatabaseField nodes (V2).
+ *
+ * Replaces the Y.Doc extraction path (schema-resolver.ts): in the V2 model
+ * the field list lives in DatabaseField nodes and the schema version lives
+ * on the Database node's `schemaVersion` property.
+ */
+
+/** Default version for databases that have never bumped their schema. */
+declare const DEFAULT_DATABASE_SCHEMA_VERSION = "1.0.0";
+/**
+ * Convert field nodes to the StoredColumn shape used by schema building,
+ * cloning, and templates.
+ */
+declare function fieldsToStoredColumns(fields: FieldNode[]): StoredColumn[];
+/**
+ * Build the database-defined Schema for a database from its field nodes.
+ * Returns null when the database doesn't exist.
+ */
+declare function buildSchemaFromFields(store: NodeStore, databaseId: string): Promise<Schema | null>;
+/**
+ * Get the current database-defined schema IRI for a database.
+ * Returns null when the database doesn't exist.
+ */
+declare function getDatabaseSchemaIRI(store: NodeStore, databaseId: string): Promise<SchemaIRI | null>;
+/**
+ * Create a remote resolver for database-defined schemas backed by the
+ * NodeStore (V2 replacement for createDatabaseSchemaResolver).
+ *
+ * @example
+ * schemaRegistry.setRemoteResolver(createNodeDatabaseSchemaResolver({ store }))
+ */
+declare function createNodeDatabaseSchemaResolver(options: {
+    store: NodeStore;
+}): (iri: SchemaIRI) => Promise<Schema | null>;
+
+/**
+ * Database Y.Doc initialization and management.
+ *
+ * The database's Y.Doc contains:
+ * - columns: Y.Array of column definitions
+ * - views: Y.Map of view configurations
+ * - meta: Y.Map of metadata (row count cache, etc.)
+ */
+
+/**
+ * Initialize the Y.Doc structure for a new database.
+ * Creates the columns array, views map, and meta map if they don't exist.
+ *
+ * @example
+ * ```typescript
+ * const doc = new Y.Doc()
+ * initializeDatabaseDoc(doc)
+ * ```
+ */
+declare function initializeDatabaseDoc(doc: Y.Doc): void;
+/**
+ * Check if a Y.Doc has been initialized as a database doc.
+ */
+declare function isDatabaseDocInitialized(doc: Y.Doc): boolean;
+/**
+ * Add a default title column to a new database.
+ * Returns the column ID.
+ *
+ * @example
+ * ```typescript
+ * const doc = new Y.Doc()
+ * initializeDatabaseDoc(doc)
+ * const titleColumnId = addDefaultTitleColumn(doc)
+ * ```
+ */
+declare function addDefaultTitleColumn(doc: Y.Doc): string;
+/**
+ * Add a default table view to a new database.
+ * Returns the view ID.
+ *
+ * @example
+ * ```typescript
+ * const doc = new Y.Doc()
+ * initializeDatabaseDoc(doc)
+ * addDefaultTitleColumn(doc)
+ * const viewId = addDefaultTableView(doc)
+ * ```
+ */
+declare function addDefaultTableView(doc: Y.Doc): string;
+/**
+ * Set up a new database with default title column and table view.
+ * Returns the column ID and view ID.
+ *
+ * @example
+ * ```typescript
+ * const doc = new Y.Doc()
+ * const { columnId, viewId } = setupNewDatabase(doc)
+ * ```
+ */
+declare function setupNewDatabase(doc: Y.Doc): {
+    columnId: string;
+    viewId: string;
+};
+/**
+ * Get a metadata value from the database doc.
+ */
+declare function getMeta<T>(doc: Y.Doc, key: string): T | undefined;
+/**
+ * Set a metadata value in the database doc.
+ */
+declare function setMeta<T>(doc: Y.Doc, key: string, value: T): void;
+/**
+ * Delete a metadata value from the database doc.
+ */
+declare function deleteMeta(doc: Y.Doc, key: string): void;
+/**
+ * Storage model of a database Y.Doc. V2 keeps the Y.Doc presence-only, so
+ * docs are either 'canonical' (pre-V2 columns/views/meta present) or
+ * 'empty'. The legacy Y.Map row model was removed with exploration 0159.
+ */
+type DatabaseDocumentModel = 'canonical' | 'empty';
+/**
+ * Detect whether a database Y.Doc carries canonical column/view state.
+ */
+declare function getDatabaseDocumentModel(doc: Y.Doc): DatabaseDocumentModel;
+
+/**
+ * Column CRUD operations for database columns.
+ *
+ * Columns are stored in the database's Y.Doc as a Y.Array of Y.Maps.
+ * This enables CRDT-based ordering and real-time schema sync.
+ */
+
+/**
+ * Get all columns from a database doc.
+ *
+ * @example
+ * ```typescript
+ * const columns = getColumns(doc)
+ * console.log(columns.map(c => c.name))
+ * ```
+ */
+declare function getColumns(doc: Y.Doc): ColumnDefinition[];
+/**
+ * Get a single column by ID.
+ *
+ * @example
+ * ```typescript
+ * const column = getColumn(doc, 'abc123')
+ * if (column) {
+ *   console.log(column.name, column.type)
+ * }
+ * ```
+ */
+declare function getColumn(doc: Y.Doc, columnId: string): ColumnDefinition | null;
+/**
+ * Get the index of a column by ID.
+ * Returns -1 if not found.
+ */
+declare function getColumnIndex(doc: Y.Doc, columnId: string): number;
+/**
+ * Get the title column from a database doc.
+ * Returns null if no title column is defined.
+ */
+declare function getTitleColumn(doc: Y.Doc): ColumnDefinition | null;
+/**
+ * Create a new column.
+ * Returns the new column ID.
+ *
+ * @example
+ * ```typescript
+ * const id = createColumn(doc, {
+ *   name: 'Status',
+ *   type: 'select',
+ *   config: {
+ *     options: [
+ *       { id: 'todo', name: 'To Do', color: 'gray' },
+ *       { id: 'done', name: 'Done', color: 'green' }
+ *     ]
+ *   }
+ * })
+ * ```
+ */
+declare function createColumn(doc: Y.Doc, definition: Omit<ColumnDefinition, 'id'>): string;
+/**
+ * Update a column's properties.
+ *
+ * @example
+ * ```typescript
+ * updateColumn(doc, 'abc123', { name: 'Project Status' })
+ * ```
+ */
+declare function updateColumn(doc: Y.Doc, columnId: string, updates: Partial<Omit<ColumnDefinition, 'id'>>): void;
+/**
+ * Delete a column.
+ * Also removes the column from all views' visible columns.
+ *
+ * @example
+ * ```typescript
+ * deleteColumn(doc, 'abc123')
+ * ```
+ */
+declare function deleteColumn(doc: Y.Doc, columnId: string): void;
+/**
+ * Reorder a column to a new position.
+ *
+ * @example
+ * ```typescript
+ * // Move column to the beginning
+ * reorderColumn(doc, 'abc123', 0)
+ * ```
+ */
+declare function reorderColumn(doc: Y.Doc, columnId: string, newIndex: number): void;
+/**
+ * Duplicate a column.
+ * Returns the new column ID.
+ *
+ * @example
+ * ```typescript
+ * const newId = duplicateColumn(doc, 'abc123', 'Status (Copy)')
+ * ```
+ */
+declare function duplicateColumn(doc: Y.Doc, columnId: string, newName?: string): string | null;
+
+/**
+ * View CRUD operations for database views.
+ *
+ * Views are stored in the database's Y.Doc as a Y.Map of view configs.
+ * This enables collaborative view editing and real-time sync.
+ */
+
+/**
+ * Get all views from a database doc.
+ *
+ * @example
+ * ```typescript
+ * const views = getViews(doc)
+ * console.log(views.map(v => v.name))
+ * ```
+ */
+declare function getViews(doc: Y.Doc): ViewConfig[];
+/**
+ * Get a single view by ID.
+ *
+ * @example
+ * ```typescript
+ * const view = getView(doc, 'abc123')
+ * if (view) {
+ *   console.log(view.name, view.type)
+ * }
+ * ```
+ */
+declare function getView(doc: Y.Doc, viewId: string): ViewConfig | null;
+/**
+ * Get the first view of a specific type.
+ */
+declare function getViewByType(doc: Y.Doc, type: ViewType): ViewConfig | null;
+/**
+ * Create a new view.
+ * Returns the new view ID.
+ *
+ * @example
+ * ```typescript
+ * const id = createView(doc, {
+ *   name: 'Board View',
+ *   type: 'board',
+ *   visibleColumns: ['col1', 'col2'],
+ *   groupBy: 'col1'
+ * })
+ * ```
+ */
+declare function createView(doc: Y.Doc, config: Omit<ViewConfig, 'id'>): string;
+/**
+ * Update a view's properties.
+ *
+ * @example
+ * ```typescript
+ * updateView(doc, 'abc123', { name: 'My Board' })
+ * ```
+ */
+declare function updateView(doc: Y.Doc, viewId: string, updates: Partial<Omit<ViewConfig, 'id'>>): void;
+/**
+ * Delete a view.
+ *
+ * @example
+ * ```typescript
+ * deleteView(doc, 'abc123')
+ * ```
+ */
+declare function deleteView(doc: Y.Doc, viewId: string): void;
+/**
+ * Duplicate a view.
+ * Returns the new view ID.
+ *
+ * @example
+ * ```typescript
+ * const newId = duplicateView(doc, 'abc123', 'My Copy')
+ * ```
+ */
+declare function duplicateView(doc: Y.Doc, viewId: string, newName?: string): string;
+/**
+ * Set the filters for a view.
+ *
+ * @example
+ * ```typescript
+ * setViewFilters(doc, 'view123', {
+ *   operator: 'and',
+ *   conditions: [
+ *     { columnId: 'status', operator: 'equals', value: 'done' }
+ *   ]
+ * })
+ * ```
+ */
+declare function setViewFilters(doc: Y.Doc, viewId: string, filters: FilterGroup | null): void;
+/**
+ * Clear all filters from a view.
+ */
+declare function clearViewFilters(doc: Y.Doc, viewId: string): void;
+/**
+ * Set the sorts for a view.
+ *
+ * @example
+ * ```typescript
+ * setViewSorts(doc, 'view123', [
+ *   { columnId: 'date', direction: 'desc' },
+ *   { columnId: 'name', direction: 'asc' }
+ * ])
+ * ```
+ */
+declare function setViewSorts(doc: Y.Doc, viewId: string, sorts: SortConfig[]): void;
+/**
+ * Add a sort to a view.
+ */
+declare function addViewSort(doc: Y.Doc, viewId: string, sort: SortConfig): void;
+/**
+ * Remove a sort from a view by column ID.
+ */
+declare function removeViewSort(doc: Y.Doc, viewId: string, columnId: string): void;
+/**
+ * Clear all sorts from a view.
+ */
+declare function clearViewSorts(doc: Y.Doc, viewId: string): void;
+/**
+ * Set the group by column for a view.
+ */
+declare function setViewGroupBy(doc: Y.Doc, viewId: string, columnId: string | null): void;
+/**
+ * Toggle a group's collapsed state.
+ */
+declare function toggleGroupCollapsed$1(doc: Y.Doc, viewId: string, groupId: string): void;
+/**
+ * Set which columns are visible in a view.
+ */
+declare function setVisibleColumns(doc: Y.Doc, viewId: string, columnIds: string[]): void;
+/**
+ * Show a column in a view.
+ */
+declare function showColumn(doc: Y.Doc, viewId: string, columnId: string): void;
+/**
+ * Hide a column in a view.
+ */
+declare function hideColumn(doc: Y.Doc, viewId: string, columnId: string): void;
+/**
+ * Reorder columns in a view.
+ */
+declare function reorderViewColumns(doc: Y.Doc, viewId: string, columnId: string, newIndex: number): void;
+/**
+ * Set a column's width in a view.
+ */
+declare function setColumnWidth(doc: Y.Doc, viewId: string, columnId: string, width: number): void;
+
+/**
+ * Filter operators by column type.
+ *
+ * Maps each column type to the filter operators that are valid for that type.
+ */
+
+/**
+ * Valid filter operators for each column type.
+ */
+declare const OPERATORS_BY_TYPE: Record<ColumnType, FilterOperator[]>;
+/**
+ * Human-readable labels for filter operators.
+ */
+declare const OPERATOR_LABELS: Record<FilterOperator, string>;
+/**
+ * Get valid operators for a column type.
+ */
+declare function getOperatorsForType(type: ColumnType): FilterOperator[];
+/**
+ * Check if an operator is valid for a column type.
+ */
+declare function isValidOperator(type: ColumnType, operator: FilterOperator): boolean;
+/**
+ * Get the human-readable label for an operator.
+ */
+declare function getOperatorLabel(operator: FilterOperator): string;
+/**
+ * Check if an operator requires a value.
+ */
+declare function operatorRequiresValue(operator: FilterOperator): boolean;
+
+/**
+ * Filter engine for in-memory row filtering.
+ *
+ * Evaluates filter groups and conditions against database rows.
+ */
+
+/**
+ * A database row with cells.
+ */
+interface FilterableRow {
+    id: string;
+    cells: Record<string, unknown>;
+}
+/**
+ * Filter rows in memory using a filter group.
+ *
+ * @param rows - Rows to filter
+ * @param columns - Column definitions for type information
+ * @param filter - Filter group to apply (null returns all rows)
+ * @returns Filtered rows
+ *
+ * @example
+ * ```typescript
+ * const filtered = filterRows(rows, columns, {
+ *   operator: 'and',
+ *   conditions: [
+ *     { columnId: 'status', operator: 'equals', value: 'active' }
+ *   ]
+ * })
+ * ```
+ */
+declare function filterRows<T extends FilterableRow>(rows: T[], columns: ColumnDefinition[], filter: FilterGroup | null): T[];
+/**
+ * Create a simple equals filter.
+ */
+declare function createEqualsFilter(columnId: string, value: unknown): FilterGroup;
+/**
+ * Create a filter that matches any of the given values.
+ */
+declare function createAnyOfFilter(columnId: string, values: unknown[]): FilterGroup;
+/**
+ * Combine multiple filter groups with AND.
+ */
+declare function combineFiltersAnd(filters: FilterGroup[]): FilterGroup;
+/**
+ * Combine multiple filter groups with OR.
+ */
+declare function combineFiltersOr(filters: FilterGroup[]): FilterGroup;
+
+/**
+ * Sort engine for in-memory row sorting.
+ *
+ * Supports multi-column sorting with type-aware comparison.
+ */
+
+/**
+ * A database row with cells and sortKey.
+ */
+interface SortableRow {
+    id: string;
+    sortKey: string;
+    cells: Record<string, unknown>;
+}
+/**
+ * Sort rows in memory using multi-column sort config.
+ *
+ * @param rows - Rows to sort
+ * @param columns - Column definitions for type information
+ * @param sorts - Sort configurations (applied in order)
+ * @returns Sorted rows (new array)
+ *
+ * @example
+ * ```typescript
+ * const sorted = sortRows(rows, columns, [
+ *   { columnId: 'status', direction: 'asc' },
+ *   { columnId: 'name', direction: 'desc' }
+ * ])
+ * ```
+ */
+declare function sortRows<T extends SortableRow>(rows: T[], columns: ColumnDefinition[], sorts: SortConfig[]): T[];
+/**
+ * Create a single-column sort config.
+ */
+declare function createSort(columnId: string, direction?: 'asc' | 'desc'): SortConfig;
+/**
+ * Toggle sort direction.
+ */
+declare function toggleSortDirection(direction: 'asc' | 'desc'): 'asc' | 'desc';
+/**
+ * Add or update a sort in a sort list.
+ * If the column already exists, toggles direction.
+ * If it doesn't exist, adds it at the beginning.
+ */
+declare function addOrToggleSort(sorts: SortConfig[], columnId: string): SortConfig[];
+/**
+ * Remove a sort from a sort list.
+ */
+declare function removeSort(sorts: SortConfig[], columnId: string): SortConfig[];
+
+/**
+ * Group engine for in-memory row grouping.
+ *
+ * Groups rows by column value and calculates aggregates.
+ */
+
+/**
+ * A database row with cells.
+ */
+interface GroupableRow {
+    id: string;
+    cells: Record<string, unknown>;
+}
+/**
+ * Group configuration.
+ */
+interface GroupConfig {
+    /** Column ID to group by */
+    columnId: string;
+    /** Sort direction for groups */
+    sort?: 'asc' | 'desc';
+    /** Collapsed group keys */
+    collapsedGroups?: string[];
+}
+/**
+ * A group of rows.
+ */
+interface RowGroup<T extends GroupableRow = GroupableRow> {
+    /** Group key (column value or special key like '_empty') */
+    key: string;
+    /** Display label */
+    label: string;
+    /** Group color (for select columns) */
+    color?: string;
+    /** Rows in this group */
+    rows: T[];
+    /** Calculated aggregates */
+    aggregates: GroupAggregates;
+    /** Whether this group is collapsed */
+    collapsed?: boolean;
+}
+/**
+ * Aggregate values for a group.
+ */
+interface GroupAggregates {
+    /** Row count */
+    count: number;
+    /** Sum of number columns (keyed by columnId_sum) */
+    [key: string]: number | undefined;
+}
+/**
+ * Group rows by a column value.
+ *
+ * @param rows - Rows to group
+ * @param columns - Column definitions for type information
+ * @param groupBy - Group configuration (null returns single group with all rows)
+ * @returns Array of row groups
+ *
+ * @example
+ * ```typescript
+ * const groups = groupRows(rows, columns, { columnId: 'status' })
+ * // Returns: [{ key: 'active', label: 'Active', rows: [...] }, ...]
+ * ```
+ */
+declare function groupRows<T extends GroupableRow>(rows: T[], columns: ColumnDefinition[], groupBy: GroupConfig | null): RowGroup<T>[];
+/**
+ * Toggle a group's collapsed state.
+ */
+declare function toggleGroupCollapsed(collapsedGroups: string[] | undefined, groupKey: string): string[];
+/**
+ * Expand all groups.
+ */
+declare function expandAllGroups(): string[];
+/**
+ * Collapse all groups.
+ */
+declare function collapseAllGroups<T extends GroupableRow>(groups: RowGroup<T>[]): string[];
+
+/**
+ * Query pipeline for database rows.
+ *
+ * Executes filter -> sort -> group pipeline on rows.
+ */
+
+/**
+ * A row that can be processed by the query pipeline.
+ */
+interface QueryableRow extends FilterableRow, SortableRow, GroupableRow {
+    id: string;
+    sortKey: string;
+    cells: Record<string, unknown>;
+}
+/**
+ * Query options for the pipeline.
+ */
+interface QueryOptions {
+    /** Filter configuration */
+    filter?: FilterGroup | null;
+    /** Sort configurations (applied in order) */
+    sorts?: SortConfig[];
+    /** Group configuration */
+    groupBy?: GroupConfig | null;
+    /** Maximum rows to return */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+}
+/**
+ * Result of a query execution.
+ */
+interface QueryResult<T extends QueryableRow = QueryableRow> {
+    /** Grouped rows */
+    groups: RowGroup<T>[];
+    /** Total row count (before filtering) */
+    total: number;
+    /** Filtered row count (after filtering, before pagination) */
+    filtered: number;
+}
+/**
+ * Execute a full query pipeline: filter -> sort -> group.
+ *
+ * @param rows - Rows to query
+ * @param columns - Column definitions for type information
+ * @param options - Query options
+ * @returns Query result with groups, total, and filtered counts
+ *
+ * @example
+ * ```typescript
+ * const result = executeQuery(rows, columns, {
+ *   filter: { operator: 'and', conditions: [{ columnId: 'status', operator: 'equals', value: 'active' }] },
+ *   sorts: [{ columnId: 'name', direction: 'asc' }],
+ *   groupBy: { columnId: 'status' }
+ * })
+ * ```
+ */
+declare function executeQuery<T extends QueryableRow>(rows: T[], columns: ColumnDefinition[], options?: QueryOptions): QueryResult<T>;
+/**
+ * Create a simple query with just filtering.
+ */
+declare function createFilterQuery(filter: FilterGroup): QueryOptions;
+/**
+ * Create a simple query with just sorting.
+ */
+declare function createSortQuery(sorts: SortConfig[]): QueryOptions;
+/**
+ * Create a paginated query.
+ */
+declare function createPaginatedQuery(page: number, pageSize: number, options?: Omit<QueryOptions, 'limit' | 'offset'>): QueryOptions;
+/**
+ * Flatten groups into a single array of rows.
+ */
+declare function flattenGroups<T extends QueryableRow>(groups: RowGroup<T>[]): T[];
+/**
+ * Get total row count from groups.
+ */
+declare function getTotalFromGroups<T extends QueryableRow>(groups: RowGroup<T>[]): number;
+
+/**
+ * Rollup aggregation engine for computed columns.
+ *
+ * Rollups aggregate values from related rows via relation columns.
+ * Supports count, sum, avg, min, max, concat, unique, and percentage functions.
+ */
+
+/**
+ * A row with cells for rollup computation.
+ */
+interface RollupRow {
+    id: string;
+    databaseId: string;
+    cells: Record<string, CellValue>;
+}
+/**
+ * Context for rollup computation.
+ */
+interface RollupContext {
+    /** Get related rows for a row via a relation column */
+    getRelatedRows: (rowId: string, relationColumnId: string) => Promise<RollupRow[]>;
+    /** Get column definitions for a database */
+    getColumns: (databaseId: string) => Promise<ColumnDefinition[]>;
+    /** Get a specific column by ID */
+    getColumn: (databaseId: string, columnId: string) => Promise<ColumnDefinition | undefined>;
+}
+/**
+ * Aggregate an array of values using the specified function.
+ */
+declare function aggregate(values: unknown[], aggregation: RollupAggregation): unknown;
+/**
+ * Get the default/empty value for an aggregation function.
+ */
+declare function getEmptyValue(aggregation: RollupAggregation): unknown;
+/**
+ * Compute a rollup value for a row.
+ *
+ * @example
+ * ```typescript
+ * const value = await computeRollup(row, rollupColumn, context)
+ * // Returns aggregated value from related rows
+ * ```
+ */
+declare function computeRollup(row: RollupRow, rollupColumn: ColumnDefinition, context: RollupContext): Promise<unknown>;
+/**
+ * Batch compute rollups for multiple rows.
+ *
+ * @example
+ * ```typescript
+ * const results = await batchComputeRollups(rows, rollupColumn, context)
+ * // Map<rowId, aggregatedValue>
+ * ```
+ */
+declare function batchComputeRollups(rows: RollupRow[], rollupColumn: ColumnDefinition, context: RollupContext): Promise<Map<string, unknown>>;
+/**
+ * Validate a rollup column configuration.
+ */
+declare function validateRollupConfig(config: RollupColumnConfig, columns: ColumnDefinition[]): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Check if an aggregation function is numeric (requires number values).
+ */
+declare function isNumericAggregation(aggregation: RollupAggregation): boolean;
+/**
+ * Get the result type for an aggregation function.
+ */
+declare function getAggregationResultType(aggregation: RollupAggregation): 'number' | 'text' | 'array';
+
+/**
+ * Formula service for computing formula column values.
+ *
+ * Provides caching, validation, and batch computation for formula columns.
+ */
+
+/**
+ * A row with cells for formula computation.
+ */
+interface FormulaRow {
+    id: string;
+    databaseId: string;
+    cells: Record<string, CellValue>;
+}
+/**
+ * Result of formula validation.
+ */
+interface FormulaValidationResult {
+    valid: boolean;
+    error?: string;
+    dependencies?: string[];
+}
+declare class FormulaService {
+    private parser;
+    private astCache;
+    private valueCache;
+    /**
+     * Compute a formula value for a row.
+     *
+     * @example
+     * ```typescript
+     * const service = new FormulaService()
+     * const value = service.compute(row, formulaColumn, columns)
+     * ```
+     */
+    compute(row: FormulaRow, column: ColumnDefinition, columns: ColumnDefinition[]): unknown;
+    /**
+     * Batch compute formulas for multiple rows.
+     */
+    batchCompute(rows: FormulaRow[], column: ColumnDefinition, columns: ColumnDefinition[]): Map<string, unknown>;
+    /**
+     * Validate a formula expression.
+     *
+     * @example
+     * ```typescript
+     * const result = service.validate('{{price}} * {{quantity}}', columns)
+     * if (!result.valid) {
+     *   console.error(result.error)
+     * }
+     * ```
+     */
+    validate(expression: string, columns: ColumnDefinition[]): FormulaValidationResult;
+    /**
+     * Invalidate cache for a row.
+     */
+    invalidate(rowId: string): void;
+    /**
+     * Invalidate all cached values.
+     */
+    invalidateAll(): void;
+    /**
+     * Clear AST cache (use when formula expressions change).
+     */
+    clearAstCache(): void;
+    private computeHash;
+    private coerceResult;
+}
+/**
+ * Create a new FormulaService instance.
+ */
+declare function createFormulaService(): FormulaService;
+
+/**
+ * CSV parser for database import.
+ *
+ * Parses CSV text into headers and rows, with support for:
+ * - Quoted values with commas
+ * - Escaped quotes (doubled quotes)
+ * - Column type inference
+ * - Value parsing by type
+ */
+
+/**
+ * Result of parsing a CSV file.
+ */
+interface ParsedCSV {
+    /** Column headers from the first row */
+    headers: string[];
+    /** Data rows (each row is an array of string values) */
+    rows: string[][];
+}
+/**
+ * Options for CSV parsing.
+ */
+interface CsvParseOptions {
+    /** Delimiter character (default: comma) */
+    delimiter?: string;
+    /** Whether the first row contains headers (default: true) */
+    hasHeaders?: boolean;
+    /** Skip empty lines (default: true) */
+    skipEmptyLines?: boolean;
+}
+/**
+ * Parse CSV text into headers and rows.
+ *
+ * @example
+ * const csv = `name,age,active
+ * Alice,30,true
+ * Bob,25,false`
+ *
+ * const result = parseCSV(csv)
+ * // { headers: ['name', 'age', 'active'], rows: [['Alice', '30', 'true'], ['Bob', '25', 'false']] }
+ */
+declare function parseCSV(text: string, options?: CsvParseOptions): ParsedCSV;
+/**
+ * Parse a single CSV line into an array of values.
+ * Handles quoted values and escaped quotes.
+ */
+declare function parseCSVLine(line: string, delimiter?: string): string[];
+/**
+ * Guess the column type from sample values.
+ *
+ * @example
+ * guessColumnType(['1', '2.5', '100']) // 'number'
+ * guessColumnType(['true', 'false', 'yes']) // 'checkbox'
+ * guessColumnType(['2024-01-01', '2024-06-15']) // 'date'
+ */
+declare function guessColumnType(values: string[]): ColumnType;
+/**
+ * Parse a string value to the appropriate type.
+ *
+ * @example
+ * parseValue('42', 'number') // 42
+ * parseValue('true', 'checkbox') // true
+ * parseValue('2024-01-15', 'date') // '2024-01-15T00:00:00.000Z'
+ */
+declare function parseValue(value: string, type: ColumnType): unknown;
+/**
+ * Parse all values in a row according to column types.
+ */
+declare function parseRow(row: string[], headers: string[], columnTypes: Map<string, ColumnType>): Record<string, unknown>;
+/**
+ * Infer column types from all rows.
+ */
+declare function inferColumnTypes(headers: string[], rows: string[][]): Map<string, ColumnType>;
+
+/**
+ * JSON parser for database import.
+ *
+ * Parses JSON data into rows and inferred column definitions.
+ * Supports:
+ * - Array of objects: [{ name: 'Alice', age: 30 }, ...]
+ * - Object with rows property: { rows: [...], columns?: [...] }
+ */
+
+/**
+ * Result of parsing a JSON file.
+ */
+interface ParsedJSON {
+    /** Data rows as objects */
+    rows: Record<string, unknown>[];
+    /** Inferred or provided column definitions */
+    inferredColumns: InferredColumn[];
+}
+/**
+ * Inferred column from JSON data.
+ */
+interface InferredColumn {
+    /** Column name (from object keys) */
+    name: string;
+    /** Inferred column type */
+    type: ColumnType;
+    /** Sample values for preview */
+    sampleValues?: unknown[];
+}
+/**
+ * Options for JSON parsing.
+ */
+interface JsonParseOptions {
+    /** Maximum rows to parse (for large files) */
+    maxRows?: number;
+    /** Sample size for type inference */
+    sampleSize?: number;
+}
+/**
+ * Parse JSON text into rows and inferred columns.
+ *
+ * @example
+ * // Array of objects
+ * parseJSON('[{"name": "Alice", "age": 30}]')
+ *
+ * // Object with rows
+ * parseJSON('{"rows": [{"name": "Alice"}], "columns": [...]}')
+ */
+declare function parseJSON(text: string, options?: JsonParseOptions): ParsedJSON;
+/**
+ * Infer column definitions from rows.
+ */
+declare function inferColumnsFromRows(rows: Record<string, unknown>[], sampleSize?: number): InferredColumn[];
+/**
+ * Infer column type from JavaScript values.
+ */
+declare function inferTypeFromValues(values: unknown[]): ColumnType;
+/**
+ * Convert parsed JSON to column definitions with IDs.
+ */
+declare function toColumnDefinitions(inferredColumns: InferredColumn[]): ColumnDefinition[];
+/**
+ * Validate JSON data structure.
+ */
+declare function validateJsonData(data: unknown): {
+    valid: boolean;
+    errors: string[];
+};
+
+/**
+ * CSV exporter for database data.
+ *
+ * Exports database rows to CSV format with:
+ * - Configurable column selection
+ * - Proper escaping of special characters
+ * - Type-aware value formatting
+ */
+
+/**
+ * A database row for export.
+ */
+interface ExportRow$1 {
+    id: string;
+    sortKey: string;
+    cells: Record<string, unknown>;
+}
+/**
+ * Options for CSV export.
+ */
+interface CsvExportOptions {
+    /** Column IDs to include (default: all) */
+    columns?: string[];
+    /** Include header row (default: true) */
+    includeHeaders?: boolean;
+    /** Delimiter character (default: comma) */
+    delimiter?: string;
+    /** Line ending (default: CRLF for Windows compatibility) */
+    lineEnding?: string;
+    /** Date format (default: ISO) */
+    dateFormat?: 'iso' | 'locale' | 'short';
+}
+/**
+ * Export database rows to CSV format.
+ *
+ * @example
+ * const csv = exportToCsv(rows, columns)
+ * // "Name,Age\r\nAlice,30\r\nBob,25"
+ */
+declare function exportToCsv(rows: ExportRow$1[], columns: ColumnDefinition[], options?: CsvExportOptions): string;
+/**
+ * Escape a value for CSV output.
+ * Wraps in quotes if the value contains delimiter, quotes, or newlines.
+ */
+declare function escapeCSV(value: string, delimiter?: string): string;
+/**
+ * Format a cell value for CSV output.
+ */
+declare function formatValue(value: unknown, column: ColumnDefinition, dateFormat?: 'iso' | 'locale' | 'short'): string;
+/**
+ * Create a downloadable CSV blob.
+ */
+declare function createCsvBlob(csvContent: string): Blob;
+/**
+ * Trigger a CSV file download in the browser.
+ */
+declare function downloadCsv(csvContent: string, filename: string): void;
+
+/**
+ * JSON exporter for database data.
+ *
+ * Exports database rows to JSON format with:
+ * - Optional schema/column definitions
+ * - Configurable column selection
+ * - Pretty printing option
+ */
+
+/**
+ * A database row for export.
+ */
+interface ExportRow {
+    id: string;
+    sortKey: string;
+    cells: Record<string, unknown>;
+}
+/**
+ * Options for JSON export.
+ */
+interface JsonExportOptions {
+    /** Column IDs to include (default: all) */
+    columns?: string[];
+    /** Include column definitions in output (default: true) */
+    includeSchema?: boolean;
+    /** Pretty print with indentation (default: true) */
+    pretty?: boolean;
+    /** Include row IDs (default: false) */
+    includeIds?: boolean;
+    /** Use column names as keys instead of IDs (default: true) */
+    useColumnNames?: boolean;
+}
+/**
+ * Exported JSON structure.
+ */
+interface ExportedJSON {
+    /** Column definitions (if includeSchema is true) */
+    columns?: ExportedColumn[];
+    /** Data rows */
+    rows: Record<string, unknown>[];
+    /** Export metadata */
+    metadata?: {
+        exportedAt: string;
+        rowCount: number;
+        columnCount: number;
+    };
+}
+/**
+ * Exported column definition.
+ */
+interface ExportedColumn {
+    name: string;
+    type: string;
+    config?: Record<string, unknown>;
+}
+/**
+ * Export database rows to JSON format.
+ *
+ * @example
+ * const json = exportToJson(rows, columns)
+ * // { "columns": [...], "rows": [...] }
+ */
+declare function exportToJson(rows: ExportRow[], columns: ColumnDefinition[], options?: JsonExportOptions): string;
+/**
+ * Export rows as a simple array of objects (no schema).
+ */
+declare function exportToJsonArray(rows: ExportRow[], columns: ColumnDefinition[], options?: Omit<JsonExportOptions, 'includeSchema'>): string;
+/**
+ * Create a downloadable JSON blob.
+ */
+declare function createJsonBlob(jsonContent: string): Blob;
+/**
+ * Trigger a JSON file download in the browser.
+ */
+declare function downloadJson(jsonContent: string, filename: string): void;
+/**
+ * Export to NDJSON (Newline Delimited JSON) format.
+ * Useful for streaming large datasets.
+ */
+declare function exportToNdjson(rows: ExportRow[], columns: ColumnDefinition[], options?: Omit<JsonExportOptions, 'pretty' | 'includeSchema'>): string;
+
+/**
+ * Database Schema Resolver
+ *
+ * Factory for creating a remote resolver that can fetch database-defined schemas
+ * from their Y.Doc storage.
+ */
+
+/**
+ * Interface for fetching Y.Doc by document ID.
+ * This allows the resolver to work with any sync mechanism.
+ */
+interface DocFetcher {
+    /**
+     * Fetch a Y.Doc by its document ID.
+     * @returns The Y.Doc, or null if not found
+     */
+    getDoc(docId: string): Promise<Y.Doc | null>;
+}
+/**
+ * Options for creating a database schema resolver.
+ */
+interface CreateDatabaseSchemaResolverOptions {
+    /** The doc fetcher to use for retrieving Y.Doc instances */
+    docFetcher: DocFetcher;
+}
+/**
+ * Create a remote resolver for database-defined schemas.
+ *
+ * The resolver:
+ * 1. Parses the IRI to extract database ID and version
+ * 2. Fetches the database's Y.Doc
+ * 3. Extracts schema metadata and columns
+ * 4. Builds and returns the Schema object
+ *
+ * @example
+ * const resolver = createDatabaseSchemaResolver({
+ *   docFetcher: syncManager
+ * })
+ * schemaRegistry.setRemoteResolver(resolver)
+ */
+declare function createDatabaseSchemaResolver(options: CreateDatabaseSchemaResolverOptions): (iri: SchemaIRI) => Promise<Schema | null>;
+/**
+ * Extract schema from a loaded Y.Doc.
+ * Useful for direct access without going through the resolver.
+ *
+ * @param databaseId - The database node ID
+ * @param doc - The database's Y.Doc
+ * @returns The Schema object, or null if data is missing
+ */
+declare function extractSchemaFromDoc(databaseId: string, doc: Y.Doc): Schema | null;
+/**
+ * Get the current schema IRI for a database from its Y.Doc.
+ *
+ * @param databaseId - The database node ID
+ * @param doc - The database's Y.Doc
+ * @returns The schema IRI, or null if metadata is missing
+ */
+declare function getSchemaIRIFromDoc(databaseId: string, doc: Y.Doc): SchemaIRI | null;
+
+/**
+ * Database Schema Clone
+ *
+ * Utilities for cloning a database schema to create a new database
+ * with the same structure but fresh data.
+ */
+
+/**
+ * Options for cloning a database schema.
+ */
+interface CloneSchemaOptions {
+    /** Name for the new database (defaults to "Original Name (Copy)") */
+    name?: string;
+    /** Description for the new database */
+    description?: string;
+    /** Whether to include sample rows (default: false) */
+    includeRows?: boolean;
+    /** Maximum number of sample rows to include (default: 10) */
+    maxSampleRows?: number;
+}
+/**
+ * Result of cloning a database schema.
+ */
+interface CloneSchemaResult {
+    /** New column definitions with remapped IDs */
+    columns: StoredColumn[];
+    /** Mapping from old column IDs to new column IDs */
+    columnIdMap: Map<string, string>;
+    /** New schema metadata */
+    metadata: DatabaseSchemaMetadata;
+    /** Remapped view configurations */
+    views: {
+        tableView?: ViewConfig;
+        boardView?: ViewConfig;
+        [key: string]: ViewConfig | undefined;
+    };
+    /** Sample rows (if includeRows was true) */
+    sampleRows?: Array<Record<string, unknown>>;
+}
+/**
+ * Source data for cloning.
+ */
+interface CloneSourceData {
+    columns: StoredColumn[];
+    metadata: DatabaseSchemaMetadata;
+    tableView?: ViewConfig;
+    boardView?: ViewConfig;
+    rows?: Array<Record<string, unknown>>;
+}
+/**
+ * Generate new column IDs for cloning.
+ * Returns a map from old IDs to new IDs.
+ */
+declare function generateColumnIdMap(columns: StoredColumn[]): Map<string, string>;
+/**
+ * Clone columns with new IDs.
+ */
+declare function cloneColumns(columns: StoredColumn[], idMap: Map<string, string>): StoredColumn[];
+/**
+ * Remap column IDs in a view configuration.
+ * This handles all the places where column IDs are referenced.
+ */
+declare function remapViewColumnIds(view: ViewConfig, idMap: Map<string, string>): ViewConfig;
+/**
+ * Clone sample rows with new IDs.
+ */
+declare function cloneSampleRows(rows: Array<Record<string, unknown>>, idMap: Map<string, string>, maxRows?: number): Array<Record<string, unknown>>;
+/**
+ * Clone a database schema to create a new database.
+ *
+ * This creates new column definitions, remapped view configs,
+ * and fresh schema metadata with version 1.0.0.
+ *
+ * @param source - The source database data
+ * @param options - Clone options
+ * @returns The cloned schema data ready to be saved to a new Y.Doc
+ *
+ * @example
+ * ```typescript
+ * const source = {
+ *   columns: getColumns(doc),
+ *   metadata: getSchemaMetadata(doc),
+ *   tableView: getTableView(doc),
+ *   boardView: getBoardView(doc),
+ *   rows: getRows(doc)
+ * }
+ *
+ * const result = cloneSchema(source, { name: 'My New Database' })
+ *
+ * // Apply to new Y.Doc
+ * newDoc.getMap('data').set('columns', result.columns)
+ * newDoc.getMap('data').set('schema', result.metadata)
+ * // etc.
+ * ```
+ */
+declare function cloneSchema(source: CloneSourceData, options?: CloneSchemaOptions): CloneSchemaResult;
+
+export { toSelectOptionNode as $, needsRebalancing as A, getRichTextCell as B, type CellValue as C, type DateRange as D, hasRichTextContent as E, type FileRef as F, hasRichTextColumns as G, getRichTextColumnIds as H, deleteRichTextCell as I, getRichTextPlainText as J, type FieldType as K, type FieldConfig as L, MAX_KEY_LENGTH as M, type FieldNode as N, FIELD_TYPES as O, SELECT_COLORS as P, type QueryRowsOptions as Q, RICHTEXT_PREFIX as R, type SelectOptionNode as S, isFieldType as T, isSelectColor as U, autoColor as V, isNodeStoreFieldType as W, isComputedFieldType as X, isAutoFieldType as Y, isYDocFieldType as Z, toFieldNode as _, CELL_PREFIX as a, computeRollup as a$, type CreateFieldOptions as a0, type UpdateFieldOptions as a1, type CreateSelectOptionOptions as a2, getFields as a3, getField as a4, getTitleField as a5, createField as a6, updateField as a7, deleteField as a8, moveField as a9, toggleViewGroupCollapsed as aA, setFieldHidden as aB, setViewFieldWidth as aC, setViewFieldOrder as aD, effectiveFieldSortKey as aE, setupDatabase as aF, type SetupDatabaseResult as aG, DEFAULT_DATABASE_SCHEMA_VERSION as aH, fieldsToStoredColumns as aI, buildSchemaFromFields as aJ, getDatabaseSchemaIRI as aK, createNodeDatabaseSchemaResolver as aL, initializeDatabaseDoc as aM, isDatabaseDocInitialized as aN, addDefaultTitleColumn as aO, addDefaultTableView as aP, setupNewDatabase as aQ, getMeta as aR, setMeta as aS, deleteMeta as aT, getDatabaseDocumentModel as aU, type DatabaseDocumentModel as aV, convertCellValue as aW, cellValueToText as aX, type ConvertContext as aY, type ConvertedCell as aZ, aggregate as a_, duplicateField as aa, ensureSchemaExtension as ab, createExtensionField as ac, renameExtensionField as ad, deleteExtensionField as ae, type EnsureExtensionOptions as af, type CreateExtensionFieldOptions as ag, getSelectOptions as ah, getDatabaseSelectOptions as ai, createSelectOption as aj, updateSelectOption as ak, deleteSelectOption as al, moveSelectOption as am, type ViewNode as an, type CreateViewOptions as ao, type UpdateViewOptions as ap, getViews$1 as aq, getView$1 as ar, createView$1 as as, updateView$1 as at, deleteView$1 as au, duplicateView$1 as av, moveView as aw, setViewFilters$1 as ax, setViewSorts$1 as ay, setViewGroupBy$1 as az, columnIdFromKey as b, setVisibleColumns as b$, batchComputeRollups as b0, validateRollupConfig as b1, type RollupRow as b2, type RollupContext as b3, FormulaService as b4, createFormulaService as b5, type FormulaRow as b6, type FormulaValidationResult as b7, parseCSV as b8, parseCSVLine as b9, type JsonExportOptions as bA, type ExportedJSON as bB, type ExportedColumn as bC, getColumns as bD, getColumn as bE, getColumnIndex as bF, getTitleColumn as bG, createColumn as bH, updateColumn as bI, deleteColumn as bJ, reorderColumn as bK, duplicateColumn as bL, getViews as bM, getView as bN, getViewByType as bO, createView as bP, updateView as bQ, deleteView as bR, duplicateView as bS, setViewFilters as bT, clearViewFilters as bU, setViewSorts as bV, addViewSort as bW, removeViewSort as bX, clearViewSorts as bY, setViewGroupBy as bZ, toggleGroupCollapsed$1 as b_, guessColumnType as ba, parseValue as bb, parseRow as bc, inferColumnTypes as bd, parseJSON as be, inferColumnsFromRows as bf, inferTypeFromValues as bg, toColumnDefinitions as bh, validateJsonData as bi, type ParsedCSV as bj, type CsvParseOptions as bk, type ParsedJSON as bl, type InferredColumn as bm, type JsonParseOptions as bn, exportToCsv as bo, escapeCSV as bp, formatValue as bq, createCsvBlob as br, downloadCsv as bs, exportToJson as bt, exportToJsonArray as bu, exportToNdjson as bv, createJsonBlob as bw, downloadJson as bx, type ExportRow$1 as by, type CsvExportOptions as bz, cellKey as c, cloneSampleRows as c$, showColumn as c0, hideColumn as c1, reorderViewColumns as c2, setColumnWidth as c3, OPERATORS_BY_TYPE as c4, OPERATOR_LABELS as c5, getOperatorsForType as c6, isValidOperator as c7, getOperatorLabel as c8, operatorRequiresValue as c9, type QueryableRow as cA, type QueryOptions as cB, type QueryResult as cC, buildSchemaIRI as cD, parseDatabaseSchemaIRI as cE, isDatabaseSchemaIRI as cF, parseVersion as cG, bumpSchemaVersion as cH, createInitialSchemaMetadata as cI, buildDatabaseSchema as cJ, createVersionEntry as cK, pruneVersionHistory as cL, getVersionBumpType as cM, DATABASE_SCHEMA_NAMESPACE as cN, DATABASE_SCHEMA_PREFIX as cO, MAX_VERSION_HISTORY as cP, type DatabaseSchemaMetadata as cQ, type StoredColumn as cR, type SchemaVersionEntry as cS, type VersionBumpType as cT, createDatabaseSchemaResolver as cU, extractSchemaFromDoc as cV, getSchemaIRIFromDoc as cW, type DocFetcher as cX, type CreateDatabaseSchemaResolverOptions as cY, cloneSchema as cZ, cloneColumns as c_, filterRows as ca, createEqualsFilter as cb, createAnyOfFilter as cc, combineFiltersAnd as cd, combineFiltersOr as ce, type FilterableRow as cf, sortRows as cg, createSort as ch, toggleSortDirection as ci, addOrToggleSort as cj, removeSort as ck, type SortableRow as cl, groupRows as cm, toggleGroupCollapsed as cn, expandAllGroups as co, collapseAllGroups as cp, type GroupableRow as cq, type GroupConfig as cr, type RowGroup as cs, type GroupAggregates as ct, executeQuery as cu, createFilterQuery as cv, createSortQuery as cw, createPaginatedQuery as cx, flattenGroups as cy, getTotalFromGroups as cz, isDateRange as d, generateColumnIdMap as d0, remapViewColumnIds as d1, type CloneSchemaOptions as d2, type CloneSchemaResult as d3, type CloneSourceData as d4, getEmptyValue as d5, isNumericAggregation as d6, getAggregationResultType as d7, isFileRef as e, fromCellProperties as f, isCellValue as g, type CreateRowOptions as h, isCellKey as i, type QueryRowsResult as j, type DatabaseRowNode as k, createRow as l, updateCells as m, deleteRow as n, getRow as o, moveRow as p, queryRows as q, rebalanceDatabase as r, checkNeedsRebalancing as s, toCellProperties as t, updateCell as u, generateSortKey as v, generateSortKeyWithJitter as w, isValidSortKey as x, compareSortKeys as y, rebalanceSortKeys as z };