@elaraai/e3-ui 1.0.98 → 1.0.99

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

@@ -105,11 +105,80 @@ export declare const CalendarShiftTemplate: StructType<{
 export declare const calendarMachines: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly area: StringType;
-}>>, [variant<"field", "records">, variant<"field", "calendar_machines">]>;
+}>>, [variant<"field", "records">, variant<"field", "calendar_machines">], import("@elaraai/e3").IndexesOf<{
+    calendar_machines_by_area: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["area"], unknown>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly area: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly area: StringType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly area: StringType;
+            }>>;
+        }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly name: StringType;
+                readonly area: StringType;
+            }>;
+            insert: StructType<{
+                readonly name: StringType;
+                readonly area: StringType;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly name: StringType;
+                        readonly area: StringType;
+                    }>;
+                    after: StructType<{
+                        readonly name: StringType;
+                        readonly area: StringType;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly name: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly area: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly area: StringType;
+}>>>>;
 export declare const calendarPeople: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly team: StringType;
-}>>, [variant<"field", "records">, variant<"field", "calendar_people">]>;
+}>>, [variant<"field", "records">, variant<"field", "calendar_people">], import("@elaraai/e3").IndexesOf<{
+    calendar_people_by_team: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["team"], unknown>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly team: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly team: StringType;
+}>>>>;
 export declare const calendarJobs: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
@@ -123,8 +192,48 @@ export declare const calendarJobs: import("@elaraai/e3").RecordDef<DictType<Stri
     readonly hours: FloatType;
     readonly customer: StringType;
     readonly due: OptionType<DateTimeType>;
-}>>, [variant<"field", "records">, variant<"field", "calendar_jobs">]>;
-export declare const calendarJobsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "calendar_jobs">], import("@elaraai/e3").IndexesOf<{
+    calendar_jobs_by_time: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        node: IntegerType;
+        at: OptionType<DateTimeType>;
+    }>, NullType, readonly [], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
+    }>;
+    calendar_jobs_by_status_time: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<{
+            status: VariantType<{
+                readonly planned: NullType;
+                readonly active: NullType;
+                readonly done: NullType;
+            }>;
+        }>;
+        node: IntegerType;
+        at: OptionType<DateTimeType>;
+    }>, NullType, readonly ["status"], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
+    }>;
+    calendar_jobs_by_machine_time: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<{
+            machine: OptionType<StringType>;
+        }>;
+        node: IntegerType;
+        at: OptionType<DateTimeType>;
+    }>, NullType, readonly ["machine"], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
+    }>;
+    calendar_jobs_by_day: import("@elaraai/e3").IndexDraft<DateTimeType, NullType, undefined, unknown>;
+    calendar_jobs_unscheduled: import("@elaraai/e3").IndexDraft<OptionType<DateTimeType>, NullType, undefined, unknown>;
+}, DictType<StringType, StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
@@ -137,255 +246,270 @@ export declare const calendarJobsPatch: import("@elaraai/e3").MutationDef<"patch
     readonly hours: FloatType;
     readonly customer: StringType;
     readonly due: OptionType<DateTimeType>;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly machine: OptionType<StringType>;
-            readonly status: VariantType<{
-                readonly planned: NullType;
-                readonly active: NullType;
-                readonly done: NullType;
-            }>;
-            readonly hours: FloatType;
-            readonly customer: StringType;
-            readonly due: OptionType<DateTimeType>;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly machine: OptionType<StringType>;
-            readonly status: VariantType<{
-                readonly planned: NullType;
-                readonly active: NullType;
-                readonly done: NullType;
-            }>;
-            readonly hours: FloatType;
-            readonly customer: StringType;
-            readonly due: OptionType<DateTimeType>;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly machine: OptionType<StringType>;
-            readonly status: VariantType<{
-                readonly planned: NullType;
-                readonly active: NullType;
-                readonly done: NullType;
-            }>;
-            readonly hours: FloatType;
-            readonly customer: StringType;
-            readonly due: OptionType<DateTimeType>;
-        }>;
-        insert: StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly machine: OptionType<StringType>;
-            readonly status: VariantType<{
-                readonly planned: NullType;
-                readonly active: NullType;
-                readonly done: NullType;
-            }>;
-            readonly hours: FloatType;
-            readonly customer: StringType;
-            readonly due: OptionType<DateTimeType>;
-        }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly title: StringType;
-                    readonly start: OptionType<DateTimeType>;
-                    readonly end: OptionType<DateTimeType>;
-                    readonly machine: OptionType<StringType>;
-                    readonly status: VariantType<{
-                        readonly planned: NullType;
-                        readonly active: NullType;
-                        readonly done: NullType;
-                    }>;
-                    readonly hours: FloatType;
-                    readonly customer: StringType;
-                    readonly due: OptionType<DateTimeType>;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly machine: OptionType<StringType>;
+                readonly status: VariantType<{
+                    readonly planned: NullType;
+                    readonly active: NullType;
+                    readonly done: NullType;
                 }>;
