@elaraai/e3-ui 1.0.97 → 1.0.99

package/dist/test/sheet/sheet-records.examples.d.ts

@@ -3,15 +3,12 @@
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
 /** @jsxImportSource @elaraai/east-ui */
-import { ArrayType, BooleanType, DateTimeType, DictType, IntegerType, SetType, StringType, StructType, variant } from "@elaraai/east";
-/** The same work order can be edited as a Sheet row or scheduled on a Plan. */
-export declare const IndexedOperation: StructType<{
-    readonly key: StringType;
-    readonly label: StringType;
-    readonly start: DateTimeType;
-    readonly end: DateTimeType;
-}>;
-/** Work orders retain their original String record keys through every index. */
+import { BooleanType, DateTimeType, DictType, IntegerType, SetType, StringType, StructType, variant } from "@elaraai/east";
+/**
+ * A work order: edited as a Sheet row, and a row of the Plan whose operations
+ * are a record of their own (`plan/plan-records.examples.tsx`). Its String
+ * record key is kept through every index.
+ */
 export declare const IndexedWork: StructType<{
     readonly reference: StringType;
     readonly job: StringType;
@@ -20,13 +17,13 @@ export declare const IndexedWork: StructType<{
     readonly quantity: IntegerType;
     readonly urgent: BooleanType;
     readonly tags: SetType<StringType>;
-    readonly operations: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly start: DateTimeType;
-        readonly end: DateTimeType;
-    }>>;
 }>;
+/** The `i`-th work order's reference, its record key: `JOB-` and its number plus 10,000, so key order is number order. */
+export declare const indexedWorkReference: import("@elaraai/east").CallableFunctionExpr<[IntegerType], StringType>;
+/** The job the `i`-th work order runs: cut panels, edge band, inspect and pack, in turn. */
+export declare const indexedWorkJob: import("@elaraai/east").CallableFunctionExpr<[IntegerType], StringType>;
+/** When the `i`-th work order is due: a day of the ninety from 1 October 2026, each order thirty-seven days on from the one before. */
+export declare const indexedWorkDue: import("@elaraai/east").CallableFunctionExpr<[IntegerType], DateTimeType>;
 export declare const indexedWorkCount: import("@elaraai/e3").DatasetDef<IntegerType, [variant<"field", "inputs">, variant<"field", "indexed_work_count">]>;
 export declare const indexedWorkGenerated: import("@elaraai/e3").TaskDef<DictType<StringType, StructType<{
     readonly reference: StringType;
@@ -36,12 +33,6 @@ export declare const indexedWorkGenerated: import("@elaraai/e3").TaskDef<DictTyp
     readonly quantity: IntegerType;
     readonly urgent: BooleanType;
     readonly tags: SetType<StringType>;
-    readonly operations: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly start: DateTimeType;
-        readonly end: DateTimeType;
-    }>>;
 }>>, [variant<"field", "tasks">, variant<"field", "indexed_work_generated">, variant<"field", "output">]>;
 export declare const indexedWorkOrders: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly reference: StringType;
@@ -51,14 +42,17 @@ export declare const indexedWorkOrders: import("@elaraai/e3").RecordDef<DictType
     readonly quantity: IntegerType;
     readonly urgent: BooleanType;
     readonly tags: SetType<StringType>;
