@xnetjs/data 0.2.0 → 0.4.0

package/dist/form-types-BlZvpDEE.d.ts

@@ -0,0 +1,645 @@
+/**
+ * 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;
+
+/**
+ * Column type definitions for database columns.
+ *
+ * Columns are stored in the database's Y.Doc as a Y.Array of Y.Maps,
+ * enabling CRDT-based ordering and real-time schema sync.
+ */
+/**
+ * All supported column types.
+ */
+type ColumnType = 'text' | 'number' | 'checkbox' | 'date' | 'dateRange' | 'select' | 'multiSelect' | 'person' | 'url' | 'email' | 'phone' | 'file' | 'relation' | 'tasks' | 'rollup' | 'formula' | 'richText' | 'created' | 'createdBy' | 'updated' | 'updatedBy';
+/**
+ * Column definition stored in the database's Y.Doc.
+ */
+interface ColumnDefinition {
+    /** Unique column ID (nanoid) */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Column type */
+    type: ColumnType;
+    /** Type-specific configuration */
+    config: ColumnConfig;
+    /** Width in pixels (for table view) */
+    width?: number;
+    /** Whether this is the title column */
+    isTitle?: boolean;
+}
+/**
+ * Union of all column configuration types.
+ */
+type ColumnConfig = TextColumnConfig | NumberColumnConfig | SelectColumnConfig | RelationColumnConfig | RollupColumnConfig | FormulaColumnConfig | DateColumnConfig | FileColumnConfig | EmptyConfig;
+/**
+ * Empty config for simple types with no configuration.
+ */
+type EmptyConfig = Record<string, never>;
+/**
+ * Text column configuration.
+ */
+interface TextColumnConfig {
+    /** Maximum length (optional) */
+    maxLength?: number;
+}
+/**
+ * Number column configuration.
+ */
+interface NumberColumnConfig {
+    /** Number format */
+    format?: 'number' | 'percent' | 'currency';
+    /** Currency code (if format is currency) */
+    currency?: string;
+    /** Decimal places */
+    precision?: number;
+}
+/**
+ * Select/MultiSelect column configuration.
+ */
+interface SelectColumnConfig {
+    /** Available options */
+    options: SelectOption[];
+    /** Allow creating new options inline */
+    allowCreate?: boolean;
+}
+/**
+ * A single select option.
+ */
+interface SelectOption {
+    id: string;
+    name: string;
+    color?: SelectColor;
+}
+/**
+ * Available colors for select options.
+ */
+type SelectColor = 'gray' | 'brown' | 'orange' | 'yellow' | 'green' | 'blue' | 'purple' | 'pink' | 'red';
+/**
+ * Relation column configuration.
+ */
+interface RelationColumnConfig {
+    /** Target database ID */
+    targetDatabase: string;
+    /** Allow multiple relations */
+    allowMultiple?: boolean;
+}
+/**
+ * Rollup column configuration.
+ */
+interface RollupColumnConfig {
+    /** Column ID of the relation to aggregate */
+    relationColumn: string;
+    /** Column ID on related rows to aggregate */
+    targetColumn: string;
+    /** Aggregation function */
+    aggregation: RollupAggregation;
+}
+/**
+ * Available rollup aggregation functions.
+ */
+type RollupAggregation = 'sum' | 'avg' | 'count' | 'min' | 'max' | 'concat' | 'unique' | 'empty' | 'notEmpty' | 'percentEmpty' | 'percentNotEmpty';
+/**
+ * Formula column configuration.
+ */
+interface FormulaColumnConfig {
+    /** Formula expression with {{columnId}} references */
+    expression: string;
+    /** Result type */
+    resultType: 'text' | 'number' | 'date' | 'checkbox';
+    /** Cached dependencies (auto-computed from expression) */
+    dependencies?: string[];
+}
+/**
+ * Date column configuration.
+ */
+interface DateColumnConfig {
+    /** Include time */
+    includeTime?: boolean;
+    /** Date format */
+    format?: 'full' | 'short' | 'relative';
+}
+/**
+ * File column configuration.
+ */
+interface FileColumnConfig {
+    /** Accepted MIME types */
+    accept?: string[];
+    /** Allow multiple files */
+    allowMultiple?: boolean;
+}
+/**
+ * Check if a column type stores data in NodeStore (vs Y.Doc).
+ */
+declare function isNodeStoreColumnType(type: ColumnType): boolean;
+/**
+ * Check if a column type is computed (formula/rollup).
+ */
+declare function isComputedColumnType(type: ColumnType): boolean;
+/**
+ * Check if a column type is auto-populated.
+ */
+declare function isAutoColumnType(type: ColumnType): boolean;
+/**
+ * Check if a column type uses Y.Doc for storage.
+ */
+declare function isYDocColumnType(type: ColumnType): boolean;
+
+/**
+ * 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;
+
+/**
+ * Row-height density tiers for the database grid (Airtable parity).
+ *
+ * A view persists a named tier; the grid resolves it to a pixel height that
+ * `GridSurface` uses for virtualization and row layout. Pure + tiny so the
+ * toolbar control, the schema default, and the grid all agree on one mapping.
+ */
+/** Named row-height tiers, densest first. */
+type RowHeight = 'short' | 'medium' | 'tall' | 'extraTall';
+/** Pixel height per tier (approximating Airtable's Short/Medium/Tall/Extra). */
+declare const ROW_HEIGHT_PX: Record<RowHeight, number>;
+/** Tier order for cycling / menu rendering. */
+declare const ROW_HEIGHTS: RowHeight[];
+/** Human label for a tier. */
+declare function rowHeightLabel(height: RowHeight): string;
+/** The default tier (densest, matching the prior fixed look). */
+declare const DEFAULT_ROW_HEIGHT: RowHeight;
+/**
+ * Resolve a persisted value (possibly undefined or an unknown string) to a
+ * pixel height, falling back to the default tier.
+ */
+declare function resolveRowHeightPx(height: string | null | undefined): number;
+/** Narrow an arbitrary string to a `RowHeight`, or the default. */
+declare function asRowHeight(height: string | null | undefined): RowHeight;
+
+/**
+ * Summary engine for the database grid's footer bar (Airtable parity).
+ *
+ * Pure, store-agnostic per-column aggregations: given the rows currently in
+ * view, a column, and a chosen {@link SummaryFunction}, compute one footer
+ * value. Type-aware — `SUMMARY_FUNCTIONS_BY_TYPE` lists which functions a
+ * given column type may offer. Numbers add sum/average/min/max/range/median;
+ * checkboxes add checked/unchecked; dates add earliest/latest; every type
+ * offers the count family (filled/empty/unique and their percentages).
+ *
+ * Kept deliberately free of React/Y.Doc/NodeStore so it is trivially unit
+ * tested and shared by `GridSummaryBar` and any future query-result footer.
+ */
+
+/** A row reduced to the cells the summary bar reads. */
+interface SummaryRow {
+    cells: Record<string, unknown>;
+}
+/** The minimum a summary needs to know about a column. */
+interface SummaryColumnLike {
+    id: string;
+    type: ColumnType;
+}
+/** A footer aggregation. `none` renders nothing. */
+type SummaryFunction = 'none' | 'filled' | 'empty' | 'percentFilled' | 'percentEmpty' | 'unique' | 'sum' | 'average' | 'min' | 'max' | 'range' | 'median' | 'checked' | 'unchecked' | 'percentChecked' | 'percentUnchecked' | 'earliest' | 'latest';
+/** The result of computing one column summary. */
+interface ColumnSummaryResult {
+    fn: SummaryFunction;
+    /** Numeric value where meaningful (percentages are 0–100); else null. */
+    value: number | null;
+    /** Formatted display string (`''` for `none`, `'—'` for empty/N-A). */
+    display: string;
+}
+/** Which summary functions each column type offers, in menu order. */
+declare const SUMMARY_FUNCTIONS_BY_TYPE: Record<ColumnType, SummaryFunction[]>;
+/** Human label for a summary function (for menus and footer captions). */
+declare function summaryFunctionLabel(fn: SummaryFunction): string;
+/** A cell counts as filled unless it is null/undefined, '', or an empty array. */
+declare function isFilledValue(value: unknown): boolean;
+/**
+ * Compute a single column summary over the in-view rows.
+ *
+ * @param rows - rows currently displayed (already filtered)
+ * @param column - the column being summarised
+ * @param fn - the chosen aggregation
+ */
+declare function computeColumnSummary(rows: readonly SummaryRow[], column: SummaryColumnLike, fn: SummaryFunction): ColumnSummaryResult;
+
+/**
+ * View type definitions for database views.
+ *
+ * Views are stored in the database's Y.Doc as a Y.Map of view configs,
+ * enabling collaborative view editing and real-time sync.
+ */
+
+/**
+ * Available view types.
+ */
+type ViewType = 'table' | 'board' | 'list' | 'gallery' | 'calendar' | 'timeline' | 'form';
+/**
+ * View configuration stored in the database's Y.Doc.
+ */
+interface ViewConfig {
+    /** Unique view ID */
+    id: string;
+    /** Display name */
+    name: string;
+    /** View type */
+    type: ViewType;
+    /** Column visibility and order */
+    visibleColumns: string[];
+    /** Per-column widths (overrides column.width) */
+    columnWidths?: Record<string, number>;
+    /** Filter configuration */
+    filters?: FilterGroup | null;
+    /** Sort configuration */
+    sorts?: SortConfig[];
+    /** Group by column ID */
+    groupBy?: string | null;
+    /** Group sort direction */
+    groupSort?: 'asc' | 'desc';
+    /** Collapsed group IDs */
+    collapsedGroups?: string[];
+    /** Row-height density tier */
+    rowHeight?: RowHeight;
+    /** Per-column footer summary functions: columnId -> SummaryFunction */
+    columnSummaries?: Record<string, SummaryFunction>;
+    /** Cover image column ID */
+    coverColumn?: string;
+    /** Card size */
+    cardSize?: 'small' | 'medium' | 'large';
+    /** Start date column ID */
+    dateColumn?: string;
+    /** End date column ID */
+    endDateColumn?: string;
+}
+/**
+ * A group of filter conditions combined with AND/OR.
+ */
+interface FilterGroup {
+    /** Logical operator */
+    operator: 'and' | 'or';
+    /** Conditions or nested groups */
+    conditions: Array<FilterCondition | FilterGroup>;
+}
+/**
+ * A single filter condition.
+ */
+interface FilterCondition {
+    /** Column ID to filter on */
+    columnId: string;
+    /** Filter operator */
+    operator: FilterOperator;
+    /** Filter value (type depends on column type and operator) */
+    value: unknown;
+}
+/**
+ * Available filter operators.
+ */
+type FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'isEmpty' | 'isNotEmpty' | 'greaterThan' | 'lessThan' | 'greaterOrEqual' | 'lessOrEqual' | 'before' | 'after' | 'between' | 'hasAny' | 'hasAll' | 'hasNone';
+/**
+ * Sort configuration for a column.
+ */
+interface SortConfig {
+    /** Column ID to sort by */
+    columnId: string;
+    /** Sort direction */
+    direction: 'asc' | 'desc';
+}
+/**
+ * Check if a filter item is a group (vs a condition).
+ */
+declare function isFilterGroup(item: FilterCondition | FilterGroup): item is FilterGroup;
+/**
+ * Check if a filter item is a condition (vs a group).
+ */
+declare function isFilterCondition(item: FilterCondition | FilterGroup): item is FilterCondition;
+/**
+ * Check if a view type supports grouping.
+ */
+declare function supportsGrouping(type: ViewType): boolean;
+/**
+ * Check if a view type requires a date column.
+ */
+declare function requiresDateColumn(type: ViewType): boolean;
+
+/**
+ * Form view types and validation (exploration 0278).
+ *
+ * A form is a `DatabaseView` of type `'form'`: the view node carries the
+ * question list, per-question show-if rules, and submission settings; every
+ * accepted submission becomes a new `DatabaseRow`. The validation core here
+ * is deliberately UI-free so the same code runs in the in-app fill view and
+ * at drain time when the owner's client materializes public submissions
+ * (which may arrive long after the fields changed).
+ *
+ * Show-if rules reuse the `FilterCondition` grammar and the filter engine:
+ * a rule is evaluated by running the in-progress answers as a single
+ * pseudo-row through `filterRows`, so form logic and view filters can never
+ * drift apart in operator semantics.
+ */
+
+/** One question on the form; omitted fields are not asked. */
+interface FormQuestion {
+    /** DatabaseField node id this question writes to. */
+    fieldId: string;
+    /** Overrides the field name as the question label. */
+    label?: string;
+    /** Helper text under the label. */
+    description?: string;
+    /** Require an answer (independent of the field's own required flag). */
+    required?: boolean;
+}
+/** Confirmation screen shown after a successful submission. */
+interface FormConfirmation {
+    title?: string;
+    body?: string;
+}
+/** Form view configuration (the `formConfig` json property). */
+interface FormViewConfig {
+    /** Defaults to the database title. */
+    title?: string;
+    description?: string;
+    /** Ordered question list. */
+    questions: FormQuestion[];
+    confirmation?: FormConfirmation;
+    submitLabel?: string;
+}
+/**
+ * Per-question show-if rule (the `formRules` json property, keyed by
+ * fieldId). The question renders only when the conditions hold against the
+ * in-progress answers. Conditions use the same shape/operators as view
+ * filters (`FilterCondition`).
+ */
+interface FormFieldRule {
+    when: FilterCondition[];
+    /** 'all' = AND, 'any' = OR. */
+    match: 'all' | 'any';
+}
+/**
+ * Provenance stamped on rows created by a form submission (the row's
+ * `submissionMeta` property). `nonce` is the submitter's idempotency key:
+ * public submissions derive the row id from it, so retries and double-drains
+ * LWW-upsert instead of duplicating.
+ */
+interface FormSubmissionMeta {
+    via: 'form';
+    /** The form view the submission came through. */
+    viewId: string;
+    /** Client-generated idempotency key (public submissions). */
+    nonce?: string;
+    /** When the submission was received (hub time for public, client for in-app). */
+    submittedAt: number;
+}
+/**
+ * A question as published to the hub for the public form page: the
+ * `FormQuestion` config plus just enough field shape (type, select options)
+ * to render an editor — never the full field node.
+ */
+interface PublicFormQuestion extends FormQuestion {
+    type: FieldType;
+    options?: Array<{
+        id: string;
+        name: string;
+        color?: string;
+    }>;
+}
+/**
+ * The sanitized snapshot the owner's client publishes when minting or
+ * refreshing a public form link. This is the ONLY thing the hub serves to
+ * anonymous respondents, so building it here — through the public field
+ * gate — is the leak barrier: no DIDs, node ids (beyond fieldIds), row
+ * data, or workspace structure.
+ */
+interface PublicFormDefinition {
+    title?: string;
+    description?: string;
+    questions: PublicFormQuestion[];
+    /** Show-if rules for the published questions only. */
+    rules?: Record<string, FormFieldRule>;
+    submitLabel?: string;
+    confirmation?: FormConfirmation;
+}
+type PublicOption = {
+    id: string;
+    name: string;
+    color?: string;
+};
+/**
+ * Build the public snapshot from the form view config and the current
+ * fields. Questions whose field is missing or not public-safe are dropped;
+ * select options are reduced to id/name/color.
+ */
+declare function buildPublicFormDefinition(config: FormViewConfig, rules: Record<string, FormFieldRule> | undefined, columns: ColumnDefinition[], fieldOptions?: Record<string, PublicOption[]>): PublicFormDefinition;
+/**
+ * Deterministic row id for a drained public submission: retries and
+ * double-drains produce the same id, so the create is an LWW upsert.
+ * SHA-256 via WebCrypto (browser and Node ≥19).
+ */
+declare function submissionRowId(tokenHash: string, nonce: string): Promise<string>;
+/**
+ * Field types an anonymous public respondent may be asked. Everything that
+ * leaks workspace data (person/relation), requires identity or blob plumbing
+ * (file), or is computed/auto is excluded.
+ */
+declare const PUBLIC_SAFE_FORM_FIELD_TYPES: readonly FieldType[];
+/** Where the form is being filled from. */
+type FormAudience = 'workspace' | 'public';
+/**
+ * Whether a field type may appear as a form question for the given audience.
+ * Workspace forms additionally allow person/relation/file (respondents are
+ * authenticated members with blob + graph access); computed and auto fields
+ * are never askable.
+ */
+declare function isFormFieldTypeAllowed(type: FieldType, audience: FormAudience): boolean;
+/**
+ * Evaluate a show-if rule against the in-progress answers. Empty/missing
+ * rules always show. A condition referencing a deleted field passes (the
+ * filter-engine semantic), so the question stays reachable instead of being
+ * permanently hidden behind an unsatisfiable rule.
+ */
+declare function isFormQuestionVisible(rule: FormFieldRule | undefined, answers: Record<string, CellValue>, columns: ColumnDefinition[]): boolean;
+/**
+ * The questions currently visible: configured, allowed for the audience,
+ * backed by a live field, and passing their show-if rule.
+ */
+declare function visibleFormQuestions(config: FormViewConfig, rules: Record<string, FormFieldRule> | undefined, answers: Record<string, CellValue>, columns: ColumnDefinition[], audience: FormAudience): FormQuestion[];
+interface FormValidationError {
+    fieldId: string;
+    /** Machine-readable reason; the UI maps these to copy. */
+    reason: 'required' | 'unknown-field' | 'type-not-allowed' | 'bad-option' | 'bad-value';
+}
+interface FormValidationResult {
+    ok: boolean;
+    errors: FormValidationError[];
+    /** Answers restricted to visible questions, ready for `cell_` mapping. */
+    cells: Record<string, CellValue>;
+}
+/**
+ * Validate a submission against the form config and the *current* fields.
+ * Answers for hidden (rule-suppressed) or unconfigured questions are dropped,
+ * not errors — respondents may race a config edit. Unknown field ids and
+ * disallowed types ARE errors: they signal drift between submission and
+ * schema that a human should review (exploration 0278's Rejected state).
+ */
+declare function validateFormSubmission(config: FormViewConfig, rules: Record<string, FormFieldRule> | undefined, answers: Record<string, CellValue>, columns: ColumnDefinition[], audience: FormAudience): FormValidationResult;
+
+export { isFilterCondition as $, toSelectOptionNode as A, type ColumnType as B, type CellValue as C, type DateRange as D, type ColumnDefinition as E, type FileRef as F, type ColumnConfig as G, type EmptyConfig as H, type SelectColumnConfig as I, type SelectOption as J, type SelectColor as K, type RollupAggregation as L, isNodeStoreColumnType as M, type NumberColumnConfig as N, isComputedColumnType as O, isAutoColumnType as P, isYDocColumnType as Q, type RelationColumnConfig as R, type SelectOptionNode as S, type TextColumnConfig as T, type ViewConfig as U, type ViewType as V, type FilterGroup as W, type FilterCondition as X, type FilterOperator as Y, type SortConfig as Z, isFilterGroup as _, CELL_PREFIX as a, supportsGrouping as a0, requiresDateColumn as a1, type FormQuestion as a2, type FormConfirmation as a3, type FormViewConfig as a4, type FormFieldRule as a5, type FormAudience as a6, type FormSubmissionMeta as a7, type FormValidationError as a8, type FormValidationResult as a9, type PublicFormQuestion as aa, type PublicFormDefinition as ab, PUBLIC_SAFE_FORM_FIELD_TYPES as ac, isFormFieldTypeAllowed as ad, isFormQuestionVisible as ae, visibleFormQuestions as af, validateFormSubmission as ag, buildPublicFormDefinition as ah, submissionRowId as ai, SUMMARY_FUNCTIONS_BY_TYPE as aj, summaryFunctionLabel as ak, isFilledValue as al, computeColumnSummary as am, type SummaryFunction as an, type SummaryRow as ao, type SummaryColumnLike as ap, type ColumnSummaryResult as aq, ROW_HEIGHT_PX as ar, ROW_HEIGHTS as as, DEFAULT_ROW_HEIGHT as at, rowHeightLabel as au, resolveRowHeightPx as av, asRowHeight as aw, type RowHeight as ax, columnIdFromKey as b, cellKey as c, isDateRange as d, isFileRef as e, fromCellProperties as f, isCellValue as g, type FieldType as h, isCellKey as i, type FieldConfig as j, type FieldNode as k, type RollupColumnConfig as l, type FormulaColumnConfig as m, type DateColumnConfig as n, type FileColumnConfig as o, FIELD_TYPES as p, SELECT_COLORS as q, isFieldType as r, isSelectColor as s, toCellProperties as t, autoColor as u, isNodeStoreFieldType as v, isComputedFieldType as w, isAutoFieldType as x, isYDocFieldType as y, toFieldNode as z };