-                after: StructType<{
-                    readonly title: StringType;
-                    readonly start: OptionType<DateTimeType>;
-                    readonly end: OptionType<DateTimeType>;
-                    readonly machine: OptionType<StringType>;
-                    readonly status: VariantType<{
-                        readonly planned: NullType;
-                        readonly active: NullType;
-                        readonly done: NullType;
-                    }>;
-                    readonly hours: FloatType;
-                    readonly customer: StringType;
-                    readonly due: OptionType<DateTimeType>;
+                readonly hours: FloatType;
+                readonly customer: StringType;
+                readonly due: OptionType<DateTimeType>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly machine: OptionType<StringType>;
+                readonly status: VariantType<{
+                    readonly planned: NullType;
+                    readonly active: NullType;
+                    readonly done: NullType;
+                }>;
+                readonly hours: FloatType;
+                readonly customer: StringType;
+                readonly due: OptionType<DateTimeType>;
+            }>>;
+        }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly machine: OptionType<StringType>;
+                readonly status: VariantType<{
+                    readonly planned: NullType;
+                    readonly active: NullType;
+                    readonly done: NullType;
                 }>;
+                readonly hours: FloatType;
+                readonly customer: StringType;
+                readonly due: OptionType<DateTimeType>;
             }>;
-            patch: StructType<{
-                readonly title: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
+            insert: StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly machine: OptionType<StringType>;
+                readonly status: VariantType<{
+                    readonly planned: NullType;
+                    readonly active: NullType;
+                    readonly done: NullType;
                 }>;
-                readonly start: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
-                    }>;
-                    patch: VariantType<{
-                        none: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                readonly hours: FloatType;
+                readonly customer: StringType;
+                readonly due: OptionType<DateTimeType>;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly title: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                        readonly machine: OptionType<StringType>;
+                        readonly status: VariantType<{
+                            readonly planned: NullType;
+                            readonly active: NullType;
+                            readonly done: NullType;
                         }>;
-                        some: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: DateTimeType;
-                                after: DateTimeType;
-                            }>;
+                        readonly hours: FloatType;
+                        readonly customer: StringType;
+                        readonly due: OptionType<DateTimeType>;
+                    }>;
+                    after: StructType<{
+                        readonly title: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                        readonly machine: OptionType<StringType>;
+                        readonly status: VariantType<{
+                            readonly planned: NullType;
+                            readonly active: NullType;
+                            readonly done: NullType;
                         }>;
+                        readonly hours: FloatType;
+                        readonly customer: StringType;
+                        readonly due: OptionType<DateTimeType>;
                     }>;
                 }>;
-                readonly end: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
+                patch: StructType<{
+                    readonly title: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                    patch: VariantType<{
-                        none: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                    readonly start: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
                         }>;
-                        some: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: DateTimeType;
-                                after: DateTimeType;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly machine: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: OptionType<StringType>;
-                        after: OptionType<StringType>;
-                    }>;
-                    patch: VariantType<{
-                        none: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                    readonly end: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
                         }>;
-                        some: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly status: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: VariantType<{
-                            readonly planned: NullType;
-                            readonly active: NullType;
-                            readonly done: NullType;
+                    readonly machine: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<StringType>;
+                            after: OptionType<StringType>;
                         }>;
-                        after: VariantType<{
-                            readonly planned: NullType;
-                            readonly active: NullType;
-                            readonly done: NullType;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
                         }>;
                     }>;
-                    patch: VariantType<{
-                        readonly planned: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+                    readonly status: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: VariantType<{
+                                readonly planned: NullType;
+                                readonly active: NullType;
+                                readonly done: NullType;
                             }>;
-                        }>;
-                        readonly active: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+                            after: VariantType<{
+                                readonly planned: NullType;
+                                readonly active: NullType;
+                                readonly done: NullType;
                             }>;
                         }>;
-                        readonly done: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+                        patch: VariantType<{
+                            readonly planned: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly active: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly done: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly hours: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
-                    }>;
-                }>;
-                readonly customer: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly hours: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly due: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
+                    readonly customer: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                    patch: VariantType<{
-                        none: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                    readonly due: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
                         }>;
-                        some: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: DateTimeType;
-                                after: DateTimeType;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
                             }>;
                         }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+    readonly machine: OptionType<StringType>;
+    readonly status: VariantType<{
+        readonly planned: NullType;
+        readonly active: NullType;
+        readonly done: NullType;
+    }>;
+    readonly hours: FloatType;
+    readonly customer: StringType;
+    readonly due: OptionType<DateTimeType>;
+}>>>>;
 export declare const calendarServices: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly title: StringType;
     readonly start: DateTimeType;
@@ -393,226 +517,287 @@ export declare const calendarServices: import("@elaraai/e3").RecordDef<DictType<
     readonly machine: StringType;
     readonly technician: StringType;
     readonly notes: StringType;
-}>>, [variant<"field", "records">, variant<"field", "calendar_services">]>;
-export declare const calendarServicesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "calendar_services">], import("@elaraai/e3").IndexesOf<{
+    calendar_services_by_time: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        node: IntegerType;
+        at: DateTimeType;
+    }>, NullType, readonly [], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
+    }>;
+    calendar_services_by_machine_time: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<{
+            machine: StringType;
+        }>;
+        node: IntegerType;
+        at: DateTimeType;
+    }>, NullType, readonly ["machine"], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
+    }>;
+}, DictType<StringType, StructType<{
     readonly title: StringType;
     readonly start: DateTimeType;
     readonly end: DateTimeType;
     readonly machine: StringType;
     readonly technician: StringType;
     readonly notes: StringType;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly title: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
-            readonly machine: StringType;
-            readonly technician: StringType;
-            readonly notes: StringType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly title: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
-            readonly machine: StringType;
-            readonly technician: StringType;
-            readonly notes: StringType;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly title: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
-            readonly machine: StringType;
-            readonly technician: StringType;
-            readonly notes: StringType;
-        }>;
-        insert: StructType<{
-            readonly title: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
-            readonly machine: StringType;
-            readonly technician: StringType;
-            readonly notes: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly title: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly machine: StringType;
+                readonly technician: StringType;
+                readonly notes: StringType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly title: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly machine: StringType;
+                readonly technician: StringType;
+                readonly notes: StringType;
+            }>>;
         }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly title: StringType;