-    readonly operations: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly start: DateTimeType;
-        readonly end: DateTimeType;
-    }>>;
-}>>, [variant<"field", "records">, variant<"field", "indexed_work_orders">]>;
-export declare const indexedWorkPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "indexed_work_orders">], import("@elaraai/e3").IndexesOf<{
+    by_status_due: import("@elaraai/e3").IndexDraft<StructType<{
+        status: StringType;
+        due: DateTimeType;
+    }>, import("@elaraai/east").NullType, readonly ["status", "due"], unknown>;
+    by_due: import("@elaraai/e3").IndexDraft<DateTimeType, import("@elaraai/east").NullType, readonly ["due"], unknown>;
+    by_job: import("@elaraai/e3").IndexDraft<StringType, import("@elaraai/east").NullType, readonly ["job"], unknown>;
+    by_quantity: import("@elaraai/e3").IndexDraft<IntegerType, import("@elaraai/east").NullType, readonly ["quantity"], unknown>;
+    by_urgent: import("@elaraai/e3").IndexDraft<BooleanType, import("@elaraai/east").NullType, readonly ["urgent"], unknown>;
+    by_tag: import("@elaraai/e3").IndexDraft<StringType, import("@elaraai/east").NullType, readonly ["tags"], unknown>;
+}, DictType<StringType, StructType<{
     readonly reference: StringType;
     readonly job: StringType;
     readonly status: StringType;
@@ -66,340 +60,129 @@ export declare const indexedWorkPatch: import("@elaraai/e3").MutationDef<"patch"
     readonly quantity: IntegerType;
     readonly urgent: BooleanType;
     readonly tags: SetType<StringType>;
-    readonly operations: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly start: DateTimeType;
-        readonly end: DateTimeType;
-    }>>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: import("@elaraai/east").NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly reference: StringType;
-            readonly job: StringType;
-            readonly status: StringType;
-            readonly due: DateTimeType;
-            readonly quantity: IntegerType;
-            readonly urgent: BooleanType;
-            readonly tags: SetType<StringType>;
-            readonly operations: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly label: StringType;
-                readonly start: DateTimeType;
-                readonly end: DateTimeType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: import("@elaraai/east").NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly reference: StringType;
+                readonly job: StringType;
+                readonly status: StringType;
+                readonly due: DateTimeType;
+                readonly quantity: IntegerType;
+                readonly urgent: BooleanType;
+                readonly tags: SetType<StringType>;
             }>>;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly reference: StringType;
-            readonly job: StringType;
-            readonly status: StringType;
-            readonly due: DateTimeType;
-            readonly quantity: IntegerType;
-            readonly urgent: BooleanType;
-            readonly tags: SetType<StringType>;
-            readonly operations: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly label: StringType;
-                readonly start: DateTimeType;
-                readonly end: DateTimeType;
-            }>>;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: StructType<{
-            readonly reference: StringType;
-            readonly job: StringType;
-            readonly status: StringType;
-            readonly due: DateTimeType;
-            readonly quantity: IntegerType;
-            readonly urgent: BooleanType;
-            readonly tags: SetType<StringType>;
-            readonly operations: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly label: StringType;
-                readonly start: DateTimeType;
-                readonly end: DateTimeType;
+            after: DictType<StringType, StructType<{
+                readonly reference: StringType;
+                readonly job: StringType;
+                readonly status: StringType;
+                readonly due: DateTimeType;
+                readonly quantity: IntegerType;
+                readonly urgent: BooleanType;
+                readonly tags: SetType<StringType>;
             }>>;
         }>;
-        insert: StructType<{
-            readonly reference: StringType;
-            readonly job: StringType;
-            readonly status: StringType;
-            readonly due: DateTimeType;
-            readonly quantity: IntegerType;
-            readonly urgent: BooleanType;
-            readonly tags: SetType<StringType>;
-            readonly operations: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly label: StringType;
-                readonly start: DateTimeType;
-                readonly end: DateTimeType;
-            }>>;
-        }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: import("@elaraai/east").NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly reference: StringType;
-                    readonly job: StringType;
-                    readonly status: StringType;
-                    readonly due: DateTimeType;
-                    readonly quantity: IntegerType;
-                    readonly urgent: BooleanType;
-                    readonly tags: SetType<StringType>;
-                    readonly operations: ArrayType<StructType<{
-                        readonly key: StringType;
-                        readonly label: StringType;
-                        readonly start: DateTimeType;
-                        readonly end: DateTimeType;
-                    }>>;
-                }>;
-                after: StructType<{
-                    readonly reference: StringType;
-                    readonly job: StringType;
-                    readonly status: StringType;
-                    readonly due: DateTimeType;
-                    readonly quantity: IntegerType;
-                    readonly urgent: BooleanType;
-                    readonly tags: SetType<StringType>;
-                    readonly operations: ArrayType<StructType<{
-                        readonly key: StringType;
-                        readonly label: StringType;
-                        readonly start: DateTimeType;
-                        readonly end: DateTimeType;
-                    }>>;
-                }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly reference: StringType;
+                readonly job: StringType;
+                readonly status: StringType;
+                readonly due: DateTimeType;
+                readonly quantity: IntegerType;
+                readonly urgent: BooleanType;
+                readonly tags: SetType<StringType>;
+            }>;
+            insert: StructType<{
+                readonly reference: StringType;
+                readonly job: StringType;
+                readonly status: StringType;
+                readonly due: DateTimeType;
+                readonly quantity: IntegerType;
+                readonly urgent: BooleanType;
+                readonly tags: SetType<StringType>;
             }>;
