@elaraai/e3-ui 1.0.98 → 1.0.99

package/dist/test/allocation/allocation.examples.d.ts

@@ -24,8 +24,18 @@ export declare const kilnBins: import("@elaraai/e3").RecordDef<DictType<StringTy
     readonly gradeBooked: StringType;
     readonly gradeMeasured: StringType;
     readonly instruction: import("@elaraai/east").OptionType<StringType>;
-}>>, [variant<"field", "records">, variant<"field", "kiln_bins">]>;
-export declare const kilnBinsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, import("@elaraai/east").StructType<{
+}>>, [variant<"field", "records">, variant<"field", "kiln_bins">], import("@elaraai/e3").IndexesOf<{
+    kiln_bins_by_time: import("@elaraai/e3").IndexDraft<import("@elaraai/east").StructType<{
+        on: import("@elaraai/east").StructType<Record<never, never>>;
+        node: import("@elaraai/east").IntegerType;
+        at: DateTimeType;
+    }>, NullType, readonly [], {
+        readonly interval: {
+            readonly from: "at";
+            readonly to: "at";
+        };
+    }>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly bay: StringType;
     readonly at: DateTimeType;
     readonly load: import("@elaraai/east").OptionType<StringType>;
@@ -44,334 +54,334 @@ export declare const kilnBinsPatch: import("@elaraai/e3").MutationDef<"patch", D
     readonly gradeBooked: StringType;
     readonly gradeMeasured: StringType;
     readonly instruction: import("@elaraai/east").OptionType<StringType>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: NullType;
-    replace: import("@elaraai/east").StructType<{
-        before: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly spec: import("@elaraai/east").OptionType<StringType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly specBooked: StringType;
-            readonly specMeasured: StringType;
-            readonly gradeBooked: StringType;
-            readonly gradeMeasured: StringType;
-            readonly instruction: import("@elaraai/east").OptionType<StringType>;
-        }>>;
-        after: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly spec: import("@elaraai/east").OptionType<StringType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly specBooked: StringType;
-            readonly specMeasured: StringType;
-            readonly gradeBooked: StringType;
-            readonly gradeMeasured: StringType;
-            readonly instruction: import("@elaraai/east").OptionType<StringType>;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly spec: import("@elaraai/east").OptionType<StringType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly specBooked: StringType;
-            readonly specMeasured: StringType;
-            readonly gradeBooked: StringType;
-            readonly gradeMeasured: StringType;
-            readonly instruction: import("@elaraai/east").OptionType<StringType>;
-        }>;
-        insert: import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly spec: import("@elaraai/east").OptionType<StringType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly specBooked: StringType;
-            readonly specMeasured: StringType;
-            readonly gradeBooked: StringType;
-            readonly gradeMeasured: StringType;
-            readonly instruction: import("@elaraai/east").OptionType<StringType>;
-        }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: NullType;
-            replace: import("@elaraai/east").StructType<{
-                before: import("@elaraai/east").StructType<{
-                    readonly bay: StringType;
-                    readonly at: DateTimeType;
-                    readonly load: import("@elaraai/east").OptionType<StringType>;
-                    readonly m3: import("@elaraai/east").FloatType;
-                    readonly spec: import("@elaraai/east").OptionType<StringType>;
-                    readonly dryFor: import("@elaraai/east").VariantType<{
-                        readonly minutes: import("@elaraai/east").FloatType;
-                        readonly hours: import("@elaraai/east").FloatType;
-                        readonly days: import("@elaraai/east").FloatType;
-                        readonly weeks: import("@elaraai/east").FloatType;
-                        readonly months: import("@elaraai/east").FloatType;
-                    }>;
-                    readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-                    readonly specBooked: StringType;
-                    readonly specMeasured: StringType;
-                    readonly gradeBooked: StringType;
-                    readonly gradeMeasured: StringType;
-                    readonly instruction: import("@elaraai/east").OptionType<StringType>;
-                }>;
-                after: import("@elaraai/east").StructType<{
-                    readonly bay: StringType;
-                    readonly at: DateTimeType;
-                    readonly load: import("@elaraai/east").OptionType<StringType>;
-                    readonly m3: import("@elaraai/east").FloatType;
-                    readonly spec: import("@elaraai/east").OptionType<StringType>;
-                    readonly dryFor: import("@elaraai/east").VariantType<{
-                        readonly minutes: import("@elaraai/east").FloatType;
-                        readonly hours: import("@elaraai/east").FloatType;
-                        readonly days: import("@elaraai/east").FloatType;
-                        readonly weeks: import("@elaraai/east").FloatType;
-                        readonly months: import("@elaraai/east").FloatType;
-                    }>;
-                    readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-                    readonly specBooked: StringType;
-                    readonly specMeasured: StringType;
-                    readonly gradeBooked: StringType;
-                    readonly gradeMeasured: StringType;
-                    readonly instruction: import("@elaraai/east").OptionType<StringType>;
-                }>;
-            }>;
-            patch: import("@elaraai/east").StructType<{
-                readonly bay: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
-                }>;
-                readonly at: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
-                    }>;
-                }>;
-                readonly load: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").OptionType<StringType>;
-                        after: import("@elaraai/east").OptionType<StringType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
-                        }>;
-                    }>;
-                }>;
-                readonly m3: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").FloatType;
-                        after: import("@elaraai/east").FloatType;
-                    }>;
-                }>;
-                readonly spec: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").OptionType<StringType>;
-                        after: import("@elaraai/east").OptionType<StringType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
-                        }>;
-                    }>;
-                }>;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: import("@elaraai/east").StructType<{
+            before: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly spec: import("@elaraai/east").OptionType<StringType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly specBooked: StringType;
+                readonly specMeasured: StringType;
+                readonly gradeBooked: StringType;
+                readonly gradeMeasured: StringType;
+                readonly instruction: import("@elaraai/east").OptionType<StringType>;
+            }>>;
+            after: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly spec: import("@elaraai/east").OptionType<StringType>;
                 readonly dryFor: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly specBooked: StringType;
+                readonly specMeasured: StringType;
+                readonly gradeBooked: StringType;
+                readonly gradeMeasured: StringType;
+                readonly instruction: import("@elaraai/east").OptionType<StringType>;
+            }>>;
+        }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly spec: import("@elaraai/east").OptionType<StringType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly specBooked: StringType;
+                readonly specMeasured: StringType;
+                readonly gradeBooked: StringType;
+                readonly gradeMeasured: StringType;
+                readonly instruction: import("@elaraai/east").OptionType<StringType>;
+            }>;
+            insert: import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly spec: import("@elaraai/east").OptionType<StringType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly specBooked: StringType;
+                readonly specMeasured: StringType;
+                readonly gradeBooked: StringType;
+                readonly gradeMeasured: StringType;
+                readonly instruction: import("@elaraai/east").OptionType<StringType>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: import("@elaraai/east").StructType<{
+                    before: import("@elaraai/east").StructType<{
+                        readonly bay: StringType;
+                        readonly at: DateTimeType;
+                        readonly load: import("@elaraai/east").OptionType<StringType>;
+                        readonly m3: import("@elaraai/east").FloatType;
+                        readonly spec: import("@elaraai/east").OptionType<StringType>;
+                        readonly dryFor: import("@elaraai/east").VariantType<{
                             readonly minutes: import("@elaraai/east").FloatType;
                             readonly hours: import("@elaraai/east").FloatType;
                             readonly days: import("@elaraai/east").FloatType;
                             readonly weeks: import("@elaraai/east").FloatType;
                             readonly months: import("@elaraai/east").FloatType;
                         }>;
-                        after: import("@elaraai/east").VariantType<{
+                        readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                        readonly specBooked: StringType;
+                        readonly specMeasured: StringType;
+                        readonly gradeBooked: StringType;
+                        readonly gradeMeasured: StringType;
+                        readonly instruction: import("@elaraai/east").OptionType<StringType>;
+                    }>;
+                    after: import("@elaraai/east").StructType<{
+                        readonly bay: StringType;
+                        readonly at: DateTimeType;
+                        readonly load: import("@elaraai/east").OptionType<StringType>;
+                        readonly m3: import("@elaraai/east").FloatType;
+                        readonly spec: import("@elaraai/east").OptionType<StringType>;
+                        readonly dryFor: import("@elaraai/east").VariantType<{
                             readonly minutes: import("@elaraai/east").FloatType;
                             readonly hours: import("@elaraai/east").FloatType;
                             readonly days: import("@elaraai/east").FloatType;
                             readonly weeks: import("@elaraai/east").FloatType;
                             readonly months: import("@elaraai/east").FloatType;
                         }>;
+                        readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                        readonly specBooked: StringType;
+                        readonly specMeasured: StringType;
+                        readonly gradeBooked: StringType;
+                        readonly gradeMeasured: StringType;
+                        readonly instruction: import("@elaraai/east").OptionType<StringType>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        readonly minutes: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
-                            }>;
+                }>;
+                patch: import("@elaraai/east").StructType<{
+                    readonly bay: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
                         }>;
-                        readonly hours: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
-                            }>;
+                    }>;
+                    readonly at: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
                         }>;
-                        readonly days: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
-                            }>;
+                    }>;
+                    readonly load: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").OptionType<StringType>;
+                            after: import("@elaraai/east").OptionType<StringType>;
                         }>;
-                        readonly weeks: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
                             }>;
-                        }>;
-                        readonly months: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly kilns: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: DictType<StringType, import("@elaraai/east").FloatType>;
-                        after: DictType<StringType, import("@elaraai/east").FloatType>;
+                    readonly m3: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").FloatType;
+                            after: import("@elaraai/east").FloatType;
+                        }>;
                     }>;
-                    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-                        delete: import("@elaraai/east").FloatType;
-                        insert: import("@elaraai/east").FloatType;
-                        update: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
+                    readonly spec: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").OptionType<StringType>;
+                            after: import("@elaraai/east").OptionType<StringType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
-                    }>>;
-                }>;
-                readonly specBooked: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
                     }>;
-                }>;
-                readonly specMeasured: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly dryFor: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly minutes: import("@elaraai/east").FloatType;
+                                readonly hours: import("@elaraai/east").FloatType;
+                                readonly days: import("@elaraai/east").FloatType;
+                                readonly weeks: import("@elaraai/east").FloatType;
+                                readonly months: import("@elaraai/east").FloatType;
+                            }>;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly minutes: import("@elaraai/east").FloatType;
+                                readonly hours: import("@elaraai/east").FloatType;
+                                readonly days: import("@elaraai/east").FloatType;
+                                readonly weeks: import("@elaraai/east").FloatType;
+                                readonly months: import("@elaraai/east").FloatType;
+                            }>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly minutes: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly hours: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly days: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly weeks: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly months: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                        }>;
                     }>;
-                }>;
-                readonly gradeBooked: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly kilns: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: DictType<StringType, import("@elaraai/east").FloatType>;
+                            after: DictType<StringType, import("@elaraai/east").FloatType>;
+                        }>;
+                        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+                            delete: import("@elaraai/east").FloatType;
+                            insert: import("@elaraai/east").FloatType;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                        }>>;
                     }>;
-                }>;
-                readonly gradeMeasured: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly specBooked: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly instruction: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").OptionType<StringType>;
-                        after: import("@elaraai/east").OptionType<StringType>;
+                    readonly specMeasured: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                    readonly gradeBooked: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly gradeMeasured: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly instruction: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").OptionType<StringType>;
+                            after: import("@elaraai/east").OptionType<StringType>;
                         }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: StringType;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-/** The bins by their time: what the board's slice reads a day of them through, its navigation writing the range. */