-                    readonly start: DateTimeType;
-                    readonly end: DateTimeType;
-                    readonly machine: StringType;
-                    readonly technician: StringType;
-                    readonly notes: StringType;
-                }>;
-                after: StructType<{
-                    readonly title: StringType;
-                    readonly start: DateTimeType;
-                    readonly end: DateTimeType;
-                    readonly machine: StringType;
-                    readonly technician: StringType;
-                    readonly notes: StringType;
-                }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly title: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly machine: StringType;
+                readonly technician: StringType;
+                readonly notes: StringType;
+            }>;
+            insert: StructType<{
+                readonly title: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly machine: StringType;
+                readonly technician: StringType;
+                readonly notes: StringType;
             }>;
-            patch: StructType<{
-                readonly title: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly title: StringType;
+                        readonly start: DateTimeType;
+                        readonly end: DateTimeType;
+                        readonly machine: StringType;
+                        readonly technician: StringType;
+                        readonly notes: StringType;
                     }>;
-                }>;
-                readonly start: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
+                    after: StructType<{
+                        readonly title: StringType;
+                        readonly start: DateTimeType;
+                        readonly end: DateTimeType;
+                        readonly machine: StringType;
+                        readonly technician: StringType;
+                        readonly notes: StringType;
                     }>;
                 }>;
-                readonly end: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
+                patch: StructType<{
+                    readonly title: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly machine: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly start: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
+                        }>;
                     }>;
-                }>;
-                readonly technician: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly end: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
+                        }>;
                     }>;
-                }>;
-                readonly notes: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly machine: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly technician: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly notes: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-export declare const calendarShifts: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
     readonly title: StringType;
     readonly start: DateTimeType;
     readonly end: DateTimeType;
-    readonly person: StringType;
+    readonly machine: StringType;
+    readonly technician: StringType;
     readonly notes: StringType;
-}>>, [variant<"field", "records">, variant<"field", "calendar_shifts">]>;
-export declare const calendarShiftsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>>>;
+export declare const calendarShifts: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly title: StringType;
     readonly start: DateTimeType;
     readonly end: DateTimeType;
     readonly person: StringType;
     readonly notes: StringType;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly title: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
-            readonly person: StringType;
-            readonly notes: StringType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly title: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
-            readonly person: StringType;
-            readonly notes: StringType;
-        }>>;
+}>>, [variant<"field", "records">, variant<"field", "calendar_shifts">], import("@elaraai/e3").IndexesOf<{
+    calendar_shifts_by_time: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        node: IntegerType;
+        at: DateTimeType;
+    }>, NullType, readonly [], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
     }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly title: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
-            readonly person: StringType;
-            readonly notes: StringType;
+    calendar_shifts_by_person_time: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<{
+            person: StringType;
         }>;
-        insert: StructType<{
-            readonly title: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
-            readonly person: StringType;
-            readonly notes: StringType;
+        node: IntegerType;
+        at: DateTimeType;
+    }>, NullType, readonly ["person"], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
+    }>;
+}, DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly person: StringType;
+    readonly notes: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly title: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly person: StringType;
+                readonly notes: StringType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly title: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly person: StringType;
+                readonly notes: StringType;
+            }>>;
         }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly title: StringType;
-                    readonly start: DateTimeType;
-                    readonly end: DateTimeType;
-                    readonly person: StringType;
-                    readonly notes: StringType;
-                }>;
-                after: StructType<{
-                    readonly title: StringType;
-                    readonly start: DateTimeType;
-                    readonly end: DateTimeType;
-                    readonly person: StringType;
-                    readonly notes: StringType;
-                }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly title: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly person: StringType;
+                readonly notes: StringType;
+            }>;
+            insert: StructType<{
+                readonly title: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+                readonly person: StringType;
+                readonly notes: StringType;
             }>;
-            patch: StructType<{
-                readonly title: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly title: StringType;
+                        readonly start: DateTimeType;
+                        readonly end: DateTimeType;
+                        readonly person: StringType;
+                        readonly notes: StringType;
                     }>;
-                }>;
-                readonly start: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
+                    after: StructType<{
+                        readonly title: StringType;
+                        readonly start: DateTimeType;
+                        readonly end: DateTimeType;
+                        readonly person: StringType;
+                        readonly notes: StringType;
                     }>;
                 }>;
-                readonly end: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
+                patch: StructType<{
+                    readonly title: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly person: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly start: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
+                        }>;
                     }>;
