@elaraai/e3-ui 1.0.86 → 1.0.88

package/dist/src/sheet/fields.d.ts

@@ -0,0 +1,693 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * The Sheet's inspector forms (#1188, `Sheet Builder Spec.md` §5.3,
+ * SB10): every field of a row — a grouped sheet's line — and of a group,
+ * resolved through `Fields`, each column's kind its field's default hint and
+ * an explicit hint (`fields`, `groupFields`) winning.
+ *
+ * | The field's column | Its editor |
+ * |---|---|
+ * | `text` | Text |
+ * | `custom` | Text — the column's own `print` shows it, its `parse` reads it |
+ * | `date` | The date field, at the row's date level (the renderer sets its precision) |
+ * | `quantity`, `integer` | The number field — a quantity in the driver's unit |
+ * | `lookup`, `reference`, `enum` | A select over the register's members (`reference` of the register) |
+ * | `set`, `link` | Read only here: the renderer draws the members, and edits them in the grid |
+ * | `stamped`, a `value` projection, `editable: false` | Read only |
+ * | No column | By its type, as `Fields.specs` resolves it |
+ *
+ * A field with a column is read and written through it: its spec names the
+ * column (or the band cell, on a group), and an edit in the inspector is the
+ * cell's write, as typing in it is (SB52). A field with none is the draft's
+ * own. A hint may label a column's field, give it a help line, make it read
+ * only or hide it; an editor hint must fit the field's type, and a read-only
+ * column takes none. Each form carries the cells a patch of its struct sets
+ * (`encode`) — the projection the copilot's proposals and the templates go
+ * through — so a whole-row write (a custom inspector's `update`, SB58) lands
+ * on the cells as the grid would write them.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, BlobType, FunctionType, OptionType, StringType, StructType, type ExprType } from "@elaraai/east";
+import { type SheetBridge, type SheetColumnMeta } from "./bridge.js";
+/**
+ * One field of an inspector form on the wire.
+ *
+ * @property spec - What the form draws — `Fields`' spec
+ * @property column - The column it is read and written through, by key (on a group, the band cell's key); `none` for a field the draft holds alone
+ */
+export declare const SheetFieldType: StructType<{
+    readonly spec: StructType<{
+        readonly path: ArrayType<StringType>;
+        readonly label: StringType;
+        readonly help: OptionType<StringType>;
+        readonly group: OptionType<StringType>;
+        readonly type: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+            readonly Never: import("@elaraai/east").NullType;
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").NullType;
+            readonly Integer: import("@elaraai/east").NullType;
+            readonly Float: import("@elaraai/east").NullType;
+            readonly String: import("@elaraai/east").NullType;
+            readonly DateTime: import("@elaraai/east").NullType;
+            readonly Blob: import("@elaraai/east").NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: import("@elaraai/east").VariantType<{
+                readonly ref: import("@elaraai/east").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("@elaraai/east").IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly optional: import("@elaraai/east").BooleanType;
+        readonly editor: import("@elaraai/east").VariantType<{
+            readonly text: StructType<{
+                readonly placeholder: OptionType<StringType>;
+            }>;
+            readonly number: StructType<{
+                readonly unit: OptionType<StringType>;
+                readonly step: OptionType<import("@elaraai/east").FloatType>;
+                readonly min: OptionType<import("@elaraai/east").FloatType>;
+                readonly max: OptionType<import("@elaraai/east").FloatType>;
+            }>;
+            readonly checkbox: import("@elaraai/east").NullType;
+            readonly datetime: StructType<{
+                readonly precision: OptionType<import("@elaraai/east").VariantType<{
+                    readonly date: import("@elaraai/east").NullType;
+                    readonly time: import("@elaraai/east").NullType;
+                    readonly datetime: import("@elaraai/east").NullType;
+                }>>;
+            }>;
+            readonly select: ArrayType<StructType<{
+                readonly case: StringType;
+                readonly label: StringType;
+            }>>;
+            readonly tags: StructType<{
+                readonly options: ArrayType<StringType>;
+            }>;
+            readonly checklist: StructType<{
+                readonly text: StringType;
+                readonly done: StringType;
+            }>;
+            readonly reference: StructType<{
+                readonly of: StringType;
+            }>;
+            readonly readonly: import("@elaraai/east").NullType;
+        }>;
+    }>;
+    readonly column: OptionType<StringType>;
+}>;
+/** Type representing {@link SheetFieldType}. */
+export type SheetFieldType = typeof SheetFieldType;
+/**
+ * One inspector form on the wire: the struct it edits, its fields in the
+ * form's order, and the cells a patch of the struct sets.
+ *
+ * @property type - The struct the form edits — the row (a grouped sheet's line), or the group
+ * @property fields - Its fields: the hinted first, in hint order, then the rest in declared order
+ * @property columns - The struct's fields its editable columns write — a column's own, a link's other half — whatever the form shows: a whole-row write sets these through `encode`
+ * @property readonly - The struct's fields its read-only columns show — a stamped code, a `value` projection, a column `editable: false` — which a whole-row write leaves as they are, as the grid does; every other field a whole-row write sets on the draft
+ * @property encode - A `Sheet.Types.Patch` of the struct, encoded (beast2) → the cells it sets through the sheet's editable columns (or the band's cells)
+ */
+export declare const SheetFormType: StructType<{
+    readonly type: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+        readonly Never: import("@elaraai/east").NullType;
+        readonly Null: import("@elaraai/east").NullType;
+        readonly Boolean: import("@elaraai/east").NullType;
+        readonly Integer: import("@elaraai/east").NullType;
+        readonly Float: import("@elaraai/east").NullType;
+        readonly String: import("@elaraai/east").NullType;
+        readonly DateTime: import("@elaraai/east").NullType;
+        readonly Blob: import("@elaraai/east").NullType;
+        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Dict: StructType<{
+            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Struct: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Variant: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Recursive: import("@elaraai/east").VariantType<{
+            readonly ref: import("@elaraai/east").IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: import("@elaraai/east").IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    readonly fields: ArrayType<StructType<{
+        readonly spec: StructType<{
+            readonly path: ArrayType<StringType>;
+            readonly label: StringType;
+            readonly help: OptionType<StringType>;
+            readonly group: OptionType<StringType>;
+            readonly type: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                readonly Never: import("@elaraai/east").NullType;
+                readonly Null: import("@elaraai/east").NullType;
+                readonly Boolean: import("@elaraai/east").NullType;
+                readonly Integer: import("@elaraai/east").NullType;
+                readonly Float: import("@elaraai/east").NullType;
+                readonly String: import("@elaraai/east").NullType;
+                readonly DateTime: import("@elaraai/east").NullType;
+                readonly Blob: import("@elaraai/east").NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: import("@elaraai/east").VariantType<{
+                    readonly ref: import("@elaraai/east").IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: import("@elaraai/east").IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly optional: import("@elaraai/east").BooleanType;
+            readonly editor: import("@elaraai/east").VariantType<{
+                readonly text: StructType<{
+                    readonly placeholder: OptionType<StringType>;
+                }>;
+                readonly number: StructType<{
+                    readonly unit: OptionType<StringType>;
+                    readonly step: OptionType<import("@elaraai/east").FloatType>;
+                    readonly min: OptionType<import("@elaraai/east").FloatType>;
+                    readonly max: OptionType<import("@elaraai/east").FloatType>;
+                }>;
+                readonly checkbox: import("@elaraai/east").NullType;
+                readonly datetime: StructType<{
+                    readonly precision: OptionType<import("@elaraai/east").VariantType<{
+                        readonly date: import("@elaraai/east").NullType;
+                        readonly time: import("@elaraai/east").NullType;
+                        readonly datetime: import("@elaraai/east").NullType;
+                    }>>;
+                }>;
+                readonly select: ArrayType<StructType<{
+                    readonly case: StringType;
+                    readonly label: StringType;
+                }>>;
+                readonly tags: StructType<{
+                    readonly options: ArrayType<StringType>;
+                }>;
+                readonly checklist: StructType<{
+                    readonly text: StringType;
+                    readonly done: StringType;
+                }>;
+                readonly reference: StructType<{
+                    readonly of: StringType;
+                }>;
+                readonly readonly: import("@elaraai/east").NullType;
+            }>;
+        }>;
+        readonly column: OptionType<StringType>;
+    }>>;
+    readonly columns: ArrayType<StringType>;
+    readonly readonly: ArrayType<StringType>;
+    readonly encode: FunctionType<[BlobType], import("@elaraai/east").DictType<StringType, import("@elaraai/east").VariantType<{
+        readonly Invalid: StringType;
+        readonly Null: import("@elaraai/east").NullType;
+        readonly Boolean: import("@elaraai/east").BooleanType;
+        readonly Integer: import("@elaraai/east").IntegerType;
+        readonly Float: import("@elaraai/east").FloatType;
+        readonly String: StringType;
+        readonly DateTime: import("@elaraai/east").DateTimeType;
+        readonly Link: StructType<{
+            readonly from: ArrayType<import("@elaraai/east").VariantType<{
+                readonly identified: StructType<{
+                    readonly key: StringType;
+                }>;
+                readonly range: StructType<{
+                    readonly from: StringType;
+                    readonly to: StringType;
+                }>;
+                readonly counted: StructType<{
+                    readonly n: import("@elaraai/east").IntegerType;
+                    readonly key: StringType;
+                }>;
+                readonly placeholder: import("@elaraai/east").NullType;
+                readonly text: StringType;
+            }>>;
+            readonly to: ArrayType<import("@elaraai/east").VariantType<{
+                readonly identified: StructType<{
+                    readonly key: StringType;
+                }>;
+                readonly range: StructType<{
+                    readonly from: StringType;
+                    readonly to: StringType;
+                }>;
+                readonly counted: StructType<{
+                    readonly n: import("@elaraai/east").IntegerType;
+                    readonly key: StringType;
+                }>;
+                readonly placeholder: import("@elaraai/east").NullType;
+                readonly text: StringType;
+            }>>;
+        }>;
+    }>>>;
+}>;
+/** Type representing {@link SheetFormType}. */
+export type SheetFormType = typeof SheetFormType;
+/**
+ * The inspector's forms on the wire.
+ *
+ * @property row - A row's — a grouped sheet's line's
+ * @property group - A group's own fields, on a grouped sheet
+ */
+export declare const SheetFormsType: StructType<{
+    readonly row: StructType<{
+        readonly type: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+            readonly Never: import("@elaraai/east").NullType;
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").NullType;
+            readonly Integer: import("@elaraai/east").NullType;
+            readonly Float: import("@elaraai/east").NullType;
+            readonly String: import("@elaraai/east").NullType;
+            readonly DateTime: import("@elaraai/east").NullType;
+            readonly Blob: import("@elaraai/east").NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: import("@elaraai/east").VariantType<{
+                readonly ref: import("@elaraai/east").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("@elaraai/east").IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly fields: ArrayType<StructType<{
+            readonly spec: StructType<{
+                readonly path: ArrayType<StringType>;
+                readonly label: StringType;
+                readonly help: OptionType<StringType>;
+                readonly group: OptionType<StringType>;
+                readonly type: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                    readonly Never: import("@elaraai/east").NullType;
+                    readonly Null: import("@elaraai/east").NullType;
+                    readonly Boolean: import("@elaraai/east").NullType;
+                    readonly Integer: import("@elaraai/east").NullType;
+                    readonly Float: import("@elaraai/east").NullType;
+                    readonly String: import("@elaraai/east").NullType;
+                    readonly DateTime: import("@elaraai/east").NullType;
+                    readonly Blob: import("@elaraai/east").NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: import("@elaraai/east").VariantType<{
+                        readonly ref: import("@elaraai/east").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("@elaraai/east").IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly optional: import("@elaraai/east").BooleanType;
+                readonly editor: import("@elaraai/east").VariantType<{
+                    readonly text: StructType<{
+                        readonly placeholder: OptionType<StringType>;
+                    }>;
+                    readonly number: StructType<{
+                        readonly unit: OptionType<StringType>;
+                        readonly step: OptionType<import("@elaraai/east").FloatType>;
+                        readonly min: OptionType<import("@elaraai/east").FloatType>;
+                        readonly max: OptionType<import("@elaraai/east").FloatType>;
+                    }>;
+                    readonly checkbox: import("@elaraai/east").NullType;
+                    readonly datetime: StructType<{
+                        readonly precision: OptionType<import("@elaraai/east").VariantType<{
+                            readonly date: import("@elaraai/east").NullType;
+                            readonly time: import("@elaraai/east").NullType;
+                            readonly datetime: import("@elaraai/east").NullType;
+                        }>>;
+                    }>;
+                    readonly select: ArrayType<StructType<{
+                        readonly case: StringType;
+                        readonly label: StringType;
+                    }>>;
+                    readonly tags: StructType<{
+                        readonly options: ArrayType<StringType>;
+                    }>;
+                    readonly checklist: StructType<{
+                        readonly text: StringType;
+                        readonly done: StringType;
+                    }>;
+                    readonly reference: StructType<{
+                        readonly of: StringType;
+                    }>;
+                    readonly readonly: import("@elaraai/east").NullType;
+                }>;
+            }>;
+            readonly column: OptionType<StringType>;
+        }>>;
+        readonly columns: ArrayType<StringType>;
+        readonly readonly: ArrayType<StringType>;
+        readonly encode: FunctionType<[BlobType], import("@elaraai/east").DictType<StringType, import("@elaraai/east").VariantType<{
+            readonly Invalid: StringType;
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").BooleanType;
+            readonly Integer: import("@elaraai/east").IntegerType;
+            readonly Float: import("@elaraai/east").FloatType;
+            readonly String: StringType;
+            readonly DateTime: import("@elaraai/east").DateTimeType;
+            readonly Link: StructType<{
+                readonly from: ArrayType<import("@elaraai/east").VariantType<{
+                    readonly identified: StructType<{
+                        readonly key: StringType;
+                    }>;
+                    readonly range: StructType<{
+                        readonly from: StringType;
+                        readonly to: StringType;
+                    }>;
+                    readonly counted: StructType<{
+                        readonly n: import("@elaraai/east").IntegerType;
+                        readonly key: StringType;
+                    }>;
+                    readonly placeholder: import("@elaraai/east").NullType;
+                    readonly text: StringType;
+                }>>;
+                readonly to: ArrayType<import("@elaraai/east").VariantType<{
+                    readonly identified: StructType<{
+                        readonly key: StringType;
+                    }>;
+                    readonly range: StructType<{
+                        readonly from: StringType;
+                        readonly to: StringType;
+                    }>;
+                    readonly counted: StructType<{
+                        readonly n: import("@elaraai/east").IntegerType;
+                        readonly key: StringType;
+                    }>;
+                    readonly placeholder: import("@elaraai/east").NullType;
+                    readonly text: StringType;
+                }>>;
+            }>;
+        }>>>;
+    }>;
+    readonly group: OptionType<StructType<{
+        readonly type: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+            readonly Never: import("@elaraai/east").NullType;
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").NullType;
+            readonly Integer: import("@elaraai/east").NullType;
+            readonly Float: import("@elaraai/east").NullType;
+            readonly String: import("@elaraai/east").NullType;
+            readonly DateTime: import("@elaraai/east").NullType;
+            readonly Blob: import("@elaraai/east").NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: import("@elaraai/east").VariantType<{
+                readonly ref: import("@elaraai/east").IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: import("@elaraai/east").IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly fields: ArrayType<StructType<{
+            readonly spec: StructType<{
+                readonly path: ArrayType<StringType>;
+                readonly label: StringType;
+                readonly help: OptionType<StringType>;
+                readonly group: OptionType<StringType>;
+                readonly type: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+                    readonly Never: import("@elaraai/east").NullType;
+                    readonly Null: import("@elaraai/east").NullType;
+                    readonly Boolean: import("@elaraai/east").NullType;
+                    readonly Integer: import("@elaraai/east").NullType;
+                    readonly Float: import("@elaraai/east").NullType;
+                    readonly String: import("@elaraai/east").NullType;
+                    readonly DateTime: import("@elaraai/east").NullType;
+                    readonly Blob: import("@elaraai/east").NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: import("@elaraai/east").VariantType<{
+                        readonly ref: import("@elaraai/east").IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: import("@elaraai/east").IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly optional: import("@elaraai/east").BooleanType;
+                readonly editor: import("@elaraai/east").VariantType<{
+                    readonly text: StructType<{
+                        readonly placeholder: OptionType<StringType>;
+                    }>;
+                    readonly number: StructType<{
+                        readonly unit: OptionType<StringType>;
+                        readonly step: OptionType<import("@elaraai/east").FloatType>;
+                        readonly min: OptionType<import("@elaraai/east").FloatType>;
+                        readonly max: OptionType<import("@elaraai/east").FloatType>;
+                    }>;
+                    readonly checkbox: import("@elaraai/east").NullType;
+                    readonly datetime: StructType<{
+                        readonly precision: OptionType<import("@elaraai/east").VariantType<{
+                            readonly date: import("@elaraai/east").NullType;
+                            readonly time: import("@elaraai/east").NullType;
+                            readonly datetime: import("@elaraai/east").NullType;
+                        }>>;
+                    }>;
+                    readonly select: ArrayType<StructType<{
+                        readonly case: StringType;
+                        readonly label: StringType;
+                    }>>;
+                    readonly tags: StructType<{
+                        readonly options: ArrayType<StringType>;
+                    }>;
+                    readonly checklist: StructType<{
+                        readonly text: StringType;
+                        readonly done: StringType;
+                    }>;
+                    readonly reference: StructType<{
+                        readonly of: StringType;
+                    }>;
+                    readonly readonly: import("@elaraai/east").NullType;
+                }>;
+            }>;
+            readonly column: OptionType<StringType>;
+        }>>;
+        readonly columns: ArrayType<StringType>;
+        readonly readonly: ArrayType<StringType>;
+        readonly encode: FunctionType<[BlobType], import("@elaraai/east").DictType<StringType, import("@elaraai/east").VariantType<{
+            readonly Invalid: StringType;
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").BooleanType;
+            readonly Integer: import("@elaraai/east").IntegerType;
+            readonly Float: import("@elaraai/east").FloatType;
+            readonly String: StringType;
+            readonly DateTime: import("@elaraai/east").DateTimeType;
+            readonly Link: StructType<{
+                readonly from: ArrayType<import("@elaraai/east").VariantType<{
+                    readonly identified: StructType<{
+                        readonly key: StringType;
+                    }>;
+                    readonly range: StructType<{
+                        readonly from: StringType;
+                        readonly to: StringType;
+                    }>;
+                    readonly counted: StructType<{
+                        readonly n: import("@elaraai/east").IntegerType;
+                        readonly key: StringType;
+                    }>;
+                    readonly placeholder: import("@elaraai/east").NullType;
+                    readonly text: StringType;
+                }>>;
+                readonly to: ArrayType<import("@elaraai/east").VariantType<{
+                    readonly identified: StructType<{
+                        readonly key: StringType;
+                    }>;
+                    readonly range: StructType<{
+                        readonly from: StringType;
+                        readonly to: StringType;
+                    }>;
+                    readonly counted: StructType<{
+                        readonly n: import("@elaraai/east").IntegerType;
+                        readonly key: StringType;
+                    }>;
+                    readonly placeholder: import("@elaraai/east").NullType;
+                    readonly text: StringType;
+                }>>;
+            }>;
+        }>>>;
+    }>>;
+}>;
+/** Type representing {@link SheetFormsType}. */
+export type SheetFormsType = typeof SheetFormsType;
+/**
+ * Builds the inspector's forms (SB10): a row's (a grouped sheet's line's) and,
+ * on a grouped sheet, a group's.
+ *
+ * @param bridge - The sheet's bridge, as its root compiled it
+ * @param metas - The declared columns, described against the row (or line) type
+ * @param hints - `fields`: the author's hints for the row's fields
+ * @param groupHints - `groupFields`: the author's hints for the group's own fields
+ * @param idField - The rows' identity field, which the form leaves to the header
+ * @param registers - The sheet's registers' names, the driver's among them: what a `reference` hint may name
+ * @returns The forms on the wire
+ * @throws Error naming the prop: `groupFields` on a flat sheet, and each refusal of a hint
+ * @internal
+ */
+export declare function buildForms(bridge: SheetBridge, metas: readonly SheetColumnMeta[], hints: Readonly<Record<string, unknown>> | undefined, groupHints: Readonly<Record<string, unknown>> | undefined, idField: string | undefined, registers: readonly string[]): ExprType<SheetFormsType>;
+/**
+ * `Sheet.field` — the inspector's hints, `Fields`' own (#1147): a label, a
+ * help line, an editor for a field the inspector shows by its type, a field
+ * read only or hidden. A column's field takes a label, a help line, read only
+ * or hidden, and an editor that fits its type when its column is written.
+ */
+export declare const SheetField: import("@elaraai/east-ui/internal").FieldsNamespace;
+//# sourceMappingURL=fields.d.ts.map