-export declare const kilnBinsByTime: import("@elaraai/e3").RecordIndexDef<"kiln_bins_by_time", DictType<StringType, import("@elaraai/east").StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly bay: StringType;
     readonly at: DateTimeType;
     readonly load: import("@elaraai/east").OptionType<StringType>;
@@ -390,16 +400,7 @@ export declare const kilnBinsByTime: import("@elaraai/e3").RecordIndexDef<"kiln_
     readonly gradeBooked: StringType;
     readonly gradeMeasured: StringType;
     readonly instruction: import("@elaraai/east").OptionType<StringType>;
-}>>, import("@elaraai/east").StructType<Record<never, never> & {
-    __interval: import("@elaraai/east").IntegerType;
-} & {
-    at: DateTimeType;
-}>, NullType, readonly ["at"]> & {
-    interval: {
-        readonly from: "at";
-        readonly to: "at";
-    };
-};
+}>>>>;
 /** The days of the yard's plan, what the board publishes: Tue 4 May issued, Tue 11 and Wed 12 drafts. */
 export declare const yardDays: import("@elaraai/e3").RecordDef<DictType<DateTimeType, import("@elaraai/east").StructType<{
     readonly state: import("@elaraai/east").VariantType<{
@@ -408,112 +409,113 @@ export declare const yardDays: import("@elaraai/e3").RecordDef<DictType<DateTime
             readonly at: DateTimeType;
         }>;
     }>;
-}>>, [variant<"field", "records">, variant<"field", "yard_days">]>;
-export declare const yardDaysPatch: import("@elaraai/e3").MutationDef<"patch", DictType<DateTimeType, import("@elaraai/east").StructType<{
+}>>, [variant<"field", "records">, variant<"field", "yard_days">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<DateTimeType, import("@elaraai/east").StructType<{
     readonly state: import("@elaraai/east").VariantType<{
         readonly draft: NullType;
         readonly issued: import("@elaraai/east").StructType<{
             readonly at: DateTimeType;
         }>;
     }>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: NullType;
-    replace: import("@elaraai/east").StructType<{
-        before: DictType<DateTimeType, import("@elaraai/east").StructType<{
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly issued: import("@elaraai/east").StructType<{
-                    readonly at: DateTimeType;
-                }>;
-            }>;
-        }>>;
-        after: DictType<DateTimeType, import("@elaraai/east").StructType<{
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly issued: import("@elaraai/east").StructType<{
-                    readonly at: DateTimeType;
-                }>;
-            }>;
-        }>>;
-    }>;
-    patch: DictType<DateTimeType, import("@elaraai/east").VariantType<{
-        delete: import("@elaraai/east").StructType<{
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly issued: import("@elaraai/east").StructType<{
-                    readonly at: DateTimeType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: import("@elaraai/east").StructType<{
+            before: DictType<DateTimeType, import("@elaraai/east").StructType<{
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly draft: NullType;
+                    readonly issued: import("@elaraai/east").StructType<{
+                        readonly at: DateTimeType;
+                    }>;
                 }>;
-            }>;
-        }>;
-        insert: import("@elaraai/east").StructType<{
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly issued: import("@elaraai/east").StructType<{
-                    readonly at: DateTimeType;
+            }>>;
+            after: DictType<DateTimeType, import("@elaraai/east").StructType<{
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly draft: NullType;
+                    readonly issued: import("@elaraai/east").StructType<{
+                        readonly at: DateTimeType;
+                    }>;
                 }>;
-            }>;
+            }>>;
         }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: NullType;
-            replace: import("@elaraai/east").StructType<{
-                before: import("@elaraai/east").StructType<{
-                    readonly state: import("@elaraai/east").VariantType<{
-                        readonly draft: NullType;
-                        readonly issued: import("@elaraai/east").StructType<{
-                            readonly at: DateTimeType;
-                        }>;
+        patch: DictType<DateTimeType, import("@elaraai/east").VariantType<{
+            delete: import("@elaraai/east").StructType<{
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly draft: NullType;
+                    readonly issued: import("@elaraai/east").StructType<{
+                        readonly at: DateTimeType;
                     }>;
                 }>;
-                after: import("@elaraai/east").StructType<{
-                    readonly state: import("@elaraai/east").VariantType<{
-                        readonly draft: NullType;
-                        readonly issued: import("@elaraai/east").StructType<{
-                            readonly at: DateTimeType;
-                        }>;
+            }>;
+            insert: import("@elaraai/east").StructType<{
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly draft: NullType;
+                    readonly issued: import("@elaraai/east").StructType<{
+                        readonly at: DateTimeType;
                     }>;
                 }>;
             }>;
-            patch: import("@elaraai/east").StructType<{
-                readonly state: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").VariantType<{
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: import("@elaraai/east").StructType<{
+                    before: import("@elaraai/east").StructType<{
+                        readonly state: import("@elaraai/east").VariantType<{
                             readonly draft: NullType;
                             readonly issued: import("@elaraai/east").StructType<{
                                 readonly at: DateTimeType;
                             }>;
                         }>;
-                        after: import("@elaraai/east").VariantType<{
+                    }>;
+                    after: import("@elaraai/east").StructType<{
+                        readonly state: import("@elaraai/east").VariantType<{
                             readonly draft: NullType;
                             readonly issued: import("@elaraai/east").StructType<{
                                 readonly at: DateTimeType;
                             }>;
                         }>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        readonly draft: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
-                        }>;
-                        readonly issued: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").StructType<{
+                }>;
+                patch: import("@elaraai/east").StructType<{
+                    readonly state: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly draft: NullType;
+                                readonly issued: import("@elaraai/east").StructType<{
                                     readonly at: DateTimeType;
                                 }>;
-                                after: import("@elaraai/east").StructType<{
+                            }>;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly draft: NullType;
+                                readonly issued: import("@elaraai/east").StructType<{
                                     readonly at: DateTimeType;
                                 }>;
                             }>;
-                            patch: import("@elaraai/east").StructType<{
-                                readonly at: import("@elaraai/east").VariantType<{
-                                    unchanged: NullType;
-                                    replace: import("@elaraai/east").StructType<{
-                                        before: DateTimeType;
-                                        after: DateTimeType;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly draft: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly issued: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").StructType<{
+                                        readonly at: DateTimeType;
+                                    }>;
+                                    after: import("@elaraai/east").StructType<{
+                                        readonly at: DateTimeType;
+                                    }>;
+                                }>;
+                                patch: import("@elaraai/east").StructType<{
+                                    readonly at: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: DateTimeType;
+                                            after: DateTimeType;
+                                        }>;
                                     }>;
                                 }>;
                             }>;
@@ -521,9 +523,16 @@ export declare const yardDaysPatch: import("@elaraai/e3").MutationDef<"patch", D
                     }>;
                 }>;
             }>;
+        }>>;
+    }>]>;
+}, DictType<DateTimeType, import("@elaraai/east").StructType<{
+    readonly state: import("@elaraai/east").VariantType<{
+        readonly draft: NullType;
+        readonly issued: import("@elaraai/east").StructType<{
+            readonly at: DateTimeType;
         }>;
-    }>>;
-}>]>;
+    }>;
+}>>>>;
 /** The same bins, locked for the day: their door, a checked one, refuses every change, naming why — what a Save over it is answered. */
 export declare const kilnLockedBins: import("@elaraai/e3").RecordDef<DictType<StringType, import("@elaraai/east").StructType<{
     readonly bay: StringType;
@@ -544,37 +553,18 @@ export declare const kilnLockedBins: import("@elaraai/e3").RecordDef<DictType<St
     readonly gradeBooked: StringType;
     readonly gradeMeasured: StringType;
     readonly instruction: import("@elaraai/east").OptionType<StringType>;
-}>>, [variant<"field", "records">, variant<"field", "kiln_locked_bins">]>;
-export declare const kilnLockedBinsByTime: import("@elaraai/e3").RecordIndexDef<"kiln_locked_bins_by_time", DictType<StringType, import("@elaraai/east").StructType<{
-    readonly bay: StringType;
-    readonly at: DateTimeType;
-    readonly load: import("@elaraai/east").OptionType<StringType>;
-    readonly m3: import("@elaraai/east").FloatType;
-    readonly spec: import("@elaraai/east").OptionType<StringType>;
-    readonly dryFor: import("@elaraai/east").VariantType<{
-        readonly minutes: import("@elaraai/east").FloatType;
-        readonly hours: import("@elaraai/east").FloatType;
-        readonly days: import("@elaraai/east").FloatType;
-        readonly weeks: import("@elaraai/east").FloatType;
-        readonly months: import("@elaraai/east").FloatType;
+}>>, [variant<"field", "records">, variant<"field", "kiln_locked_bins">], import("@elaraai/e3").IndexesOf<{
+    kiln_locked_bins_by_time: import("@elaraai/e3").IndexDraft<import("@elaraai/east").StructType<{
+        on: import("@elaraai/east").StructType<Record<never, never>>;
+        node: import("@elaraai/east").IntegerType;
+        at: DateTimeType;
+    }>, NullType, readonly [], {
+        readonly interval: {
+            readonly from: "at";
+            readonly to: "at";
+        };
     }>;
-    readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-    readonly specBooked: StringType;
-    readonly specMeasured: StringType;
-    readonly gradeBooked: StringType;
-    readonly gradeMeasured: StringType;
-    readonly instruction: import("@elaraai/east").OptionType<StringType>;
-}>>, import("@elaraai/east").StructType<Record<never, never> & {
-    __interval: import("@elaraai/east").IntegerType;
-} & {
-    at: DateTimeType;
-}>, NullType, readonly ["at"]> & {
-    interval: {
-        readonly from: "at";
-        readonly to: "at";
-    };
-};
-export declare const kilnLockedBinsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, import("@elaraai/east").StructType<{
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly bay: StringType;
     readonly at: DateTimeType;
     readonly load: import("@elaraai/east").OptionType<StringType>;
@@ -593,332 +583,353 @@ export declare const kilnLockedBinsPatch: import("@elaraai/e3").MutationDef<"pat
     readonly gradeBooked: StringType;
     readonly gradeMeasured: StringType;
     readonly instruction: import("@elaraai/east").OptionType<StringType>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: NullType;
-    replace: import("@elaraai/east").StructType<{
-        before: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly spec: import("@elaraai/east").OptionType<StringType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly specBooked: StringType;
-            readonly specMeasured: StringType;
-            readonly gradeBooked: StringType;
-            readonly gradeMeasured: StringType;
-            readonly instruction: import("@elaraai/east").OptionType<StringType>;
-        }>>;
-        after: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly spec: import("@elaraai/east").OptionType<StringType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly specBooked: StringType;
-            readonly specMeasured: StringType;
-            readonly gradeBooked: StringType;
-            readonly gradeMeasured: StringType;
-            readonly instruction: import("@elaraai/east").OptionType<StringType>;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly spec: import("@elaraai/east").OptionType<StringType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly specBooked: StringType;
-            readonly specMeasured: StringType;
-            readonly gradeBooked: StringType;
-            readonly gradeMeasured: StringType;
-            readonly instruction: import("@elaraai/east").OptionType<StringType>;
-        }>;
-        insert: import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly spec: import("@elaraai/east").OptionType<StringType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly specBooked: StringType;
-            readonly specMeasured: StringType;
-            readonly gradeBooked: StringType;
-            readonly gradeMeasured: StringType;
-            readonly instruction: import("@elaraai/east").OptionType<StringType>;
-        }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: NullType;
-            replace: import("@elaraai/east").StructType<{
-                before: import("@elaraai/east").StructType<{
-                    readonly bay: StringType;
-                    readonly at: DateTimeType;
-                    readonly load: import("@elaraai/east").OptionType<StringType>;
-                    readonly m3: import("@elaraai/east").FloatType;
-                    readonly spec: import("@elaraai/east").OptionType<StringType>;
-                    readonly dryFor: import("@elaraai/east").VariantType<{
-                        readonly minutes: import("@elaraai/east").FloatType;
-                        readonly hours: import("@elaraai/east").FloatType;
-                        readonly days: import("@elaraai/east").FloatType;
-                        readonly weeks: import("@elaraai/east").FloatType;
-                        readonly months: import("@elaraai/east").FloatType;
-                    }>;
-                    readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-                    readonly specBooked: StringType;
-                    readonly specMeasured: StringType;
-                    readonly gradeBooked: StringType;
-                    readonly gradeMeasured: StringType;
-                    readonly instruction: import("@elaraai/east").OptionType<StringType>;
-                }>;
-                after: import("@elaraai/east").StructType<{
-                    readonly bay: StringType;
-                    readonly at: DateTimeType;
-                    readonly load: import("@elaraai/east").OptionType<StringType>;
-                    readonly m3: import("@elaraai/east").FloatType;
-                    readonly spec: import("@elaraai/east").OptionType<StringType>;
-                    readonly dryFor: import("@elaraai/east").VariantType<{
-                        readonly minutes: import("@elaraai/east").FloatType;
-                        readonly hours: import("@elaraai/east").FloatType;
-                        readonly days: import("@elaraai/east").FloatType;
-                        readonly weeks: import("@elaraai/east").FloatType;
-                        readonly months: import("@elaraai/east").FloatType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: import("@elaraai/east").StructType<{
+            before: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly spec: import("@elaraai/east").OptionType<StringType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly specBooked: StringType;
+                readonly specMeasured: StringType;
+                readonly gradeBooked: StringType;
+                readonly gradeMeasured: StringType;
+                readonly instruction: import("@elaraai/east").OptionType<StringType>;
+            }>>;
+            after: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly spec: import("@elaraai/east").OptionType<StringType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly specBooked: StringType;
+                readonly specMeasured: StringType;
+                readonly gradeBooked: StringType;
+                readonly gradeMeasured: StringType;
+                readonly instruction: import("@elaraai/east").OptionType<StringType>;
+            }>>;
+        }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly spec: import("@elaraai/east").OptionType<StringType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly specBooked: StringType;
+                readonly specMeasured: StringType;
+                readonly gradeBooked: StringType;
+                readonly gradeMeasured: StringType;
+                readonly instruction: import("@elaraai/east").OptionType<StringType>;
+            }>;
+            insert: import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly spec: import("@elaraai/east").OptionType<StringType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly specBooked: StringType;
+                readonly specMeasured: StringType;
+                readonly gradeBooked: StringType;
+                readonly gradeMeasured: StringType;
+                readonly instruction: import("@elaraai/east").OptionType<StringType>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: import("@elaraai/east").StructType<{
+                    before: import("@elaraai/east").StructType<{
+                        readonly bay: StringType;
+                        readonly at: DateTimeType;
+                        readonly load: import("@elaraai/east").OptionType<StringType>;
+                        readonly m3: import("@elaraai/east").FloatType;
+                        readonly spec: import("@elaraai/east").OptionType<StringType>;
+                        readonly dryFor: import("@elaraai/east").VariantType<{
+                            readonly minutes: import("@elaraai/east").FloatType;
+                            readonly hours: import("@elaraai/east").FloatType;
+                            readonly days: import("@elaraai/east").FloatType;
+                            readonly weeks: import("@elaraai/east").FloatType;
+                            readonly months: import("@elaraai/east").FloatType;
+                        }>;
+                        readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                        readonly specBooked: StringType;
+                        readonly specMeasured: StringType;
+                        readonly gradeBooked: StringType;
+                        readonly gradeMeasured: StringType;
+                        readonly instruction: import("@elaraai/east").OptionType<StringType>;
+                    }>;
+                    after: import("@elaraai/east").StructType<{
+                        readonly bay: StringType;
+                        readonly at: DateTimeType;
+                        readonly load: import("@elaraai/east").OptionType<StringType>;
+                        readonly m3: import("@elaraai/east").FloatType;
+                        readonly spec: import("@elaraai/east").OptionType<StringType>;
+                        readonly dryFor: import("@elaraai/east").VariantType<{
+                            readonly minutes: import("@elaraai/east").FloatType;
+                            readonly hours: import("@elaraai/east").FloatType;
+                            readonly days: import("@elaraai/east").FloatType;
+                            readonly weeks: import("@elaraai/east").FloatType;
+                            readonly months: import("@elaraai/east").FloatType;
+                        }>;
+                        readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                        readonly specBooked: StringType;
+                        readonly specMeasured: StringType;
+                        readonly gradeBooked: StringType;
+                        readonly gradeMeasured: StringType;
+                        readonly instruction: import("@elaraai/east").OptionType<StringType>;
                     }>;
-                    readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-                    readonly specBooked: StringType;
-                    readonly specMeasured: StringType;
-                    readonly gradeBooked: StringType;
-                    readonly gradeMeasured: StringType;
-                    readonly instruction: import("@elaraai/east").OptionType<StringType>;
                 }>;
