@elaraai/e3-ui 1.0.94 → 1.0.96

package/dist/test/bind/data/data.examples.d.ts

@@ -3,7 +3,7 @@
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
 /** @jsxImportSource @elaraai/e3-ui */
-import { ArrayType, DateTimeType, DictType, FloatType, IntegerType, NullType, OptionType, RecursiveType, StringType, StructType, variant } from "@elaraai/east";
+import { ArrayType, DateTimeType, DictType, FloatType, IntegerType, NullType, OptionType, RecursiveType, SetType, StringType, StructType, variant } from "@elaraai/east";
 import * as e3 from "@elaraai/e3";
 export declare const thresholdInput: e3.DatasetDef<FloatType, [variant<"field", "inputs">, variant<"field", "threshold">]>;
 export declare const thresholdPatchInput: e3.DatasetDef<import("@elaraai/east").VariantType<{
@@ -159,6 +159,118 @@ export declare const workQueue: e3.RecordIndexDef<"by_status", DictType<StringTy
 }>, StringType, undefined> & {
     interval: undefined;
 };
+/** The work orders' patch door: another session's change to an order commits through it, and moves the queue with it. */
+export declare const workOrdersPatch: e3.MutationDef<"patch", DictType<StringType, StructType<{
+    readonly site: StringType;
+    readonly title: StringType;
+    readonly crew: StringType;
+    /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
+     *  the index sorts the queue with no rank to compute. */
+    readonly status: StringType;
+    readonly due: DateTimeType;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly site: StringType;
+            readonly title: StringType;
+            readonly crew: StringType;
+            /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
+             *  the index sorts the queue with no rank to compute. */
+            readonly status: StringType;
+            readonly due: DateTimeType;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly site: StringType;
+            readonly title: StringType;
+            readonly crew: StringType;
+            /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
+             *  the index sorts the queue with no rank to compute. */
+            readonly status: StringType;
+            readonly due: DateTimeType;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly site: StringType;
+            readonly title: StringType;
+            readonly crew: StringType;
+            /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
+             *  the index sorts the queue with no rank to compute. */
+            readonly status: StringType;
+            readonly due: DateTimeType;
+        }>;
+        insert: StructType<{
+            readonly site: StringType;
+            readonly title: StringType;
+            readonly crew: StringType;
+            /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
+             *  the index sorts the queue with no rank to compute. */
+            readonly status: StringType;
+            readonly due: DateTimeType;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly site: StringType;
+                    readonly title: StringType;
+                    readonly crew: StringType;
+                    /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
+                     *  the index sorts the queue with no rank to compute. */
+                    readonly status: StringType;
+                    readonly due: DateTimeType;
+                }>;
+                after: StructType<{
+                    readonly site: StringType;
+                    readonly title: StringType;
+                    readonly crew: StringType;
+                    /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
+                     *  the index sorts the queue with no rank to compute. */
+                    readonly status: StringType;
+                    readonly due: DateTimeType;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly site: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly title: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly crew: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly status: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly due: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: DateTimeType;
+                        after: DateTimeType;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
 export declare const dataBindFloat: import("@elaraai/east").ExampleDef<[], any>;
 export declare const dataBindVariants: import("@elaraai/east").ExampleDef<[], any>;
 export declare const dataBindStagedFloat: import("@elaraai/east").ExampleDef<[], any>;
@@ -241,4 +353,542 @@ export declare const jobsTask: e3.TaskDef<DictType<StringType, StructType<{
     readonly qty: OptionType<FloatType>;
 }>>, [variant<"field", "tasks">, variant<"field", "jobs">, variant<"field", "output">]>;
 export declare const dataBindPagedSheet: import("@elaraai/east").ExampleDef<[], any>;
+/** Counts by key: a collection a preview shows whole while it edits it, and a page at a time while it only reads it. */
+export declare const previewCountsInput: e3.DatasetDef<DictType<StringType, IntegerType>, [variant<"field", "inputs">, variant<"field", "preview_counts">]>;
+/** A value nested three deep: a preview's tree opens one level of it, so `deep` starts hidden. */
+export declare const PreviewNested: StructType<{
+    readonly outer: StructType<{
+        readonly inner: StructType<{
+            readonly deep: IntegerType;
+        }>;
+    }>;
+}>;
+export declare const previewNestedInput: e3.DatasetDef<StructType<{
+    readonly outer: StructType<{
+        readonly inner: StructType<{
+            readonly deep: IntegerType;
+        }>;
+    }>;
+}>, [variant<"field", "inputs">, variant<"field", "preview_nested">]>;
+/** A row of a collection a preview pages: its `inner` starts collapsed. */
+export declare const PreviewRow: StructType<{
+    readonly inner: StructType<{
+        readonly deep: IntegerType;
+    }>;
+}>;
+export declare const previewNestedRowsInput: e3.DatasetDef<DictType<StringType, StructType<{
+    readonly inner: StructType<{
+        readonly deep: IntegerType;
+    }>;
+}>>, [variant<"field", "inputs">, variant<"field", "preview_nested_rows">]>;
+/** Integers a preview pages, as many as another session writes. */
+export declare const previewRowsInput: e3.DatasetDef<ArrayType<IntegerType>, [variant<"field", "inputs">, variant<"field", "preview_rows">]>;
+/** Lines of text a preview pages, as wide as another session writes them. */
+export declare const previewLinesInput: e3.DatasetDef<ArrayType<StringType>, [variant<"field", "inputs">, variant<"field", "preview_lines">]>;
+/** A machine, and the label its row shows. */
+export declare const PreviewMachine: StructType<{
+    readonly label: StringType;
+}>;
+/** Machines by key, which a canvas and a sheet page and follow as another session writes them. */
+export declare const previewMachinesInput: e3.DatasetDef<DictType<StringType, StructType<{
+    readonly label: StringType;
+}>>, [variant<"field", "inputs">, variant<"field", "preview_machines">]>;
+/** A data task reporting the counts' total: its output is what a task's preview shows. */
+export declare const previewReportTask: e3.TaskDef<IntegerType, [variant<"field", "tasks">, variant<"field", "preview_report">, variant<"field", "output">]>;
+/** The lines a task writes to its log, as many as another session writes. */
+export declare const previewLogLinesInput: e3.DatasetDef<ArrayType<StringType>, [variant<"field", "inputs">, variant<"field", "preview_log_lines">]>;
+/**
+ * A task that writes each of its lines to its log as it runs — standard
+ * output — and how many there were to standard error: what a task's log
+ * preview polls. Run over other lines, it is another execution, with a log of
+ * its own.
+ */
+export declare const previewLogTask: e3.TaskDef<IntegerType, [variant<"field", "tasks">, variant<"field", "preview_log">, variant<"field", "output">]>;
+/** A ui task binding nothing: its output is the view a ui task's preview draws. */
+export declare const previewView: e3.TaskDef<RecursiveType<import("@elaraai/east-ui").UIComponentNode>, [variant<"field", "tasks">, variant<"field", "preview_view">, variant<"field", "output">]>;
+/** How many counts there are, as a view. */
+export declare const countsSaid: import("@elaraai/east").CallableFunctionExpr<[DictType<StringType, IntegerType>], RecursiveType<import("@elaraai/east-ui").UIComponentNode>>;
+/** A ui task over the counts, which its preview loads before it draws. */
+export declare const previewCountsView: e3.TaskDef<RecursiveType<import("@elaraai/east-ui").UIComponentNode>, [variant<"field", "tasks">, variant<"field", "preview_counts_view">, variant<"field", "output">]>;
+/** A ui task over the work orders, their queue read a window at a time beside the commits of their record, which is never read whole. */
+export declare const previewOrdersView: e3.TaskDef<RecursiveType<import("@elaraai/east-ui").UIComponentNode>, [variant<"field", "tasks">, variant<"field", "preview_orders_view">, variant<"field", "output">]>;
+/** A person and the skills they hold: a Set field, which an index lists once under each skill. */
+export declare const IndexedPerson: StructType<{
+    readonly name: StringType;
+    readonly skills: SetType<StringType>;
+}>;
+/** People by key: Ada and Amy share skill `b`, and Abe holds none, so the skills index lists him nowhere. */
+export declare const indexedPeople: e3.RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly skills: SetType<StringType>;
+}>>, [variant<"field", "records">, variant<"field", "indexed_people">]>;
+export declare const indexedPeoplePatch: e3.MutationDef<"patch", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly skills: SetType<StringType>;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly skills: SetType<StringType>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly skills: SetType<StringType>;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly name: StringType;
+            readonly skills: SetType<StringType>;
+        }>;
+        insert: StructType<{
+            readonly name: StringType;
+            readonly skills: SetType<StringType>;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly name: StringType;
+                    readonly skills: SetType<StringType>;
+                }>;
+                after: StructType<{
+                    readonly name: StringType;
+                    readonly skills: SetType<StringType>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly name: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly skills: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: SetType<StringType>;
+                        after: SetType<StringType>;
+                    }>;
+                    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+                        delete: NullType;
+                        insert: NullType;
+                    }>>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+export declare const peopleByName: e3.RecordIndexDef<"by_name", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly skills: SetType<StringType>;
+}>>, StringType, NullType, readonly ["name"]> & {
+    interval: undefined;
+};
+export declare const peopleBySkill: e3.RecordIndexDef<"by_skill", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly skills: SetType<StringType>;
+}>>, StringType, NullType, readonly ["skills"]> & {
+    interval: undefined;
+};
+/** An event of a status over a span of time: no end is an instant, and no start the backlog. */
+export declare const IntervalEvent: StructType<{
+    readonly status: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+}>;
+/**
+ * Events about one day, 2 October 2026: one carried in from the night before,
+ * one spanning it, one inside it, one ending as it starts and one starting as
+ * it ends, an instant at each of its bounds, one cancelled and one in the
+ * backlog — what an overlap with `[2 Oct, 3 Oct)` takes and what it leaves.
+ */
+export declare const indexedIntervals: e3.RecordDef<DictType<StringType, StructType<{
+    readonly status: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+}>>, [variant<"field", "records">, variant<"field", "indexed_intervals">]>;
+export declare const indexedIntervalsPatch: e3.MutationDef<"patch", DictType<StringType, StructType<{
+    readonly status: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly status: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly status: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly status: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+        }>;
+        insert: StructType<{
+            readonly status: StringType;
+            readonly start: OptionType<DateTimeType>;
+            readonly end: OptionType<DateTimeType>;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly status: StringType;
+                    readonly start: OptionType<DateTimeType>;
+                    readonly end: OptionType<DateTimeType>;
+                }>;
+                after: StructType<{
+                    readonly status: StringType;
+                    readonly start: OptionType<DateTimeType>;
+                    readonly end: OptionType<DateTimeType>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly status: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly start: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<DateTimeType>;
+                        after: OptionType<DateTimeType>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        none: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: DateTimeType;
+                                after: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly end: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<DateTimeType>;
+                        after: OptionType<DateTimeType>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        none: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: DateTimeType;
+                                after: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+export declare const intervalsByStart: e3.RecordIndexDef<"by_start", DictType<StringType, StructType<{
+    readonly status: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+}>>, OptionType<DateTimeType>, NullType, readonly ["start"]> & {
+    interval: undefined;
+};
+export declare const intervalsByStatusTime: e3.RecordIndexDef<"by_status_time", DictType<StringType, StructType<{
+    readonly status: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+}>>, StructType<{
+    status: StringType;
+} & {
+    __interval: IntegerType;
+} & {
+    start: OptionType<DateTimeType>;
+}>, NullType, readonly ["status", "start"]> & {
+    interval: {
+        readonly from: "start";
+        readonly to: "end";
+    };
+};
+export declare const intervalsByTime: e3.RecordIndexDef<"by_time", DictType<StringType, StructType<{
+    readonly status: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+}>>, StructType<Record<never, never> & {
+    __interval: IntegerType;
+} & {
+    start: OptionType<DateTimeType>;
+}>, NullType, readonly ["start"]> & {
+    interval: {
+        readonly from: "start";
+        readonly to: "end";
+    };
+};
+/** A step of a flow: its lane, and who owns it, if anyone. */
+export declare const ComputedStep: StructType<{
+    readonly lane: StringType;
+    readonly owner: OptionType<StringType>;
+}>;
+/** A flow: what it is, and its steps. */
+export declare const ComputedFlow: StructType<{
+    readonly description: StringType;
+    readonly states: ArrayType<StructType<{
+        readonly lane: StringType;
+        readonly owner: OptionType<StringType>;
+    }>>;
+}>;
+/** Flows whose indexes are computed from their steps: `a` has two steps in one lane, `c` a step no one owns, and `d` none at all. */
+export declare const computedFlows: e3.RecordDef<DictType<StringType, StructType<{
+    readonly description: StringType;
+    readonly states: ArrayType<StructType<{
+        readonly lane: StringType;
+        readonly owner: OptionType<StringType>;
+    }>>;
+}>>, [variant<"field", "records">, variant<"field", "computed_flows">]>;
+export declare const computedFlowsPatch: e3.MutationDef<"patch", DictType<StringType, StructType<{
+    readonly description: StringType;
+    readonly states: ArrayType<StructType<{
+        readonly lane: StringType;
+        readonly owner: OptionType<StringType>;
+    }>>;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly description: StringType;
+            readonly states: ArrayType<StructType<{
+                readonly lane: StringType;
+                readonly owner: OptionType<StringType>;
+            }>>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly description: StringType;
+            readonly states: ArrayType<StructType<{
+                readonly lane: StringType;
+                readonly owner: OptionType<StringType>;
+            }>>;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly description: StringType;
+            readonly states: ArrayType<StructType<{
+                readonly lane: StringType;
+                readonly owner: OptionType<StringType>;
+            }>>;
+        }>;
+        insert: StructType<{
+            readonly description: StringType;
+            readonly states: ArrayType<StructType<{
+                readonly lane: StringType;
+                readonly owner: OptionType<StringType>;
+            }>>;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly description: StringType;
+                    readonly states: ArrayType<StructType<{
+                        readonly lane: StringType;
+                        readonly owner: OptionType<StringType>;
+                    }>>;
+                }>;
+                after: StructType<{
+                    readonly description: StringType;
+                    readonly states: ArrayType<StructType<{
+                        readonly lane: StringType;
+                        readonly owner: OptionType<StringType>;
+                    }>>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly description: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly states: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly lane: StringType;
+                            readonly owner: OptionType<StringType>;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly lane: StringType;
+                            readonly owner: OptionType<StringType>;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly lane: StringType;
+                                readonly owner: OptionType<StringType>;
+                            }>;
+                            insert: StructType<{
+                                readonly lane: StringType;
+                                readonly owner: OptionType<StringType>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly lane: StringType;
+                                        readonly owner: OptionType<StringType>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly lane: StringType;
+                                        readonly owner: OptionType<StringType>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly lane: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly owner: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+export declare const computedByDescription: e3.RecordIndexDef<"description", DictType<StringType, StructType<{
+    readonly description: StringType;
+    readonly states: ArrayType<StructType<{
+        readonly lane: StringType;
+        readonly owner: OptionType<StringType>;
+    }>>;
+}>>, StringType, NullType, readonly ["description"]> & {
+    interval: undefined;
+};
+export declare const computedByStateCount: e3.RecordIndexDef<"state_count", DictType<StringType, StructType<{
+    readonly description: StringType;
+    readonly states: ArrayType<StructType<{
+        readonly lane: StringType;
+        readonly owner: OptionType<StringType>;
+    }>>;
+}>>, StructType<{
+    readonly stateCount: IntegerType;
+}>, NullType, undefined> & {
+    interval: undefined;
+};
+export declare const computedByDescriptionCount: e3.RecordIndexDef<"description_count", DictType<StringType, StructType<{
+    readonly description: StringType;
+    readonly states: ArrayType<StructType<{
+        readonly lane: StringType;
+        readonly owner: OptionType<StringType>;
+    }>>;
+}>>, StructType<{
+    readonly description: StringType;
+    readonly stateCount: IntegerType;
+}>, NullType, undefined> & {
+    interval: undefined;
+};
+export declare const computedByLane: e3.RecordIndexDef<"lane", DictType<StringType, StructType<{
+    readonly description: StringType;
+    readonly states: ArrayType<StructType<{
+        readonly lane: StringType;
+        readonly owner: OptionType<StringType>;
+    }>>;
+}>>, StructType<{
+    readonly lane: StringType;
+}>, NullType, undefined> & {
+    interval: undefined;
+};
+export declare const computedByOwner: e3.RecordIndexDef<"owner", DictType<StringType, StructType<{
+    readonly description: StringType;
+    readonly states: ArrayType<StructType<{
+        readonly lane: StringType;
+        readonly owner: OptionType<StringType>;
+    }>>;
+}>>, StructType<{
+    readonly owner: OptionType<StringType>;
+}>, NullType, undefined> & {
+    interval: undefined;
+};
+export declare const computedByLabel: e3.RecordIndexDef<"label", DictType<StringType, StructType<{
+    readonly description: StringType;
+    readonly states: ArrayType<StructType<{
+        readonly lane: StringType;
+        readonly owner: OptionType<StringType>;
+    }>>;
+}>>, StringType, NullType, undefined> & {
+    interval: undefined;
+};
+export declare const computedBySize: e3.RecordIndexDef<"size", DictType<StringType, StructType<{
+    readonly description: StringType;
+    readonly states: ArrayType<StructType<{
+        readonly lane: StringType;
+        readonly owner: OptionType<StringType>;
+    }>>;
+}>>, IntegerType, NullType, undefined> & {
+    interval: undefined;
+};
+export declare const computedByDecisionOwner: e3.RecordIndexDef<"decisionOwner", DictType<StringType, StructType<{
+    readonly description: StringType;
+    readonly states: ArrayType<StructType<{
+        readonly lane: StringType;
+        readonly owner: OptionType<StringType>;
+    }>>;
+}>>, OptionType<StringType>, NullType, undefined> & {
+    interval: undefined;
+};
 //# sourceMappingURL=data.examples.d.ts.map