-                }>;
-                readonly notes: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly end: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
+                        }>;
+                    }>;
+                    readonly person: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly notes: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-export declare const calendarJobTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
-    readonly name: StringType;
-    readonly group: StringType;
-    readonly hours: FloatType;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+    readonly person: StringType;
+    readonly notes: StringType;
+}>>>>;
+export declare const calendarJobTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly hours: FloatType;
     readonly values: StructType<{
         readonly title: StringType;
         readonly status: VariantType<{
@@ -624,82 +809,9 @@ export declare const calendarJobTemplates: import("@elaraai/e3").RecordDef<DictT
         readonly customer: StringType;
         readonly due: OptionType<DateTimeType>;
     }>;
-}>>, [variant<"field", "records">, variant<"field", "calendar_job_templates">]>;
-export declare const calendarServiceTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
-    readonly name: StringType;
-    readonly group: StringType;
-    readonly hours: FloatType;
-    readonly values: StructType<{
-        readonly title: StringType;
-        readonly technician: StringType;
-        readonly notes: StringType;
-    }>;
-}>>, [variant<"field", "records">, variant<"field", "calendar_service_templates">]>;
-export declare const calendarShiftTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
-    readonly name: StringType;
-    readonly group: StringType;
-    readonly hour: IntegerType;
-    readonly values: StructType<{
-        readonly title: StringType;
-        readonly notes: StringType;
-    }>;
-}>>, [variant<"field", "records">, variant<"field", "calendar_shift_templates">]>;
-export declare const calendarMachinesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
-    readonly name: StringType;
-    readonly area: StringType;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly name: StringType;
-            readonly area: StringType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly name: StringType;
-            readonly area: StringType;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly name: StringType;
-            readonly area: StringType;
-        }>;
-        insert: StructType<{
-            readonly name: StringType;
-            readonly area: StringType;
-        }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly name: StringType;
-                    readonly area: StringType;
-                }>;
-                after: StructType<{
-                    readonly name: StringType;
-                    readonly area: StringType;
-                }>;
-            }>;
-            patch: StructType<{
-                readonly name: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
-                }>;
-                readonly area: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
-                }>;
-            }>;
-        }>;
-    }>>;
-}>]>;
-export declare const calendarJobTemplatesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "calendar_job_templates">], import("@elaraai/e3").IndexesOf<{
+    calendar_job_templates_by_group: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["group"], unknown>;
+}, DictType<StringType, StructType<{
     readonly name: StringType;
     readonly group: StringType;
     readonly hours: FloatType;
@@ -714,137 +826,84 @@ export declare const calendarJobTemplatesPatch: import("@elaraai/e3").MutationDe
         readonly customer: StringType;
         readonly due: OptionType<DateTimeType>;
     }>;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly name: StringType;
-            readonly group: StringType;
-            readonly hours: FloatType;
-            readonly values: StructType<{
-                readonly title: StringType;
-                readonly status: VariantType<{
-                    readonly planned: NullType;
-                    readonly active: NullType;
-                    readonly done: NullType;
-                }>;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly group: StringType;
                 readonly hours: FloatType;
-                readonly customer: StringType;
-                readonly due: OptionType<DateTimeType>;
-            }>;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly name: StringType;
-            readonly group: StringType;
-            readonly hours: FloatType;
-            readonly values: StructType<{
-                readonly title: StringType;
-                readonly status: VariantType<{
-                    readonly planned: NullType;
-                    readonly active: NullType;
-                    readonly done: NullType;
+                readonly values: StructType<{
+                    readonly title: StringType;
+                    readonly status: VariantType<{
+                        readonly planned: NullType;
+                        readonly active: NullType;
+                        readonly done: NullType;
+                    }>;
+                    readonly hours: FloatType;
+                    readonly customer: StringType;
+                    readonly due: OptionType<DateTimeType>;
                 }>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly group: StringType;
                 readonly hours: FloatType;
-                readonly customer: StringType;
-                readonly due: OptionType<DateTimeType>;
-            }>;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly name: StringType;
-            readonly group: StringType;
-            readonly hours: FloatType;
-            readonly values: StructType<{
-                readonly title: StringType;
-                readonly status: VariantType<{
-                    readonly planned: NullType;
-                    readonly active: NullType;
-                    readonly done: NullType;
+                readonly values: StructType<{
+                    readonly title: StringType;
+                    readonly status: VariantType<{
+                        readonly planned: NullType;
+                        readonly active: NullType;
+                        readonly done: NullType;
+                    }>;
+                    readonly hours: FloatType;
+                    readonly customer: StringType;
+                    readonly due: OptionType<DateTimeType>;
                 }>;
-                readonly hours: FloatType;
-                readonly customer: StringType;
-                readonly due: OptionType<DateTimeType>;
-            }>;
+            }>>;
         }>;
-        insert: StructType<{
-            readonly name: StringType;
-            readonly group: StringType;
-            readonly hours: FloatType;
-            readonly values: StructType<{
-                readonly title: StringType;
-                readonly status: VariantType<{
-                    readonly planned: NullType;
-                    readonly active: NullType;
-                    readonly done: NullType;
-                }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly name: StringType;
+                readonly group: StringType;
                 readonly hours: FloatType;
-                readonly customer: StringType;
-                readonly due: OptionType<DateTimeType>;
-            }>;
-        }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly name: StringType;
-                    readonly group: StringType;
-                    readonly hours: FloatType;
-                    readonly values: StructType<{
-                        readonly title: StringType;
-                        readonly status: VariantType<{
-                            readonly planned: NullType;
-                            readonly active: NullType;
-                            readonly done: NullType;
-                        }>;
-                        readonly hours: FloatType;
-                        readonly customer: StringType;
-                        readonly due: OptionType<DateTimeType>;
+                readonly values: StructType<{
+                    readonly title: StringType;
+                    readonly status: VariantType<{
+                        readonly planned: NullType;
+                        readonly active: NullType;
+                        readonly done: NullType;
                     }>;
-                }>;
-                after: StructType<{
-                    readonly name: StringType;
-                    readonly group: StringType;
                     readonly hours: FloatType;
-                    readonly values: StructType<{
-                        readonly title: StringType;
-                        readonly status: VariantType<{
-                            readonly planned: NullType;
-                            readonly active: NullType;
-                            readonly done: NullType;
-                        }>;
-                        readonly hours: FloatType;
-                        readonly customer: StringType;
-                        readonly due: OptionType<DateTimeType>;
-                    }>;
+                    readonly customer: StringType;
+                    readonly due: OptionType<DateTimeType>;
                 }>;
             }>;