-            }>;
-            patch: import("@elaraai/east").StructType<{
-                readonly bay: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
+                patch: import("@elaraai/east").StructType<{
+                    readonly bay: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly at: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
+                    readonly at: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
+                        }>;
                     }>;
-                }>;
-                readonly load: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").OptionType<StringType>;
-                        after: import("@elaraai/east").OptionType<StringType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                    readonly load: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").OptionType<StringType>;
+                            after: import("@elaraai/east").OptionType<StringType>;
                         }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: StringType;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
                             }>;
-                        }>;
-                    }>;
-                }>;
-                readonly m3: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").FloatType;
-                        after: import("@elaraai/east").FloatType;
-                    }>;
-                }>;
-                readonly spec: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").OptionType<StringType>;
-                        after: import("@elaraai/east").OptionType<StringType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: NullType;
-                                after: NullType;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
+                    }>;
+                    readonly m3: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").FloatType;
+                            after: import("@elaraai/east").FloatType;
                         }>;
                     }>;
-                }>;
-                readonly dryFor: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").VariantType<{
-                            readonly minutes: import("@elaraai/east").FloatType;
-                            readonly hours: import("@elaraai/east").FloatType;
-                            readonly days: import("@elaraai/east").FloatType;
-                            readonly weeks: import("@elaraai/east").FloatType;
-                            readonly months: import("@elaraai/east").FloatType;
+                    readonly spec: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").OptionType<StringType>;
+                            after: import("@elaraai/east").OptionType<StringType>;
                         }>;
-                        after: import("@elaraai/east").VariantType<{
-                            readonly minutes: import("@elaraai/east").FloatType;
-                            readonly hours: import("@elaraai/east").FloatType;
-                            readonly days: import("@elaraai/east").FloatType;
-                            readonly weeks: import("@elaraai/east").FloatType;
-                            readonly months: import("@elaraai/east").FloatType;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
                         }>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        readonly minutes: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
+                    readonly dryFor: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly minutes: import("@elaraai/east").FloatType;
+                                readonly hours: import("@elaraai/east").FloatType;
+                                readonly days: import("@elaraai/east").FloatType;
+                                readonly weeks: import("@elaraai/east").FloatType;
+                                readonly months: import("@elaraai/east").FloatType;
+                            }>;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly minutes: import("@elaraai/east").FloatType;
+                                readonly hours: import("@elaraai/east").FloatType;
+                                readonly days: import("@elaraai/east").FloatType;
+                                readonly weeks: import("@elaraai/east").FloatType;
+                                readonly months: import("@elaraai/east").FloatType;
+                            }>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly minutes: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
                             }>;
-                        }>;
-                        readonly hours: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
+                            readonly hours: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
                             }>;
-                        }>;
-                        readonly days: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
+                            readonly days: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
                             }>;
-                        }>;
-                        readonly weeks: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
+                            readonly weeks: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
                             }>;
-                        }>;
-                        readonly months: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
+                            readonly months: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly kilns: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: DictType<StringType, import("@elaraai/east").FloatType>;
-                        after: DictType<StringType, import("@elaraai/east").FloatType>;
-                    }>;
-                    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-                        delete: import("@elaraai/east").FloatType;
-                        insert: import("@elaraai/east").FloatType;
-                        update: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
-                            }>;
+                    readonly kilns: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: DictType<StringType, import("@elaraai/east").FloatType>;
+                            after: DictType<StringType, import("@elaraai/east").FloatType>;
                         }>;
-                    }>>;
-                }>;
-                readonly specBooked: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
+                        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+                            delete: import("@elaraai/east").FloatType;
+                            insert: import("@elaraai/east").FloatType;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                        }>>;
                     }>;
-                }>;
-                readonly specMeasured: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly specBooked: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly gradeBooked: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly specMeasured: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly gradeMeasured: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly gradeBooked: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly instruction: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").OptionType<StringType>;
-                        after: import("@elaraai/east").OptionType<StringType>;
+                    readonly gradeMeasured: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                    readonly instruction: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").OptionType<StringType>;
+                            after: import("@elaraai/east").OptionType<StringType>;
                         }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: StringType;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
+        }>>;
+    }>]>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
+    readonly bay: StringType;
+    readonly at: DateTimeType;
+    readonly load: import("@elaraai/east").OptionType<StringType>;
+    readonly m3: import("@elaraai/east").FloatType;
+    readonly spec: import("@elaraai/east").OptionType<StringType>;
+    readonly dryFor: import("@elaraai/east").VariantType<{
+        readonly minutes: import("@elaraai/east").FloatType;
+        readonly hours: import("@elaraai/east").FloatType;
+        readonly days: import("@elaraai/east").FloatType;
+        readonly weeks: import("@elaraai/east").FloatType;
+        readonly months: import("@elaraai/east").FloatType;
+    }>;
+    readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+    readonly specBooked: StringType;
+    readonly specMeasured: StringType;
+    readonly gradeBooked: StringType;
+    readonly gradeMeasured: StringType;
+    readonly instruction: import("@elaraai/east").OptionType<StringType>;
+}>>>>;
 /** The same days, locked: the site office issues them, and their door refuses every change, naming why. */
 export declare const yardLockedDays: import("@elaraai/e3").RecordDef<DictType<DateTimeType, import("@elaraai/east").StructType<{
     readonly state: import("@elaraai/east").VariantType<{
@@ -927,112 +938,113 @@ export declare const yardLockedDays: import("@elaraai/e3").RecordDef<DictType<Da
             readonly at: DateTimeType;
         }>;
     }>;
-}>>, [variant<"field", "records">, variant<"field", "yard_locked_days">]>;
-export declare const yardLockedDaysPatch: import("@elaraai/e3").MutationDef<"patch", DictType<DateTimeType, import("@elaraai/east").StructType<{
+}>>, [variant<"field", "records">, variant<"field", "yard_locked_days">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<DateTimeType, import("@elaraai/east").StructType<{
     readonly state: import("@elaraai/east").VariantType<{
         readonly draft: NullType;
         readonly issued: import("@elaraai/east").StructType<{
             readonly at: DateTimeType;
         }>;
     }>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: NullType;
-    replace: import("@elaraai/east").StructType<{
-        before: DictType<DateTimeType, import("@elaraai/east").StructType<{
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly issued: import("@elaraai/east").StructType<{
-                    readonly at: DateTimeType;
-                }>;
-            }>;
-        }>>;
-        after: DictType<DateTimeType, import("@elaraai/east").StructType<{
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly issued: import("@elaraai/east").StructType<{
-                    readonly at: DateTimeType;
-                }>;
-            }>;
-        }>>;
-    }>;
-    patch: DictType<DateTimeType, import("@elaraai/east").VariantType<{
-        delete: import("@elaraai/east").StructType<{
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly issued: import("@elaraai/east").StructType<{
-                    readonly at: DateTimeType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: import("@elaraai/east").StructType<{
+            before: DictType<DateTimeType, import("@elaraai/east").StructType<{
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly draft: NullType;
+                    readonly issued: import("@elaraai/east").StructType<{
+                        readonly at: DateTimeType;
+                    }>;
                 }>;
-            }>;
-        }>;
-        insert: import("@elaraai/east").StructType<{
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly issued: import("@elaraai/east").StructType<{
-                    readonly at: DateTimeType;
+            }>>;
+            after: DictType<DateTimeType, import("@elaraai/east").StructType<{
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly draft: NullType;
+                    readonly issued: import("@elaraai/east").StructType<{
+                        readonly at: DateTimeType;
+                    }>;
                 }>;
-            }>;
+            }>>;
         }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: NullType;
