@elaraai/east-ui 1.0.83 → 1.0.85

package/dist/src/layout/snap-grid/types.d.ts

@@ -0,0 +1,1046 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * SnapGrid types — the 12-column snap grid of tiles (#989, #990), the editing
+ * canvas's chrome (#995), and the changes (#996) and the Apply (#998) a host
+ * asks of it.
+ *
+ * A cell carries its content — and the editing canvas its toolbar items and
+ * panes — and the inline `SnapGrid` arm of `UIComponentType` spells those with
+ * the recursion `node` while `SnapGrid.Types.Root` spells them
+ * `UIComponentType`. Both are built here, over the content's type
+ * ({@link SnapGridRootOf}), so the two are one East type by construction. This
+ * file imports no `UIComponentType`, so `component.ts` can import it.
+ */
+import { ArrayType, BlobType, BooleanType, FloatType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, VariantType } from "@elaraai/east";
+/**
+ * Where a cell shorter than its row sits in it.
+ *
+ * @property top - At the row's top
+ * @property center - Centred in the row
+ * @property stretch - As tall as the row
+ */
+export declare const SnapGridAlignType: VariantType<{
+    readonly top: NullType;
+    readonly center: NullType;
+    readonly stretch: NullType;
+}>;
+/** Type representing a SnapGrid cell's alignment. */
+export type SnapGridAlignType = typeof SnapGridAlignType;
+/** Literal shorthand for {@link SnapGridAlignType}. */
+export type SnapGridAlignLiteral = "top" | "center" | "stretch";
+/**
+ * How a SnapGrid draws its cells.
+ *
+ * @property tiles - Each cell's content, in its tile
+ * @property wireframe - Each cell an outline at its tile's size, its content
+ *   not drawn, and with no cells the blank page — the page library's
+ *   thumbnails, framed by their host
+ */
+export declare const SnapGridVariantType: VariantType<{
+    readonly tiles: NullType;
+    readonly wireframe: NullType;
+}>;
+/** Type representing a SnapGrid's variant. */
+export type SnapGridVariantType = typeof SnapGridVariantType;
+/** Literal shorthand for {@link SnapGridVariantType}. */
+export type SnapGridVariantLiteral = "tiles" | "wireframe";
+/**
+ * A change a host asks the editing canvas to make to one tile (#996) — an
+ * inspector's edit. The canvas takes it as ONE gesture of its session, by the
+ * rules its own handles and drags keep, and writes the `ui` state's `request`
+ * back to `none`.
+ *
+ * @property key - The tile's key
+ * @property change - What to change: its `span`, held to what its row has room
+ *   for; its `row`, counting from 1 — a row past the last, or one already
+ *   holding its most tiles, is a new row after it; its `height`, `none` for its
+ *   content's own; or its `align`, written to the field `edit.align` names
+ */
+export declare const SnapGridRequestType: StructType<{
+    readonly key: StringType;
+    readonly change: VariantType<{
+        readonly span: IntegerType;
+        readonly row: IntegerType;
+        readonly height: OptionType<IntegerType>;
+        readonly align: VariantType<{
+            readonly top: NullType;
+            readonly center: NullType;
+            readonly stretch: NullType;
+        }>;
+    }>;
+}>;
+/** Type representing a change asked of the editing canvas. */
+export type SnapGridRequestType = typeof SnapGridRequestType;
+/**
+ * The SnapGrid's interaction state, as a host holds it — the value behind a
+ * bound `ui` ({@link SnapGridUiBindType}, #990). Bound, the SnapGrid draws the
+ * selection it holds and writes the user's back, so a host selects a tile
+ * from outside (an inspector, a list beside the canvas) and reads the one the
+ * user chose. A `request` asks the editing canvas for a change (#996), as the
+ * Plan's `focus` asks it for a row.
+ *
+ * @property selected - The selected tile's key (`none` ⇒ nothing selected)
+ * @property request - A change asked of the editing canvas ({@link SnapGridRequestType}), taken as one gesture and written back `none`
+ */
+export declare const SnapGridUiStateType: StructType<{
+    readonly selected: OptionType<StringType>;
+    readonly request: OptionType<StructType<{
+        readonly key: StringType;
+        readonly change: VariantType<{
+            readonly span: IntegerType;
+            readonly row: IntegerType;
+            readonly height: OptionType<IntegerType>;
+            readonly align: VariantType<{
+                readonly top: NullType;
+                readonly center: NullType;
+                readonly stretch: NullType;
+            }>;
+        }>;
+    }>>;
+}>;
+/** Type representing a SnapGrid's interaction state. */
+export type SnapGridUiStateType = typeof SnapGridUiStateType;
+/**
+ * A bound {@link SnapGridUiStateType} — exactly `State.bind`'s handle at it, so
+ * `State.bind([SnapGrid.Types.UiState], key, SnapGrid.uiState())` passes straight
+ * through as a SnapGrid's `ui`.
+ *
+ * @remarks
+ * Field order is `read` / `write` / `has`: East struct subtyping is exact, so
+ * declaring the shape here means a change to `State.bind`'s fails this file's
+ * build rather than a canvas's.
+ *
+ * @property read - The current state
+ * @property write - Replace it
+ * @property has - Whether the key is set
+ */
+export declare const SnapGridUiBindType: StructType<{
+    readonly read: FunctionType<[], StructType<{
+        readonly selected: OptionType<StringType>;
+        readonly request: OptionType<StructType<{
+            readonly key: StringType;
+            readonly change: VariantType<{
+                readonly span: IntegerType;
+                readonly row: IntegerType;
+                readonly height: OptionType<IntegerType>;
+                readonly align: VariantType<{
+                    readonly top: NullType;
+                    readonly center: NullType;
+                    readonly stretch: NullType;
+                }>;
+            }>;
+        }>>;
+    }>>;
+    readonly write: FunctionType<[StructType<{
+        readonly selected: OptionType<StringType>;
+        readonly request: OptionType<StructType<{
+            readonly key: StringType;
+            readonly change: VariantType<{
+                readonly span: IntegerType;
+                readonly row: IntegerType;
+                readonly height: OptionType<IntegerType>;
+                readonly align: VariantType<{
+                    readonly top: NullType;
+                    readonly center: NullType;
+                    readonly stretch: NullType;
+                }>;
+            }>;
+        }>>;
+    }>], NullType>;
+    readonly has: FunctionType<[], BooleanType>;
+}>;
+/** Type representing a bound SnapGrid interaction state. */
+export type SnapGridUiBindType = typeof SnapGridUiBindType;
+/**
+ * The design width and the zoom the editing canvas draws at, as a host holds
+ * them — the value behind a bound `view` ({@link SnapGridViewBindType}, #995).
+ * Bound, the canvas draws at them and writes the user's choices back — a
+ * width preset, a zoom step — so a preview beside it shows the page at the
+ * width the builder chose.
+ *
+ * @property width - The design width, a CSS length; `none` ⇒ the SnapGrid's `width`
+ * @property zoom - The scale it draws at; `none` ⇒ the SnapGrid's `zoom`, else actual size
+ */
+export declare const SnapGridViewStateType: StructType<{
+    readonly width: OptionType<StringType>;
+    readonly zoom: OptionType<FloatType>;
+}>;
+/** Type representing the editing canvas's design width and zoom. */
+export type SnapGridViewStateType = typeof SnapGridViewStateType;
+/**
+ * A bound {@link SnapGridViewStateType} — exactly `State.bind`'s handle at it,
+ * so `State.bind([SnapGrid.Types.ViewState], key, SnapGrid.viewState())`
+ * passes straight through as a SnapGrid's `view`.
+ *
+ * @property read - The current state
+ * @property write - Replace it
+ * @property has - Whether the key is set
+ */
+export declare const SnapGridViewBindType: StructType<{
+    readonly read: FunctionType<[], StructType<{
+        readonly width: OptionType<StringType>;
+        readonly zoom: OptionType<FloatType>;
+    }>>;
+    readonly write: FunctionType<[StructType<{
+        readonly width: OptionType<StringType>;
+        readonly zoom: OptionType<FloatType>;
+    }>], NullType>;
+    readonly has: FunctionType<[], BooleanType>;
+}>;
+/** Type representing a bound view state. */
+export type SnapGridViewBindType = typeof SnapGridViewBindType;
+/**
+ * An Apply a host asks of the editing canvas, and the canvas's answer (#998) —
+ * the value behind a bound `apply` ({@link SnapGridApplyBindType}). A host
+ * writes `asked` with an id of its own — a publish that must not leave drafts
+ * behind; the canvas applies its drafts as its own Apply does, and answers
+ * under the same id: `applied` once the source confirms them, or at once when
+ * it has none; `refused` when they cannot land, with why.
+ *
+ * @property idle - Nothing asked
+ * @property asked - An Apply asked — its id
+ * @property applied - The drafts landed, or there were none — the id asked
+ * @property refused - They cannot land — the id asked, and why, in the canvas's words
+ */
+export declare const SnapGridApplyStateType: VariantType<{
+    readonly idle: NullType;
+    readonly asked: StringType;
+    readonly applied: StringType;
+    readonly refused: StructType<{
+        readonly id: StringType;
+        readonly reason: StringType;
+    }>;
+}>;
+/** Type representing an Apply asked of the editing canvas, and its answer. */
+export type SnapGridApplyStateType = typeof SnapGridApplyStateType;
+/**
+ * A bound {@link SnapGridApplyStateType} — exactly `State.bind`'s handle at it,
+ * so `State.bind([SnapGrid.Types.ApplyState], key, variant("idle", null))`
+ * passes straight through as a SnapGrid's `apply`.
+ *
+ * @property read - The current state
+ * @property write - Replace it
+ * @property has - Whether the key is set
+ */
+export declare const SnapGridApplyBindType: StructType<{
+    readonly read: FunctionType<[], VariantType<{
+        readonly idle: NullType;
+        readonly asked: StringType;
+        readonly applied: StringType;
+        readonly refused: StructType<{
+            readonly id: StringType;
+            readonly reason: StringType;
+        }>;
+    }>>;
+    readonly write: FunctionType<[VariantType<{
+        readonly idle: NullType;
+        readonly asked: StringType;
+        readonly applied: StringType;
+        readonly refused: StructType<{
+            readonly id: StringType;
+            readonly reason: StringType;
+        }>;
+    }>], NullType>;
+    readonly has: FunctionType<[], BooleanType>;
+}>;
+/** Type representing a bound Apply request. */
+export type SnapGridApplyBindType = typeof SnapGridApplyBindType;
+/**
+ * A design width the editing canvas's toolbar offers (#995) — a device the
+ * page is laid out for, such as Desktop or Tablet.
+ *
+ * @property label - Its name in the toolbar
+ * @property icon - A Font Awesome solid icon name, beside the name
+ * @property width - The design width, a CSS length (`"1440px"`)
+ */
+export declare const SnapGridWidthType: StructType<{
+    readonly label: StringType;
+    readonly icon: OptionType<StringType>;
+    readonly width: StringType;
+}>;
+/** Type representing one of the editing canvas's design widths. */
+export type SnapGridWidthType = typeof SnapGridWidthType;
+/**
+ * The chrome the editing canvas draws around itself (#995).
+ *
+ * @property card - Its own bordered, rounded frame (the default)
+ * @property shell - No frame: the canvas sits inside a host's
+ */
+export declare const SnapGridSurfaceType: VariantType<{
+    readonly card: NullType;
+    readonly shell: NullType;
+}>;
+/** Type representing the editing canvas's chrome. */
+export type SnapGridSurfaceType = typeof SnapGridSurfaceType;
+/** Literal shorthand for {@link SnapGridSurfaceType}. */
+export type SnapGridSurfaceLiteral = "card" | "shell";
+/**
+ * Where a dropped card lands (#990) — what `edit.create` builds the new entry
+ * at.
+ *
+ * @remarks
+ * The canvas fits the entry `create` returns: it writes `row` into the field
+ * `edit.row` names, and holds its span to what the row has room for.
+ *
+ * @property key - A fresh key for the new entry, unique among the entries' identities
+ * @property row - The key of the row it lands in — an existing row's, or a new row's
+ */
+export declare const SnapGridPlaceType: StructType<{
+    readonly key: StringType;
+    readonly row: StringType;
+}>;
+/** Type representing where a dropped card lands. */
+export type SnapGridPlaceType = typeof SnapGridPlaceType;
+/**
+ * The entry fields a gesture writes, as `edit` names them (#990).
+ *
+ * @internal
+ * @property key - The String identity field
+ * @property row - The String field holding the row key
+ * @property span - The Integer field holding the span
+ * @property height - The `Option<Integer>` field holding the height, when a height is edited
+ * @property align - The `SnapGrid.Types.Align` field an align request writes, when one is taken (#996)
+ */
+export declare const SnapGridEditFieldsType: StructType<{
+    readonly key: StringType;
+    readonly row: StringType;
+    readonly span: StringType;
+    readonly height: OptionType<StringType>;
+    readonly align: OptionType<StringType>;
+}>;
+/**
+ * A drafted entry the author's readiness check reads (#990).
+ *
+ * @internal
+ * @property id - The entry's identity
+ * @property entry - The drafted entry, encoded
+ */
+export declare const SnapGridReadyEntryType: StructType<{
+    readonly id: StringType;
+    readonly entry: BlobType;
+}>;
+/**
+ * One tile, over its content's type — its identity, where it sits, and what
+ * it shows.
+ *
+ * @remarks
+ * Rows order by their first appearance among the cells, and the cells of a
+ * row by their order in the SnapGrid's `data`.
+ *
+ * @typeParam C - The content's type
+ * @param content - The content's type — the recursion node in the inline arm, `UIComponentType` in `SnapGrid.Types.Cell`
+ * @returns The cell struct
+ *
+ * @property key - The cell's identity
+ * @property row - The key of the row it sits in
+ * @property span - Its width, in columns of 12
+ * @property height - Its height in px; `none` is its content's height
+ * @property minHeight - The least height a height drag leaves it, in px; `none` stops it at its content's height
+ * @property align - Where it sits in a taller row
+ * @property frame - Drawn in a tile frame, or bare
+ * @property label - Its name — the drag ghost's, the announcements' and the history's; `none` names it by its key
+ * @property icon - A Font Awesome solid icon name, which the editing canvas's selection bar shows beside its name
+ * @property meta - A line the selection bar shows after its name — what it is, what it reads
+ * @property content - What it shows
+ */
+export declare function SnapGridCellOf<const C>(content: C): StructType<{
+    readonly key: StringType;
+    readonly row: StringType;
+    readonly span: IntegerType;
+    readonly height: OptionType<IntegerType>;
+    readonly minHeight: OptionType<IntegerType>;
+    readonly align: VariantType<{
+        readonly top: NullType;
+        readonly center: NullType;
+        readonly stretch: NullType;
+    }>;
+    readonly frame: BooleanType;
+    readonly label: OptionType<StringType>;
+    readonly icon: OptionType<StringType>;
+    readonly meta: OptionType<StringType>;
+    readonly content: C;
+}>;
+/**
+ * The host's items in the editing canvas's toolbar (#995), over their content
+ * type: the `start` items lead the row, the `end` items close it.
+ *
+ * @typeParam C - The items' type
+ * @param content - The items' type — the recursion node in the inline arm, `UIComponentType` in `SnapGrid.Types.Root`
+ * @returns The toolbar struct
+ *
+ * @property start - Before the canvas's own items, at the row's start
+ * @property end - After the canvas's own items, at the row's end
+ */
+export declare function SnapGridToolbarOf<const C>(content: C): StructType<{
+    readonly start: ArrayType<C>;
+    readonly end: ArrayType<C>;
+}>;
+/**
+ * The panes beside the editing canvas, under its toolbar (#995), over their
+ * content type — a palette, an inspector.
+ *
+ * @typeParam C - The panes' type
+ * @param content - The panes' type — the recursion node in the inline arm, `UIComponentType` in `SnapGrid.Types.Root`
+ * @returns The panes struct
+ *
+ * @property start - The pane before the canvas
+ * @property end - The pane after it
+ */
+export declare function SnapGridPanesOf<const C>(content: C): StructType<{
+    readonly start: OptionType<C>;
+    readonly end: OptionType<C>;
+}>;
+/**
+ * A SnapGrid's editing declaration, on the wire (#990), over its cells' content
+ * type — the shared session's fields ({@link EditingSessionFields}) and the
+ * canvas's own. Entries cross as bytes at the exact type the wire names, so
+ * the arm stays a closed type whatever the SnapGrid's rows are.
+ *
+ * @internal
+ * @typeParam C - The cells' content type
+ * @param content - The cells' content type
+ * @returns The editing struct
+ *
+ * @property fields - The entry fields a gesture writes ({@link SnapGridEditFieldsType})
+ * @property derive - The cells of a whole drafted collection, encoded — what the canvas draws a draft as, exactly as Apply leaves it
+ * @property create - A dropped card's new entry, encoded — the author's `edit.create`; `none` takes no card
+ * @property ready - The author's readiness check over drafted entries, one result each, in order
+ * @property onDrafted - The author's `editing.onDrafted`, over the drafted rows' bytes — hears the rows the canvas draws (#996)
+ */
+export declare function SnapGridEditingOf<const C>(content: C): StructType<{
+    readonly fields: StructType<{
+        readonly key: StringType;
+        readonly row: StringType;
+        readonly span: StringType;
+        readonly height: OptionType<StringType>;
+        readonly align: OptionType<StringType>;
+    }>;
+    readonly derive: FunctionType<[BlobType], ArrayType<StructType<{
+        readonly key: StringType;
+        readonly row: StringType;
+        readonly span: IntegerType;
+        readonly height: OptionType<IntegerType>;
+        readonly minHeight: OptionType<IntegerType>;
+        readonly align: VariantType<{
+            readonly top: NullType;
+            readonly center: NullType;
+            readonly stretch: NullType;
+        }>;
+        readonly frame: BooleanType;
+        readonly label: OptionType<StringType>;
+        readonly icon: OptionType<StringType>;
+        readonly meta: OptionType<StringType>;
+        readonly content: C;
+    }>>>;
+    readonly create: OptionType<FunctionType<[StructType<{
+        readonly library: StringType;
+        readonly key: StringType;
+    }>, StructType<{
+        readonly key: StringType;
+        readonly row: StringType;
+    }>], BlobType>>;
+    readonly ready: OptionType<FunctionType<[ArrayType<StructType<{
+        readonly id: StringType;
+        readonly entry: BlobType;
+    }>>], ArrayType<VariantType<{
+        readonly ready: NullType;
+        readonly incomplete: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+        readonly invalid: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+    }>>>>;
+    readonly onDrafted: OptionType<FunctionType<[BlobType], NullType>>;
+    readonly sourceId: StringType;
+    readonly entryType: import("@elaraai/east").RecursiveType<VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: 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: VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: 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 idField: OptionType<StringType>;
+    readonly draftType: import("@elaraai/east").RecursiveType<VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: 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: VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: 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 children: OptionType<StringType>;
+    readonly keyType: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: 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: VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: 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 snapshot: OptionType<BlobType>;
+    readonly readEntry: FunctionType<[StringType, IntegerType], OptionType<BlobType>>;
+    readonly onPatch: OptionType<FunctionType<[BlobType], NullType>>;
+    readonly onApply: OptionType<VariantType<{
+        readonly sync: FunctionType<[BlobType], VariantType<{
+            readonly applied: StructType<{
+                readonly revision: OptionType<StringType>;
+            }>;
+            readonly rejected: ArrayType<StructType<{
+                readonly entry: StringType;
+                readonly row: OptionType<IntegerType>;
+                readonly field: OptionType<StringType>;
+                readonly message: StringType;
+            }>>;
+            readonly conflict: ArrayType<StructType<{
+                readonly entry: StringType;
+                readonly row: OptionType<IntegerType>;
+                readonly field: OptionType<StringType>;
+                readonly message: StringType;
+            }>>;
+        }>>;
+        readonly async: import("@elaraai/east").AsyncFunctionType<[BlobType], VariantType<{
+            readonly applied: StructType<{
+                readonly revision: OptionType<StringType>;
+            }>;
+            readonly rejected: ArrayType<StructType<{
+                readonly entry: StringType;
+                readonly row: OptionType<IntegerType>;
+                readonly field: OptionType<StringType>;
+                readonly message: StringType;
+            }>>;
+            readonly conflict: ArrayType<StructType<{
+                readonly entry: StringType;
+                readonly row: OptionType<IntegerType>;
+                readonly field: OptionType<StringType>;
+                readonly message: StringType;
+            }>>;
+        }>>;
+    }>>;
+    readonly mode: VariantType<{
+        readonly batch: NullType;
+        readonly auto: NullType;
+    }>;
+}>;
+/**
+ * A SnapGrid's value, over its cells' content type.
+ *
+ * @typeParam C - The cells' content type
+ * @param content - The cells' content type — the recursion node in the inline arm, `UIComponentType` in `SnapGrid.Types.Root`
+ * @returns The root struct
+ *
+ * @property cells - Every cell, in the order `data` holds them
+ * @property variant - Tiles (the default) or a wireframe
+ * @property width - The design width, a CSS length
+ * @property height - A pinned height, a CSS length; the grid scrolls within
+ * @property maxHeight - A height cap, a CSS length; the grid scrolls past it
+ * @property zoom - The scale the canvas draws at (`1.0` actual size)
+ * @property guides - Draw the column ruler and the column bands
+ * @property editing - The editing session (#990); `none` takes no gesture
+ * @property ui - The bound selection ({@link SnapGridUiBindType}); `none` keeps it in the canvas
+ * @property view - The bound design width and zoom ({@link SnapGridViewBindType}, #995); `none` keeps them in the canvas
+ * @property apply - The bound Apply request ({@link SnapGridApplyBindType}, #998); `none` takes none
+ * @property id - The drag surface's name in a drop's cell refs; `none` names one of its own
+ * @property sources - The library ids whose cards land on the canvas
+ * @property canDrop - The veto over a drop where the drag rests (the shared grammar)
+ * @property widths - The design widths the editing canvas's toolbar offers (#995)
+ * @property toolbar - The host's items in the editing canvas's toolbar (#995)
+ * @property panes - The panes beside the editing canvas, under its toolbar (#995)
+ * @property surface - The editing canvas's frame, or none (#995); `none` draws the frame
+ */
+export declare function SnapGridRootOf<const C>(content: C): StructType<{
+    readonly cells: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly row: StringType;
+        readonly span: IntegerType;
+        readonly height: OptionType<IntegerType>;
+        readonly minHeight: OptionType<IntegerType>;
+        readonly align: VariantType<{
+            readonly top: NullType;
+            readonly center: NullType;
+            readonly stretch: NullType;
+        }>;
+        readonly frame: BooleanType;
+        readonly label: OptionType<StringType>;
+        readonly icon: OptionType<StringType>;
+        readonly meta: OptionType<StringType>;
+        readonly content: C;
+    }>>;
+    readonly variant: OptionType<VariantType<{
+        readonly tiles: NullType;
+        readonly wireframe: NullType;
+    }>>;
+    readonly width: OptionType<StringType>;
+    readonly height: OptionType<StringType>;
+    readonly maxHeight: OptionType<StringType>;
+    readonly zoom: OptionType<FloatType>;
+    readonly guides: BooleanType;
+    readonly editing: OptionType<StructType<{
+        readonly fields: StructType<{
+            readonly key: StringType;
+            readonly row: StringType;
+            readonly span: StringType;
+            readonly height: OptionType<StringType>;
+            readonly align: OptionType<StringType>;
+        }>;
+        readonly derive: FunctionType<[BlobType], ArrayType<StructType<{
+            readonly key: StringType;
+            readonly row: StringType;
+            readonly span: IntegerType;
+            readonly height: OptionType<IntegerType>;
+            readonly minHeight: OptionType<IntegerType>;
+            readonly align: VariantType<{
+                readonly top: NullType;
+                readonly center: NullType;
+                readonly stretch: NullType;
+            }>;
+            readonly frame: BooleanType;
+            readonly label: OptionType<StringType>;
+            readonly icon: OptionType<StringType>;
+            readonly meta: OptionType<StringType>;
+            readonly content: C;
+        }>>>;
+        readonly create: OptionType<FunctionType<[StructType<{
+            readonly library: StringType;
+            readonly key: StringType;
+        }>, StructType<{
+            readonly key: StringType;
+            readonly row: StringType;
+        }>], BlobType>>;
+        readonly ready: OptionType<FunctionType<[ArrayType<StructType<{
+            readonly id: StringType;
+            readonly entry: BlobType;
+        }>>], ArrayType<VariantType<{
+            readonly ready: NullType;
+            readonly incomplete: ArrayType<StructType<{
+                readonly field: StringType;
+                readonly message: StringType;
+            }>>;
+            readonly invalid: ArrayType<StructType<{
+                readonly field: StringType;
+                readonly message: StringType;
+            }>>;
+        }>>>>;
+        readonly onDrafted: OptionType<FunctionType<[BlobType], NullType>>;
+        readonly sourceId: StringType;
+        readonly entryType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: 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: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: 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 idField: OptionType<StringType>;
+        readonly draftType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: 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: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: 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 children: OptionType<StringType>;
+        readonly keyType: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: 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: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: 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 snapshot: OptionType<BlobType>;
+        readonly readEntry: FunctionType<[StringType, IntegerType], OptionType<BlobType>>;
+        readonly onPatch: OptionType<FunctionType<[BlobType], NullType>>;
+        readonly onApply: OptionType<VariantType<{
+            readonly sync: FunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+            readonly async: import("@elaraai/east").AsyncFunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+        }>>;
+        readonly mode: VariantType<{
+            readonly batch: NullType;
+            readonly auto: NullType;
+        }>;
+    }>>;
+    readonly ui: OptionType<StructType<{
+        readonly read: FunctionType<[], StructType<{
+            readonly selected: OptionType<StringType>;
+            readonly request: OptionType<StructType<{
+                readonly key: StringType;
+                readonly change: VariantType<{
+                    readonly span: IntegerType;
+                    readonly row: IntegerType;
+                    readonly height: OptionType<IntegerType>;
+                    readonly align: VariantType<{
+                        readonly top: NullType;
+                        readonly center: NullType;
+                        readonly stretch: NullType;
+                    }>;
+                }>;
+            }>>;
+        }>>;
+        readonly write: FunctionType<[StructType<{
+            readonly selected: OptionType<StringType>;
+            readonly request: OptionType<StructType<{
+                readonly key: StringType;
+                readonly change: VariantType<{
+                    readonly span: IntegerType;
+                    readonly row: IntegerType;
+                    readonly height: OptionType<IntegerType>;
+                    readonly align: VariantType<{
+                        readonly top: NullType;
+                        readonly center: NullType;
+                        readonly stretch: NullType;
+                    }>;
+                }>;
+            }>>;
+        }>], NullType>;
+        readonly has: FunctionType<[], BooleanType>;
+    }>>;
+    readonly view: OptionType<StructType<{
+        readonly read: FunctionType<[], StructType<{
+            readonly width: OptionType<StringType>;
+            readonly zoom: OptionType<FloatType>;
+        }>>;
+        readonly write: FunctionType<[StructType<{
+            readonly width: OptionType<StringType>;
+            readonly zoom: OptionType<FloatType>;
+        }>], NullType>;
+        readonly has: FunctionType<[], BooleanType>;
+    }>>;
+    readonly apply: OptionType<StructType<{
+        readonly read: FunctionType<[], VariantType<{
+            readonly idle: NullType;
+            readonly asked: StringType;
+            readonly applied: StringType;
+            readonly refused: StructType<{
+                readonly id: StringType;
+                readonly reason: StringType;
+            }>;
+        }>>;
+        readonly write: FunctionType<[VariantType<{
+            readonly idle: NullType;
+            readonly asked: StringType;
+            readonly applied: StringType;
+            readonly refused: StructType<{
+                readonly id: StringType;
+                readonly reason: StringType;
+            }>;
+        }>], NullType>;
+        readonly has: FunctionType<[], BooleanType>;
+    }>>;
+    readonly id: OptionType<StringType>;
+    readonly sources: ArrayType<StringType>;
+    readonly canDrop: OptionType<FunctionType<[VariantType<{
+        readonly add: StructType<{
+            readonly from: StructType<{
+                readonly library: StringType;
+                readonly key: StringType;
+            }>;
+            readonly into: StructType<{
+                readonly surface: StringType;
+                readonly row: StringType;
+                readonly slot: StringType;
+                readonly event: OptionType<StringType>;
+            }>;
+            readonly duplicate: BooleanType;
+        }>;
+        readonly move: StructType<{
+            readonly from: StructType<{
+                readonly surface: StringType;
+                readonly row: StringType;
+                readonly slot: StringType;
+                readonly event: OptionType<StringType>;
+            }>;
+            readonly to: StructType<{
+                readonly surface: StringType;
+                readonly row: StringType;
+                readonly slot: StringType;
+                readonly event: OptionType<StringType>;
+            }>;
+        }>;
+        readonly remove: StructType<{
+            readonly from: StructType<{
+                readonly surface: StringType;
+                readonly row: StringType;
+                readonly slot: StringType;
+                readonly event: OptionType<StringType>;
+            }>;
+            readonly to: VariantType<{
+                readonly trash: NullType;
+                readonly source: NullType;
+            }>;
+        }>;
+        readonly resize: StructType<{
+            readonly event: StructType<{
+                readonly surface: StringType;
+                readonly row: StringType;
+                readonly slot: StringType;
+                readonly event: OptionType<StringType>;
+            }>;
+            readonly edge: VariantType<{
+                readonly start: NullType;
+                readonly end: NullType;
+            }>;
+        }>;
+    }>], BooleanType>>;
+    readonly widths: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly icon: OptionType<StringType>;
+        readonly width: StringType;
+    }>>;
+    readonly toolbar: StructType<{
+        readonly start: ArrayType<C>;
+        readonly end: ArrayType<C>;
+    }>;
+    readonly panes: StructType<{
+        readonly start: OptionType<C>;
+        readonly end: OptionType<C>;
+    }>;
+    readonly surface: OptionType<VariantType<{
+        readonly card: NullType;
+        readonly shell: NullType;
+    }>>;
+}>;
+//# sourceMappingURL=types.d.ts.map