-            patch: StructType<{
-                readonly name: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
-                }>;
-                readonly group: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
-                }>;
-                readonly hours: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+            insert: StructType<{
+                readonly name: StringType;
+                readonly group: StringType;
+                readonly hours: FloatType;
+                readonly values: StructType<{
+                    readonly title: StringType;
+                    readonly status: VariantType<{
+                        readonly planned: NullType;
+                        readonly active: NullType;
+                        readonly done: NullType;
                     }>;
+                    readonly hours: FloatType;
+                    readonly customer: StringType;
+                    readonly due: OptionType<DateTimeType>;
                 }>;
-                readonly values: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StructType<{
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly name: StringType;
+                        readonly group: StringType;
+                        readonly hours: FloatType;
+                        readonly values: StructType<{
                             readonly title: StringType;
                             readonly status: VariantType<{
                                 readonly planned: NullType;
@@ -855,7 +914,12 @@ export declare const calendarJobTemplatesPatch: import("@elaraai/e3").MutationDe
                             readonly customer: StringType;
                             readonly due: OptionType<DateTimeType>;
                         }>;
-                        after: StructType<{
+                    }>;
+                    after: StructType<{
+                        readonly name: StringType;
+                        readonly group: StringType;
+                        readonly hours: FloatType;
+                        readonly values: StructType<{
                             readonly title: StringType;
                             readonly status: VariantType<{
                                 readonly planned: NullType;
@@ -867,85 +931,135 @@ export declare const calendarJobTemplatesPatch: import("@elaraai/e3").MutationDe
                             readonly due: OptionType<DateTimeType>;
                         }>;
                     }>;
-                    patch: StructType<{
-                        readonly title: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
+                }>;
+                patch: StructType<{
+                    readonly name: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
                         }>;
-                        readonly status: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: VariantType<{
+                    }>;
+                    readonly group: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly hours: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly values: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StructType<{
+                                readonly title: StringType;
+                                readonly status: VariantType<{
                                     readonly planned: NullType;
                                     readonly active: NullType;
                                     readonly done: NullType;
                                 }>;
-                                after: VariantType<{
+                                readonly hours: FloatType;
+                                readonly customer: StringType;
+                                readonly due: OptionType<DateTimeType>;
+                            }>;
+                            after: StructType<{
+                                readonly title: StringType;
+                                readonly status: VariantType<{
                                     readonly planned: NullType;
                                     readonly active: NullType;
                                     readonly done: NullType;
                                 }>;
+                                readonly hours: FloatType;
+                                readonly customer: StringType;
+                                readonly due: OptionType<DateTimeType>;
                             }>;
-                            patch: VariantType<{
-                                readonly planned: VariantType<{
-                                    unchanged: NullType;
-                                    replace: StructType<{
-                                        before: NullType;
-                                        after: NullType;
-                                    }>;
+                        }>;
+                        patch: StructType<{
+                            readonly title: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
                                 }>;
-                                readonly active: VariantType<{
-                                    unchanged: NullType;
-                                    replace: StructType<{
-                                        before: NullType;
-                                        after: NullType;
+                            }>;
+                            readonly status: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: VariantType<{
+                                        readonly planned: NullType;
+                                        readonly active: NullType;
+                                        readonly done: NullType;
+                                    }>;
+                                    after: VariantType<{
+                                        readonly planned: NullType;
+                                        readonly active: NullType;
+                                        readonly done: NullType;
                                     }>;
                                 }>;
-                                readonly done: VariantType<{
-                                    unchanged: NullType;
-                                    replace: StructType<{
-                                        before: NullType;
-                                        after: NullType;
+                                patch: VariantType<{
+                                    readonly planned: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: NullType;
+                                            after: NullType;
+                                        }>;
+                                    }>;
+                                    readonly active: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: NullType;
+                                            after: NullType;
+                                        }>;
+                                    }>;
+                                    readonly done: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: NullType;
+                                            after: NullType;
+                                        }>;
                                     }>;
                                 }>;
                             }>;
-                        }>;
-                        readonly hours: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: FloatType;
-                                after: FloatType;
-                            }>;
-                        }>;
-                        readonly customer: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
+                            readonly hours: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: FloatType;
+                                    after: FloatType;
+                                }>;
                             }>;
-                        }>;
-                        readonly due: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: OptionType<DateTimeType>;
-                                after: OptionType<DateTimeType>;
+                            readonly customer: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
-                            patch: VariantType<{
-                                none: VariantType<{
-                                    unchanged: NullType;
-                                    replace: StructType<{
-                                        before: NullType;
-                                        after: NullType;
-                                    }>;
+                            readonly due: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: OptionType<DateTimeType>;
+                                    after: OptionType<DateTimeType>;
                                 }>;
-                                some: VariantType<{
-                                    unchanged: NullType;
-                                    replace: StructType<{
-                                        before: DateTimeType;
-                                        after: DateTimeType;
+                                patch: VariantType<{
+                                    none: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: NullType;
+                                            after: NullType;
+                                        }>;
+                                    }>;
+                                    some: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: DateTimeType;
+                                            after: DateTimeType;
+                                        }>;
                                     }>;
                                 }>;
                             }>;