-            replace: import("@elaraai/east").StructType<{
-                before: import("@elaraai/east").StructType<{
-                    readonly state: import("@elaraai/east").VariantType<{
-                        readonly draft: NullType;
-                        readonly issued: import("@elaraai/east").StructType<{
-                            readonly at: DateTimeType;
-                        }>;
+        patch: DictType<DateTimeType, import("@elaraai/east").VariantType<{
+            delete: import("@elaraai/east").StructType<{
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly draft: NullType;
+                    readonly issued: import("@elaraai/east").StructType<{
+                        readonly at: DateTimeType;
                     }>;
                 }>;
-                after: import("@elaraai/east").StructType<{
-                    readonly state: import("@elaraai/east").VariantType<{
-                        readonly draft: NullType;
-                        readonly issued: import("@elaraai/east").StructType<{
-                            readonly at: DateTimeType;
-                        }>;
+            }>;
+            insert: import("@elaraai/east").StructType<{
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly draft: NullType;
+                    readonly issued: import("@elaraai/east").StructType<{
+                        readonly at: DateTimeType;
                     }>;
                 }>;
             }>;
-            patch: import("@elaraai/east").StructType<{
-                readonly state: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").VariantType<{
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: import("@elaraai/east").StructType<{
+                    before: import("@elaraai/east").StructType<{
+                        readonly state: import("@elaraai/east").VariantType<{
                             readonly draft: NullType;
                             readonly issued: import("@elaraai/east").StructType<{
                                 readonly at: DateTimeType;
                             }>;
                         }>;
-                        after: import("@elaraai/east").VariantType<{
+                    }>;
+                    after: import("@elaraai/east").StructType<{
+                        readonly state: import("@elaraai/east").VariantType<{
                             readonly draft: NullType;
                             readonly issued: import("@elaraai/east").StructType<{
                                 readonly at: DateTimeType;
                             }>;
                         }>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        readonly draft: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
-                        }>;
-                        readonly issued: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").StructType<{
+                }>;
+                patch: import("@elaraai/east").StructType<{
+                    readonly state: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly draft: NullType;
+                                readonly issued: import("@elaraai/east").StructType<{
                                     readonly at: DateTimeType;
                                 }>;
-                                after: import("@elaraai/east").StructType<{
+                            }>;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly draft: NullType;
+                                readonly issued: import("@elaraai/east").StructType<{
                                     readonly at: DateTimeType;
                                 }>;
                             }>;
-                            patch: import("@elaraai/east").StructType<{
-                                readonly at: import("@elaraai/east").VariantType<{
-                                    unchanged: NullType;
-                                    replace: import("@elaraai/east").StructType<{
-                                        before: DateTimeType;
-                                        after: DateTimeType;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly draft: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly issued: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").StructType<{
+                                        readonly at: DateTimeType;
+                                    }>;
+                                    after: import("@elaraai/east").StructType<{
+                                        readonly at: DateTimeType;
+                                    }>;
+                                }>;
+                                patch: import("@elaraai/east").StructType<{
+                                    readonly at: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: DateTimeType;
+                                            after: DateTimeType;
+                                        }>;
                                     }>;
                                 }>;
                             }>;
@@ -1040,9 +1052,16 @@ export declare const yardLockedDaysPatch: import("@elaraai/e3").MutationDef<"pat
                     }>;
                 }>;
             }>;
+        }>>;
+    }>]>;
+}, DictType<DateTimeType, import("@elaraai/east").StructType<{
+    readonly state: import("@elaraai/east").VariantType<{
+        readonly draft: NullType;
+        readonly issued: import("@elaraai/east").StructType<{
+            readonly at: DateTimeType;
         }>;
-    }>>;
-}>]>;
+    }>;
+}>>>>;
 /** Two years of the yard's bins, for the board read a day at a time through its slice. */
 export declare const kilnBinHistory: import("@elaraai/e3").RecordDef<DictType<StringType, import("@elaraai/east").StructType<{
     readonly bay: StringType;
@@ -1063,8 +1082,18 @@ export declare const kilnBinHistory: import("@elaraai/e3").RecordDef<DictType<St
     readonly gradeBooked: StringType;
     readonly gradeMeasured: StringType;
     readonly instruction: import("@elaraai/east").OptionType<StringType>;
-}>>, [variant<"field", "records">, variant<"field", "kiln_bin_history">]>;
-export declare const kilnBinHistoryPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, import("@elaraai/east").StructType<{
+}>>, [variant<"field", "records">, variant<"field", "kiln_bin_history">], import("@elaraai/e3").IndexesOf<{
+    kiln_bin_history_by_time: import("@elaraai/e3").IndexDraft<import("@elaraai/east").StructType<{
+        on: import("@elaraai/east").StructType<Record<never, never>>;
+        node: import("@elaraai/east").IntegerType;
+        at: DateTimeType;
+    }>, NullType, readonly [], {
+        readonly interval: {
+            readonly from: "at";
+            readonly to: "at";
+        };
+    }>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly bay: StringType;
     readonly at: DateTimeType;
     readonly load: import("@elaraai/east").OptionType<StringType>;
@@ -1083,333 +1112,334 @@ export declare const kilnBinHistoryPatch: import("@elaraai/e3").MutationDef<"pat
     readonly gradeBooked: StringType;
     readonly gradeMeasured: StringType;
     readonly instruction: import("@elaraai/east").OptionType<StringType>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: NullType;
-    replace: import("@elaraai/east").StructType<{
-        before: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly spec: import("@elaraai/east").OptionType<StringType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly specBooked: StringType;
-            readonly specMeasured: StringType;
-            readonly gradeBooked: StringType;
-            readonly gradeMeasured: StringType;
-            readonly instruction: import("@elaraai/east").OptionType<StringType>;
-        }>>;
-        after: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly spec: import("@elaraai/east").OptionType<StringType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly specBooked: StringType;
-            readonly specMeasured: StringType;
-            readonly gradeBooked: StringType;
-            readonly gradeMeasured: StringType;
-            readonly instruction: import("@elaraai/east").OptionType<StringType>;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly spec: import("@elaraai/east").OptionType<StringType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly specBooked: StringType;
-            readonly specMeasured: StringType;
-            readonly gradeBooked: StringType;
-            readonly gradeMeasured: StringType;
-            readonly instruction: import("@elaraai/east").OptionType<StringType>;
-        }>;
-        insert: import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly spec: import("@elaraai/east").OptionType<StringType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly specBooked: StringType;
-            readonly specMeasured: StringType;
-            readonly gradeBooked: StringType;
-            readonly gradeMeasured: StringType;
-            readonly instruction: import("@elaraai/east").OptionType<StringType>;
-        }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: NullType;
-            replace: import("@elaraai/east").StructType<{
-                before: import("@elaraai/east").StructType<{
-                    readonly bay: StringType;
-                    readonly at: DateTimeType;
-                    readonly load: import("@elaraai/east").OptionType<StringType>;
-                    readonly m3: import("@elaraai/east").FloatType;
-                    readonly spec: import("@elaraai/east").OptionType<StringType>;
-                    readonly dryFor: import("@elaraai/east").VariantType<{
-                        readonly minutes: import("@elaraai/east").FloatType;
-                        readonly hours: import("@elaraai/east").FloatType;
-                        readonly days: import("@elaraai/east").FloatType;
-                        readonly weeks: import("@elaraai/east").FloatType;
-                        readonly months: import("@elaraai/east").FloatType;
-                    }>;
-                    readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-                    readonly specBooked: StringType;
-                    readonly specMeasured: StringType;
-                    readonly gradeBooked: StringType;
-                    readonly gradeMeasured: StringType;
-                    readonly instruction: import("@elaraai/east").OptionType<StringType>;
-                }>;
-                after: import("@elaraai/east").StructType<{
-                    readonly bay: StringType;
-                    readonly at: DateTimeType;
-                    readonly load: import("@elaraai/east").OptionType<StringType>;
-                    readonly m3: import("@elaraai/east").FloatType;
-                    readonly spec: import("@elaraai/east").OptionType<StringType>;
-                    readonly dryFor: import("@elaraai/east").VariantType<{
-                        readonly minutes: import("@elaraai/east").FloatType;
-                        readonly hours: import("@elaraai/east").FloatType;
-                        readonly days: import("@elaraai/east").FloatType;
-                        readonly weeks: import("@elaraai/east").FloatType;
-                        readonly months: import("@elaraai/east").FloatType;
-                    }>;
-                    readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-                    readonly specBooked: StringType;
-                    readonly specMeasured: StringType;
-                    readonly gradeBooked: StringType;
-                    readonly gradeMeasured: StringType;
-                    readonly instruction: import("@elaraai/east").OptionType<StringType>;
-                }>;
-            }>;
-            patch: import("@elaraai/east").StructType<{
-                readonly bay: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
-                }>;
-                readonly at: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
-                    }>;
-                }>;
-                readonly load: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").OptionType<StringType>;
-                        after: import("@elaraai/east").OptionType<StringType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
-                        }>;
-                    }>;
-                }>;
-                readonly m3: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").FloatType;
-                        after: import("@elaraai/east").FloatType;
-                    }>;
-                }>;
-                readonly spec: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").OptionType<StringType>;
-                        after: import("@elaraai/east").OptionType<StringType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
-                        }>;
-                    }>;
-                }>;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: import("@elaraai/east").StructType<{
+            before: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly spec: import("@elaraai/east").OptionType<StringType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly specBooked: StringType;
+                readonly specMeasured: StringType;
+                readonly gradeBooked: StringType;
+                readonly gradeMeasured: StringType;
+                readonly instruction: import("@elaraai/east").OptionType<StringType>;
+            }>>;
+            after: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly spec: import("@elaraai/east").OptionType<StringType>;
                 readonly dryFor: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly specBooked: StringType;