-            patch: StructType<{
-                readonly reference: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: import("@elaraai/east").NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly reference: StringType;
+                        readonly job: StringType;
+                        readonly status: StringType;
+                        readonly due: DateTimeType;
+                        readonly quantity: IntegerType;
+                        readonly urgent: BooleanType;
+                        readonly tags: SetType<StringType>;
                     }>;
-                }>;
-                readonly job: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    after: StructType<{
+                        readonly reference: StringType;
+                        readonly job: StringType;
+                        readonly status: StringType;
+                        readonly due: DateTimeType;
+                        readonly quantity: IntegerType;
+                        readonly urgent: BooleanType;
+                        readonly tags: SetType<StringType>;
                     }>;
                 }>;
-                readonly status: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                patch: StructType<{
+                    readonly reference: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly due: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
+                    readonly job: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly quantity: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: IntegerType;
-                        after: IntegerType;
+                    readonly status: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly urgent: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: BooleanType;
-                        after: BooleanType;
+                    readonly due: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
+                        }>;
                     }>;
-                }>;
-                readonly tags: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: SetType<StringType>;
-                        after: SetType<StringType>;
+                    readonly quantity: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: IntegerType;
+                            after: IntegerType;
+                        }>;
                     }>;
-                    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-                        delete: import("@elaraai/east").NullType;
-                        insert: import("@elaraai/east").NullType;
-                    }>>;
-                }>;
-                readonly operations: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: StructType<{
-                        before: ArrayType<StructType<{
-                            readonly key: StringType;
-                            readonly label: StringType;
-                            readonly start: DateTimeType;
-                            readonly end: DateTimeType;
-                        }>>;
-                        after: ArrayType<StructType<{
-                            readonly key: StringType;
-                            readonly label: StringType;
-                            readonly start: DateTimeType;
-                            readonly end: DateTimeType;
-                        }>>;
+                    readonly urgent: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: BooleanType;
+                            after: BooleanType;
+                        }>;
                     }>;
