@elaraai/east-ui 1.0.80 → 1.0.82

package/dist/src/contracts/editing.d.ts

@@ -0,0 +1,1283 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * The editing contract (#879) — one transaction session for every editable
+ * collection. A gesture edits DRAFTS (every field missing, a value, or text
+ * that could not be read); each gesture is one undoable transaction, reported
+ * to the host as a {@link EditingPatchEventTypeFor patch event}; and Apply
+ * sends one checked, idempotent batch ({@link EditingChangeSetTypeFor}) against
+ * the base the drafts began from, which {@link applyEditing} applies to a
+ * collection atomically.
+ *
+ * The Sheet was first to speak it, and keeps its names for it —
+ * `Sheet.Types.ChangeSet` is `Editing.Types.ChangeSet`, `Sheet.apply` is
+ * `Editing.apply`. What only a sheet has (a new row's destination among a
+ * group's children, the `newRow` / `newGroup` contexts) stays the Sheet's.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, AsyncFunctionType, BlobType, DictType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, type EastType, type ExprType, type PatchTypeOf } from "@elaraai/east";
+/**
+ * A position in an explicitly ordered collection.
+ *
+ * @property start - First
+ * @property end - Last
+ * @property before - Just before the entry with this id
+ * @property after - Just after the entry with this id
+ */
+export declare const EditingPositionType: VariantType<{
+    readonly start: NullType;
+    readonly end: NullType;
+    readonly before: StringType;
+    readonly after: StringType;
+}>;
+/**
+ * Where an entry stands: a position in an ordered collection, or the key order
+ * of a keyed one.
+ *
+ * @property ordered - A position in an Array source
+ * @property keyOrder - A keyed source's own order — its entries sort by key
+ */
+export declare const EditingPlacementType: VariantType<{
+    readonly ordered: VariantType<{
+        readonly start: NullType;
+        readonly end: NullType;
+        readonly before: StringType;
+        readonly after: StringType;
+    }>;
+    readonly keyOrder: NullType;
+}>;
+/**
+ * One issue on a field, as an author check reports it.
+ *
+ * @property field - The field
+ * @property message - What is wrong, in the author's words
+ */
+export declare const EditingFieldIssueType: StructType<{
+    readonly field: StringType;
+    readonly message: StringType;
+}>;
+/**
+ * One entry's readiness, after the structural checks and the author's.
+ *
+ * @property ready - Nothing stands in the way
+ * @property incomplete - Fields still missing
+ * @property invalid - Fields whose text could not be read, or that a check refused
+ */
+export declare const EditingReadinessType: VariantType<{
+    readonly ready: NullType;
+    readonly incomplete: ArrayType<StructType<{
+        readonly field: StringType;
+        readonly message: StringType;
+    }>>;
+    readonly invalid: ArrayType<StructType<{
+        readonly field: StringType;
+        readonly message: StringType;
+    }>>;
+}>;
+/**
+ * An issue addressed to an entry, and optionally to a child row and a field.
+ *
+ * @property entry - The entry's id
+ * @property row - The child row's index in a group's children, when it is one
+ * @property field - The field, when the issue has one
+ * @property message - What is wrong
+ */
+export declare const EditingIssueType: StructType<{
+    readonly entry: StringType;
+    readonly row: OptionType<IntegerType>;
+    readonly field: OptionType<StringType>;
+    readonly message: StringType;
+}>;
+/**
+ * The readiness of a whole batch — every draft's issues together.
+ *
+ * @property ready - The batch may be applied
+ * @property incomplete - Fields still missing
+ * @property invalid - Fields whose text could not be read, or that a check refused
+ */
+export declare const EditingBatchReadinessType: VariantType<{
+    readonly ready: NullType;
+    readonly incomplete: ArrayType<StructType<{
+        readonly entry: StringType;
+        readonly row: OptionType<IntegerType>;
+        readonly field: OptionType<StringType>;
+        readonly message: StringType;
+    }>>;
+    readonly invalid: ArrayType<StructType<{
+        readonly entry: StringType;
+        readonly row: OptionType<IntegerType>;
+        readonly field: OptionType<StringType>;
+        readonly message: StringType;
+    }>>;
+}>;
+/**
+ * The gesture that made one transaction — how a host tells typing from a
+ * paste, a copilot's fill from a planner's drag, and a history step from both.
+ *
+ * @property typed - Typed into a cell
+ * @property pasted - Pasted
+ * @property fill - A copilot's fill taken
+ * @property row - A copilot's row fill taken
+ * @property pattern - A proposed row taken
+ * @property insert - An entry inserted
+ * @property move - An entry moved
+ * @property remove - An entry removed
+ * @property resize - An element's extent changed (#879 — a Plan run's start or end)
+ * @property drop - Something dropped onto the collection from elsewhere (#879)
+ * @property verdict - A review verdict (#879 — Approve, Reject, and their "all" forms)
+ * @property undo - Undo
+ * @property redo - Redo
+ * @property discard - Drafts discarded
+ */
+export declare const EditingOriginType: VariantType<{
+    readonly typed: NullType;
+    readonly pasted: NullType;
+    readonly fill: NullType;
+    readonly row: NullType;
+    readonly pattern: NullType;
+    readonly insert: NullType;
+    readonly move: NullType;
+    readonly remove: NullType;
+    readonly resize: NullType;
+    readonly drop: NullType;
+    readonly verdict: NullType;
+    readonly undo: NullType;
+    readonly redo: NullType;
+    readonly discard: NullType;
+}>;
+/**
+ * The source's authoritative answer to one idempotent request.
+ *
+ * @property applied - Applied; a mutable source names the revision it committed
+ * @property rejected - Refused as asked — revise the drafts before applying again
+ * @property conflict - The source moved on — review or discard the drafts
+ */
+export declare const EditingApplyResultType: 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;
+    }>>;
+}>;
+/**
+ * One field of a draft — missing, a value of the field's type, or the text a
+ * planner typed that could not be read, kept as typed.
+ *
+ * @typeParam T - The field's type
+ * @param type - The field's type
+ * @returns The field's draft variant
+ */
+export declare function EditingDraftFieldType<T extends EastType>(type: T): VariantType<{
+    readonly missing: NullType;
+    readonly value: T;
+    readonly invalid: StringType;
+}>;
+/** The field-by-field draft type of a domain struct. */
+export type EditingDraftOf<R extends StructType> = StructType<{
+    [K in keyof R["fields"]]: ReturnType<typeof EditingDraftFieldType<R["fields"][K]>>;
+}>;
+/**
+ * Constructs the field-by-field draft type of a struct, including the fields
+ * no column shows.
+ *
+ * @typeParam R - The domain row type
+ * @param rowType - The complete domain struct
+ * @returns The draft struct; an optional domain field still starts missing
+ */
+export declare function EditingDraftTypeFor<R extends StructType>(rowType: R): EditingDraftOf<R>;
+/** Fields that can hold a group's child rows. */
+export type EditingChildrenField<G extends StructType> = {
+    [K in keyof G["fields"] & string]: G["fields"][K] extends ArrayType<StructType> ? K : never;
+}[keyof G["fields"] & string];
+/** The row type a group's child array holds. */
+export type EditingChildOf<G extends StructType, F extends EditingChildrenField<G>> = G["fields"][F] extends ArrayType<infer R extends StructType> ? R : never;
+/** A group's draft — its own fields drafted, its child array kept ordered, each child a draft. */
+export type EditingDraftGroupOf<G extends StructType, F extends EditingChildrenField<G>> = StructType<{
+    [K in keyof G["fields"]]: K extends F ? ArrayType<EditingDraftOf<EditingChildOf<G, F>>> : ReturnType<typeof EditingDraftFieldType<G["fields"][K]>>;
+}>;
+/**
+ * Constructs a group's draft type, with drafts in its child array.
+ *
+ * @typeParam G - The complete group struct
+ * @typeParam F - Its Array-of-structs child field
+ * @param groupType - The group type
+ * @param field - The child array field
+ * @returns The group's draft struct
+ * @throws {Error} When the named field is not an Array of structs
+ */
+export declare function EditingDraftGroupTypeFor<G extends StructType, F extends EditingChildrenField<G>>(groupType: G, field: F): EditingDraftGroupOf<G, F>;
+/**
+ * Constructs the union of groups carrying child rows and ungrouped rows. The
+ * child field is recorded with the type, so {@link EditingDraftEntryTypeFor}
+ * and {@link EditingPatchEventTypeFor} find it without being told again.
+ *
+ * @remarks
+ * The Sheet names it `Sheet.Types.Entry`; the example below uses that name.
+ *
+ * @typeParam G - The group struct
+ * @typeParam F - Its Array-of-structs child field
+ * @param groupType - The group type
+ * @param field - The child array field
+ * @returns The group-or-row entry type
+ * @throws {Error} When the child field is not an Array of structs
+ * @example
+ * ```ts
+ * import { ArrayType, East, OptionType, StringType, StructType, none, some, variant } from "@elaraai/east";
+ * import { Sheet } from "@elaraai/east-ui";
+ *
+ * const reordered = East.function([], ArrayType(StringType), ($) => {
+ *     const TaskType = StructType({ id: StringType, task: StringType });
+ *     const PackageType = StructType({ id: StringType, name: StringType, tasks: ArrayType(TaskType) });
+ *     const Entry = Sheet.Types.Entry(PackageType, "tasks");
+ *     const before = $.const(variant("group", { id: "p1", name: "P-40 roughing", tasks: [
+ *         { id: "t1", task: "Machine blanks" }, { id: "t2", task: "Inspect lots" },
+ *     ] }), Entry);
+ *     const after = $.const(variant("group", { id: "p1", name: "P-40 roughing", tasks: [
+ *         { id: "t2", task: "Inspect lots" }, { id: "t1", task: "Machine blanks" },
+ *     ] }), Entry);
+ *     const loose = $.const(variant("row", { id: "t9", task: "Pack for shipping" }), Entry);
+ *     const entries = $.const([before, loose], ArrayType(Entry));
+ *     const oldEntry = $.const(some(before), OptionType(Entry));
+ *     const newEntry = $.const(some(after), OptionType(Entry));
+ *     const batch = $.const({
+ *         requestId: "reorder-roughing", base: variant("snapshot", entries), label: "Move a task",
+ *         changes: [{ id: "p1", patch: East.diff(oldEntry, newEntry), place: none }],
+ *     }, Sheet.Types.ChangeSet(Entry));
+ *     const apply = $.const(Sheet.apply(Entry, "id"));
+ *     const applied = $.const(apply(entries, batch, none).unwrap("applied"));
+ *     return applied.map((_$, entry) => entry.match({
+ *         group: (_$2, p) => East.str`${p.name}: ${p.tasks.map((_$3, t) => t.task).stringJoin(" → ")}`,
+ *         row:   (_$2, t) => t.task,
+ *     }));
+ * });
+ * ```
+ */
+export declare function EditingEntryTypeFor<G extends StructType, F extends EditingChildrenField<G>>(groupType: G, field: F): VariantType<{
+    group: G;
+    row: EditingChildOf<G, F>;
+}>;
+/** Child fields whose row type matches an entry union's ungrouped arm. */
+type MatchingChildren<G extends StructType, R extends StructType> = {
+    [K in EditingChildrenField<G>]: G["fields"][K] extends ArrayType<R> ? K : never;
+}[EditingChildrenField<G>];
+/** The draft type of a flat, grouped-only, or group-or-row entry. */
+export type EditingDraftEntryOf<E extends EastType, F extends string = never> = E extends VariantType<{
+    group: infer G extends StructType;
+    row: infer R extends StructType;
+}> ? VariantType<{
+    group: EditingDraftGroupOf<G, MatchingChildren<G, R>>;
+    row: EditingDraftOf<R>;
+}> : E extends StructType ? [F] extends [never] ? EditingDraftOf<E> : EditingDraftGroupOf<E, F & EditingChildrenField<E>> : never;
+/**
+ * Constructs the draft equivalent of a source entry.
+ *
+ * @typeParam E - The entry schema
+ * @typeParam F - A groups-only source's child field
+ * @param entryType - A flat struct or a group-or-row union
+ * @param field - The child field for a groups-only source
+ * @returns The draft entry schema
+ * @throws {Error} When a group union has no unambiguous child field
+ */
+export declare function EditingDraftEntryTypeFor<E extends EastType, F extends string = never>(entryType: E, field?: F): EditingDraftEntryOf<E, F>;
+/** The collection a source of entries `E` holds: an Array, or a Dict keyed by `K`. */
+export type EditingCollectionOf<E extends EastType, K extends EastType | undefined> = [
+    K
+] extends [EastType] ? DictType<K, E> : ArrayType<E>;
+/**
+ * Constructs the checked base of a batch — the revision a mutable source
+ * committed, or the whole inline collection the drafts began from.
+ *
+ * @typeParam E - The source entry type
+ * @typeParam K - A keyed source's key type; omitted for an Array
+ * @param entryType - The source entry type
+ * @param keyType - A keyed source's key type
+ * @returns A revision token or the complete collection snapshot
+ */
+export declare function EditingBaseTypeFor<E extends EastType, K extends EastType | undefined = undefined>(entryType: E, keyType?: K): VariantType<{
+    revision: StringType;
+    snapshot: EditingCollectionOf<E, K>;
+}>;
+/**
+ * Constructs one composed entry patch and its placement.
+ *
+ * @typeParam E - The source entry type
+ * @param entryType - The source entry type
+ * @returns An entry-addressed East patch; `none` stands for an absent entry
+ */
+export declare function EditingChangeTypeFor<E extends EastType>(entryType: E): StructType<{
+    readonly id: StringType;
+    readonly patch: PatchTypeOf<OptionType<E>>;
+    readonly place: OptionType<VariantType<{
+        readonly ordered: VariantType<{
+            readonly start: NullType;
+            readonly end: NullType;
+            readonly before: StringType;
+            readonly after: StringType;
+        }>;
+        readonly keyOrder: NullType;
+    }>>;
+}>;
+/**
+ * Constructs an atomic request against a checked base — what `onApply`
+ * receives.
+ *
+ * @typeParam E - The source entry type
+ * @typeParam K - A keyed source's key type; omitted for an Array
+ * @param entryType - The source entry type
+ * @param keyType - A keyed source's key type
+ * @returns The batch type
+ */
+export declare function EditingChangeSetTypeFor<E extends EastType, K extends EastType | undefined = undefined>(entryType: E, keyType?: K): StructType<{
+    readonly requestId: StringType;
+    readonly base: VariantType<{
+        revision: StringType;
+        snapshot: EditingCollectionOf<E, K>;
+    }>;
+    readonly label: StringType;
+    readonly changes: ArrayType<StructType<{
+        readonly id: StringType;
+        readonly patch: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: OptionType<E>;
+                after: OptionType<E>;
+            }>;
+            patch: VariantType<{
+                none: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: NullType;
+                        after: NullType;
+                    }>;
+                }>;
+                some: E extends EastType ? PatchTypeOf<E> : never;
+            }>;
+        }>;
+        readonly place: OptionType<VariantType<{
+            readonly ordered: VariantType<{
+                readonly start: NullType;
+                readonly end: NullType;
+                readonly before: StringType;
+                readonly after: StringType;
+            }>;
+            readonly keyOrder: NullType;
+        }>>;
+    }>>;
+}>;
+/**
+ * Constructs the result of {@link applyEditing}.
+ *
+ * @typeParam E - The source entry type
+ * @typeParam K - A keyed source's key type; omitted for an Array
+ * @param entryType - The source entry type
+ * @param keyType - A keyed source's key type
+ * @returns The complete applied collection, or the conflict's issues
+ */
+export declare function EditingAppliedTypeFor<E extends EastType, K extends EastType | undefined = undefined>(entryType: E, keyType?: K): VariantType<{
+    applied: EditingCollectionOf<E, K>;
+    conflict: ArrayType<typeof EditingIssueType>;
+}>;
+/**
+ * Constructs one gesture's typed, draft-aware patch event — what `onPatch`
+ * receives, incomplete drafts included.
+ *
+ * @typeParam E - The source entry type
+ * @typeParam F - A groups-only source's child field
+ * @param entryType - The domain entry schema
+ * @param field - The child field for a groups-only source
+ * @returns The event: its gesture, the draft changes, the domain changes once every draft is complete, and the batch's readiness
+ */
+export declare function EditingPatchEventTypeFor<E extends EastType, F extends string = never>(entryType: E, field?: F): StructType<{
+    readonly transactionId: StringType;
+    readonly origin: VariantType<{
+        readonly typed: NullType;
+        readonly pasted: NullType;
+        readonly fill: NullType;
+        readonly row: NullType;
+        readonly pattern: NullType;
+        readonly insert: NullType;
+        readonly move: NullType;
+        readonly remove: NullType;
+        readonly resize: NullType;
+        readonly drop: NullType;
+        readonly verdict: NullType;
+        readonly undo: NullType;
+        readonly redo: NullType;
+        readonly discard: NullType;
+    }>;
+    readonly label: StringType;
+    readonly draftChanges: ArrayType<StructType<{
+        readonly id: StringType;
+        readonly patch: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: OptionType<EditingDraftEntryOf<E, F>>;
+                after: OptionType<EditingDraftEntryOf<E, F>>;
+            }>;
+            patch: VariantType<{
+                none: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: NullType;
+                        after: NullType;
+                    }>;
+                }>;
+                some: EditingDraftEntryOf<E, F> extends EastType ? PatchTypeOf<EditingDraftEntryOf<E, F>> : never;
+            }>;
+        }>;
+        readonly place: OptionType<VariantType<{
+            readonly ordered: VariantType<{
+                readonly start: NullType;
+                readonly end: NullType;
+                readonly before: StringType;
+                readonly after: StringType;
+            }>;
+            readonly keyOrder: NullType;
+        }>>;
+    }>>;
+    readonly domainChanges: OptionType<ArrayType<StructType<{
+        readonly id: StringType;
+        readonly patch: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: OptionType<E>;
+                after: OptionType<E>;
+            }>;
+            patch: VariantType<{
+                none: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: NullType;
+                        after: NullType;
+                    }>;
+                }>;
+                some: E extends EastType ? PatchTypeOf<E> : never;
+            }>;
+        }>;
+        readonly place: OptionType<VariantType<{
+            readonly ordered: VariantType<{
+                readonly start: NullType;
+                readonly end: NullType;
+                readonly before: StringType;
+                readonly after: StringType;
+            }>;
+            readonly keyOrder: NullType;
+        }>>;
+    }>>>;
+    readonly readiness: VariantType<{
+        readonly ready: NullType;
+        readonly incomplete: ArrayType<StructType<{
+            readonly entry: StringType;
+            readonly row: OptionType<IntegerType>;
+            readonly field: OptionType<StringType>;
+            readonly message: StringType;
+        }>>;
+        readonly invalid: ArrayType<StructType<{
+            readonly entry: StringType;
+            readonly row: OptionType<IntegerType>;
+            readonly field: OptionType<StringType>;
+            readonly message: StringType;
+        }>>;
+    }>;
+}>;
+/**
+ * Constructs the patch event of a collection whose drafts take another shape
+ * than a field-by-field one — the Plan drafts a whole entry at once
+ * (`DraftField(E)`, #880), since every gesture on it writes a complete entry.
+ * {@link EditingPatchEventTypeFor} is this over the field-by-field draft.
+ *
+ * @typeParam E - The source entry type
+ * @typeParam D - The entry's draft type
+ * @param entryType - The domain entry schema
+ * @param draftType - The entry's draft schema
+ * @returns The event: its gesture, the draft changes, the domain changes once every draft is complete, and the batch's readiness
+ */
+export declare function EditingPatchEventTypeWith<E extends EastType, D extends EastType>(entryType: E, draftType: D): StructType<{
+    readonly transactionId: StringType;
+    readonly origin: VariantType<{
+        readonly typed: NullType;
+        readonly pasted: NullType;
+        readonly fill: NullType;
+        readonly row: NullType;
+        readonly pattern: NullType;
+        readonly insert: NullType;
+        readonly move: NullType;
+        readonly remove: NullType;
+        readonly resize: NullType;
+        readonly drop: NullType;
+        readonly verdict: NullType;
+        readonly undo: NullType;
+        readonly redo: NullType;
+        readonly discard: NullType;
+    }>;
+    readonly label: StringType;
+    readonly draftChanges: ArrayType<StructType<{
+        readonly id: StringType;
+        readonly patch: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: OptionType<D>;
+                after: OptionType<D>;
+            }>;
+            patch: VariantType<{
+                none: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: NullType;
+                        after: NullType;
+                    }>;
+                }>;
+                some: D extends EastType ? PatchTypeOf<D> : never;
+            }>;
+        }>;
+        readonly place: OptionType<VariantType<{
+            readonly ordered: VariantType<{
+                readonly start: NullType;
+                readonly end: NullType;
+                readonly before: StringType;
+                readonly after: StringType;
+            }>;
+            readonly keyOrder: NullType;
+        }>>;
+    }>>;
+    readonly domainChanges: OptionType<ArrayType<StructType<{
+        readonly id: StringType;
+        readonly patch: VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: OptionType<E>;
+                after: OptionType<E>;
+            }>;
+            patch: VariantType<{
+                none: VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: NullType;
+                        after: NullType;
+                    }>;
+                }>;
+                some: E extends EastType ? PatchTypeOf<E> : never;
+            }>;
+        }>;
+        readonly place: OptionType<VariantType<{
+            readonly ordered: VariantType<{
+                readonly start: NullType;
+                readonly end: NullType;
+                readonly before: StringType;
+                readonly after: StringType;
+            }>;
+            readonly keyOrder: NullType;
+        }>>;
+    }>>>;
+    readonly readiness: VariantType<{
+        readonly ready: NullType;
+        readonly incomplete: ArrayType<StructType<{
+            readonly entry: StringType;
+            readonly row: OptionType<IntegerType>;
+            readonly field: OptionType<StringType>;
+            readonly message: StringType;
+        }>>;
+        readonly invalid: ArrayType<StructType<{
+            readonly entry: StringType;
+            readonly row: OptionType<IntegerType>;
+            readonly field: OptionType<StringType>;
+            readonly message: StringType;
+        }>>;
+    }>;
+}>;
+/**
+ * Constructs an entry-addressed draft patch, placement included.
+ *
+ * @typeParam E - The source entry schema
+ * @typeParam F - A groups-only source's child field
+ * @param entryType - The source entry type
+ * @param field - The child field for a groups-only source
+ * @returns One change to the local draft collection
+ */
+export declare function EditingDraftChangeTypeFor<E extends EastType, F extends string = never>(entryType: E, field?: F): StructType<{
+    readonly id: StringType;
+    readonly patch: VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: OptionType<EditingDraftEntryOf<E, F>>;
+            after: OptionType<EditingDraftEntryOf<E, F>>;
+        }>;
+        patch: VariantType<{
+            none: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: NullType;
+                    after: NullType;
+                }>;
+            }>;
+            some: EditingDraftEntryOf<E, F> extends EastType ? PatchTypeOf<EditingDraftEntryOf<E, F>> : never;
+        }>;
+    }>;
+    readonly place: OptionType<VariantType<{
+        readonly ordered: VariantType<{
+            readonly start: NullType;
+            readonly end: NullType;
+            readonly before: StringType;
+            readonly after: StringType;
+        }>;
+        readonly keyOrder: NullType;
+    }>>;
+}>;
+/** The batch the Array form of {@link applyEditing} takes. */
+type OrderedBatchOf<E extends EastType> = ReturnType<typeof EditingChangeSetTypeFor<E>>;
+/** The batch the keyed form of {@link applyEditing} takes. */
+type KeyedBatchOf<E extends EastType, K extends EastType> = ReturnType<typeof EditingChangeSetTypeFor<E, K>>;
+/**
+ * Creates a reified East function that applies a complete batch to a
+ * collection atomically: every change, or none.
+ *
+ * Checks the whole snapshot or the authoritative revision before inspecting any
+ * patch; no positional rebasing takes place. The function does not own request
+ * deduplication — the live binding or the application's `onApply` does.
+ *
+ * - **An Array** (`Editing.apply(E, idField)`) addresses its entries by a
+ *   String identity field every entry arm carries, and places a new entry by
+ *   an ordered position.
+ * - **A keyed Dict** (`Editing.apply(DictType(K, E))`) addresses its entries
+ *   by key: a String key is its own id, any other key its `.east` text
+ *   (`East.print(key)`), parsed back. Its entries sort by key, so a new one's
+ *   placement is `keyOrder`, and an ordered placement is refused.
+ *
+ * @typeParam E - The source entry type
+ * @param entryType - A row struct or a variant of entry structs
+ * @param idField - The String identity field shared by every entry arm
+ * @returns An East function taking the latest collection, the batch and the authoritative revision
+ * @throws {Error} When the identity field is not String on every entry arm
+ * @example
+ * ```ts
+ * import { ArrayType, East, IntegerType, OptionType, StringType, StructType, none, some, variant } from "@elaraai/east";
+ * import { Editing } from "@elaraai/east-ui";
+ *
+ * const Job = StructType({ id: StringType, task: StringType, qty: IntegerType });
+ *
+ * const applied = East.function([], ArrayType(Job), ($) => {
+ *     const before = $.const({ id: "a", task: "Cut", qty: 2n }, Job);
+ *     const after = $.const({ id: "a", task: "Cut", qty: 3n }, Job);
+ *     const rows = $.const([before], ArrayType(Job));
+ *     const oldEntry = $.const(some(before), OptionType(Job));
+ *     const newEntry = $.const(some(after), OptionType(Job));
+ *     const batch = $.const({
+ *         requestId: "example-request", base: variant("snapshot", rows), label: "Set quantity",
+ *         changes: [{ id: "a", patch: East.diff(oldEntry, newEntry), place: none }],
+ *     }, Editing.Types.ChangeSet(Job));
+ *     const apply = $.const(Editing.apply(Job, "id"));
+ *     return apply(rows, batch, none).unwrap("applied");
+ * });
+ * ```
+ * @example
+ * ```ts
+ * import { DictType, East, IntegerType, OptionType, StringType, StructType, none, some, variant } from "@elaraai/east";
+ * import { Editing } from "@elaraai/east-ui";
+ *
+ * const KeyedJob = StructType({ task: StringType, qty: IntegerType });
+ *
+ * const applied = East.function([], DictType(StringType, KeyedJob), ($) => {
+ *     const jobs = $.const(new Map([
+ *         ["a", { task: "Cut", qty: 2n }],
+ *         ["c", { task: "Weld", qty: 1n }],
+ *     ]), DictType(StringType, KeyedJob));
+ *     const cut = $.const(some({ task: "Cut", qty: 2n }), OptionType(KeyedJob));
+ *     const cutMore = $.const(some({ task: "Cut", qty: 3n }), OptionType(KeyedJob));
+ *     const weld = $.const(some({ task: "Weld", qty: 1n }), OptionType(KeyedJob));
+ *     const paint = $.const(some({ task: "Paint", qty: 4n }), OptionType(KeyedJob));
+ *     const absent = $.const(none, OptionType(KeyedJob));
+ *     const batch = $.const({
+ *         requestId: "keyed-request", base: variant("snapshot", jobs), label: "Edit jobs",
+ *         changes: [
+ *             { id: "a", patch: East.diff(cut, cutMore), place: none },
+ *             { id: "b", patch: East.diff(absent, paint), place: some(variant("keyOrder", null)) },
+ *             { id: "c", patch: East.diff(weld, absent), place: none },
+ *         ],
+ *     }, Editing.Types.ChangeSet(KeyedJob, StringType));
+ *     const apply = $.const(Editing.apply(DictType(StringType, KeyedJob)));
+ *     return apply(jobs, batch, none).unwrap("applied");
+ * });
+ * ```
+ */
+export declare function applyEditing<E extends EastType>(entryType: E, idField: string): ExprType<FunctionType<[
+    ArrayType<E>,
+    OrderedBatchOf<E>,
+    OptionType<StringType>
+], ReturnType<typeof EditingAppliedTypeFor<E>>>>;
+/**
+ * The keyed form: applies a batch to a Dict source, its entries addressed by key.
+ *
+ * @typeParam K - The source's key type
+ * @typeParam E - The source entry type
+ * @param sourceType - The source's Dict type
+ * @returns An East function taking the latest collection, the batch and the authoritative revision
+ */
+export declare function applyEditing<K extends EastType, E extends EastType>(sourceType: DictType<K, E>): ExprType<FunctionType<[
+    DictType<K, E>,
+    KeyedBatchOf<E, K>,
+    OptionType<StringType>
+], ReturnType<typeof EditingAppliedTypeFor<E, K>>>>;
+/**
+ * A synchronous or asynchronous authoritative apply callback, over the batch's
+ * bytes.
+ *
+ * @internal
+ * @property sync - A function
+ * @property async - An async function
+ */
+export declare const EditingWireApplyType: 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: 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;
+        }>>;
+    }>>;
+}>;
+/**
+ * When a ready batch goes: on Apply, or as soon as it is ready. Both use the
+ * same serial checked protocol.
+ *
+ * @property batch - On Apply
+ * @property auto - As soon as the batch is ready
+ */
+export declare const EditingApplyModeType: VariantType<{
+    readonly batch: NullType;
+    readonly auto: NullType;
+}>;
+/**
+ * The fields every source-bound editing session carries to the renderer's
+ * shared session — a collection's own editing declaration spreads them beside
+ * its own (`SheetEditingType`). Blobs carry values at the exact schemas named,
+ * so no hidden domain field is ever lost.
+ *
+ * @internal
+ */
+export declare const EditingSessionFields: {
+    /** The source's identity — one session, and one unresolved request, per source. */
+    sourceId: StringType;
+    /** The entry schema. */
+    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;
+    }>>;
+    /** An Array source's String identity field. */
+    idField: OptionType<StringType>;
+    /** The entry's draft schema. */
+    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;
+    }>>;
+    /** A group entry's child field. */
+    children: OptionType<StringType>;
+    /**
+     * A keyed source's key type — its entries sort by key, a change names its
+     * entry by the key's text (a String key as it is, any other key its
+     * `.east` text), its batches are `ChangeSet(E, K)` and an inline snapshot
+     * is a `Dict` of it; `none` for an Array source.
+     */
+    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;
+    }>>>;
+    /** An inline source's whole collection — the base its batches check. */
+    snapshot: OptionType<BlobType>;
+    /** One entry by id at its source offset, for a paged source's reads. */
+    readEntry: FunctionType<[StringType, IntegerType], OptionType<BlobType>>;
+    /** The author's patch observer, over the event's bytes. */
+    onPatch: OptionType<FunctionType<[BlobType], NullType>>;
+    /** The authoritative apply. */
+    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: 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;
+            }>>;
+        }>>;
+    }>>;
+    /** When a ready batch goes. */
+    mode: VariantType<{
+        readonly batch: NullType;
+        readonly auto: NullType;
+    }>;
+};
+/**
+ * The shared session's wire declaration — {@link EditingSessionFields} alone.
+ *
+ * @internal
+ */
+export declare const EditingType: StructType<{
+    /** The source's identity — one session, and one unresolved request, per source. */
+    sourceId: StringType;
+    /** The entry schema. */
+    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;
+    }>>;
+    /** An Array source's String identity field. */
+    idField: OptionType<StringType>;
+    /** The entry's draft schema. */
+    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;
+    }>>;
+    /** A group entry's child field. */
+    children: OptionType<StringType>;
+    /**
+     * A keyed source's key type — its entries sort by key, a change names its
+     * entry by the key's text (a String key as it is, any other key its
+     * `.east` text), its batches are `ChangeSet(E, K)` and an inline snapshot
+     * is a `Dict` of it; `none` for an Array source.
+     */
+    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;
+    }>>>;
+    /** An inline source's whole collection — the base its batches check. */
+    snapshot: OptionType<BlobType>;
+    /** One entry by id at its source offset, for a paged source's reads. */
+    readEntry: FunctionType<[StringType, IntegerType], OptionType<BlobType>>;
+    /** The author's patch observer, over the event's bytes. */
+    onPatch: OptionType<FunctionType<[BlobType], NullType>>;
+    /** The authoritative apply. */
+    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: 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;
+            }>>;
+        }>>;
+    }>>;
+    /** When a ready batch goes. */
+    mode: VariantType<{
+        readonly batch: NullType;
+        readonly auto: NullType;
+    }>;
+}>;
+/**
+ * The inline adapter's request ledger. Unlike reactive state, it must outlive
+ * a collection disappearing from a render; the browser implementation scopes
+ * it to the current UI store's lifetime.
+ *
+ * @internal
+ */
+export declare const EditingRequestStore: {
+    readonly read: import("@elaraai/east").PlatformDefinition<[StringType], OptionType<BlobType>>;
+    readonly write: import("@elaraai/east").PlatformDefinition<[StringType, BlobType], NullType>;
+};
+/**
+ * Builds the inline `onUpdate` adapter over a live Array handle.
+ *
+ * A confirmed request replays before any stale-base check. A throwing write
+ * leaves an unresolved request in the store: retries confirm the target by
+ * reading it, and never repeat an uncertain mutation. The request table lives
+ * in the same browser state store as the binding, surviving remounts. It
+ * holds the source's latest request alone — a new one is taken only once
+ * every earlier one is resolved, so none of those is retried again — and a
+ * confirmed request keeps no copy of the collection it wrote.
+ *
+ * @internal
+ * @param entryType - The exact domain schema
+ * @param idField - The entry identity field
+ * @param sourceId - Stable identity of the captured binding
+ * @param read - Invocation-time collection reader
+ * @param write - The author's whole-collection writer
+ * @returns A closed Blob transport function for the typed apply callback
+ */
+export declare function buildInlineApply(entryType: EastType, idField: string, sourceId: ExprType<StringType>, read: ExprType<FunctionType>, write: ExprType<FunctionType>): ExprType<FunctionType<[BlobType], typeof EditingApplyResultType>>;
+/**
+ * Builds the inline `onUpdate` adapter over a live keyed handle — the
+ * {@link buildInlineApply} protocol over a `Dict`, its batches applied by key
+ * (`Editing.apply(DictType(K, E))`, #880).
+ *
+ * @internal
+ * @param sourceType - The source's Dict type
+ * @param sourceId - Stable identity of the captured binding
+ * @param read - Invocation-time collection reader
+ * @param write - The author's whole-collection writer
+ * @returns A closed Blob transport function for the typed apply callback
+ */
+export declare function buildKeyedInlineApply(sourceType: DictType, sourceId: ExprType<StringType>, read: ExprType<FunctionType>, write: ExprType<FunctionType>): ExprType<FunctionType<[BlobType], typeof EditingApplyResultType>>;
+/**
+ * The type of the {@link Editing} namespace — declared explicitly so the
+ * declaration emit stays within TypeScript's serialization limit.
+ */
+export interface EditingNamespace {
+    /** Applies a checked batch to a collection atomically — an Array by identity field, or a keyed Dict by key. */
+    apply: typeof applyEditing;
+    /** The editing contract's East types. */
+    Types: {
+        /** `DraftField(T)` — one field of a draft: missing, a value, or unreadable text ({@link EditingDraftFieldType}). */
+        DraftField: typeof EditingDraftFieldType;
+        /** `Draft(R)` — a struct's field-by-field draft ({@link EditingDraftTypeFor}). */
+        Draft: typeof EditingDraftTypeFor;
+        /** `DraftGroup(G, "rows")` — a group's draft, its children drafts ({@link EditingDraftGroupTypeFor}). */
+        DraftGroup: typeof EditingDraftGroupTypeFor;
+        /** `Entry(G, "rows")` — groups with their rows beside ungrouped rows, as one union ({@link EditingEntryTypeFor}). */
+        Entry: typeof EditingEntryTypeFor;
+        /** `DraftEntry(E)` — an entry's draft ({@link EditingDraftEntryTypeFor}). */
+        DraftEntry: typeof EditingDraftEntryTypeFor;
+        /** `DraftChange(E)` — one change to the drafts ({@link EditingDraftChangeTypeFor}). */
+        DraftChange: typeof EditingDraftChangeTypeFor;
+        /** `Change(E)` — one entry's composed patch and placement ({@link EditingChangeTypeFor}). */
+        Change: typeof EditingChangeTypeFor;
+        /** `ChangeSet(E)` / `ChangeSet(E, K)` — an atomic request against a checked base ({@link EditingChangeSetTypeFor}). */
+        ChangeSet: typeof EditingChangeSetTypeFor;
+        /** `Base(E)` / `Base(E, K)` — a revision, or the whole collection ({@link EditingBaseTypeFor}). */
+        Base: typeof EditingBaseTypeFor;
+        /** `Applied(E)` / `Applied(E, K)` — the applied collection or the conflict ({@link EditingAppliedTypeFor}). */
+        Applied: typeof EditingAppliedTypeFor;
+        /** The source's answer to a request ({@link EditingApplyResultType}). */
+        ApplyResult: typeof EditingApplyResultType;
+        /** An issue addressed to an entry ({@link EditingIssueType}). */
+        Issue: typeof EditingIssueType;
+        /** An issue on a field ({@link EditingFieldIssueType}). */
+        FieldIssue: typeof EditingFieldIssueType;
+        /** One entry's readiness ({@link EditingReadinessType}). */
+        Readiness: typeof EditingReadinessType;
+        /** A batch's readiness ({@link EditingBatchReadinessType}). */
+        BatchReadiness: typeof EditingBatchReadinessType;
+        /** The gesture that made a transaction ({@link EditingOriginType}). */
+        Origin: typeof EditingOriginType;
+        /** `PatchEvent(E)` — what `onPatch` receives ({@link EditingPatchEventTypeFor}). */
+        PatchEvent: typeof EditingPatchEventTypeFor;
+        /** Where an entry stands — ordered, or in key order ({@link EditingPlacementType}). */
+        Placement: typeof EditingPlacementType;
+        /** A position in an ordered collection ({@link EditingPositionType}). */
+        Position: typeof EditingPositionType;
+    };
+}
+/**
+ * The editing contract (#879) — the one transaction session every editable
+ * collection speaks: drafts, one undoable transaction per gesture reported as a
+ * `PatchEvent`, and Apply as one checked, idempotent `ChangeSet` applied with
+ * `Editing.apply`. The Sheet keeps its names for it (`Sheet.Types.ChangeSet`,
+ * `Sheet.apply`, …) — the same values.
+ */
+export declare const Editing: EditingNamespace;
+export {};
+//# sourceMappingURL=editing.d.ts.map