+                readonly specMeasured: StringType;
+                readonly gradeBooked: StringType;
+                readonly gradeMeasured: StringType;
+                readonly instruction: import("@elaraai/east").OptionType<StringType>;
+            }>>;
+        }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly spec: import("@elaraai/east").OptionType<StringType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly specBooked: StringType;
+                readonly specMeasured: StringType;
+                readonly gradeBooked: StringType;
+                readonly gradeMeasured: StringType;
+                readonly instruction: import("@elaraai/east").OptionType<StringType>;
+            }>;
+            insert: import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly spec: import("@elaraai/east").OptionType<StringType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly specBooked: StringType;
+                readonly specMeasured: StringType;
+                readonly gradeBooked: StringType;
+                readonly gradeMeasured: StringType;
+                readonly instruction: import("@elaraai/east").OptionType<StringType>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: import("@elaraai/east").StructType<{
+                    before: import("@elaraai/east").StructType<{
+                        readonly bay: StringType;
+                        readonly at: DateTimeType;
+                        readonly load: import("@elaraai/east").OptionType<StringType>;
+                        readonly m3: import("@elaraai/east").FloatType;
+                        readonly spec: import("@elaraai/east").OptionType<StringType>;
+                        readonly dryFor: import("@elaraai/east").VariantType<{
                             readonly minutes: import("@elaraai/east").FloatType;
                             readonly hours: import("@elaraai/east").FloatType;
                             readonly days: import("@elaraai/east").FloatType;
                             readonly weeks: import("@elaraai/east").FloatType;
                             readonly months: import("@elaraai/east").FloatType;
                         }>;
-                        after: import("@elaraai/east").VariantType<{
+                        readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                        readonly specBooked: StringType;
+                        readonly specMeasured: StringType;
+                        readonly gradeBooked: StringType;
+                        readonly gradeMeasured: StringType;
+                        readonly instruction: import("@elaraai/east").OptionType<StringType>;
+                    }>;
+                    after: import("@elaraai/east").StructType<{
+                        readonly bay: StringType;
+                        readonly at: DateTimeType;
+                        readonly load: import("@elaraai/east").OptionType<StringType>;
+                        readonly m3: import("@elaraai/east").FloatType;
+                        readonly spec: import("@elaraai/east").OptionType<StringType>;
+                        readonly dryFor: import("@elaraai/east").VariantType<{
                             readonly minutes: import("@elaraai/east").FloatType;
                             readonly hours: import("@elaraai/east").FloatType;
                             readonly days: import("@elaraai/east").FloatType;
                             readonly weeks: import("@elaraai/east").FloatType;
                             readonly months: import("@elaraai/east").FloatType;
                         }>;
+                        readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                        readonly specBooked: StringType;
+                        readonly specMeasured: StringType;
+                        readonly gradeBooked: StringType;
+                        readonly gradeMeasured: StringType;
+                        readonly instruction: import("@elaraai/east").OptionType<StringType>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        readonly minutes: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
-                            }>;
+                }>;
+                patch: import("@elaraai/east").StructType<{
+                    readonly bay: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
                         }>;
-                        readonly hours: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
-                            }>;
+                    }>;
+                    readonly at: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
                         }>;
-                        readonly days: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
-                            }>;
+                    }>;
+                    readonly load: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").OptionType<StringType>;
+                            after: import("@elaraai/east").OptionType<StringType>;
                         }>;
-                        readonly weeks: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
                             }>;
-                        }>;
-                        readonly months: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly kilns: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: DictType<StringType, import("@elaraai/east").FloatType>;
-                        after: DictType<StringType, import("@elaraai/east").FloatType>;
+                    readonly m3: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").FloatType;
+                            after: import("@elaraai/east").FloatType;
+                        }>;
                     }>;
-                    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-                        delete: import("@elaraai/east").FloatType;
-                        insert: import("@elaraai/east").FloatType;
-                        update: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
+                    readonly spec: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").OptionType<StringType>;
+                            after: import("@elaraai/east").OptionType<StringType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
-                    }>>;
-                }>;
-                readonly specBooked: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
                     }>;
-                }>;
-                readonly specMeasured: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly dryFor: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly minutes: import("@elaraai/east").FloatType;
+                                readonly hours: import("@elaraai/east").FloatType;
+                                readonly days: import("@elaraai/east").FloatType;
+                                readonly weeks: import("@elaraai/east").FloatType;
+                                readonly months: import("@elaraai/east").FloatType;
+                            }>;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly minutes: import("@elaraai/east").FloatType;
+                                readonly hours: import("@elaraai/east").FloatType;
+                                readonly days: import("@elaraai/east").FloatType;
+                                readonly weeks: import("@elaraai/east").FloatType;
+                                readonly months: import("@elaraai/east").FloatType;
+                            }>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly minutes: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly hours: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly days: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly weeks: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly months: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                        }>;
                     }>;
-                }>;
-                readonly gradeBooked: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly kilns: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: DictType<StringType, import("@elaraai/east").FloatType>;
+                            after: DictType<StringType, import("@elaraai/east").FloatType>;
+                        }>;
+                        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+                            delete: import("@elaraai/east").FloatType;
+                            insert: import("@elaraai/east").FloatType;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                        }>>;
                     }>;
-                }>;
-                readonly gradeMeasured: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly specBooked: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly instruction: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").OptionType<StringType>;
-                        after: import("@elaraai/east").OptionType<StringType>;
+                    readonly specMeasured: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                    readonly gradeBooked: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly gradeMeasured: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
                         }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: StringType;
+                    }>;
+                    readonly instruction: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").OptionType<StringType>;
+                            after: import("@elaraai/east").OptionType<StringType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-export declare const kilnBinHistoryByTime: import("@elaraai/e3").RecordIndexDef<"kiln_bin_history_by_time", DictType<StringType, import("@elaraai/east").StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly bay: StringType;
     readonly at: DateTimeType;
     readonly load: import("@elaraai/east").OptionType<StringType>;
@@ -1428,16 +1458,7 @@ export declare const kilnBinHistoryByTime: import("@elaraai/e3").RecordIndexDef<
     readonly gradeBooked: StringType;
     readonly gradeMeasured: StringType;
     readonly instruction: import("@elaraai/east").OptionType<StringType>;
-}>>, import("@elaraai/east").StructType<Record<never, never> & {
-    __interval: import("@elaraai/east").IntegerType;
-} & {
-    at: DateTimeType;
-}>, NullType, readonly ["at"]> & {
-    interval: {
-        readonly from: "at";
-        readonly to: "at";
-    };
-};
+}>>>>;
 /** The days of those two years, read by key. */
 export declare const yardDayHistory: import("@elaraai/e3").RecordDef<DictType<DateTimeType, import("@elaraai/east").StructType<{
     readonly state: import("@elaraai/east").VariantType<{
@@ -1446,112 +1467,113 @@ export declare const yardDayHistory: import("@elaraai/e3").RecordDef<DictType<Da
             readonly at: DateTimeType;
         }>;
     }>;
-}>>, [variant<"field", "records">, variant<"field", "yard_day_history">]>;
-export declare const yardDayHistoryPatch: import("@elaraai/e3").MutationDef<"patch", DictType<DateTimeType, import("@elaraai/east").StructType<{
+}>>, [variant<"field", "records">, variant<"field", "yard_day_history">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<DateTimeType, import("@elaraai/east").StructType<{
     readonly state: import("@elaraai/east").VariantType<{
         readonly draft: NullType;
         readonly issued: import("@elaraai/east").StructType<{
             readonly at: DateTimeType;
         }>;
     }>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: NullType;
-    replace: import("@elaraai/east").StructType<{
-        before: DictType<DateTimeType, import("@elaraai/east").StructType<{
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly issued: import("@elaraai/east").StructType<{
-                    readonly at: DateTimeType;
-                }>;
-            }>;
-        }>>;
-        after: DictType<DateTimeType, import("@elaraai/east").StructType<{
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly issued: import("@elaraai/east").StructType<{
-                    readonly at: DateTimeType;
-                }>;
-            }>;
-        }>>;
-    }>;
-    patch: DictType<DateTimeType, import("@elaraai/east").VariantType<{
-        delete: import("@elaraai/east").StructType<{
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly issued: import("@elaraai/east").StructType<{
-                    readonly at: DateTimeType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: import("@elaraai/east").StructType<{
+            before: DictType<DateTimeType, import("@elaraai/east").StructType<{
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly draft: NullType;
+                    readonly issued: import("@elaraai/east").StructType<{
+                        readonly at: DateTimeType;
+                    }>;
                 }>;
-            }>;
-        }>;
-        insert: import("@elaraai/east").StructType<{
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly draft: NullType;
-                readonly issued: import("@elaraai/east").StructType<{
-                    readonly at: DateTimeType;
+            }>>;
+            after: DictType<DateTimeType, import("@elaraai/east").StructType<{
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly draft: NullType;
+                    readonly issued: import("@elaraai/east").StructType<{
+                        readonly at: DateTimeType;
+                    }>;
                 }>;
-            }>;
+            }>>;
         }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: NullType;
-            replace: import("@elaraai/east").StructType<{
-                before: import("@elaraai/east").StructType<{
-                    readonly state: import("@elaraai/east").VariantType<{
-                        readonly draft: NullType;
-                        readonly issued: import("@elaraai/east").StructType<{
-                            readonly at: DateTimeType;
-                        }>;
+        patch: DictType<DateTimeType, import("@elaraai/east").VariantType<{
+            delete: import("@elaraai/east").StructType<{
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly draft: NullType;
+                    readonly issued: import("@elaraai/east").StructType<{
+                        readonly at: DateTimeType;
                     }>;
                 }>;
-                after: import("@elaraai/east").StructType<{
-                    readonly state: import("@elaraai/east").VariantType<{
-                        readonly draft: NullType;
-                        readonly issued: import("@elaraai/east").StructType<{
-                            readonly at: DateTimeType;
-                        }>;
+            }>;
+            insert: import("@elaraai/east").StructType<{
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly draft: NullType;
+                    readonly issued: import("@elaraai/east").StructType<{
+                        readonly at: DateTimeType;
                     }>;
                 }>;
             }>;
-            patch: import("@elaraai/east").StructType<{
-                readonly state: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").VariantType<{
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: import("@elaraai/east").StructType<{
+                    before: import("@elaraai/east").StructType<{
+                        readonly state: import("@elaraai/east").VariantType<{
                             readonly draft: NullType;
                             readonly issued: import("@elaraai/east").StructType<{
                                 readonly at: DateTimeType;
                             }>;
                         }>;
-                        after: import("@elaraai/east").VariantType<{
+                    }>;
+                    after: import("@elaraai/east").StructType<{
+                        readonly state: import("@elaraai/east").VariantType<{
                             readonly draft: NullType;
                             readonly issued: import("@elaraai/east").StructType<{
                                 readonly at: DateTimeType;
                             }>;
                         }>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        readonly draft: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
-                        }>;
-                        readonly issued: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").StructType<{
+                }>;
+                patch: import("@elaraai/east").StructType<{
+                    readonly state: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly draft: NullType;
+                                readonly issued: import("@elaraai/east").StructType<{
                                     readonly at: DateTimeType;
                                 }>;
-                                after: import("@elaraai/east").StructType<{
+                            }>;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly draft: NullType;
+                                readonly issued: import("@elaraai/east").StructType<{
                                     readonly at: DateTimeType;
                                 }>;
                             }>;
-                            patch: import("@elaraai/east").StructType<{
-                                readonly at: import("@elaraai/east").VariantType<{
-                                    unchanged: NullType;
-                                    replace: import("@elaraai/east").StructType<{
-                                        before: DateTimeType;
-                                        after: DateTimeType;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly draft: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly issued: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").StructType<{
+                                        readonly at: DateTimeType;
+                                    }>;
+                                    after: import("@elaraai/east").StructType<{
+                                        readonly at: DateTimeType;
+                                    }>;
+                                }>;
+                                patch: import("@elaraai/east").StructType<{
+                                    readonly at: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: DateTimeType;
+                                            after: DateTimeType;
+                                        }>;
                                     }>;
                                 }>;
                             }>;
@@ -1559,9 +1581,16 @@ export declare const yardDayHistoryPatch: import("@elaraai/e3").MutationDef<"pat
                     }>;
                 }>;
             }>;
+        }>>;
+    }>]>;
+}, DictType<DateTimeType, import("@elaraai/east").StructType<{
+    readonly state: import("@elaraai/east").VariantType<{
+        readonly draft: NullType;
+        readonly issued: import("@elaraai/east").StructType<{
+            readonly at: DateTimeType;
         }>;
-    }>>;
-}>]>;
+    }>;
+}>>>>;
 export declare const kilns: import("@elaraai/e3").RecordDef<DictType<StringType, import("@elaraai/east").StructType<{
     readonly name: StringType;
     readonly group: StringType;
@@ -1574,8 +1603,14 @@ export declare const kilns: import("@elaraai/e3").RecordDef<DictType<StringType,
         readonly start: DateTimeType;
         readonly end: DateTimeType;
     }>>;