@@ -953,165 +1067,9 @@ export declare const calendarJobTemplatesPatch: import("@elaraai/e3").MutationDe
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-export declare const calendarJobsByTime: import("@elaraai/e3").RecordIndexDef<"calendar_jobs_by_time", DictType<StringType, StructType<{
-    readonly title: StringType;
-    readonly start: OptionType<DateTimeType>;
-    readonly end: OptionType<DateTimeType>;
-    readonly machine: OptionType<StringType>;
-    readonly status: VariantType<{
-        readonly planned: NullType;
-        readonly active: NullType;
-        readonly done: NullType;
-    }>;
-    readonly hours: FloatType;
-    readonly customer: StringType;
-    readonly due: OptionType<DateTimeType>;
-}>>, StructType<Record<never, never> & {
-    __interval: IntegerType;
-} & {
-    start: OptionType<DateTimeType>;
-}>, NullType, readonly ["start"]> & {
-    interval: {
-        readonly from: "start";
-        readonly to: "end";
-    };
-};
-export declare const calendarJobsByStatusTime: import("@elaraai/e3").RecordIndexDef<"calendar_jobs_by_status_time", DictType<StringType, StructType<{
-    readonly title: StringType;
-    readonly start: OptionType<DateTimeType>;
-    readonly end: OptionType<DateTimeType>;
-    readonly machine: OptionType<StringType>;
-    readonly status: VariantType<{
-        readonly planned: NullType;
-        readonly active: NullType;
-        readonly done: NullType;
-    }>;
-    readonly hours: FloatType;
-    readonly customer: StringType;
-    readonly due: OptionType<DateTimeType>;
-}>>, StructType<{
-    status: VariantType<{
-        readonly planned: NullType;
-        readonly active: NullType;
-        readonly done: NullType;
-    }>;
-} & {
-    __interval: IntegerType;
-} & {
-    start: OptionType<DateTimeType>;
-}>, NullType, readonly ["status", "start"]> & {
-    interval: {
-        readonly from: "start";
-        readonly to: "end";
-    };
-};
-export declare const calendarJobsByMachineTime: import("@elaraai/e3").RecordIndexDef<"calendar_jobs_by_machine_time", DictType<StringType, StructType<{
-    readonly title: StringType;
-    readonly start: OptionType<DateTimeType>;
-    readonly end: OptionType<DateTimeType>;
-    readonly machine: OptionType<StringType>;
-    readonly status: VariantType<{
-        readonly planned: NullType;
-        readonly active: NullType;
-        readonly done: NullType;
-    }>;
-    readonly hours: FloatType;
-    readonly customer: StringType;
-    readonly due: OptionType<DateTimeType>;
-}>>, StructType<{
-    machine: OptionType<StringType>;
-} & {
-    __interval: IntegerType;
-} & {
-    start: OptionType<DateTimeType>;
-}>, NullType, readonly ["machine", "start"]> & {
-    interval: {
-        readonly from: "start";
-        readonly to: "end";
-    };
-};
-export declare const calendarServicesByTime: import("@elaraai/e3").RecordIndexDef<"calendar_services_by_time", DictType<StringType, StructType<{
-    readonly title: StringType;
-    readonly start: DateTimeType;
-    readonly end: DateTimeType;
-    readonly machine: StringType;
-    readonly technician: StringType;
-    readonly notes: StringType;
-}>>, StructType<Record<never, never> & {
-    __interval: IntegerType;
-} & {
-    start: DateTimeType;
-}>, NullType, readonly ["start"]> & {
-    interval: {
-        readonly from: "start";
-        readonly to: "end";
-    };
-};
-export declare const calendarServicesByMachineTime: import("@elaraai/e3").RecordIndexDef<"calendar_services_by_machine_time", DictType<StringType, StructType<{
-    readonly title: StringType;
-    readonly start: DateTimeType;
-    readonly end: DateTimeType;
-    readonly machine: StringType;
-    readonly technician: StringType;
-    readonly notes: StringType;
-}>>, StructType<{
-    machine: StringType;
-} & {
-    __interval: IntegerType;
-} & {
-    start: DateTimeType;
-}>, NullType, readonly ["machine", "start"]> & {
-    interval: {
-        readonly from: "start";
-        readonly to: "end";
-    };
-};
-export declare const calendarShiftsByTime: import("@elaraai/e3").RecordIndexDef<"calendar_shifts_by_time", DictType<StringType, StructType<{
-    readonly title: StringType;
-    readonly start: DateTimeType;
-    readonly end: DateTimeType;
-    readonly person: StringType;
-    readonly notes: StringType;
-}>>, StructType<Record<never, never> & {
-    __interval: IntegerType;
-} & {
-    start: DateTimeType;
-}>, NullType, readonly ["start"]> & {
-    interval: {
-        readonly from: "start";
-        readonly to: "end";
-    };
-};
-export declare const calendarShiftsByPersonTime: import("@elaraai/e3").RecordIndexDef<"calendar_shifts_by_person_time", DictType<StringType, StructType<{
-    readonly title: StringType;
-    readonly start: DateTimeType;
-    readonly end: DateTimeType;
-    readonly person: StringType;
-    readonly notes: StringType;
-}>>, StructType<{
-    person: StringType;
-} & {
-    __interval: IntegerType;
-} & {
-    start: DateTimeType;
-}>, NullType, readonly ["person", "start"]> & {
-    interval: {
-        readonly from: "start";
-        readonly to: "end";
-    };
-};
-export declare const calendarMachinesByArea: import("@elaraai/e3").RecordIndexDef<"calendar_machines_by_area", DictType<StringType, StructType<{
-    readonly name: StringType;
-    readonly area: StringType;
-}>>, StringType, NullType, readonly ["area"]>;
-export declare const calendarPeopleByTeam: import("@elaraai/e3").RecordIndexDef<"calendar_people_by_team", DictType<StringType, StructType<{
-    readonly name: StringType;
-    readonly team: StringType;
-}>>, StringType, NullType, readonly ["team"]>;
-export declare const calendarJobTemplatesByGroup: import("@elaraai/e3").RecordIndexDef<"calendar_job_templates_by_group", DictType<StringType, StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
     readonly name: StringType;
     readonly group: StringType;
     readonly hours: FloatType;