-                    patch: ArrayType<StructType<{
-                        key: IntegerType;
-                        offset: IntegerType;
-                        operation: import("@elaraai/east").VariantType<{
-                            delete: StructType<{
-                                readonly key: StringType;
-                                readonly label: StringType;
-                                readonly start: DateTimeType;
-                                readonly end: DateTimeType;
-                            }>;
-                            insert: StructType<{
-                                readonly key: StringType;
-                                readonly label: StringType;
-                                readonly start: DateTimeType;
-                                readonly end: DateTimeType;
-                            }>;
-                            update: import("@elaraai/east").VariantType<{
-                                unchanged: import("@elaraai/east").NullType;
-                                replace: StructType<{
-                                    before: StructType<{
-                                        readonly key: StringType;
-                                        readonly label: StringType;
-                                        readonly start: DateTimeType;
-                                        readonly end: DateTimeType;
-                                    }>;
-                                    after: StructType<{
-                                        readonly key: StringType;
-                                        readonly label: StringType;
-                                        readonly start: DateTimeType;
-                                        readonly end: DateTimeType;
-                                    }>;
-                                }>;
-                                patch: StructType<{
-                                    readonly key: import("@elaraai/east").VariantType<{
-                                        unchanged: import("@elaraai/east").NullType;
-                                        replace: StructType<{
-                                            before: StringType;
-                                            after: StringType;
-                                        }>;
-                                    }>;
-                                    readonly label: import("@elaraai/east").VariantType<{
-                                        unchanged: import("@elaraai/east").NullType;
-                                        replace: StructType<{
-                                            before: StringType;
-                                            after: StringType;
-                                        }>;
-                                    }>;
-                                    readonly start: import("@elaraai/east").VariantType<{
-                                        unchanged: import("@elaraai/east").NullType;
-                                        replace: StructType<{
-                                            before: DateTimeType;
-                                            after: DateTimeType;
-                                        }>;
-                                    }>;
-                                    readonly end: import("@elaraai/east").VariantType<{
-                                        unchanged: import("@elaraai/east").NullType;
-                                        replace: StructType<{
-                                            before: DateTimeType;
-                                            after: DateTimeType;
-                                        }>;
-                                    }>;
-                                }>;
-                            }>;
+                    readonly tags: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: SetType<StringType>;
+                            after: SetType<StringType>;
                         }>;
-                    }>>;
+                        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+                            delete: import("@elaraai/east").NullType;
+                            insert: import("@elaraai/east").NullType;
+                        }>>;
+                    }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-export declare const indexedWorkByStatusDue: import("@elaraai/e3").RecordIndexDef<"by_status_due", DictType<StringType, StructType<{
-    readonly reference: StringType;
-    readonly job: StringType;
-    readonly status: StringType;
-    readonly due: DateTimeType;
-    readonly quantity: IntegerType;
-    readonly urgent: BooleanType;
-    readonly tags: SetType<StringType>;
-    readonly operations: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly start: DateTimeType;
-        readonly end: DateTimeType;
-    }>>;
-}>>, StructType<{
-    status: StringType;
-    due: DateTimeType;
-}>, import("@elaraai/east").NullType, readonly ["status", "due"]> & {
-    interval: undefined;
-};
-export declare const indexedWorkByDue: import("@elaraai/e3").RecordIndexDef<"by_due", DictType<StringType, StructType<{
-    readonly reference: StringType;
-    readonly job: StringType;
-    readonly status: StringType;
-    readonly due: DateTimeType;
-    readonly quantity: IntegerType;
-    readonly urgent: BooleanType;
-    readonly tags: SetType<StringType>;
-    readonly operations: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly start: DateTimeType;
-        readonly end: DateTimeType;
-    }>>;
-}>>, DateTimeType, import("@elaraai/east").NullType, readonly ["due"]> & {
-    interval: undefined;
-};
-export declare const indexedWorkByJob: import("@elaraai/e3").RecordIndexDef<"by_job", DictType<StringType, StructType<{
-    readonly reference: StringType;
-    readonly job: StringType;
-    readonly status: StringType;
-    readonly due: DateTimeType;
-    readonly quantity: IntegerType;
-    readonly urgent: BooleanType;
-    readonly tags: SetType<StringType>;
-    readonly operations: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly start: DateTimeType;
-        readonly end: DateTimeType;
-    }>>;
-}>>, StringType, import("@elaraai/east").NullType, readonly ["job"]> & {
-    interval: undefined;
-};
-export declare const indexedWorkByQuantity: import("@elaraai/e3").RecordIndexDef<"by_quantity", DictType<StringType, StructType<{
-    readonly reference: StringType;
-    readonly job: StringType;
-    readonly status: StringType;
-    readonly due: DateTimeType;
-    readonly quantity: IntegerType;
-    readonly urgent: BooleanType;
-    readonly tags: SetType<StringType>;
-    readonly operations: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly start: DateTimeType;
-        readonly end: DateTimeType;
-    }>>;
-}>>, IntegerType, import("@elaraai/east").NullType, readonly ["quantity"]> & {
-    interval: undefined;
-};
-export declare const indexedWorkByUrgent: import("@elaraai/e3").RecordIndexDef<"by_urgent", DictType<StringType, StructType<{
-    readonly reference: StringType;
-    readonly job: StringType;
-    readonly status: StringType;
-    readonly due: DateTimeType;
-    readonly quantity: IntegerType;
-    readonly urgent: BooleanType;
-    readonly tags: SetType<StringType>;
-    readonly operations: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly start: DateTimeType;
-        readonly end: DateTimeType;
-    }>>;
-}>>, BooleanType, import("@elaraai/east").NullType, readonly ["urgent"]> & {
-    interval: undefined;
-};
-export declare const indexedWorkByTag: import("@elaraai/e3").RecordIndexDef<"by_tag", DictType<StringType, StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
     readonly reference: StringType;
     readonly job: StringType;
     readonly status: StringType;
@@ -407,15 +190,84 @@ export declare const indexedWorkByTag: import("@elaraai/e3").RecordIndexDef<"by_
     readonly quantity: IntegerType;
     readonly urgent: BooleanType;
     readonly tags: SetType<StringType>;