-}>>, [variant<"field", "records">, variant<"field", "kilns">]>;
-export declare const kilnsByGroup: import("@elaraai/e3").RecordIndexDef<"kilns_by_group", DictType<StringType, import("@elaraai/east").StructType<{
+}>>, [variant<"field", "records">, variant<"field", "kilns">], import("@elaraai/e3").IndexesOf<{
+    kilns_by_group: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["group"], unknown>;
+    kilns_by_group_max: import("@elaraai/e3").IndexDraft<import("@elaraai/east").StructType<{
+        max: import("@elaraai/east").FloatType;
+        group: StringType;
+    }>, NullType, readonly ["group", "max"], unknown>;
+    kilns_by_name: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["name"], unknown>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly name: StringType;
     readonly group: StringType;
     readonly min: import("@elaraai/east").FloatType;
@@ -1587,267 +1622,239 @@ export declare const kilnsByGroup: import("@elaraai/e3").RecordIndexDef<"kilns_b
         readonly start: DateTimeType;
         readonly end: DateTimeType;
     }>>;
-}>>, StringType, NullType, readonly ["group"]>;
-export declare const kilnsByGroupMax: import("@elaraai/e3").RecordIndexDef<"kilns_by_group_max", DictType<StringType, import("@elaraai/east").StructType<{
-    readonly name: StringType;
-    readonly group: StringType;
-    readonly min: import("@elaraai/east").FloatType;
-    readonly max: import("@elaraai/east").FloatType;
-    readonly days: import("@elaraai/east").FloatType;
-    readonly note: import("@elaraai/east").OptionType<StringType>;
-    readonly charges: ArrayType<import("@elaraai/east").StructType<{
-        readonly label: StringType;
-        readonly start: DateTimeType;
-        readonly end: DateTimeType;
-    }>>;
-}>>, import("@elaraai/east").StructType<{
-    max: import("@elaraai/east").FloatType;
-    group: StringType;
-}>, NullType, readonly ["group", "max"]>;
-export declare const kilnsByName: import("@elaraai/e3").RecordIndexDef<"kilns_by_name", DictType<StringType, import("@elaraai/east").StructType<{
-    readonly name: StringType;
-    readonly group: StringType;
-    readonly min: import("@elaraai/east").FloatType;
-    readonly max: import("@elaraai/east").FloatType;
-    readonly days: import("@elaraai/east").FloatType;
-    readonly note: import("@elaraai/east").OptionType<StringType>;
-    readonly charges: ArrayType<import("@elaraai/east").StructType<{
-        readonly label: StringType;
-        readonly start: DateTimeType;
-        readonly end: DateTimeType;
-    }>>;
-}>>, StringType, NullType, readonly ["name"]>;
-export declare const kilnsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, import("@elaraai/east").StructType<{
-    readonly name: StringType;
-    readonly group: StringType;
-    readonly min: import("@elaraai/east").FloatType;
-    readonly max: import("@elaraai/east").FloatType;
-    readonly days: import("@elaraai/east").FloatType;
-    readonly note: import("@elaraai/east").OptionType<StringType>;
-    readonly charges: ArrayType<import("@elaraai/east").StructType<{
-        readonly label: StringType;
-        readonly start: DateTimeType;
-        readonly end: DateTimeType;
-    }>>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: NullType;
-    replace: import("@elaraai/east").StructType<{
-        before: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly name: StringType;
-            readonly group: StringType;
-            readonly min: import("@elaraai/east").FloatType;
-            readonly max: import("@elaraai/east").FloatType;
-            readonly days: import("@elaraai/east").FloatType;
-            readonly note: import("@elaraai/east").OptionType<StringType>;
-            readonly charges: ArrayType<import("@elaraai/east").StructType<{
-                readonly label: StringType;
-                readonly start: DateTimeType;
-                readonly end: DateTimeType;
-            }>>;
-        }>>;
-        after: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly name: StringType;
-            readonly group: StringType;
-            readonly min: import("@elaraai/east").FloatType;
-            readonly max: import("@elaraai/east").FloatType;
-            readonly days: import("@elaraai/east").FloatType;
-            readonly note: import("@elaraai/east").OptionType<StringType>;
-            readonly charges: ArrayType<import("@elaraai/east").StructType<{
-                readonly label: StringType;
-                readonly start: DateTimeType;
-                readonly end: DateTimeType;
-            }>>;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: import("@elaraai/east").StructType<{
-            readonly name: StringType;
-            readonly group: StringType;
-            readonly min: import("@elaraai/east").FloatType;
-            readonly max: import("@elaraai/east").FloatType;
-            readonly days: import("@elaraai/east").FloatType;
-            readonly note: import("@elaraai/east").OptionType<StringType>;
-            readonly charges: ArrayType<import("@elaraai/east").StructType<{
-                readonly label: StringType;
-                readonly start: DateTimeType;
-                readonly end: DateTimeType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: import("@elaraai/east").StructType<{
+            before: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly name: StringType;
+                readonly group: StringType;
+                readonly min: import("@elaraai/east").FloatType;
+                readonly max: import("@elaraai/east").FloatType;
+                readonly days: import("@elaraai/east").FloatType;
+                readonly note: import("@elaraai/east").OptionType<StringType>;
+                readonly charges: ArrayType<import("@elaraai/east").StructType<{
+                    readonly label: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                }>>;
             }>>;
-        }>;
-        insert: import("@elaraai/east").StructType<{
-            readonly name: StringType;
-            readonly group: StringType;
-            readonly min: import("@elaraai/east").FloatType;
-            readonly max: import("@elaraai/east").FloatType;
-            readonly days: import("@elaraai/east").FloatType;
-            readonly note: import("@elaraai/east").OptionType<StringType>;
-            readonly charges: ArrayType<import("@elaraai/east").StructType<{
-                readonly label: StringType;
-                readonly start: DateTimeType;
-                readonly end: DateTimeType;
+            after: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly name: StringType;
+                readonly group: StringType;
+                readonly min: import("@elaraai/east").FloatType;
+                readonly max: import("@elaraai/east").FloatType;
+                readonly days: import("@elaraai/east").FloatType;
+                readonly note: import("@elaraai/east").OptionType<StringType>;
+                readonly charges: ArrayType<import("@elaraai/east").StructType<{
+                    readonly label: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                }>>;
             }>>;
         }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: NullType;
-            replace: import("@elaraai/east").StructType<{
-                before: import("@elaraai/east").StructType<{
-                    readonly name: StringType;
-                    readonly group: StringType;
-                    readonly min: import("@elaraai/east").FloatType;
-                    readonly max: import("@elaraai/east").FloatType;
-                    readonly days: import("@elaraai/east").FloatType;
-                    readonly note: import("@elaraai/east").OptionType<StringType>;
-                    readonly charges: ArrayType<import("@elaraai/east").StructType<{
-                        readonly label: StringType;
-                        readonly start: DateTimeType;
-                        readonly end: DateTimeType;
-                    }>>;
-                }>;
-                after: import("@elaraai/east").StructType<{
-                    readonly name: StringType;
-                    readonly group: StringType;
-                    readonly min: import("@elaraai/east").FloatType;
-                    readonly max: import("@elaraai/east").FloatType;
-                    readonly days: import("@elaraai/east").FloatType;
-                    readonly note: import("@elaraai/east").OptionType<StringType>;
-                    readonly charges: ArrayType<import("@elaraai/east").StructType<{
-                        readonly label: StringType;
-                        readonly start: DateTimeType;
-                        readonly end: DateTimeType;
-                    }>>;
-                }>;
-            }>;
-            patch: import("@elaraai/east").StructType<{
-                readonly name: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: import("@elaraai/east").StructType<{
+                readonly name: StringType;
+                readonly group: StringType;
+                readonly min: import("@elaraai/east").FloatType;
+                readonly max: import("@elaraai/east").FloatType;
+                readonly days: import("@elaraai/east").FloatType;
+                readonly note: import("@elaraai/east").OptionType<StringType>;
+                readonly charges: ArrayType<import("@elaraai/east").StructType<{
+                    readonly label: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                }>>;
+            }>;
+            insert: import("@elaraai/east").StructType<{
+                readonly name: StringType;
+                readonly group: StringType;
+                readonly min: import("@elaraai/east").FloatType;
+                readonly max: import("@elaraai/east").FloatType;
+                readonly days: import("@elaraai/east").FloatType;
+                readonly note: import("@elaraai/east").OptionType<StringType>;
+                readonly charges: ArrayType<import("@elaraai/east").StructType<{
+                    readonly label: StringType;
+                    readonly start: DateTimeType;
+                    readonly end: DateTimeType;
+                }>>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: import("@elaraai/east").StructType<{
+                    before: import("@elaraai/east").StructType<{
+                        readonly name: StringType;
+                        readonly group: StringType;
+                        readonly min: import("@elaraai/east").FloatType;
+                        readonly max: import("@elaraai/east").FloatType;
+                        readonly days: import("@elaraai/east").FloatType;
+                        readonly note: import("@elaraai/east").OptionType<StringType>;
+                        readonly charges: ArrayType<import("@elaraai/east").StructType<{
+                            readonly label: StringType;
+                            readonly start: DateTimeType;
+                            readonly end: DateTimeType;
+                        }>>;
                     }>;
-                }>;
-                readonly group: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
+                    after: import("@elaraai/east").StructType<{
+                        readonly name: StringType;
+                        readonly group: StringType;
+                        readonly min: import("@elaraai/east").FloatType;
+                        readonly max: import("@elaraai/east").FloatType;
+                        readonly days: import("@elaraai/east").FloatType;
+                        readonly note: import("@elaraai/east").OptionType<StringType>;
+                        readonly charges: ArrayType<import("@elaraai/east").StructType<{
+                            readonly label: StringType;
+                            readonly start: DateTimeType;
+                            readonly end: DateTimeType;
+                        }>>;
                     }>;
                 }>;
-                readonly min: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").FloatType;
-                        after: import("@elaraai/east").FloatType;
+                patch: import("@elaraai/east").StructType<{
+                    readonly name: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly max: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").FloatType;
-                        after: import("@elaraai/east").FloatType;
+                    readonly group: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly days: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").FloatType;
-                        after: import("@elaraai/east").FloatType;
+                    readonly min: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").FloatType;
+                            after: import("@elaraai/east").FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly note: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").OptionType<StringType>;
-                        after: import("@elaraai/east").OptionType<StringType>;
+                    readonly max: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").FloatType;
+                            after: import("@elaraai/east").FloatType;
+                        }>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                    readonly days: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").FloatType;
+                            after: import("@elaraai/east").FloatType;
                         }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: StringType;
+                    }>;
+                    readonly note: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").OptionType<StringType>;
+                            after: import("@elaraai/east").OptionType<StringType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly charges: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: ArrayType<import("@elaraai/east").StructType<{
-                            readonly label: StringType;
-                            readonly start: DateTimeType;
-                            readonly end: DateTimeType;
-                        }>>;
-                        after: ArrayType<import("@elaraai/east").StructType<{
-                            readonly label: StringType;
-                            readonly start: DateTimeType;
-                            readonly end: DateTimeType;
-                        }>>;
-                    }>;
-                    patch: ArrayType<import("@elaraai/east").StructType<{
-                        key: import("@elaraai/east").IntegerType;
-                        offset: import("@elaraai/east").IntegerType;
-                        operation: import("@elaraai/east").VariantType<{
-                            delete: import("@elaraai/east").StructType<{
+                    readonly charges: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: ArrayType<import("@elaraai/east").StructType<{
                                 readonly label: StringType;
                                 readonly start: DateTimeType;
                                 readonly end: DateTimeType;
-                            }>;
-                            insert: import("@elaraai/east").StructType<{
+                            }>>;
+                            after: ArrayType<import("@elaraai/east").StructType<{
                                 readonly label: StringType;
                                 readonly start: DateTimeType;
                                 readonly end: DateTimeType;
-                            }>;
-                            update: import("@elaraai/east").VariantType<{
-                                unchanged: NullType;
-                                replace: import("@elaraai/east").StructType<{
-                                    before: import("@elaraai/east").StructType<{
-                                        readonly label: StringType;
-                                        readonly start: DateTimeType;
-                                        readonly end: DateTimeType;
-                                    }>;
-                                    after: import("@elaraai/east").StructType<{
-                                        readonly label: StringType;
-                                        readonly start: DateTimeType;
-                                        readonly end: DateTimeType;
-                                    }>;
+                            }>>;
+                        }>;
+                        patch: ArrayType<import("@elaraai/east").StructType<{
+                            key: import("@elaraai/east").IntegerType;
+                            offset: import("@elaraai/east").IntegerType;
+                            operation: import("@elaraai/east").VariantType<{
+                                delete: import("@elaraai/east").StructType<{
+                                    readonly label: StringType;
+                                    readonly start: DateTimeType;
+                                    readonly end: DateTimeType;
                                 }>;
-                                patch: import("@elaraai/east").StructType<{
-                                    readonly label: import("@elaraai/east").VariantType<{
-                                        unchanged: NullType;
-                                        replace: import("@elaraai/east").StructType<{
-                                            before: StringType;
-                                            after: StringType;
+                                insert: import("@elaraai/east").StructType<{
+                                    readonly label: StringType;
+                                    readonly start: DateTimeType;
+                                    readonly end: DateTimeType;
+                                }>;
+                                update: import("@elaraai/east").VariantType<{
+                                    unchanged: NullType;
+                                    replace: import("@elaraai/east").StructType<{
+                                        before: import("@elaraai/east").StructType<{
+                                            readonly label: StringType;
+                                            readonly start: DateTimeType;
+                                            readonly end: DateTimeType;
                                         }>;
-                                    }>;
-                                    readonly start: import("@elaraai/east").VariantType<{
-                                        unchanged: NullType;
-                                        replace: import("@elaraai/east").StructType<{
-                                            before: DateTimeType;
-                                            after: DateTimeType;
+                                        after: import("@elaraai/east").StructType<{
+                                            readonly label: StringType;
+                                            readonly start: DateTimeType;
+                                            readonly end: DateTimeType;
                                         }>;
                                     }>;
-                                    readonly end: import("@elaraai/east").VariantType<{
-                                        unchanged: NullType;
-                                        replace: import("@elaraai/east").StructType<{
-                                            before: DateTimeType;
-                                            after: DateTimeType;
+                                    patch: import("@elaraai/east").StructType<{
+                                        readonly label: import("@elaraai/east").VariantType<{
+                                            unchanged: NullType;
+                                            replace: import("@elaraai/east").StructType<{
+                                                before: StringType;
+                                                after: StringType;
+                                            }>;
+                                        }>;
+                                        readonly start: import("@elaraai/east").VariantType<{
+                                            unchanged: NullType;
+                                            replace: import("@elaraai/east").StructType<{
+                                                before: DateTimeType;
+                                                after: DateTimeType;
+                                            }>;
+                                        }>;
+                                        readonly end: import("@elaraai/east").VariantType<{
+                                            unchanged: NullType;
+                                            replace: import("@elaraai/east").StructType<{
+                                                before: DateTimeType;
+                                                after: DateTimeType;
+                                            }>;
                                         }>;
                                     }>;
                                 }>;
                             }>;
-                        }>;
-                    }>>;
+                        }>>;
+                    }>;
                 }>;
             }>;
-        }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly min: import("@elaraai/east").FloatType;
+    readonly max: import("@elaraai/east").FloatType;
+    readonly days: import("@elaraai/east").FloatType;
+    readonly note: import("@elaraai/east").OptionType<StringType>;
+    readonly charges: ArrayType<import("@elaraai/east").StructType<{
+        readonly label: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
     }>>;
-}>]>;
+}>>>>;
 export declare const arrivals: import("@elaraai/e3").RecordDef<DictType<StringType, import("@elaraai/east").StructType<{
     readonly code: StringType;
     readonly mill: StringType;
@@ -1860,8 +1867,21 @@ export declare const arrivals: import("@elaraai/e3").RecordDef<DictType<StringTy
     readonly to: DateTimeType;
     readonly schedule: StringType;
     readonly instruction: import("@elaraai/east").OptionType<StringType>;
-}>>, [variant<"field", "records">, variant<"field", "arrivals">]>;
-export declare const arrivalsBySpec: import("@elaraai/e3").RecordIndexDef<"arrivals_by_spec", DictType<StringType, import("@elaraai/east").StructType<{
+}>>, [variant<"field", "records">, variant<"field", "arrivals">], import("@elaraai/e3").IndexesOf<{
+    arrivals_by_spec: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["spec"], unknown>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
+    readonly code: StringType;
+    readonly mill: StringType;
+    readonly spec: StringType;
+    readonly grade: StringType;
+    readonly m3: import("@elaraai/east").FloatType;
+    readonly dryingDays: import("@elaraai/east").FloatType;
+    readonly due: DateTimeType;
+    readonly from: DateTimeType;
+    readonly to: DateTimeType;
+    readonly schedule: StringType;
+    readonly instruction: import("@elaraai/east").OptionType<StringType>;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, import("@elaraai/east").StructType<{
     readonly code: StringType;
     readonly mill: StringType;
     readonly spec: StringType;
@@ -1873,7 +1893,7 @@ export declare const arrivalsBySpec: import("@elaraai/e3").RecordIndexDef<"arriv
     readonly to: DateTimeType;
     readonly schedule: StringType;
     readonly instruction: import("@elaraai/east").OptionType<StringType>;
-}>>, StringType, NullType, readonly ["spec"]>;
+}>>>>;
 export declare const yardBays: import("@elaraai/e3").RecordDef<DictType<StringType, import("@elaraai/east").StructType<{
     readonly name: StringType;
     readonly area: StringType;
@@ -1885,8 +1905,10 @@ export declare const yardBays: import("@elaraai/e3").RecordDef<DictType<StringTy
         readonly weeks: import("@elaraai/east").FloatType;
         readonly months: import("@elaraai/east").FloatType;
     }>;