@@ -1126,8 +1084,8 @@ export declare const calendarJobTemplatesByGroup: import("@elaraai/e3").RecordIn
         readonly customer: StringType;
         readonly due: OptionType<DateTimeType>;
     }>;
-}>>, StringType, NullType, readonly ["group"]>;
-export declare const calendarServiceTemplatesByGroup: import("@elaraai/e3").RecordIndexDef<"calendar_service_templates_by_group", DictType<StringType, StructType<{
+}>>>>;
+export declare const calendarServiceTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly group: StringType;
     readonly hours: FloatType;
@@ -1136,8 +1094,28 @@ export declare const calendarServiceTemplatesByGroup: import("@elaraai/e3").Reco
         readonly technician: StringType;
         readonly notes: StringType;
     }>;
-}>>, StringType, NullType, readonly ["group"]>;
-export declare const calendarShiftTemplatesByGroup: import("@elaraai/e3").RecordIndexDef<"calendar_shift_templates_by_group", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "calendar_service_templates">], import("@elaraai/e3").IndexesOf<{
+    calendar_service_templates_by_group: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["group"], unknown>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly hours: FloatType;
+    readonly values: StructType<{
+        readonly title: StringType;
+        readonly technician: StringType;
+        readonly notes: StringType;
+    }>;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly hours: FloatType;
+    readonly values: StructType<{
+        readonly title: StringType;
+        readonly technician: StringType;
+        readonly notes: StringType;
+    }>;
+}>>>>;
+export declare const calendarShiftTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly group: StringType;
     readonly hour: IntegerType;
@@ -1145,13 +1123,120 @@ export declare const calendarShiftTemplatesByGroup: import("@elaraai/e3").Record
         readonly title: StringType;
         readonly notes: StringType;
     }>;
-}>>, StringType, NullType, readonly ["group"]>;
+}>>, [variant<"field", "records">, variant<"field", "calendar_shift_templates">], import("@elaraai/e3").IndexesOf<{
+    calendar_shift_templates_by_group: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["group"], unknown>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly hour: IntegerType;
+    readonly values: StructType<{
+        readonly title: StringType;
+        readonly notes: StringType;
+    }>;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly hour: IntegerType;
+    readonly values: StructType<{
+        readonly title: StringType;
+        readonly notes: StringType;
+    }>;
+}>>>>;
 export declare const calendarOperations: import("@elaraai/east").ExampleDef<[], any>;
 export declare const calendarMobile: import("@elaraai/east").ExampleDef<[], any>;
 export declare const calendarReadOnly: import("@elaraai/east").ExampleDef<[], any>;
 export declare const calendarMinimal: import("@elaraai/east").ExampleDef<[], any>;
-/** Each job is indexed under every UTC day it touches, leaving an exact midnight end out. */
-export declare const calendarJobsByDay: import("@elaraai/e3").RecordIndexDef<"calendar_jobs_by_day", DictType<StringType, StructType<{
+export declare const calendarWindowed: import("@elaraai/east").ExampleDef<[], any>;
+/** The smallest event record needs only its title and two instants. */
+export declare const CalendarAppointment: StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+}>;
+export declare const calendarAppointments: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+}>>, [variant<"field", "records">, variant<"field", "calendar_appointments">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly title: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly title: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+            }>>;
+        }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly title: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+            }>;
+            insert: StructType<{
+                readonly title: StringType;
+                readonly start: DateTimeType;
+                readonly end: DateTimeType;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly title: StringType;
+                        readonly start: DateTimeType;
+                        readonly end: DateTimeType;
+                    }>;
+                    after: StructType<{
+                        readonly title: StringType;
+                        readonly start: DateTimeType;
+                        readonly end: DateTimeType;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly title: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly start: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
+                        }>;
+                    }>;
+                    readonly end: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+}>>>>;
+export declare const calendarQuickstart: import("@elaraai/east").ExampleDef<[], any>;
+/** A custom inspector edits the complete typed row through the same session. */
+export declare const calendarCustomInspector: import("@elaraai/east").ExampleDef<[], any>;
+/** The jobs the conflicts example edits, in a record of their own, so no other example's edits meet them. */
+export declare const calendarConflictJobs: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
@@ -1164,9 +1249,7 @@ export declare const calendarJobsByDay: import("@elaraai/e3").RecordIndexDef<"ca
     readonly hours: FloatType;
     readonly customer: StringType;
     readonly due: OptionType<DateTimeType>;