-    readonly operations: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly start: DateTimeType;
-        readonly end: DateTimeType;
-    }>>;
-}>>, StringType, import("@elaraai/east").NullType, readonly ["tags"]> & {
-    interval: undefined;
-};
+}>>>>;
+/**
+ * The lens's benchmark record (#1349): a row of a million, in one of ten
+ * groups, and flagged or not. Empty here, so neither the showcase nor a test
+ * deploys a million rows: e3-ui-components' lens benchmark (`E3_UI_PERF=1`)
+ * fills it through its patch door, then draws two narrowings over it — the ten
+ * rows flagged, and the three groups that hold three in ten.
+ */
+export declare const LensBenchRow: StructType<{
+    readonly group: IntegerType;
+    readonly flag: BooleanType;
+}>;
+export declare const lensBenchRows: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly group: IntegerType;
+    readonly flag: BooleanType;
+}>>, [variant<"field", "records">, variant<"field", "lens_bench_rows">], import("@elaraai/e3").IndexesOf<{
+    lens_bench_by_group: import("@elaraai/e3").IndexDraft<IntegerType, import("@elaraai/east").NullType, readonly ["group"], unknown>;
+    lens_bench_by_flag: import("@elaraai/e3").IndexDraft<BooleanType, import("@elaraai/east").NullType, readonly ["flag"], unknown>;
+}, DictType<StringType, StructType<{
+    readonly group: IntegerType;
+    readonly flag: BooleanType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: import("@elaraai/east").NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly group: IntegerType;
+                readonly flag: BooleanType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly group: IntegerType;
+                readonly flag: BooleanType;
+            }>>;
+        }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly group: IntegerType;
+                readonly flag: BooleanType;
+            }>;
+            insert: StructType<{
+                readonly group: IntegerType;
+                readonly flag: BooleanType;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: import("@elaraai/east").NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly group: IntegerType;
+                        readonly flag: BooleanType;
+                    }>;
+                    after: StructType<{
+                        readonly group: IntegerType;
+                        readonly flag: BooleanType;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly group: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: IntegerType;
+                            after: IntegerType;
+                        }>;
+                    }>;
+                    readonly flag: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: StructType<{
+                            before: BooleanType;
+                            after: BooleanType;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly group: IntegerType;
+    readonly flag: BooleanType;
+}>>>>;
 export declare const sheetRecordIndexes: import("@elaraai/east").ExampleDef<[], any>;
 export declare const sheetRecordIndexesMobile: import("@elaraai/east").ExampleDef<[], any>;
 //# sourceMappingURL=sheet-records.examples.d.ts.map

package/dist/test/sheet/sheet-records.examples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sheet-records.examples.d.ts","sourceRoot":"","sources":["../../../test/sheet/sheet-records.examples.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,wCAAwC;AAExC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,QAAQ,EAAQ,WAAW,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAW,OAAO,EAAE,MAAM,eAAe,CAAC;AAKrJ,+EAA+E;AAC/E,eAAO,MAAM,gBAAgB;;;;;EAA6F,CAAC;AAC3H,gFAAgF;AAChF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;EAAgN,CAAC;AAyBzO,eAAO,MAAM,gBAAgB,qHAAwE,CAAC;AACtG,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;yGAAsE,CAAC;AACxG,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;4EAAiF,CAAC;AAChH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAuC,CAAC;AACrE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;CAAgF,CAAC;AACpH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;CAA+D,CAAC;AAC7F,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;CAA+D,CAAC;AAC7F,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;CAAyE,CAAC;AAC5G,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;CAAqE,CAAC;AACtG,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;CAAgE,CAAC;AAE9F,eAAO,MAAM,kBAAkB,6CAuB7B,CAAC;AAEH,eAAO,MAAM,wBAAwB,6CAuBnC,CAAC"}
+{"version":3,"file":"sheet-records.examples.d.ts","sourceRoot":"","sources":["../../../test/sheet/sheet-records.examples.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,wCAAwC;AAExC,OAAO,EAAa,WAAW,EAAE,YAAY,EAAE,QAAQ,EAAQ,WAAW,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAW,OAAO,EAAE,MAAM,eAAe,CAAC;AAKrJ;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;EAAuK,CAAC;AAGhM,0HAA0H;AAC1H,eAAO,MAAM,oBAAoB,yEAAsF,CAAC;AAExH,4FAA4F;AAC5F,eAAO,MAAM,cAAc,yEAGzB,CAAC;AAEH,uIAAuI;AACvI,eAAO,MAAM,cAAc,2EAGzB,CAAC;AAuBH,eAAO,MAAM,gBAAgB,qHAAwE,CAAC;AACtG,eAAO,MAAM,oBAAoB;;;;;;;;yGAAsE,CAAC;AACxG,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAa5B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,YAAY;;;EAAwD,CAAC;AAClF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KASxB,CAAC;AAEH,eAAO,MAAM,kBAAkB,6CAuB7B,CAAC;AAEH,eAAO,MAAM,wBAAwB,6CAuBnC,CAAC"}