-}>>, [variant<"field", "records">, variant<"field", "yard_bays">]>;
-export declare const yardBaysByArea: import("@elaraai/e3").RecordIndexDef<"yard_bays_by_area", DictType<StringType, import("@elaraai/east").StructType<{
+}>>, [variant<"field", "records">, variant<"field", "yard_bays">], import("@elaraai/e3").IndexesOf<{
+    yard_bays_by_area: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["area"], unknown>;
+    yard_bays_by_cover: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["cover"], unknown>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly name: StringType;
     readonly area: StringType;
     readonly cover: StringType;
@@ -1897,8 +1919,7 @@ export declare const yardBaysByArea: import("@elaraai/e3").RecordIndexDef<"yard_
         readonly weeks: import("@elaraai/east").FloatType;
         readonly months: import("@elaraai/east").FloatType;
     }>;
-}>>, StringType, NullType, readonly ["area"]>;
-export declare const yardBaysByCover: import("@elaraai/e3").RecordIndexDef<"yard_bays_by_cover", DictType<StringType, import("@elaraai/east").StructType<{
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, import("@elaraai/east").StructType<{
     readonly name: StringType;
     readonly area: StringType;
     readonly cover: StringType;
@@ -1909,7 +1930,7 @@ export declare const yardBaysByCover: import("@elaraai/e3").RecordIndexDef<"yard
         readonly weeks: import("@elaraai/east").FloatType;
         readonly months: import("@elaraai/east").FloatType;
     }>;
-}>>, StringType, NullType, readonly ["cover"]>;
+}>>>>;
 export declare const minimalBins: import("@elaraai/e3").RecordDef<DictType<StringType, import("@elaraai/east").StructType<{
     readonly bay: StringType;
     readonly at: DateTimeType;
@@ -1923,8 +1944,7 @@ export declare const minimalBins: import("@elaraai/e3").RecordDef<DictType<Strin
         readonly weeks: import("@elaraai/east").FloatType;
         readonly months: import("@elaraai/east").FloatType;
     }>;
-}>>, [variant<"field", "records">, variant<"field", "kiln_minimal_bins">]>;
-export declare const minimalBinsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, import("@elaraai/east").StructType<{
+}>>, [variant<"field", "records">, variant<"field", "kiln_minimal_bins">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, import("@elaraai/east").StructType<{
     readonly bay: StringType;
     readonly at: DateTimeType;
     readonly load: import("@elaraai/east").OptionType<StringType>;
@@ -1937,173 +1957,92 @@ export declare const minimalBinsPatch: import("@elaraai/e3").MutationDef<"patch"
         readonly weeks: import("@elaraai/east").FloatType;
         readonly months: import("@elaraai/east").FloatType;
     }>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: NullType;
-    replace: import("@elaraai/east").StructType<{
-        before: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-        }>>;
-        after: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-        }>;
-        insert: import("@elaraai/east").StructType<{
-            readonly bay: StringType;
-            readonly at: DateTimeType;
-            readonly load: import("@elaraai/east").OptionType<StringType>;
-            readonly m3: import("@elaraai/east").FloatType;
-            readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-            readonly dryFor: import("@elaraai/east").VariantType<{
-                readonly minutes: import("@elaraai/east").FloatType;
-                readonly hours: import("@elaraai/east").FloatType;
-                readonly days: import("@elaraai/east").FloatType;
-                readonly weeks: import("@elaraai/east").FloatType;
-                readonly months: import("@elaraai/east").FloatType;
-            }>;
-        }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: NullType;
-            replace: import("@elaraai/east").StructType<{
-                before: import("@elaraai/east").StructType<{
-                    readonly bay: StringType;
-                    readonly at: DateTimeType;
-                    readonly load: import("@elaraai/east").OptionType<StringType>;
-                    readonly m3: import("@elaraai/east").FloatType;
-                    readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-                    readonly dryFor: import("@elaraai/east").VariantType<{
-                        readonly minutes: import("@elaraai/east").FloatType;
-                        readonly hours: import("@elaraai/east").FloatType;
-                        readonly days: import("@elaraai/east").FloatType;
-                        readonly weeks: import("@elaraai/east").FloatType;
-                        readonly months: import("@elaraai/east").FloatType;
-                    }>;
-                }>;
-                after: import("@elaraai/east").StructType<{
-                    readonly bay: StringType;
-                    readonly at: DateTimeType;
-                    readonly load: import("@elaraai/east").OptionType<StringType>;
-                    readonly m3: import("@elaraai/east").FloatType;
-                    readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
-                    readonly dryFor: import("@elaraai/east").VariantType<{
-                        readonly minutes: import("@elaraai/east").FloatType;
-                        readonly hours: import("@elaraai/east").FloatType;
-                        readonly days: import("@elaraai/east").FloatType;
-                        readonly weeks: import("@elaraai/east").FloatType;
-                        readonly months: import("@elaraai/east").FloatType;
-                    }>;
-                }>;
-            }>;
-            patch: import("@elaraai/east").StructType<{
-                readonly bay: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
-                }>;
-                readonly at: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
-                    }>;
-                }>;
-                readonly load: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").OptionType<StringType>;
-                        after: import("@elaraai/east").OptionType<StringType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
-                        }>;
-                    }>;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: import("@elaraai/east").StructType<{
+            before: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
                 }>;