-}>>, DateTimeType, NullType, undefined>;
-/** The unscheduled rows are indexed by due date; they remain in the jobs record. */
-export declare const calendarJobsUnscheduled: import("@elaraai/e3").RecordIndexDef<"calendar_jobs_unscheduled", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "calendar_conflict_jobs">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
@@ -1179,89 +1262,277 @@ export declare const calendarJobsUnscheduled: import("@elaraai/e3").RecordIndexD
     readonly hours: FloatType;
     readonly customer: StringType;
     readonly due: OptionType<DateTimeType>;
-}>>, OptionType<DateTimeType>, NullType, undefined>;
-export declare const calendarWindowed: import("@elaraai/east").ExampleDef<[], any>;
-/** The smallest event record needs only its title and two instants. */
-export declare const CalendarAppointment: StructType<{
-    readonly title: StringType;
-    readonly start: DateTimeType;
-    readonly end: DateTimeType;
-}>;
-export declare const calendarAppointments: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
-    readonly title: StringType;
-    readonly start: DateTimeType;
-    readonly end: DateTimeType;
-}>>, [variant<"field", "records">, variant<"field", "calendar_appointments">]>;
-export declare const calendarAppointmentsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
-    readonly title: StringType;
-    readonly start: DateTimeType;
-    readonly end: DateTimeType;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly title: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly title: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly title: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
-        }>;
-        insert: StructType<{
-            readonly title: StringType;
-            readonly start: DateTimeType;
-            readonly end: DateTimeType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly machine: OptionType<StringType>;
+                readonly status: VariantType<{
+                    readonly planned: NullType;
+                    readonly active: NullType;
+                    readonly done: NullType;
+                }>;
+                readonly hours: FloatType;
+                readonly customer: StringType;
+                readonly due: OptionType<DateTimeType>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly machine: OptionType<StringType>;
+                readonly status: VariantType<{
+                    readonly planned: NullType;
+                    readonly active: NullType;
+                    readonly done: NullType;
+                }>;
+                readonly hours: FloatType;
+                readonly customer: StringType;
+                readonly due: OptionType<DateTimeType>;
+            }>>;
         }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly title: StringType;
-                    readonly start: DateTimeType;
-                    readonly end: DateTimeType;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly machine: OptionType<StringType>;
+                readonly status: VariantType<{
+                    readonly planned: NullType;
+                    readonly active: NullType;
+                    readonly done: NullType;
                 }>;
-                after: StructType<{
-                    readonly title: StringType;
-                    readonly start: DateTimeType;
-                    readonly end: DateTimeType;
+                readonly hours: FloatType;
+                readonly customer: StringType;
+                readonly due: OptionType<DateTimeType>;
+            }>;
+            insert: StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly machine: OptionType<StringType>;
+                readonly status: VariantType<{
+                    readonly planned: NullType;
+                    readonly active: NullType;
+                    readonly done: NullType;
                 }>;
+                readonly hours: FloatType;
+                readonly customer: StringType;
+                readonly due: OptionType<DateTimeType>;
             }>;
-            patch: StructType<{
-                readonly title: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly title: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                        readonly machine: OptionType<StringType>;
+                        readonly status: VariantType<{
+                            readonly planned: NullType;
+                            readonly active: NullType;
+                            readonly done: NullType;
+                        }>;
+                        readonly hours: FloatType;
+                        readonly customer: StringType;
+                        readonly due: OptionType<DateTimeType>;
                     }>;
-                }>;
-                readonly start: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
+                    after: StructType<{
+                        readonly title: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                        readonly machine: OptionType<StringType>;
+                        readonly status: VariantType<{
+                            readonly planned: NullType;
+                            readonly active: NullType;
+                            readonly done: NullType;
+                        }>;
+                        readonly hours: FloatType;
+                        readonly customer: StringType;
+                        readonly due: OptionType<DateTimeType>;
                     }>;
                 }>;
-                readonly end: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
+                patch: StructType<{
+                    readonly title: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly start: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly end: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly machine: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<StringType>;
+                            after: OptionType<StringType>;
+                        }>;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly status: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: VariantType<{
+                                readonly planned: NullType;
+                                readonly active: NullType;
+                                readonly done: NullType;
+                            }>;
+                            after: VariantType<{
+                                readonly planned: NullType;
+                                readonly active: NullType;
+                                readonly done: NullType;
+                            }>;
+                        }>;
+                        patch: VariantType<{
+                            readonly planned: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly active: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly done: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly hours: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly customer: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly due: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-export declare const calendarQuickstart: import("@elaraai/east").ExampleDef<[], any>;
-/** A custom inspector edits the complete typed row through the same session. */
-export declare const calendarCustomInspector: import("@elaraai/east").ExampleDef<[], any>;
+        }>>;
+    }>]>;
+    elsewhere: import("@elaraai/e3").MutationDraft<[]>;
+}, DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+    readonly machine: OptionType<StringType>;
+    readonly status: VariantType<{
+        readonly planned: NullType;
+        readonly active: NullType;
+        readonly done: NullType;
+    }>;
+    readonly hours: FloatType;
+    readonly customer: StringType;
+    readonly due: OptionType<DateTimeType>;
+}>>>>;
+/**
+ * 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 jobs —
+ * every job an hour later. A job you moved or resized too is a conflict, its
+ * dates one card to choose; a customer or hours you changed in the panel
+ * combines with theirs. Each press saves their change again.
+ */
+export declare const calendarConflicts: import("@elaraai/east").ExampleDef<[], any>;
 //# sourceMappingURL=calendar.examples.d.ts.map