@elaraai/e3-ui 1.0.102 → 1.0.104

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

@@ -0,0 +1,1264 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/** @jsxImportSource @elaraai/east-ui */
+/**
+ * The Sheet's action column (#1474, `Sheet Actions - DX Proposal.md` §3): a
+ * variant's state machine as a column. Each example is the proposal's, whole.
+ */
+import { ArrayType, DateTimeType, DictType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, variant } from "@elaraai/east";
+export declare const JobState: VariantType<{
+    readonly started: NullType;
+    readonly finished: NullType;
+}>;
+export declare const ActionJob: StructType<{
+    readonly task: StringType;
+    readonly state: OptionType<VariantType<{
+        readonly started: NullType;
+        readonly finished: NullType;
+    }>>;
+}>;
+export declare const sheetActionJobs: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly task: StringType;
+    readonly state: OptionType<VariantType<{
+        readonly started: NullType;
+        readonly finished: NullType;
+    }>>;
+}>>, [variant<"field", "records">, variant<"field", "sheet_action_jobs">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly task: StringType;
+    readonly state: OptionType<VariantType<{
+        readonly started: NullType;
+        readonly finished: NullType;
+    }>>;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly task: StringType;
+                readonly state: OptionType<VariantType<{
+                    readonly started: NullType;
+                    readonly finished: NullType;
+                }>>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly task: StringType;
+                readonly state: OptionType<VariantType<{
+                    readonly started: NullType;
+                    readonly finished: NullType;
+                }>>;
+            }>>;
+        }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly task: StringType;
+                readonly state: OptionType<VariantType<{
+                    readonly started: NullType;
+                    readonly finished: NullType;
+                }>>;
+            }>;
+            insert: StructType<{
+                readonly task: StringType;
+                readonly state: OptionType<VariantType<{
+                    readonly started: NullType;
+                    readonly finished: NullType;
+                }>>;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly task: StringType;
+                        readonly state: OptionType<VariantType<{
+                            readonly started: NullType;
+                            readonly finished: NullType;
+                        }>>;
+                    }>;
+                    after: StructType<{
+                        readonly task: StringType;
+                        readonly state: OptionType<VariantType<{
+                            readonly started: NullType;
+                            readonly finished: NullType;
+                        }>>;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly task: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly state: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<VariantType<{
+                                readonly started: NullType;
+                                readonly finished: NullType;
+                            }>>;
+                            after: OptionType<VariantType<{
+                                readonly started: NullType;
+                                readonly finished: NullType;
+                            }>>;
+                        }>;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: VariantType<{
+                                        readonly started: NullType;
+                                        readonly finished: NullType;
+                                    }>;
+                                    after: VariantType<{
+                                        readonly started: NullType;
+                                        readonly finished: NullType;
+                                    }>;
+                                }>;
+                                patch: VariantType<{
+                                    readonly started: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: NullType;
+                                            after: NullType;
+                                        }>;
+                                    }>;
+                                    readonly finished: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: NullType;
+                                            after: NullType;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly task: StringType;
+    readonly state: OptionType<VariantType<{
+        readonly started: NullType;
+        readonly finished: NullType;
+    }>>;
+}>>>>;
+export declare const sheetActionsBasic: import("@elaraai/east").ExampleDef<[], any>;
+export declare const HoldReason: VariantType<{
+    readonly awaiting_parts: NullType;
+    readonly machine_down: NullType;
+    readonly quality_hold: NullType;
+}>;
+export declare const StepAlert: StructType<{
+    readonly changes: StringType;
+    readonly severity: VariantType<{
+        readonly low: NullType;
+        readonly high: NullType;
+    }>;
+}>;
+export declare const StepAction: VariantType<{
+    readonly started: NullType;
+    readonly completed: NullType;
+    readonly reported: IntegerType;
+    readonly held: VariantType<{
+        readonly awaiting_parts: NullType;
+        readonly machine_down: NullType;
+        readonly quality_hold: NullType;
+    }>;
+    readonly alerted: StructType<{
+        readonly changes: StringType;
+        readonly severity: VariantType<{
+            readonly low: NullType;
+            readonly high: NullType;
+        }>;
+    }>;
+    readonly verified: NullType;
+}>;
+export declare const Step: StructType<{
+    readonly op: StringType;
+    readonly step: StringType;
+    readonly plan: IntegerType;
+    readonly good: OptionType<IntegerType>;
+    readonly done: OptionType<DateTimeType>;
+    readonly action: OptionType<VariantType<{
+        readonly started: NullType;
+        readonly completed: NullType;
+        readonly reported: IntegerType;
+        readonly held: VariantType<{
+            readonly awaiting_parts: NullType;
+            readonly machine_down: NullType;
+            readonly quality_hold: NullType;
+        }>;
+        readonly alerted: StructType<{
+            readonly changes: StringType;
+            readonly severity: VariantType<{
+                readonly low: NullType;
+                readonly high: NullType;
+            }>;
+        }>;
+        readonly verified: NullType;
+    }>>;
+}>;
+export declare const WorkOrder: StructType<{
+    readonly id: StringType;
+    readonly name: StringType;
+    readonly status: StringType;
+    readonly steps: ArrayType<StructType<{
+        readonly op: StringType;
+        readonly step: StringType;
+        readonly plan: IntegerType;
+        readonly good: OptionType<IntegerType>;
+        readonly done: OptionType<DateTimeType>;
+        readonly action: OptionType<VariantType<{
+            readonly started: NullType;
+            readonly completed: NullType;
+            readonly reported: IntegerType;
+            readonly held: VariantType<{
+                readonly awaiting_parts: NullType;
+                readonly machine_down: NullType;
+                readonly quality_hold: NullType;
+            }>;
+            readonly alerted: StructType<{
+                readonly changes: StringType;
+                readonly severity: VariantType<{
+                    readonly low: NullType;
+                    readonly high: NullType;
+                }>;
+            }>;
+            readonly verified: NullType;
+        }>>;
+    }>>;
+}>;
+export declare const WorkStatus: StructType<{
+    readonly word: StringType;
+    readonly label: StringType;
+    readonly tone: VariantType<{
+        readonly success: NullType;
+        readonly warning: NullType;
+        readonly danger: NullType;
+        readonly info: NullType;
+        readonly neutral: NullType;
+    }>;
+}>;
+export declare const sheetWorkOrders: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly id: StringType;
+    readonly name: StringType;
+    readonly status: StringType;
+    readonly steps: ArrayType<StructType<{
+        readonly op: StringType;
+        readonly step: StringType;
+        readonly plan: IntegerType;
+        readonly good: OptionType<IntegerType>;
+        readonly done: OptionType<DateTimeType>;
+        readonly action: OptionType<VariantType<{
+            readonly started: NullType;
+            readonly completed: NullType;
+            readonly reported: IntegerType;
+            readonly held: VariantType<{
+                readonly awaiting_parts: NullType;
+                readonly machine_down: NullType;
+                readonly quality_hold: NullType;
+            }>;
+            readonly alerted: StructType<{
+                readonly changes: StringType;
+                readonly severity: VariantType<{
+                    readonly low: NullType;
+                    readonly high: NullType;
+                }>;
+            }>;
+            readonly verified: NullType;
+        }>>;
+    }>>;
+}>>, [variant<"field", "records">, variant<"field", "sheet_work_orders">], import("@elaraai/e3").IndexesOf<{
+    sheet_work_orders_by_status: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["status"], unknown>;
+}, DictType<StringType, StructType<{
+    readonly id: StringType;
+    readonly name: StringType;
+    readonly status: StringType;
+    readonly steps: ArrayType<StructType<{
+        readonly op: StringType;
+        readonly step: StringType;
+        readonly plan: IntegerType;
+        readonly good: OptionType<IntegerType>;
+        readonly done: OptionType<DateTimeType>;
+        readonly action: OptionType<VariantType<{
+            readonly started: NullType;
+            readonly completed: NullType;
+            readonly reported: IntegerType;
+            readonly held: VariantType<{
+                readonly awaiting_parts: NullType;
+                readonly machine_down: NullType;
+                readonly quality_hold: NullType;
+            }>;
+            readonly alerted: StructType<{
+                readonly changes: StringType;
+                readonly severity: VariantType<{
+                    readonly low: NullType;
+                    readonly high: NullType;
+                }>;
+            }>;
+            readonly verified: NullType;
+        }>>;
+    }>>;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly id: StringType;
+                readonly name: StringType;
+                readonly status: StringType;
+                readonly steps: ArrayType<StructType<{
+                    readonly op: StringType;
+                    readonly step: StringType;
+                    readonly plan: IntegerType;
+                    readonly good: OptionType<IntegerType>;
+                    readonly done: OptionType<DateTimeType>;
+                    readonly action: OptionType<VariantType<{
+                        readonly started: NullType;
+                        readonly completed: NullType;
+                        readonly reported: IntegerType;
+                        readonly held: VariantType<{
+                            readonly awaiting_parts: NullType;
+                            readonly machine_down: NullType;
+                            readonly quality_hold: NullType;
+                        }>;
+                        readonly alerted: StructType<{
+                            readonly changes: StringType;
+                            readonly severity: VariantType<{
+                                readonly low: NullType;
+                                readonly high: NullType;
+                            }>;
+                        }>;
+                        readonly verified: NullType;
+                    }>>;
+                }>>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly id: StringType;
+                readonly name: StringType;
+                readonly status: StringType;
+                readonly steps: ArrayType<StructType<{
+                    readonly op: StringType;
+                    readonly step: StringType;
+                    readonly plan: IntegerType;
+                    readonly good: OptionType<IntegerType>;
+                    readonly done: OptionType<DateTimeType>;
+                    readonly action: OptionType<VariantType<{
+                        readonly started: NullType;
+                        readonly completed: NullType;
+                        readonly reported: IntegerType;
+                        readonly held: VariantType<{
+                            readonly awaiting_parts: NullType;
+                            readonly machine_down: NullType;
+                            readonly quality_hold: NullType;
+                        }>;
+                        readonly alerted: StructType<{
+                            readonly changes: StringType;
+                            readonly severity: VariantType<{
+                                readonly low: NullType;
+                                readonly high: NullType;
+                            }>;
+                        }>;
+                        readonly verified: NullType;
+                    }>>;
+                }>>;
+            }>>;
+        }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly id: StringType;
+                readonly name: StringType;
+                readonly status: StringType;
+                readonly steps: ArrayType<StructType<{
+                    readonly op: StringType;
+                    readonly step: StringType;
+                    readonly plan: IntegerType;
+                    readonly good: OptionType<IntegerType>;
+                    readonly done: OptionType<DateTimeType>;
+                    readonly action: OptionType<VariantType<{
+                        readonly started: NullType;
+                        readonly completed: NullType;
+                        readonly reported: IntegerType;
+                        readonly held: VariantType<{
+                            readonly awaiting_parts: NullType;
+                            readonly machine_down: NullType;
+                            readonly quality_hold: NullType;
+                        }>;
+                        readonly alerted: StructType<{
+                            readonly changes: StringType;
+                            readonly severity: VariantType<{
+                                readonly low: NullType;
+                                readonly high: NullType;
+                            }>;
+                        }>;
+                        readonly verified: NullType;
+                    }>>;
+                }>>;
+            }>;
+            insert: StructType<{
+                readonly id: StringType;
+                readonly name: StringType;
+                readonly status: StringType;
+                readonly steps: ArrayType<StructType<{
+                    readonly op: StringType;
+                    readonly step: StringType;
+                    readonly plan: IntegerType;
+                    readonly good: OptionType<IntegerType>;
+                    readonly done: OptionType<DateTimeType>;
+                    readonly action: OptionType<VariantType<{
+                        readonly started: NullType;
+                        readonly completed: NullType;
+                        readonly reported: IntegerType;
+                        readonly held: VariantType<{
+                            readonly awaiting_parts: NullType;
+                            readonly machine_down: NullType;
+                            readonly quality_hold: NullType;
+                        }>;
+                        readonly alerted: StructType<{
+                            readonly changes: StringType;
+                            readonly severity: VariantType<{
+                                readonly low: NullType;
+                                readonly high: NullType;
+                            }>;
+                        }>;
+                        readonly verified: NullType;
+                    }>>;
+                }>>;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly id: StringType;
+                        readonly name: StringType;
+                        readonly status: StringType;
+                        readonly steps: ArrayType<StructType<{
+                            readonly op: StringType;
+                            readonly step: StringType;
+                            readonly plan: IntegerType;
+                            readonly good: OptionType<IntegerType>;
+                            readonly done: OptionType<DateTimeType>;
+                            readonly action: OptionType<VariantType<{
+                                readonly started: NullType;
+                                readonly completed: NullType;
+                                readonly reported: IntegerType;
+                                readonly held: VariantType<{
+                                    readonly awaiting_parts: NullType;
+                                    readonly machine_down: NullType;
+                                    readonly quality_hold: NullType;
+                                }>;
+                                readonly alerted: StructType<{
+                                    readonly changes: StringType;
+                                    readonly severity: VariantType<{
+                                        readonly low: NullType;
+                                        readonly high: NullType;
+                                    }>;
+                                }>;
+                                readonly verified: NullType;
+                            }>>;
+                        }>>;
+                    }>;
+                    after: StructType<{
+                        readonly id: StringType;
+                        readonly name: StringType;
+                        readonly status: StringType;
+                        readonly steps: ArrayType<StructType<{
+                            readonly op: StringType;
+                            readonly step: StringType;
+                            readonly plan: IntegerType;
+                            readonly good: OptionType<IntegerType>;
+                            readonly done: OptionType<DateTimeType>;
+                            readonly action: OptionType<VariantType<{
+                                readonly started: NullType;
+                                readonly completed: NullType;
+                                readonly reported: IntegerType;
+                                readonly held: VariantType<{
+                                    readonly awaiting_parts: NullType;
+                                    readonly machine_down: NullType;
+                                    readonly quality_hold: NullType;
+                                }>;
+                                readonly alerted: StructType<{
+                                    readonly changes: StringType;
+                                    readonly severity: VariantType<{
+                                        readonly low: NullType;
+                                        readonly high: NullType;
+                                    }>;
+                                }>;
+                                readonly verified: NullType;
+                            }>>;
+                        }>>;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly id: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly name: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly status: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly steps: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: ArrayType<StructType<{
+                                readonly op: StringType;
+                                readonly step: StringType;
+                                readonly plan: IntegerType;
+                                readonly good: OptionType<IntegerType>;
+                                readonly done: OptionType<DateTimeType>;
+                                readonly action: OptionType<VariantType<{
+                                    readonly started: NullType;
+                                    readonly completed: NullType;
+                                    readonly reported: IntegerType;
+                                    readonly held: VariantType<{
+                                        readonly awaiting_parts: NullType;
+                                        readonly machine_down: NullType;
+                                        readonly quality_hold: NullType;
+                                    }>;
+                                    readonly alerted: StructType<{
+                                        readonly changes: StringType;
+                                        readonly severity: VariantType<{
+                                            readonly low: NullType;
+                                            readonly high: NullType;
+                                        }>;
+                                    }>;
+                                    readonly verified: NullType;
+                                }>>;
+                            }>>;
+                            after: ArrayType<StructType<{
+                                readonly op: StringType;
+                                readonly step: StringType;
+                                readonly plan: IntegerType;
+                                readonly good: OptionType<IntegerType>;
+                                readonly done: OptionType<DateTimeType>;
+                                readonly action: OptionType<VariantType<{
+                                    readonly started: NullType;
+                                    readonly completed: NullType;
+                                    readonly reported: IntegerType;
+                                    readonly held: VariantType<{
+                                        readonly awaiting_parts: NullType;
+                                        readonly machine_down: NullType;
+                                        readonly quality_hold: NullType;
+                                    }>;
+                                    readonly alerted: StructType<{
+                                        readonly changes: StringType;
+                                        readonly severity: VariantType<{
+                                            readonly low: NullType;
+                                            readonly high: NullType;
+                                        }>;
+                                    }>;
+                                    readonly verified: NullType;
+                                }>>;
+                            }>>;
+                        }>;
+                        patch: ArrayType<StructType<{
+                            key: IntegerType;
+                            offset: IntegerType;
+                            operation: VariantType<{
+                                delete: StructType<{
+                                    readonly op: StringType;
+                                    readonly step: StringType;
+                                    readonly plan: IntegerType;
+                                    readonly good: OptionType<IntegerType>;
+                                    readonly done: OptionType<DateTimeType>;
+                                    readonly action: OptionType<VariantType<{
+                                        readonly started: NullType;
+                                        readonly completed: NullType;
+                                        readonly reported: IntegerType;
+                                        readonly held: VariantType<{
+                                            readonly awaiting_parts: NullType;
+                                            readonly machine_down: NullType;
+                                            readonly quality_hold: NullType;
+                                        }>;
+                                        readonly alerted: StructType<{
+                                            readonly changes: StringType;
+                                            readonly severity: VariantType<{
+                                                readonly low: NullType;
+                                                readonly high: NullType;
+                                            }>;
+                                        }>;
+                                        readonly verified: NullType;
+                                    }>>;
+                                }>;
+                                insert: StructType<{
+                                    readonly op: StringType;
+                                    readonly step: StringType;
+                                    readonly plan: IntegerType;
+                                    readonly good: OptionType<IntegerType>;
+                                    readonly done: OptionType<DateTimeType>;
+                                    readonly action: OptionType<VariantType<{
+                                        readonly started: NullType;
+                                        readonly completed: NullType;
+                                        readonly reported: IntegerType;
+                                        readonly held: VariantType<{
+                                            readonly awaiting_parts: NullType;
+                                            readonly machine_down: NullType;
+                                            readonly quality_hold: NullType;
+                                        }>;
+                                        readonly alerted: StructType<{
+                                            readonly changes: StringType;
+                                            readonly severity: VariantType<{
+                                                readonly low: NullType;
+                                                readonly high: NullType;
+                                            }>;
+                                        }>;
+                                        readonly verified: NullType;
+                                    }>>;
+                                }>;
+                                update: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: StructType<{
+                                            readonly op: StringType;
+                                            readonly step: StringType;
+                                            readonly plan: IntegerType;
+                                            readonly good: OptionType<IntegerType>;
+                                            readonly done: OptionType<DateTimeType>;
+                                            readonly action: OptionType<VariantType<{
+                                                readonly started: NullType;
+                                                readonly completed: NullType;
+                                                readonly reported: IntegerType;
+                                                readonly held: VariantType<{
+                                                    readonly awaiting_parts: NullType;
+                                                    readonly machine_down: NullType;
+                                                    readonly quality_hold: NullType;
+                                                }>;
+                                                readonly alerted: StructType<{
+                                                    readonly changes: StringType;
+                                                    readonly severity: VariantType<{
+                                                        readonly low: NullType;
+                                                        readonly high: NullType;
+                                                    }>;
+                                                }>;
+                                                readonly verified: NullType;
+                                            }>>;
+                                        }>;
+                                        after: StructType<{
+                                            readonly op: StringType;
+                                            readonly step: StringType;
+                                            readonly plan: IntegerType;
+                                            readonly good: OptionType<IntegerType>;
+                                            readonly done: OptionType<DateTimeType>;
+                                            readonly action: OptionType<VariantType<{
+                                                readonly started: NullType;
+                                                readonly completed: NullType;
+                                                readonly reported: IntegerType;
+                                                readonly held: VariantType<{
+                                                    readonly awaiting_parts: NullType;
+                                                    readonly machine_down: NullType;
+                                                    readonly quality_hold: NullType;
+                                                }>;
+                                                readonly alerted: StructType<{
+                                                    readonly changes: StringType;
+                                                    readonly severity: VariantType<{
+                                                        readonly low: NullType;
+                                                        readonly high: NullType;
+                                                    }>;
+                                                }>;
+                                                readonly verified: NullType;
+                                            }>>;
+                                        }>;
+                                    }>;
+                                    patch: StructType<{
+                                        readonly op: VariantType<{
+                                            unchanged: NullType;
+                                            replace: StructType<{
+                                                before: StringType;
+                                                after: StringType;
+                                            }>;
+                                        }>;
+                                        readonly step: VariantType<{
+                                            unchanged: NullType;
+                                            replace: StructType<{
+                                                before: StringType;
+                                                after: StringType;
+                                            }>;
+                                        }>;
+                                        readonly plan: VariantType<{
+                                            unchanged: NullType;
+                                            replace: StructType<{
+                                                before: IntegerType;
+                                                after: IntegerType;
+                                            }>;
+                                        }>;
+                                        readonly good: VariantType<{
+                                            unchanged: NullType;
+                                            replace: StructType<{
+                                                before: OptionType<IntegerType>;
+                                                after: OptionType<IntegerType>;
+                                            }>;
+                                            patch: VariantType<{
+                                                none: VariantType<{
+                                                    unchanged: NullType;
+                                                    replace: StructType<{
+                                                        before: NullType;
+                                                        after: NullType;
+                                                    }>;
+                                                }>;
+                                                some: VariantType<{
+                                                    unchanged: NullType;
+                                                    replace: StructType<{
+                                                        before: IntegerType;
+                                                        after: IntegerType;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                        }>;
+                                        readonly done: 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 action: VariantType<{
+                                            unchanged: NullType;
+                                            replace: StructType<{
+                                                before: OptionType<VariantType<{
+                                                    readonly started: NullType;
+                                                    readonly completed: NullType;
+                                                    readonly reported: IntegerType;
+                                                    readonly held: VariantType<{
+                                                        readonly awaiting_parts: NullType;
+                                                        readonly machine_down: NullType;
+                                                        readonly quality_hold: NullType;
+                                                    }>;
+                                                    readonly alerted: StructType<{
+                                                        readonly changes: StringType;
+                                                        readonly severity: VariantType<{
+                                                            readonly low: NullType;
+                                                            readonly high: NullType;
+                                                        }>;
+                                                    }>;
+                                                    readonly verified: NullType;
+                                                }>>;
+                                                after: OptionType<VariantType<{
+                                                    readonly started: NullType;
+                                                    readonly completed: NullType;
+                                                    readonly reported: IntegerType;
+                                                    readonly held: VariantType<{
+                                                        readonly awaiting_parts: NullType;
+                                                        readonly machine_down: NullType;
+                                                        readonly quality_hold: NullType;
+                                                    }>;
+                                                    readonly alerted: StructType<{
+                                                        readonly changes: StringType;
+                                                        readonly severity: VariantType<{
+                                                            readonly low: NullType;
+                                                            readonly high: NullType;
+                                                        }>;
+                                                    }>;
+                                                    readonly verified: NullType;
+                                                }>>;
+                                            }>;
+                                            patch: VariantType<{
+                                                none: VariantType<{
+                                                    unchanged: NullType;
+                                                    replace: StructType<{
+                                                        before: NullType;
+                                                        after: NullType;
+                                                    }>;
+                                                }>;
+                                                some: VariantType<{
+                                                    unchanged: NullType;
+                                                    replace: StructType<{
+                                                        before: VariantType<{
+                                                            readonly started: NullType;
+                                                            readonly completed: NullType;
+                                                            readonly reported: IntegerType;
+                                                            readonly held: VariantType<{
+                                                                readonly awaiting_parts: NullType;
+                                                                readonly machine_down: NullType;
+                                                                readonly quality_hold: NullType;
+                                                            }>;
+                                                            readonly alerted: StructType<{
+                                                                readonly changes: StringType;
+                                                                readonly severity: VariantType<{
+                                                                    readonly low: NullType;
+                                                                    readonly high: NullType;
+                                                                }>;
+                                                            }>;
+                                                            readonly verified: NullType;
+                                                        }>;
+                                                        after: VariantType<{
+                                                            readonly started: NullType;
+                                                            readonly completed: NullType;
+                                                            readonly reported: IntegerType;
+                                                            readonly held: VariantType<{
+                                                                readonly awaiting_parts: NullType;
+                                                                readonly machine_down: NullType;
+                                                                readonly quality_hold: NullType;
+                                                            }>;
+                                                            readonly alerted: StructType<{
+                                                                readonly changes: StringType;
+                                                                readonly severity: VariantType<{
+                                                                    readonly low: NullType;
+                                                                    readonly high: NullType;
+                                                                }>;
+                                                            }>;
+                                                            readonly verified: NullType;
+                                                        }>;
+                                                    }>;
+                                                    patch: VariantType<{
+                                                        readonly started: VariantType<{
+                                                            unchanged: NullType;
+                                                            replace: StructType<{
+                                                                before: NullType;
+                                                                after: NullType;
+                                                            }>;
+                                                        }>;
+                                                        readonly completed: VariantType<{
+                                                            unchanged: NullType;
+                                                            replace: StructType<{
+                                                                before: NullType;
+                                                                after: NullType;
+                                                            }>;
+                                                        }>;
+                                                        readonly reported: VariantType<{
+                                                            unchanged: NullType;
+                                                            replace: StructType<{
+                                                                before: IntegerType;
+                                                                after: IntegerType;
+                                                            }>;
+                                                        }>;
+                                                        readonly held: VariantType<{
+                                                            unchanged: NullType;
+                                                            replace: StructType<{
+                                                                before: VariantType<{
+                                                                    readonly awaiting_parts: NullType;
+                                                                    readonly machine_down: NullType;
+                                                                    readonly quality_hold: NullType;
+                                                                }>;
+                                                                after: VariantType<{
+                                                                    readonly awaiting_parts: NullType;
+                                                                    readonly machine_down: NullType;
+                                                                    readonly quality_hold: NullType;
+                                                                }>;
+                                                            }>;
+                                                            patch: VariantType<{
+                                                                readonly awaiting_parts: VariantType<{
+                                                                    unchanged: NullType;
+                                                                    replace: StructType<{
+                                                                        before: NullType;
+                                                                        after: NullType;
+                                                                    }>;
+                                                                }>;
+                                                                readonly machine_down: VariantType<{
+                                                                    unchanged: NullType;
+                                                                    replace: StructType<{
+                                                                        before: NullType;
+                                                                        after: NullType;
+                                                                    }>;
+                                                                }>;
+                                                                readonly quality_hold: VariantType<{
+                                                                    unchanged: NullType;
+                                                                    replace: StructType<{
+                                                                        before: NullType;
+                                                                        after: NullType;
+                                                                    }>;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                        readonly alerted: VariantType<{
+                                                            unchanged: NullType;
+                                                            replace: StructType<{
+                                                                before: StructType<{
+                                                                    readonly changes: StringType;
+                                                                    readonly severity: VariantType<{
+                                                                        readonly low: NullType;
+                                                                        readonly high: NullType;
+                                                                    }>;
+                                                                }>;
+                                                                after: StructType<{
+                                                                    readonly changes: StringType;
+                                                                    readonly severity: VariantType<{
+                                                                        readonly low: NullType;
+                                                                        readonly high: NullType;
+                                                                    }>;
+                                                                }>;
+                                                            }>;
+                                                            patch: StructType<{
+                                                                readonly changes: VariantType<{
+                                                                    unchanged: NullType;
+                                                                    replace: StructType<{
+                                                                        before: StringType;
+                                                                        after: StringType;
+                                                                    }>;
+                                                                }>;
+                                                                readonly severity: VariantType<{
+                                                                    unchanged: NullType;
+                                                                    replace: StructType<{
+                                                                        before: VariantType<{
+                                                                            readonly low: NullType;
+                                                                            readonly high: NullType;
+                                                                        }>;
+                                                                        after: VariantType<{
+                                                                            readonly low: NullType;
+                                                                            readonly high: NullType;
+                                                                        }>;
+                                                                    }>;
+                                                                    patch: VariantType<{
+                                                                        readonly low: VariantType<{
+                                                                            unchanged: NullType;
+                                                                            replace: StructType<{
+                                                                                before: NullType;
+                                                                                after: NullType;
+                                                                            }>;
+                                                                        }>;
+                                                                        readonly high: VariantType<{
+                                                                            unchanged: NullType;
+                                                                            replace: StructType<{
+                                                                                before: NullType;
+                                                                                after: NullType;
+                                                                            }>;
+                                                                        }>;
+                                                                    }>;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                        readonly verified: VariantType<{
+                                                            unchanged: NullType;
+                                                            replace: StructType<{
+                                                                before: NullType;
+                                                                after: NullType;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly id: StringType;
+    readonly name: StringType;
+    readonly status: StringType;
+    readonly steps: ArrayType<StructType<{
+        readonly op: StringType;
+        readonly step: StringType;
+        readonly plan: IntegerType;
+        readonly good: OptionType<IntegerType>;
+        readonly done: OptionType<DateTimeType>;
+        readonly action: OptionType<VariantType<{
+            readonly started: NullType;
+            readonly completed: NullType;
+            readonly reported: IntegerType;
+            readonly held: VariantType<{
+                readonly awaiting_parts: NullType;
+                readonly machine_down: NullType;
+                readonly quality_hold: NullType;
+            }>;
+            readonly alerted: StructType<{
+                readonly changes: StringType;
+                readonly severity: VariantType<{
+                    readonly low: NullType;
+                    readonly high: NullType;
+                }>;
+            }>;
+            readonly verified: NullType;
+        }>>;
+    }>>;
+}>>>>;
+export declare const sheetActionsWorkOrders: import("@elaraai/east").ExampleDef<[], any>;
+export declare const TicketAction: VariantType<{
+    readonly acknowledged: NullType;
+    readonly deferred: DateTimeType;
+    readonly handed_over: StringType;
+    readonly closed: NullType;
+}>;
+export declare const Ticket: StructType<{
+    readonly title: StringType;
+    readonly crew: StringType;
+    readonly due: OptionType<DateTimeType>;
+    readonly action: OptionType<VariantType<{
+        readonly acknowledged: NullType;
+        readonly deferred: DateTimeType;
+        readonly handed_over: StringType;
+        readonly closed: NullType;
+    }>>;
+}>;
+export declare const Crew: StructType<{
+    readonly name: StringType;
+}>;
+export declare const sheetTickets: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly crew: StringType;
+    readonly due: OptionType<DateTimeType>;
+    readonly action: OptionType<VariantType<{
+        readonly acknowledged: NullType;
+        readonly deferred: DateTimeType;
+        readonly handed_over: StringType;
+        readonly closed: NullType;
+    }>>;
+}>>, [variant<"field", "records">, variant<"field", "sheet_tickets">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly crew: StringType;
+    readonly due: OptionType<DateTimeType>;
+    readonly action: OptionType<VariantType<{
+        readonly acknowledged: NullType;
+        readonly deferred: DateTimeType;
+        readonly handed_over: StringType;
+        readonly closed: NullType;
+    }>>;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly title: StringType;
+                readonly crew: StringType;
+                readonly due: OptionType<DateTimeType>;
+                readonly action: OptionType<VariantType<{
+                    readonly acknowledged: NullType;
+                    readonly deferred: DateTimeType;
+                    readonly handed_over: StringType;
+                    readonly closed: NullType;
+                }>>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly title: StringType;
+                readonly crew: StringType;
+                readonly due: OptionType<DateTimeType>;
+                readonly action: OptionType<VariantType<{
+                    readonly acknowledged: NullType;
+                    readonly deferred: DateTimeType;
+                    readonly handed_over: StringType;
+                    readonly closed: NullType;
+                }>>;
+            }>>;
+        }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly title: StringType;
+                readonly crew: StringType;
+                readonly due: OptionType<DateTimeType>;
+                readonly action: OptionType<VariantType<{
+                    readonly acknowledged: NullType;
+                    readonly deferred: DateTimeType;
+                    readonly handed_over: StringType;
+                    readonly closed: NullType;
+                }>>;
+            }>;
+            insert: StructType<{
+                readonly title: StringType;
+                readonly crew: StringType;
+                readonly due: OptionType<DateTimeType>;
+                readonly action: OptionType<VariantType<{
+                    readonly acknowledged: NullType;
+                    readonly deferred: DateTimeType;
+                    readonly handed_over: StringType;
+                    readonly closed: NullType;
+                }>>;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly title: StringType;
+                        readonly crew: StringType;
+                        readonly due: OptionType<DateTimeType>;
+                        readonly action: OptionType<VariantType<{
+                            readonly acknowledged: NullType;
+                            readonly deferred: DateTimeType;
+                            readonly handed_over: StringType;
+                            readonly closed: NullType;
+                        }>>;
+                    }>;
+                    after: StructType<{
+                        readonly title: StringType;
+                        readonly crew: StringType;
+                        readonly due: OptionType<DateTimeType>;
+                        readonly action: OptionType<VariantType<{
+                            readonly acknowledged: NullType;
+                            readonly deferred: DateTimeType;
+                            readonly handed_over: StringType;
+                            readonly closed: NullType;
+                        }>>;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly title: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly crew: 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;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly action: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<VariantType<{
+                                readonly acknowledged: NullType;
+                                readonly deferred: DateTimeType;
+                                readonly handed_over: StringType;
+                                readonly closed: NullType;
+                            }>>;
+                            after: OptionType<VariantType<{
+                                readonly acknowledged: NullType;
+                                readonly deferred: DateTimeType;
+                                readonly handed_over: StringType;
+                                readonly closed: NullType;
+                            }>>;
+                        }>;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: VariantType<{
+                                        readonly acknowledged: NullType;
+                                        readonly deferred: DateTimeType;
+                                        readonly handed_over: StringType;
+                                        readonly closed: NullType;
+                                    }>;
+                                    after: VariantType<{
+                                        readonly acknowledged: NullType;
+                                        readonly deferred: DateTimeType;
+                                        readonly handed_over: StringType;
+                                        readonly closed: NullType;
+                                    }>;
+                                }>;
+                                patch: VariantType<{
+                                    readonly acknowledged: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: NullType;
+                                            after: NullType;
+                                        }>;
+                                    }>;
+                                    readonly deferred: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: DateTimeType;
+                                            after: DateTimeType;
+                                        }>;
+                                    }>;
+                                    readonly handed_over: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly closed: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: NullType;
+                                            after: NullType;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly title: StringType;
+    readonly crew: StringType;
+    readonly due: OptionType<DateTimeType>;
+    readonly action: OptionType<VariantType<{
+        readonly acknowledged: NullType;
+        readonly deferred: DateTimeType;
+        readonly handed_over: StringType;
+        readonly closed: NullType;
+    }>>;
+}>>>>;
+export declare const sheetCrews: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+}>>, [variant<"field", "records">, variant<"field", "sheet_crews">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+}>>>>;
+export declare const sheetActionsTickets: import("@elaraai/east").ExampleDef<[], any>;
+export declare const sheetActionsReadOnly: import("@elaraai/east").ExampleDef<[], any>;
+export declare const sheetActionsPhone: import("@elaraai/east").ExampleDef<[], any>;
+export declare const sheetActionsPinned: import("@elaraai/east").ExampleDef<[], any>;
+//# sourceMappingURL=sheet-actions.examples.d.ts.map