-                readonly m3: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").FloatType;
-                        after: import("@elaraai/east").FloatType;
-                    }>;
+            }>>;
+            after: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
                 }>;
-                readonly kilns: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: DictType<StringType, import("@elaraai/east").FloatType>;
-                        after: DictType<StringType, import("@elaraai/east").FloatType>;
-                    }>;
-                    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-                        delete: import("@elaraai/east").FloatType;
-                        insert: import("@elaraai/east").FloatType;
-                        update: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
-                            }>;
-                        }>;
-                    }>>;
+            }>>;
+        }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
                 }>;
+            }>;
+            insert: import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
                 readonly dryFor: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: import("@elaraai/east").StructType<{
+                    before: import("@elaraai/east").StructType<{
+                        readonly bay: StringType;
+                        readonly at: DateTimeType;
+                        readonly load: import("@elaraai/east").OptionType<StringType>;
+                        readonly m3: import("@elaraai/east").FloatType;
+                        readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                        readonly dryFor: import("@elaraai/east").VariantType<{
                             readonly minutes: import("@elaraai/east").FloatType;
                             readonly hours: import("@elaraai/east").FloatType;
                             readonly days: import("@elaraai/east").FloatType;
                             readonly weeks: import("@elaraai/east").FloatType;
                             readonly months: import("@elaraai/east").FloatType;
                         }>;
-                        after: import("@elaraai/east").VariantType<{
+                    }>;
+                    after: import("@elaraai/east").StructType<{
+                        readonly bay: StringType;
+                        readonly at: DateTimeType;
+                        readonly load: import("@elaraai/east").OptionType<StringType>;
+                        readonly m3: import("@elaraai/east").FloatType;
+                        readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                        readonly dryFor: import("@elaraai/east").VariantType<{
                             readonly minutes: import("@elaraai/east").FloatType;
                             readonly hours: import("@elaraai/east").FloatType;
                             readonly days: import("@elaraai/east").FloatType;
@@ -2111,48 +2050,144 @@ export declare const minimalBinsPatch: import("@elaraai/e3").MutationDef<"patch"
                             readonly months: import("@elaraai/east").FloatType;
                         }>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        readonly minutes: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
-                            }>;
+                }>;
+                patch: import("@elaraai/east").StructType<{
+                    readonly bay: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
                         }>;
-                        readonly hours: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
-                            }>;
+                    }>;
+                    readonly at: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
                         }>;
-                        readonly days: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
-                            }>;
+                    }>;
+                    readonly load: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").OptionType<StringType>;
+                            after: import("@elaraai/east").OptionType<StringType>;
                         }>;
-                        readonly weeks: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
-                        readonly months: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").FloatType;
-                                after: import("@elaraai/east").FloatType;
+                    }>;
+                    readonly m3: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").FloatType;
+                            after: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly kilns: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: DictType<StringType, import("@elaraai/east").FloatType>;
+                            after: DictType<StringType, import("@elaraai/east").FloatType>;
+                        }>;
+                        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+                            delete: import("@elaraai/east").FloatType;
+                            insert: import("@elaraai/east").FloatType;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                        }>>;
+                    }>;
+                    readonly dryFor: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly minutes: import("@elaraai/east").FloatType;
+                                readonly hours: import("@elaraai/east").FloatType;
+                                readonly days: import("@elaraai/east").FloatType;
+                                readonly weeks: import("@elaraai/east").FloatType;
+                                readonly months: import("@elaraai/east").FloatType;
+                            }>;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly minutes: import("@elaraai/east").FloatType;
+                                readonly hours: import("@elaraai/east").FloatType;
+                                readonly days: import("@elaraai/east").FloatType;
+                                readonly weeks: import("@elaraai/east").FloatType;
+                                readonly months: import("@elaraai/east").FloatType;
+                            }>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly minutes: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly hours: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly days: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly weeks: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly months: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
                             }>;
                         }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
+        }>>;
+    }>]>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
+    readonly bay: StringType;
+    readonly at: DateTimeType;
+    readonly load: import("@elaraai/east").OptionType<StringType>;
+    readonly m3: import("@elaraai/east").FloatType;
+    readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+    readonly dryFor: import("@elaraai/east").VariantType<{
+        readonly minutes: import("@elaraai/east").FloatType;
+        readonly hours: import("@elaraai/east").FloatType;
+        readonly days: import("@elaraai/east").FloatType;
+        readonly weeks: import("@elaraai/east").FloatType;
+        readonly months: import("@elaraai/east").FloatType;
+    }>;
+}>>>>;
 /** The yard's fit's body: the built-in rules, then a greedy look-ahead over the day's other loads. */
 export declare const yardFitBody: import("@elaraai/east").CallableFunctionExpr<[import("../../src/internal.js").AllocationFitRequestType<import("@elaraai/east").StructType<{
     readonly bay: StringType;
@@ -2887,4 +2922,271 @@ export declare const allocationWindowed: import("@elaraai/east").ExampleDef<[],
 export declare const allocationMobile: import("@elaraai/east").ExampleDef<[], any>;
 export declare const allocationCustomBin: import("@elaraai/east").ExampleDef<[], any>;
 export declare const allocationFitRule: import("@elaraai/east").ExampleDef<[], any>;
+/** The bins the conflicts example edits, in a record of their own, so no other example's edits meet them. */
+export declare const conflictBins: import("@elaraai/e3").RecordDef<DictType<StringType, import("@elaraai/east").StructType<{
+    readonly bay: StringType;
+    readonly at: DateTimeType;
+    readonly load: import("@elaraai/east").OptionType<StringType>;
+    readonly m3: import("@elaraai/east").FloatType;
+    readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+    readonly dryFor: import("@elaraai/east").VariantType<{
+        readonly minutes: import("@elaraai/east").FloatType;
+        readonly hours: import("@elaraai/east").FloatType;
+        readonly days: import("@elaraai/east").FloatType;
+        readonly weeks: import("@elaraai/east").FloatType;
+        readonly months: import("@elaraai/east").FloatType;
+    }>;
+}>>, [variant<"field", "records">, variant<"field", "kiln_conflict_bins">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, import("@elaraai/east").StructType<{
+    readonly bay: StringType;
+    readonly at: DateTimeType;
+    readonly load: import("@elaraai/east").OptionType<StringType>;
+    readonly m3: import("@elaraai/east").FloatType;
+    readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+    readonly dryFor: import("@elaraai/east").VariantType<{
+        readonly minutes: import("@elaraai/east").FloatType;
+        readonly hours: import("@elaraai/east").FloatType;
+        readonly days: import("@elaraai/east").FloatType;
+        readonly weeks: import("@elaraai/east").FloatType;
+        readonly months: import("@elaraai/east").FloatType;
+    }>;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: import("@elaraai/east").StructType<{
+            before: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+            }>>;
+            after: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+            }>>;
+        }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+            }>;
+            insert: import("@elaraai/east").StructType<{
+                readonly bay: StringType;
+                readonly at: DateTimeType;
+                readonly load: import("@elaraai/east").OptionType<StringType>;
+                readonly m3: import("@elaraai/east").FloatType;
+                readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                readonly dryFor: import("@elaraai/east").VariantType<{
+                    readonly minutes: import("@elaraai/east").FloatType;
+                    readonly hours: import("@elaraai/east").FloatType;
+                    readonly days: import("@elaraai/east").FloatType;
+                    readonly weeks: import("@elaraai/east").FloatType;
+                    readonly months: import("@elaraai/east").FloatType;
+                }>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: import("@elaraai/east").StructType<{
+                    before: import("@elaraai/east").StructType<{
+                        readonly bay: StringType;
+                        readonly at: DateTimeType;
+                        readonly load: import("@elaraai/east").OptionType<StringType>;
+                        readonly m3: import("@elaraai/east").FloatType;
+                        readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                        readonly dryFor: import("@elaraai/east").VariantType<{
+                            readonly minutes: import("@elaraai/east").FloatType;
+                            readonly hours: import("@elaraai/east").FloatType;
+                            readonly days: import("@elaraai/east").FloatType;
+                            readonly weeks: import("@elaraai/east").FloatType;
+                            readonly months: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    after: import("@elaraai/east").StructType<{
+                        readonly bay: StringType;
+                        readonly at: DateTimeType;
+                        readonly load: import("@elaraai/east").OptionType<StringType>;
+                        readonly m3: import("@elaraai/east").FloatType;
+                        readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+                        readonly dryFor: import("@elaraai/east").VariantType<{
+                            readonly minutes: import("@elaraai/east").FloatType;
+                            readonly hours: import("@elaraai/east").FloatType;
+                            readonly days: import("@elaraai/east").FloatType;
+                            readonly weeks: import("@elaraai/east").FloatType;
+                            readonly months: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                }>;
+                patch: import("@elaraai/east").StructType<{
+                    readonly bay: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly at: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
+                        }>;
+                    }>;
+                    readonly load: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").OptionType<StringType>;
+                            after: import("@elaraai/east").OptionType<StringType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly m3: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").FloatType;
+                            after: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly kilns: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: DictType<StringType, import("@elaraai/east").FloatType>;
+                            after: DictType<StringType, import("@elaraai/east").FloatType>;
+                        }>;
+                        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+                            delete: import("@elaraai/east").FloatType;
+                            insert: import("@elaraai/east").FloatType;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                        }>>;
+                    }>;
+                    readonly dryFor: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly minutes: import("@elaraai/east").FloatType;
+                                readonly hours: import("@elaraai/east").FloatType;
+                                readonly days: import("@elaraai/east").FloatType;
+                                readonly weeks: import("@elaraai/east").FloatType;
+                                readonly months: import("@elaraai/east").FloatType;
+                            }>;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly minutes: import("@elaraai/east").FloatType;
+                                readonly hours: import("@elaraai/east").FloatType;
+                                readonly days: import("@elaraai/east").FloatType;
+                                readonly weeks: import("@elaraai/east").FloatType;
+                                readonly months: import("@elaraai/east").FloatType;
+                            }>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly minutes: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly hours: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly days: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly weeks: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                            readonly months: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").FloatType;
+                                    after: import("@elaraai/east").FloatType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+    elsewhere: import("@elaraai/e3").MutationDraft<[]>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
+    readonly bay: StringType;
+    readonly at: DateTimeType;
+    readonly load: import("@elaraai/east").OptionType<StringType>;
+    readonly m3: import("@elaraai/east").FloatType;
+    readonly kilns: DictType<StringType, import("@elaraai/east").FloatType>;
+    readonly dryFor: import("@elaraai/east").VariantType<{
+        readonly minutes: import("@elaraai/east").FloatType;
+        readonly hours: import("@elaraai/east").FloatType;
+        readonly days: import("@elaraai/east").FloatType;
+        readonly weeks: import("@elaraai/east").FloatType;
+        readonly months: import("@elaraai/east").FloatType;
+    }>;
+}>>>>;
+/**
+ * Your edits meeting someone else's save, in one window: edit, then press
+ * Someone else saves, which saves another person's change to the same bins —
+ * every bin a quarter hour later, and 1 m³ more on each of its kilns. A bin you
+ * moved is a conflict on its time; a bin's m³ you changed is one card, its
+ * split across kilns going with it. Each press saves their change again.
+ */
+export declare const allocationConflicts: import("@elaraai/east").ExampleDef<[], any>;
 //# sourceMappingURL=allocation.examples.d.ts.map