@elaraai/e3-ui 1.0.86 → 1.0.87

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

@@ -0,0 +1,3713 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/** @jsxImportSource @elaraai/e3-ui */
+import { ArrayType, DateTimeType, DictType, FloatType, IntegerType, NullType, OptionType, StringType, StructType, variant } from "@elaraai/east";
+export declare const depotFlows: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+    }>>;
+    readonly states: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+        readonly lane: StringType;
+        readonly members: OptionType<IntegerType>;
+        readonly notes: OptionType<StringType>;
+    }>>;
+    readonly links: ArrayType<StructType<{
+        readonly key: OptionType<StringType>;
+        readonly from: StringType;
+        readonly to: StringType;
+        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+            readonly planned: NullType;
+            readonly observed: NullType;
+        }>>;
+        readonly trigger: OptionType<StringType>;
+        readonly evidence: OptionType<StructType<{
+            readonly volume: OptionType<FloatType>;
+            readonly count: OptionType<IntegerType>;
+            readonly measuredAt: OptionType<DateTimeType>;
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly triggers: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly queue: OptionType<ArrayType<StringType>>;
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>>, [variant<"field", "records">, variant<"field", "flowchart_depot_flows">]>;
+export declare const depotFlowsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+    }>>;
+    readonly states: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+        readonly lane: StringType;
+        readonly members: OptionType<IntegerType>;
+        readonly notes: OptionType<StringType>;
+    }>>;
+    readonly links: ArrayType<StructType<{
+        readonly key: OptionType<StringType>;
+        readonly from: StringType;
+        readonly to: StringType;
+        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+            readonly planned: NullType;
+            readonly observed: NullType;
+        }>>;
+        readonly trigger: OptionType<StringType>;
+        readonly evidence: OptionType<StructType<{
+            readonly volume: OptionType<FloatType>;
+            readonly count: OptionType<IntegerType>;
+            readonly measuredAt: OptionType<DateTimeType>;
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly triggers: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly queue: OptionType<ArrayType<StringType>>;
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly description: OptionType<StringType>;
+            readonly lanes: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+            }>>;
+            readonly states: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+                readonly lane: StringType;
+                readonly members: OptionType<IntegerType>;
+                readonly notes: OptionType<StringType>;
+            }>>;
+            readonly links: ArrayType<StructType<{
+                readonly key: OptionType<StringType>;
+                readonly from: StringType;
+                readonly to: StringType;
+                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                    readonly planned: NullType;
+                    readonly observed: NullType;
+                }>>;
+                readonly trigger: OptionType<StringType>;
+                readonly evidence: OptionType<StructType<{
+                    readonly volume: OptionType<FloatType>;
+                    readonly count: OptionType<IntegerType>;
+                    readonly measuredAt: OptionType<DateTimeType>;
+                    readonly unit: OptionType<StringType>;
+                }>>;
+            }>>;
+            readonly triggers: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly letter: OptionType<StringType>;
+                readonly owner: OptionType<StringType>;
+                readonly queue: OptionType<ArrayType<StringType>>;
+                readonly outcomes: OptionType<StringType>;
+            }>>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly description: OptionType<StringType>;
+            readonly lanes: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+            }>>;
+            readonly states: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+                readonly lane: StringType;
+                readonly members: OptionType<IntegerType>;
+                readonly notes: OptionType<StringType>;
+            }>>;
+            readonly links: ArrayType<StructType<{
+                readonly key: OptionType<StringType>;
+                readonly from: StringType;
+                readonly to: StringType;
+                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                    readonly planned: NullType;
+                    readonly observed: NullType;
+                }>>;
+                readonly trigger: OptionType<StringType>;
+                readonly evidence: OptionType<StructType<{
+                    readonly volume: OptionType<FloatType>;
+                    readonly count: OptionType<IntegerType>;
+                    readonly measuredAt: OptionType<DateTimeType>;
+                    readonly unit: OptionType<StringType>;
+                }>>;
+            }>>;
+            readonly triggers: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly letter: OptionType<StringType>;
+                readonly owner: OptionType<StringType>;
+                readonly queue: OptionType<ArrayType<StringType>>;
+                readonly outcomes: OptionType<StringType>;
+            }>>;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly description: OptionType<StringType>;
+            readonly lanes: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+            }>>;
+            readonly states: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+                readonly lane: StringType;
+                readonly members: OptionType<IntegerType>;
+                readonly notes: OptionType<StringType>;
+            }>>;
+            readonly links: ArrayType<StructType<{
+                readonly key: OptionType<StringType>;
+                readonly from: StringType;
+                readonly to: StringType;
+                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                    readonly planned: NullType;
+                    readonly observed: NullType;
+                }>>;
+                readonly trigger: OptionType<StringType>;
+                readonly evidence: OptionType<StructType<{
+                    readonly volume: OptionType<FloatType>;
+                    readonly count: OptionType<IntegerType>;
+                    readonly measuredAt: OptionType<DateTimeType>;
+                    readonly unit: OptionType<StringType>;
+                }>>;
+            }>>;
+            readonly triggers: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly letter: OptionType<StringType>;
+                readonly owner: OptionType<StringType>;
+                readonly queue: OptionType<ArrayType<StringType>>;
+                readonly outcomes: OptionType<StringType>;
+            }>>;
+        }>;
+        insert: StructType<{
+            readonly description: OptionType<StringType>;
+            readonly lanes: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+            }>>;
+            readonly states: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+                readonly lane: StringType;
+                readonly members: OptionType<IntegerType>;
+                readonly notes: OptionType<StringType>;
+            }>>;
+            readonly links: ArrayType<StructType<{
+                readonly key: OptionType<StringType>;
+                readonly from: StringType;
+                readonly to: StringType;
+                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                    readonly planned: NullType;
+                    readonly observed: NullType;
+                }>>;
+                readonly trigger: OptionType<StringType>;
+                readonly evidence: OptionType<StructType<{
+                    readonly volume: OptionType<FloatType>;
+                    readonly count: OptionType<IntegerType>;
+                    readonly measuredAt: OptionType<DateTimeType>;
+                    readonly unit: OptionType<StringType>;
+                }>>;
+            }>>;
+            readonly triggers: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly letter: OptionType<StringType>;
+                readonly owner: OptionType<StringType>;
+                readonly queue: OptionType<ArrayType<StringType>>;
+                readonly outcomes: OptionType<StringType>;
+            }>>;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly description: OptionType<StringType>;
+                    readonly lanes: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: OptionType<StringType>;
+                    }>>;
+                    readonly states: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: OptionType<StringType>;
+                        readonly lane: StringType;
+                        readonly members: OptionType<IntegerType>;
+                        readonly notes: OptionType<StringType>;
+                    }>>;
+                    readonly links: ArrayType<StructType<{
+                        readonly key: OptionType<StringType>;
+                        readonly from: StringType;
+                        readonly to: StringType;
+                        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                            readonly planned: NullType;
+                            readonly observed: NullType;
+                        }>>;
+                        readonly trigger: OptionType<StringType>;
+                        readonly evidence: OptionType<StructType<{
+                            readonly volume: OptionType<FloatType>;
+                            readonly count: OptionType<IntegerType>;
+                            readonly measuredAt: OptionType<DateTimeType>;
+                            readonly unit: OptionType<StringType>;
+                        }>>;
+                    }>>;
+                    readonly triggers: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: StringType;
+                        readonly letter: OptionType<StringType>;
+                        readonly owner: OptionType<StringType>;
+                        readonly queue: OptionType<ArrayType<StringType>>;
+                        readonly outcomes: OptionType<StringType>;
+                    }>>;
+                }>;
+                after: StructType<{
+                    readonly description: OptionType<StringType>;
+                    readonly lanes: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: OptionType<StringType>;
+                    }>>;
+                    readonly states: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: OptionType<StringType>;
+                        readonly lane: StringType;
+                        readonly members: OptionType<IntegerType>;
+                        readonly notes: OptionType<StringType>;
+                    }>>;
+                    readonly links: ArrayType<StructType<{
+                        readonly key: OptionType<StringType>;
+                        readonly from: StringType;
+                        readonly to: StringType;
+                        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                            readonly planned: NullType;
+                            readonly observed: NullType;
+                        }>>;
+                        readonly trigger: OptionType<StringType>;
+                        readonly evidence: OptionType<StructType<{
+                            readonly volume: OptionType<FloatType>;
+                            readonly count: OptionType<IntegerType>;
+                            readonly measuredAt: OptionType<DateTimeType>;
+                            readonly unit: OptionType<StringType>;
+                        }>>;
+                    }>>;
+                    readonly triggers: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: StringType;
+                        readonly letter: OptionType<StringType>;
+                        readonly owner: OptionType<StringType>;
+                        readonly queue: OptionType<ArrayType<StringType>>;
+                        readonly outcomes: OptionType<StringType>;
+                    }>>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly description: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        none: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly lanes: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: OptionType<StringType>;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: OptionType<StringType>;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly key: StringType;
+                                readonly label: OptionType<StringType>;
+                            }>;
+                            insert: StructType<{
+                                readonly key: StringType;
+                                readonly label: OptionType<StringType>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: OptionType<StringType>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: OptionType<StringType>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly key: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly label: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly states: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: OptionType<StringType>;
+                            readonly lane: StringType;
+                            readonly members: OptionType<IntegerType>;
+                            readonly notes: OptionType<StringType>;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: OptionType<StringType>;
+                            readonly lane: StringType;
+                            readonly members: OptionType<IntegerType>;
+                            readonly notes: OptionType<StringType>;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly key: StringType;
+                                readonly label: OptionType<StringType>;
+                                readonly lane: StringType;
+                                readonly members: OptionType<IntegerType>;
+                                readonly notes: OptionType<StringType>;
+                            }>;
+                            insert: StructType<{
+                                readonly key: StringType;
+                                readonly label: OptionType<StringType>;
+                                readonly lane: StringType;
+                                readonly members: OptionType<IntegerType>;
+                                readonly notes: OptionType<StringType>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: OptionType<StringType>;
+                                        readonly lane: StringType;
+                                        readonly members: OptionType<IntegerType>;
+                                        readonly notes: OptionType<StringType>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: OptionType<StringType>;
+                                        readonly lane: StringType;
+                                        readonly members: OptionType<IntegerType>;
+                                        readonly notes: OptionType<StringType>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly key: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly label: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly lane: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly members: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<IntegerType>;
+                                            after: OptionType<IntegerType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: IntegerType;
+                                                    after: IntegerType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly notes: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly links: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly key: OptionType<StringType>;
+                            readonly from: StringType;
+                            readonly to: StringType;
+                            readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                readonly planned: NullType;
+                                readonly observed: NullType;
+                            }>>;
+                            readonly trigger: OptionType<StringType>;
+                            readonly evidence: OptionType<StructType<{
+                                readonly volume: OptionType<FloatType>;
+                                readonly count: OptionType<IntegerType>;
+                                readonly measuredAt: OptionType<DateTimeType>;
+                                readonly unit: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly key: OptionType<StringType>;
+                            readonly from: StringType;
+                            readonly to: StringType;
+                            readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                readonly planned: NullType;
+                                readonly observed: NullType;
+                            }>>;
+                            readonly trigger: OptionType<StringType>;
+                            readonly evidence: OptionType<StructType<{
+                                readonly volume: OptionType<FloatType>;
+                                readonly count: OptionType<IntegerType>;
+                                readonly measuredAt: OptionType<DateTimeType>;
+                                readonly unit: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly key: OptionType<StringType>;
+                                readonly from: StringType;
+                                readonly to: StringType;
+                                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                    readonly planned: NullType;
+                                    readonly observed: NullType;
+                                }>>;
+                                readonly trigger: OptionType<StringType>;
+                                readonly evidence: OptionType<StructType<{
+                                    readonly volume: OptionType<FloatType>;
+                                    readonly count: OptionType<IntegerType>;
+                                    readonly measuredAt: OptionType<DateTimeType>;
+                                    readonly unit: OptionType<StringType>;
+                                }>>;
+                            }>;
+                            insert: StructType<{
+                                readonly key: OptionType<StringType>;
+                                readonly from: StringType;
+                                readonly to: StringType;
+                                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                    readonly planned: NullType;
+                                    readonly observed: NullType;
+                                }>>;
+                                readonly trigger: OptionType<StringType>;
+                                readonly evidence: OptionType<StructType<{
+                                    readonly volume: OptionType<FloatType>;
+                                    readonly count: OptionType<IntegerType>;
+                                    readonly measuredAt: OptionType<DateTimeType>;
+                                    readonly unit: OptionType<StringType>;
+                                }>>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly key: OptionType<StringType>;
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                            readonly planned: NullType;
+                                            readonly observed: NullType;
+                                        }>>;
+                                        readonly trigger: OptionType<StringType>;
+                                        readonly evidence: OptionType<StructType<{
+                                            readonly volume: OptionType<FloatType>;
+                                            readonly count: OptionType<IntegerType>;
+                                            readonly measuredAt: OptionType<DateTimeType>;
+                                            readonly unit: OptionType<StringType>;
+                                        }>>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly key: OptionType<StringType>;
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                            readonly planned: NullType;
+                                            readonly observed: NullType;
+                                        }>>;
+                                        readonly trigger: OptionType<StringType>;
+                                        readonly evidence: OptionType<StructType<{
+                                            readonly volume: OptionType<FloatType>;
+                                            readonly count: OptionType<IntegerType>;
+                                            readonly measuredAt: OptionType<DateTimeType>;
+                                            readonly unit: OptionType<StringType>;
+                                        }>>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly key: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly from: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly to: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly kind: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<import("@elaraai/east").VariantType<{
+                                                readonly planned: NullType;
+                                                readonly observed: NullType;
+                                            }>>;
+                                            after: OptionType<import("@elaraai/east").VariantType<{
+                                                readonly planned: NullType;
+                                                readonly observed: NullType;
+                                            }>>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: import("@elaraai/east").VariantType<{
+                                                        readonly planned: NullType;
+                                                        readonly observed: NullType;
+                                                    }>;
+                                                    after: import("@elaraai/east").VariantType<{
+                                                        readonly planned: NullType;
+                                                        readonly observed: NullType;
+                                                    }>;
+                                                }>;
+                                                patch: import("@elaraai/east").VariantType<{
+                                                    readonly planned: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: NullType;
+                                                            after: NullType;
+                                                        }>;
+                                                    }>;
+                                                    readonly observed: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: NullType;
+                                                            after: NullType;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly trigger: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly evidence: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StructType<{
+                                                readonly volume: OptionType<FloatType>;
+                                                readonly count: OptionType<IntegerType>;
+                                                readonly measuredAt: OptionType<DateTimeType>;
+                                                readonly unit: OptionType<StringType>;
+                                            }>>;
+                                            after: OptionType<StructType<{
+                                                readonly volume: OptionType<FloatType>;
+                                                readonly count: OptionType<IntegerType>;
+                                                readonly measuredAt: OptionType<DateTimeType>;
+                                                readonly unit: OptionType<StringType>;
+                                            }>>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StructType<{
+                                                        readonly volume: OptionType<FloatType>;
+                                                        readonly count: OptionType<IntegerType>;
+                                                        readonly measuredAt: OptionType<DateTimeType>;
+                                                        readonly unit: OptionType<StringType>;
+                                                    }>;
+                                                    after: StructType<{
+                                                        readonly volume: OptionType<FloatType>;
+                                                        readonly count: OptionType<IntegerType>;
+                                                        readonly measuredAt: OptionType<DateTimeType>;
+                                                        readonly unit: OptionType<StringType>;
+                                                    }>;
+                                                }>;
+                                                patch: StructType<{
+                                                    readonly volume: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: OptionType<FloatType>;
+                                                            after: OptionType<FloatType>;
+                                                        }>;
+                                                        patch: import("@elaraai/east").VariantType<{
+                                                            none: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: NullType;
+                                                                    after: NullType;
+                                                                }>;
+                                                            }>;
+                                                            some: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: FloatType;
+                                                                    after: FloatType;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                    readonly count: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: OptionType<IntegerType>;
+                                                            after: OptionType<IntegerType>;
+                                                        }>;
+                                                        patch: import("@elaraai/east").VariantType<{
+                                                            none: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: NullType;
+                                                                    after: NullType;
+                                                                }>;
+                                                            }>;
+                                                            some: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: IntegerType;
+                                                                    after: IntegerType;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                    readonly measuredAt: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: OptionType<DateTimeType>;
+                                                            after: OptionType<DateTimeType>;
+                                                        }>;
+                                                        patch: import("@elaraai/east").VariantType<{
+                                                            none: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: NullType;
+                                                                    after: NullType;
+                                                                }>;
+                                                            }>;
+                                                            some: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: DateTimeType;
+                                                                    after: DateTimeType;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                    readonly unit: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: OptionType<StringType>;
+                                                            after: OptionType<StringType>;
+                                                        }>;
+                                                        patch: import("@elaraai/east").VariantType<{
+                                                            none: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: NullType;
+                                                                    after: NullType;
+                                                                }>;
+                                                            }>;
+                                                            some: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: StringType;
+                                                                    after: StringType;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly triggers: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: StringType;
+                            readonly letter: OptionType<StringType>;
+                            readonly owner: OptionType<StringType>;
+                            readonly queue: OptionType<ArrayType<StringType>>;
+                            readonly outcomes: OptionType<StringType>;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: StringType;
+                            readonly letter: OptionType<StringType>;
+                            readonly owner: OptionType<StringType>;
+                            readonly queue: OptionType<ArrayType<StringType>>;
+                            readonly outcomes: OptionType<StringType>;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly key: StringType;
+                                readonly label: StringType;
+                                readonly letter: OptionType<StringType>;
+                                readonly owner: OptionType<StringType>;
+                                readonly queue: OptionType<ArrayType<StringType>>;
+                                readonly outcomes: OptionType<StringType>;
+                            }>;
+                            insert: StructType<{
+                                readonly key: StringType;
+                                readonly label: StringType;
+                                readonly letter: OptionType<StringType>;
+                                readonly owner: OptionType<StringType>;
+                                readonly queue: OptionType<ArrayType<StringType>>;
+                                readonly outcomes: OptionType<StringType>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: StringType;
+                                        readonly letter: OptionType<StringType>;
+                                        readonly owner: OptionType<StringType>;
+                                        readonly queue: OptionType<ArrayType<StringType>>;
+                                        readonly outcomes: OptionType<StringType>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: StringType;
+                                        readonly letter: OptionType<StringType>;
+                                        readonly owner: OptionType<StringType>;
+                                        readonly queue: OptionType<ArrayType<StringType>>;
+                                        readonly outcomes: OptionType<StringType>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly key: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly label: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly letter: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly owner: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly queue: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<ArrayType<StringType>>;
+                                            after: OptionType<ArrayType<StringType>>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: ArrayType<StringType>;
+                                                    after: ArrayType<StringType>;
+                                                }>;
+                                                patch: ArrayType<StructType<{
+                                                    key: IntegerType;
+                                                    offset: IntegerType;
+                                                    operation: import("@elaraai/east").VariantType<{
+                                                        delete: StringType;
+                                                        insert: StringType;
+                                                        update: import("@elaraai/east").VariantType<{
+                                                            unchanged: NullType;
+                                                            replace: StructType<{
+                                                                before: StringType;
+                                                                after: StringType;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                }>>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly outcomes: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+export declare const collectionFlows: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+    }>>;
+    readonly states: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+        readonly lane: StringType;
+        readonly members: OptionType<IntegerType>;
+        readonly notes: OptionType<StringType>;
+    }>>;
+    readonly links: ArrayType<StructType<{
+        readonly key: OptionType<StringType>;
+        readonly from: StringType;
+        readonly to: StringType;
+        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+            readonly planned: NullType;
+            readonly observed: NullType;
+        }>>;
+        readonly trigger: OptionType<StringType>;
+        readonly evidence: OptionType<StructType<{
+            readonly volume: OptionType<FloatType>;
+            readonly count: OptionType<IntegerType>;
+            readonly measuredAt: OptionType<DateTimeType>;
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly triggers: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly queue: OptionType<ArrayType<StringType>>;
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>>, [variant<"field", "records">, variant<"field", "flowchart_collection_flows">]>;
+export declare const collectionFlowsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+    }>>;
+    readonly states: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+        readonly lane: StringType;
+        readonly members: OptionType<IntegerType>;
+        readonly notes: OptionType<StringType>;
+    }>>;
+    readonly links: ArrayType<StructType<{
+        readonly key: OptionType<StringType>;
+        readonly from: StringType;
+        readonly to: StringType;
+        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+            readonly planned: NullType;
+            readonly observed: NullType;
+        }>>;
+        readonly trigger: OptionType<StringType>;
+        readonly evidence: OptionType<StructType<{
+            readonly volume: OptionType<FloatType>;
+            readonly count: OptionType<IntegerType>;
+            readonly measuredAt: OptionType<DateTimeType>;
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly triggers: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly queue: OptionType<ArrayType<StringType>>;
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly description: OptionType<StringType>;
+            readonly lanes: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+            }>>;
+            readonly states: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+                readonly lane: StringType;
+                readonly members: OptionType<IntegerType>;
+                readonly notes: OptionType<StringType>;
+            }>>;
+            readonly links: ArrayType<StructType<{
+                readonly key: OptionType<StringType>;
+                readonly from: StringType;
+                readonly to: StringType;
+                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                    readonly planned: NullType;
+                    readonly observed: NullType;
+                }>>;
+                readonly trigger: OptionType<StringType>;
+                readonly evidence: OptionType<StructType<{
+                    readonly volume: OptionType<FloatType>;
+                    readonly count: OptionType<IntegerType>;
+                    readonly measuredAt: OptionType<DateTimeType>;
+                    readonly unit: OptionType<StringType>;
+                }>>;
+            }>>;
+            readonly triggers: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly letter: OptionType<StringType>;
+                readonly owner: OptionType<StringType>;
+                readonly queue: OptionType<ArrayType<StringType>>;
+                readonly outcomes: OptionType<StringType>;
+            }>>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly description: OptionType<StringType>;
+            readonly lanes: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+            }>>;
+            readonly states: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+                readonly lane: StringType;
+                readonly members: OptionType<IntegerType>;
+                readonly notes: OptionType<StringType>;
+            }>>;
+            readonly links: ArrayType<StructType<{
+                readonly key: OptionType<StringType>;
+                readonly from: StringType;
+                readonly to: StringType;
+                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                    readonly planned: NullType;
+                    readonly observed: NullType;
+                }>>;
+                readonly trigger: OptionType<StringType>;
+                readonly evidence: OptionType<StructType<{
+                    readonly volume: OptionType<FloatType>;
+                    readonly count: OptionType<IntegerType>;
+                    readonly measuredAt: OptionType<DateTimeType>;
+                    readonly unit: OptionType<StringType>;
+                }>>;
+            }>>;
+            readonly triggers: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly letter: OptionType<StringType>;
+                readonly owner: OptionType<StringType>;
+                readonly queue: OptionType<ArrayType<StringType>>;
+                readonly outcomes: OptionType<StringType>;
+            }>>;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly description: OptionType<StringType>;
+            readonly lanes: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+            }>>;
+            readonly states: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+                readonly lane: StringType;
+                readonly members: OptionType<IntegerType>;
+                readonly notes: OptionType<StringType>;
+            }>>;
+            readonly links: ArrayType<StructType<{
+                readonly key: OptionType<StringType>;
+                readonly from: StringType;
+                readonly to: StringType;
+                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                    readonly planned: NullType;
+                    readonly observed: NullType;
+                }>>;
+                readonly trigger: OptionType<StringType>;
+                readonly evidence: OptionType<StructType<{
+                    readonly volume: OptionType<FloatType>;
+                    readonly count: OptionType<IntegerType>;
+                    readonly measuredAt: OptionType<DateTimeType>;
+                    readonly unit: OptionType<StringType>;
+                }>>;
+            }>>;
+            readonly triggers: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly letter: OptionType<StringType>;
+                readonly owner: OptionType<StringType>;
+                readonly queue: OptionType<ArrayType<StringType>>;
+                readonly outcomes: OptionType<StringType>;
+            }>>;
+        }>;
+        insert: StructType<{
+            readonly description: OptionType<StringType>;
+            readonly lanes: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+            }>>;
+            readonly states: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+                readonly lane: StringType;
+                readonly members: OptionType<IntegerType>;
+                readonly notes: OptionType<StringType>;
+            }>>;
+            readonly links: ArrayType<StructType<{
+                readonly key: OptionType<StringType>;
+                readonly from: StringType;
+                readonly to: StringType;
+                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                    readonly planned: NullType;
+                    readonly observed: NullType;
+                }>>;
+                readonly trigger: OptionType<StringType>;
+                readonly evidence: OptionType<StructType<{
+                    readonly volume: OptionType<FloatType>;
+                    readonly count: OptionType<IntegerType>;
+                    readonly measuredAt: OptionType<DateTimeType>;
+                    readonly unit: OptionType<StringType>;
+                }>>;
+            }>>;
+            readonly triggers: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly letter: OptionType<StringType>;
+                readonly owner: OptionType<StringType>;
+                readonly queue: OptionType<ArrayType<StringType>>;
+                readonly outcomes: OptionType<StringType>;
+            }>>;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly description: OptionType<StringType>;
+                    readonly lanes: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: OptionType<StringType>;
+                    }>>;
+                    readonly states: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: OptionType<StringType>;
+                        readonly lane: StringType;
+                        readonly members: OptionType<IntegerType>;
+                        readonly notes: OptionType<StringType>;
+                    }>>;
+                    readonly links: ArrayType<StructType<{
+                        readonly key: OptionType<StringType>;
+                        readonly from: StringType;
+                        readonly to: StringType;
+                        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                            readonly planned: NullType;
+                            readonly observed: NullType;
+                        }>>;
+                        readonly trigger: OptionType<StringType>;
+                        readonly evidence: OptionType<StructType<{
+                            readonly volume: OptionType<FloatType>;
+                            readonly count: OptionType<IntegerType>;
+                            readonly measuredAt: OptionType<DateTimeType>;
+                            readonly unit: OptionType<StringType>;
+                        }>>;
+                    }>>;
+                    readonly triggers: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: StringType;
+                        readonly letter: OptionType<StringType>;
+                        readonly owner: OptionType<StringType>;
+                        readonly queue: OptionType<ArrayType<StringType>>;
+                        readonly outcomes: OptionType<StringType>;
+                    }>>;
+                }>;
+                after: StructType<{
+                    readonly description: OptionType<StringType>;
+                    readonly lanes: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: OptionType<StringType>;
+                    }>>;
+                    readonly states: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: OptionType<StringType>;
+                        readonly lane: StringType;
+                        readonly members: OptionType<IntegerType>;
+                        readonly notes: OptionType<StringType>;
+                    }>>;
+                    readonly links: ArrayType<StructType<{
+                        readonly key: OptionType<StringType>;
+                        readonly from: StringType;
+                        readonly to: StringType;
+                        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                            readonly planned: NullType;
+                            readonly observed: NullType;
+                        }>>;
+                        readonly trigger: OptionType<StringType>;
+                        readonly evidence: OptionType<StructType<{
+                            readonly volume: OptionType<FloatType>;
+                            readonly count: OptionType<IntegerType>;
+                            readonly measuredAt: OptionType<DateTimeType>;
+                            readonly unit: OptionType<StringType>;
+                        }>>;
+                    }>>;
+                    readonly triggers: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: StringType;
+                        readonly letter: OptionType<StringType>;
+                        readonly owner: OptionType<StringType>;
+                        readonly queue: OptionType<ArrayType<StringType>>;
+                        readonly outcomes: OptionType<StringType>;
+                    }>>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly description: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        none: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly lanes: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: OptionType<StringType>;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: OptionType<StringType>;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly key: StringType;
+                                readonly label: OptionType<StringType>;
+                            }>;
+                            insert: StructType<{
+                                readonly key: StringType;
+                                readonly label: OptionType<StringType>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: OptionType<StringType>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: OptionType<StringType>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly key: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly label: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly states: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: OptionType<StringType>;
+                            readonly lane: StringType;
+                            readonly members: OptionType<IntegerType>;
+                            readonly notes: OptionType<StringType>;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: OptionType<StringType>;
+                            readonly lane: StringType;
+                            readonly members: OptionType<IntegerType>;
+                            readonly notes: OptionType<StringType>;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly key: StringType;
+                                readonly label: OptionType<StringType>;
+                                readonly lane: StringType;
+                                readonly members: OptionType<IntegerType>;
+                                readonly notes: OptionType<StringType>;
+                            }>;
+                            insert: StructType<{
+                                readonly key: StringType;
+                                readonly label: OptionType<StringType>;
+                                readonly lane: StringType;
+                                readonly members: OptionType<IntegerType>;
+                                readonly notes: OptionType<StringType>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: OptionType<StringType>;
+                                        readonly lane: StringType;
+                                        readonly members: OptionType<IntegerType>;
+                                        readonly notes: OptionType<StringType>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: OptionType<StringType>;
+                                        readonly lane: StringType;
+                                        readonly members: OptionType<IntegerType>;
+                                        readonly notes: OptionType<StringType>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly key: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly label: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly lane: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly members: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<IntegerType>;
+                                            after: OptionType<IntegerType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: IntegerType;
+                                                    after: IntegerType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly notes: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly links: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly key: OptionType<StringType>;
+                            readonly from: StringType;
+                            readonly to: StringType;
+                            readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                readonly planned: NullType;
+                                readonly observed: NullType;
+                            }>>;
+                            readonly trigger: OptionType<StringType>;
+                            readonly evidence: OptionType<StructType<{
+                                readonly volume: OptionType<FloatType>;
+                                readonly count: OptionType<IntegerType>;
+                                readonly measuredAt: OptionType<DateTimeType>;
+                                readonly unit: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly key: OptionType<StringType>;
+                            readonly from: StringType;
+                            readonly to: StringType;
+                            readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                readonly planned: NullType;
+                                readonly observed: NullType;
+                            }>>;
+                            readonly trigger: OptionType<StringType>;
+                            readonly evidence: OptionType<StructType<{
+                                readonly volume: OptionType<FloatType>;
+                                readonly count: OptionType<IntegerType>;
+                                readonly measuredAt: OptionType<DateTimeType>;
+                                readonly unit: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly key: OptionType<StringType>;
+                                readonly from: StringType;
+                                readonly to: StringType;
+                                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                    readonly planned: NullType;
+                                    readonly observed: NullType;
+                                }>>;
+                                readonly trigger: OptionType<StringType>;
+                                readonly evidence: OptionType<StructType<{
+                                    readonly volume: OptionType<FloatType>;
+                                    readonly count: OptionType<IntegerType>;
+                                    readonly measuredAt: OptionType<DateTimeType>;
+                                    readonly unit: OptionType<StringType>;
+                                }>>;
+                            }>;
+                            insert: StructType<{
+                                readonly key: OptionType<StringType>;
+                                readonly from: StringType;
+                                readonly to: StringType;
+                                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                    readonly planned: NullType;
+                                    readonly observed: NullType;
+                                }>>;
+                                readonly trigger: OptionType<StringType>;
+                                readonly evidence: OptionType<StructType<{
+                                    readonly volume: OptionType<FloatType>;
+                                    readonly count: OptionType<IntegerType>;
+                                    readonly measuredAt: OptionType<DateTimeType>;
+                                    readonly unit: OptionType<StringType>;
+                                }>>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly key: OptionType<StringType>;
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                            readonly planned: NullType;
+                                            readonly observed: NullType;
+                                        }>>;
+                                        readonly trigger: OptionType<StringType>;
+                                        readonly evidence: OptionType<StructType<{
+                                            readonly volume: OptionType<FloatType>;
+                                            readonly count: OptionType<IntegerType>;
+                                            readonly measuredAt: OptionType<DateTimeType>;
+                                            readonly unit: OptionType<StringType>;
+                                        }>>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly key: OptionType<StringType>;
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                            readonly planned: NullType;
+                                            readonly observed: NullType;
+                                        }>>;
+                                        readonly trigger: OptionType<StringType>;
+                                        readonly evidence: OptionType<StructType<{
+                                            readonly volume: OptionType<FloatType>;
+                                            readonly count: OptionType<IntegerType>;
+                                            readonly measuredAt: OptionType<DateTimeType>;
+                                            readonly unit: OptionType<StringType>;
+                                        }>>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly key: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly from: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly to: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly kind: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<import("@elaraai/east").VariantType<{
+                                                readonly planned: NullType;
+                                                readonly observed: NullType;
+                                            }>>;
+                                            after: OptionType<import("@elaraai/east").VariantType<{
+                                                readonly planned: NullType;
+                                                readonly observed: NullType;
+                                            }>>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: import("@elaraai/east").VariantType<{
+                                                        readonly planned: NullType;
+                                                        readonly observed: NullType;
+                                                    }>;
+                                                    after: import("@elaraai/east").VariantType<{
+                                                        readonly planned: NullType;
+                                                        readonly observed: NullType;
+                                                    }>;
+                                                }>;
+                                                patch: import("@elaraai/east").VariantType<{
+                                                    readonly planned: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: NullType;
+                                                            after: NullType;
+                                                        }>;
+                                                    }>;
+                                                    readonly observed: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: NullType;
+                                                            after: NullType;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly trigger: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly evidence: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StructType<{
+                                                readonly volume: OptionType<FloatType>;
+                                                readonly count: OptionType<IntegerType>;
+                                                readonly measuredAt: OptionType<DateTimeType>;
+                                                readonly unit: OptionType<StringType>;
+                                            }>>;
+                                            after: OptionType<StructType<{
+                                                readonly volume: OptionType<FloatType>;
+                                                readonly count: OptionType<IntegerType>;
+                                                readonly measuredAt: OptionType<DateTimeType>;
+                                                readonly unit: OptionType<StringType>;
+                                            }>>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StructType<{
+                                                        readonly volume: OptionType<FloatType>;
+                                                        readonly count: OptionType<IntegerType>;
+                                                        readonly measuredAt: OptionType<DateTimeType>;
+                                                        readonly unit: OptionType<StringType>;
+                                                    }>;
+                                                    after: StructType<{
+                                                        readonly volume: OptionType<FloatType>;
+                                                        readonly count: OptionType<IntegerType>;
+                                                        readonly measuredAt: OptionType<DateTimeType>;
+                                                        readonly unit: OptionType<StringType>;
+                                                    }>;
+                                                }>;
+                                                patch: StructType<{
+                                                    readonly volume: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: OptionType<FloatType>;
+                                                            after: OptionType<FloatType>;
+                                                        }>;
+                                                        patch: import("@elaraai/east").VariantType<{
+                                                            none: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: NullType;
+                                                                    after: NullType;
+                                                                }>;
+                                                            }>;
+                                                            some: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: FloatType;
+                                                                    after: FloatType;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                    readonly count: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: OptionType<IntegerType>;
+                                                            after: OptionType<IntegerType>;
+                                                        }>;
+                                                        patch: import("@elaraai/east").VariantType<{
+                                                            none: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: NullType;
+                                                                    after: NullType;
+                                                                }>;
+                                                            }>;
+                                                            some: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: IntegerType;
+                                                                    after: IntegerType;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                    readonly measuredAt: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: OptionType<DateTimeType>;
+                                                            after: OptionType<DateTimeType>;
+                                                        }>;
+                                                        patch: import("@elaraai/east").VariantType<{
+                                                            none: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: NullType;
+                                                                    after: NullType;
+                                                                }>;
+                                                            }>;
+                                                            some: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: DateTimeType;
+                                                                    after: DateTimeType;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                    readonly unit: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: OptionType<StringType>;
+                                                            after: OptionType<StringType>;
+                                                        }>;
+                                                        patch: import("@elaraai/east").VariantType<{
+                                                            none: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: NullType;
+                                                                    after: NullType;
+                                                                }>;
+                                                            }>;
+                                                            some: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: StringType;
+                                                                    after: StringType;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly triggers: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: StringType;
+                            readonly letter: OptionType<StringType>;
+                            readonly owner: OptionType<StringType>;
+                            readonly queue: OptionType<ArrayType<StringType>>;
+                            readonly outcomes: OptionType<StringType>;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: StringType;
+                            readonly letter: OptionType<StringType>;
+                            readonly owner: OptionType<StringType>;
+                            readonly queue: OptionType<ArrayType<StringType>>;
+                            readonly outcomes: OptionType<StringType>;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly key: StringType;
+                                readonly label: StringType;
+                                readonly letter: OptionType<StringType>;
+                                readonly owner: OptionType<StringType>;
+                                readonly queue: OptionType<ArrayType<StringType>>;
+                                readonly outcomes: OptionType<StringType>;
+                            }>;
+                            insert: StructType<{
+                                readonly key: StringType;
+                                readonly label: StringType;
+                                readonly letter: OptionType<StringType>;
+                                readonly owner: OptionType<StringType>;
+                                readonly queue: OptionType<ArrayType<StringType>>;
+                                readonly outcomes: OptionType<StringType>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: StringType;
+                                        readonly letter: OptionType<StringType>;
+                                        readonly owner: OptionType<StringType>;
+                                        readonly queue: OptionType<ArrayType<StringType>>;
+                                        readonly outcomes: OptionType<StringType>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: StringType;
+                                        readonly letter: OptionType<StringType>;
+                                        readonly owner: OptionType<StringType>;
+                                        readonly queue: OptionType<ArrayType<StringType>>;
+                                        readonly outcomes: OptionType<StringType>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly key: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly label: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly letter: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly owner: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly queue: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<ArrayType<StringType>>;
+                                            after: OptionType<ArrayType<StringType>>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: ArrayType<StringType>;
+                                                    after: ArrayType<StringType>;
+                                                }>;
+                                                patch: ArrayType<StructType<{
+                                                    key: IntegerType;
+                                                    offset: IntegerType;
+                                                    operation: import("@elaraai/east").VariantType<{
+                                                        delete: StringType;
+                                                        insert: StringType;
+                                                        update: import("@elaraai/east").VariantType<{
+                                                            unchanged: NullType;
+                                                            replace: StructType<{
+                                                                before: StringType;
+                                                                after: StringType;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                }>>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly outcomes: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+export declare const handoverFlow: import("@elaraai/e3").DatasetDef<StructType<{
+    readonly description: OptionType<StringType>;
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+    }>>;
+    readonly states: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+        readonly lane: StringType;
+        readonly members: OptionType<IntegerType>;
+        readonly notes: OptionType<StringType>;
+    }>>;
+    readonly links: ArrayType<StructType<{
+        readonly key: OptionType<StringType>;
+        readonly from: StringType;
+        readonly to: StringType;
+        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+            readonly planned: NullType;
+            readonly observed: NullType;
+        }>>;
+        readonly trigger: OptionType<StringType>;
+        readonly evidence: OptionType<StructType<{
+            readonly volume: OptionType<FloatType>;
+            readonly count: OptionType<IntegerType>;
+            readonly measuredAt: OptionType<DateTimeType>;
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly triggers: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly queue: OptionType<ArrayType<StringType>>;
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>, [variant<"field", "inputs">, variant<"field", "flowchart_handover">]>;
+export declare const StepTemplate: StructType<{
+    readonly code: StringType;
+    readonly name: StringType;
+    readonly kind: StringType;
+    readonly slots: OptionType<IntegerType>;
+}>;
+export declare const stepTemplates: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
+    readonly code: StringType;
+    readonly name: StringType;
+    readonly kind: StringType;
+    readonly slots: OptionType<IntegerType>;
+}>>, [variant<"field", "inputs">, variant<"field", "flowchart_step_templates">]>;
+export declare const MoveTemplate: StructType<{
+    readonly kind: import("@elaraai/east").VariantType<{
+        readonly planned: NullType;
+        readonly observed: NullType;
+    }>;
+    readonly decision: OptionType<StringType>;
+    readonly note: StringType;
+}>;
+export declare const moveTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly kind: import("@elaraai/east").VariantType<{
+        readonly planned: NullType;
+        readonly observed: NullType;
+    }>;
+    readonly decision: OptionType<StringType>;
+    readonly note: StringType;
+}>>, [variant<"field", "records">, variant<"field", "flowchart_move_templates">]>;
+export declare const DecisionOwner: StructType<{
+    readonly role: StringType;
+    readonly name: StringType;
+    readonly desk: StringType;
+}>;
+export declare const decisionOwners: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
+    readonly role: StringType;
+    readonly name: StringType;
+    readonly desk: StringType;
+}>>, [variant<"field", "inputs">, variant<"field", "flowchart_decision_owners">]>;
+export declare const DepotState: StructType<{
+    readonly code: StringType;
+    readonly name: StringType;
+    readonly phase: StringType;
+    readonly slots: OptionType<IntegerType>;
+}>;
+export declare const depotStates: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
+    readonly code: StringType;
+    readonly name: StringType;
+    readonly phase: StringType;
+    readonly slots: OptionType<IntegerType>;
+}>>, [variant<"field", "inputs">, variant<"field", "flowchart_depot_states">]>;
+export declare const ScanTransition: StructType<{
+    readonly id: StringType;
+    readonly src: StringType;
+    readonly dst: StringType;
+    readonly kind: import("@elaraai/east").VariantType<{
+        readonly planned: NullType;
+        readonly observed: NullType;
+    }>;
+    readonly trigger: OptionType<StringType>;
+    readonly parcels: OptionType<FloatType>;
+    readonly n: OptionType<IntegerType>;
+    readonly at: DateTimeType;
+    readonly service: StringType;
+    readonly units: ArrayType<StringType>;
+}>;
+export declare const scanTransitions: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
+    readonly id: StringType;
+    readonly src: StringType;
+    readonly dst: StringType;
+    readonly kind: import("@elaraai/east").VariantType<{
+        readonly planned: NullType;
+        readonly observed: NullType;
+    }>;
+    readonly trigger: OptionType<StringType>;
+    readonly parcels: OptionType<FloatType>;
+    readonly n: OptionType<IntegerType>;
+    readonly at: DateTimeType;
+    readonly service: StringType;
+    readonly units: ArrayType<StringType>;
+}>>, [variant<"field", "inputs">, variant<"field", "flowchart_depot_scans">]>;
+export declare const DepotDecision: StructType<{
+    readonly id: StringType;
+    readonly name: StringType;
+    readonly who: StringType;
+}>;
+export declare const depotDecisions: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
+    readonly id: StringType;
+    readonly name: StringType;
+    readonly who: StringType;
+}>>, [variant<"field", "inputs">, variant<"field", "flowchart_depot_decisions">]>;
+export declare const flowchartFlows: import("@elaraai/east").ExampleDef<[], any>;
+/**
+ * THE Flowchart configurator — ONE live flowchart in its frame; every axis is
+ * an expression-fed prop on that single instance: the legend, the minimap and
+ * read only. Its flows are the host's (`data`): the depot's flows, read from
+ * their e3 record, and Save hands `onApply` the session's request id with the
+ * open flow's patch, which it commits through the record's patch mutation
+ * under that id and answers with what e3 said — committed, refused, out of
+ * time or beaten by another write. A write that got no answer throws, so the
+ * session's Retry sends the same request id again, and e3 answers it with the
+ * first write's commit rather than writing twice (#1275). The host hears what is selected — a
+ * state, a transition, a decision — and a path ⌥-clicked in the reactive
+ * aside, so it is given no inspector; its library is the Flows tab over the
+ * host's flows. Its panes are fixed when it is built, so they are no axis
+ * here. The configurator's axes are the viewer's own state.
+ */
+export declare const flowchartVariants: import("@elaraai/east").ExampleDef<[], any>;
+/**
+ * The library (#1248): the Flows tab, then the step types, the transition
+ * types and the roles that own a decision — each tab its own bound data,
+ * apart from the flows and from the other tabs: an input's rows, a record's
+ * rows by name, another input's. Each template card is a drag source, as is
+ * each of the author's cards, whose tab declares a `drop`; a click selects a
+ * card, and a click on the selected card lets it go.
+ */
+export declare const flowchartLibrary: import("@elaraai/east").ExampleDef<[], any>;
+/**
+ * A flow from the host's tables (§3.4) — the depot's steps by phase, the
+ * transitions mined from its scans and its decisions, each an e3 input of the
+ * app's own rows, built into one flow by `Flowchart.over` through their row
+ * mappers and shown read only: decision triggers, evidence-weighted links, a
+ * ×14 state class, an ↻ in-place loop and an unresolved ghost. A bound slice
+ * narrows the transitions the flow is built from, its rail at the toolbar's
+ * end, and the freshness chip names the evidence. Its one pane is the
+ * inspector, every field of what is selected printed, its Issues the
+ * unresolved transition.
+ */
+export declare const flowchartDepot: import("@elaraai/east").ExampleDef<[], any>;
+/**
+ * One flow of the host's — the hand-over from the last scan to the door — an
+ * input of one flow, its value written with `Flowchart.value`, bound with
+ * `Data.bind` and shown read only, top down. It is given no pane: no
+ * library, and `inspector={false}` — its toolbar, its canvas and its footer.
+ */
+export declare const flowchartHandover: import("@elaraai/east").ExampleDef<[], any>;
+/**
+ * A record's one flow, edited, with its own Details (#1247, #1250): the
+ * collections, a record of flows with one entry bound with its patch
+ * mutation. Every gesture on the canvas is a draft of its editing session —
+ * "+ LANE", a lane's header renamed and its ×, the "+ STATE" ghost, a state
+ * double-clicked into its editor or dragged across lanes, a handle dragged to
+ * another state, Del on the selection — which the history item undoes,
+ * redoes and discards, and Save commits as one patch through the record's
+ * patch mutation. `canConnect` keeps every transition out of the booking: a
+ * draft never snaps onto BKD from another state. The inspector shows a
+ * state's own Details — its key and label, its lane, and a button that gives
+ * it one more member — and a transition's own — its ends, its kind, and a
+ * button that marks it observed — each in place of its kind's form, each
+ * button's `update` one transaction of the flow's session. A decision's and a
+ * lane's Details are their forms, and Issues lists the flow's issues.
+ */
+export declare const flowchartDetail: import("@elaraai/east").ExampleDef<[], any>;
+export declare const indexedFlows: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+    }>>;
+    readonly states: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+        readonly lane: StringType;
+        readonly members: OptionType<IntegerType>;
+        readonly notes: OptionType<StringType>;
+    }>>;
+    readonly links: ArrayType<StructType<{
+        readonly key: OptionType<StringType>;
+        readonly from: StringType;
+        readonly to: StringType;
+        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+            readonly planned: NullType;
+            readonly observed: NullType;
+        }>>;
+        readonly trigger: OptionType<StringType>;
+        readonly evidence: OptionType<StructType<{
+            readonly volume: OptionType<FloatType>;
+            readonly count: OptionType<IntegerType>;
+            readonly measuredAt: OptionType<DateTimeType>;
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly triggers: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly queue: OptionType<ArrayType<StringType>>;
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>>, [variant<"field", "records">, variant<"field", "flowchart_indexed_flows">]>;
+export declare const indexedFlowsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+    }>>;
+    readonly states: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+        readonly lane: StringType;
+        readonly members: OptionType<IntegerType>;
+        readonly notes: OptionType<StringType>;
+    }>>;
+    readonly links: ArrayType<StructType<{
+        readonly key: OptionType<StringType>;
+        readonly from: StringType;
+        readonly to: StringType;
+        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+            readonly planned: NullType;
+            readonly observed: NullType;
+        }>>;
+        readonly trigger: OptionType<StringType>;
+        readonly evidence: OptionType<StructType<{
+            readonly volume: OptionType<FloatType>;
+            readonly count: OptionType<IntegerType>;
+            readonly measuredAt: OptionType<DateTimeType>;
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly triggers: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly queue: OptionType<ArrayType<StringType>>;
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly description: OptionType<StringType>;
+            readonly lanes: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+            }>>;
+            readonly states: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+                readonly lane: StringType;
+                readonly members: OptionType<IntegerType>;
+                readonly notes: OptionType<StringType>;
+            }>>;
+            readonly links: ArrayType<StructType<{
+                readonly key: OptionType<StringType>;
+                readonly from: StringType;
+                readonly to: StringType;
+                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                    readonly planned: NullType;
+                    readonly observed: NullType;
+                }>>;
+                readonly trigger: OptionType<StringType>;
+                readonly evidence: OptionType<StructType<{
+                    readonly volume: OptionType<FloatType>;
+                    readonly count: OptionType<IntegerType>;
+                    readonly measuredAt: OptionType<DateTimeType>;
+                    readonly unit: OptionType<StringType>;
+                }>>;
+            }>>;
+            readonly triggers: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly letter: OptionType<StringType>;
+                readonly owner: OptionType<StringType>;
+                readonly queue: OptionType<ArrayType<StringType>>;
+                readonly outcomes: OptionType<StringType>;
+            }>>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly description: OptionType<StringType>;
+            readonly lanes: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+            }>>;
+            readonly states: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+                readonly lane: StringType;
+                readonly members: OptionType<IntegerType>;
+                readonly notes: OptionType<StringType>;
+            }>>;
+            readonly links: ArrayType<StructType<{
+                readonly key: OptionType<StringType>;
+                readonly from: StringType;
+                readonly to: StringType;
+                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                    readonly planned: NullType;
+                    readonly observed: NullType;
+                }>>;
+                readonly trigger: OptionType<StringType>;
+                readonly evidence: OptionType<StructType<{
+                    readonly volume: OptionType<FloatType>;
+                    readonly count: OptionType<IntegerType>;
+                    readonly measuredAt: OptionType<DateTimeType>;
+                    readonly unit: OptionType<StringType>;
+                }>>;
+            }>>;
+            readonly triggers: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly letter: OptionType<StringType>;
+                readonly owner: OptionType<StringType>;
+                readonly queue: OptionType<ArrayType<StringType>>;
+                readonly outcomes: OptionType<StringType>;
+            }>>;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly description: OptionType<StringType>;
+            readonly lanes: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+            }>>;
+            readonly states: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+                readonly lane: StringType;
+                readonly members: OptionType<IntegerType>;
+                readonly notes: OptionType<StringType>;
+            }>>;
+            readonly links: ArrayType<StructType<{
+                readonly key: OptionType<StringType>;
+                readonly from: StringType;
+                readonly to: StringType;
+                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                    readonly planned: NullType;
+                    readonly observed: NullType;
+                }>>;
+                readonly trigger: OptionType<StringType>;
+                readonly evidence: OptionType<StructType<{
+                    readonly volume: OptionType<FloatType>;
+                    readonly count: OptionType<IntegerType>;
+                    readonly measuredAt: OptionType<DateTimeType>;
+                    readonly unit: OptionType<StringType>;
+                }>>;
+            }>>;
+            readonly triggers: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly letter: OptionType<StringType>;
+                readonly owner: OptionType<StringType>;
+                readonly queue: OptionType<ArrayType<StringType>>;
+                readonly outcomes: OptionType<StringType>;
+            }>>;
+        }>;
+        insert: StructType<{
+            readonly description: OptionType<StringType>;
+            readonly lanes: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+            }>>;
+            readonly states: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: OptionType<StringType>;
+                readonly lane: StringType;
+                readonly members: OptionType<IntegerType>;
+                readonly notes: OptionType<StringType>;
+            }>>;
+            readonly links: ArrayType<StructType<{
+                readonly key: OptionType<StringType>;
+                readonly from: StringType;
+                readonly to: StringType;
+                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                    readonly planned: NullType;
+                    readonly observed: NullType;
+                }>>;
+                readonly trigger: OptionType<StringType>;
+                readonly evidence: OptionType<StructType<{
+                    readonly volume: OptionType<FloatType>;
+                    readonly count: OptionType<IntegerType>;
+                    readonly measuredAt: OptionType<DateTimeType>;
+                    readonly unit: OptionType<StringType>;
+                }>>;
+            }>>;
+            readonly triggers: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly letter: OptionType<StringType>;
+                readonly owner: OptionType<StringType>;
+                readonly queue: OptionType<ArrayType<StringType>>;
+                readonly outcomes: OptionType<StringType>;
+            }>>;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly description: OptionType<StringType>;
+                    readonly lanes: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: OptionType<StringType>;
+                    }>>;
+                    readonly states: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: OptionType<StringType>;
+                        readonly lane: StringType;
+                        readonly members: OptionType<IntegerType>;
+                        readonly notes: OptionType<StringType>;
+                    }>>;
+                    readonly links: ArrayType<StructType<{
+                        readonly key: OptionType<StringType>;
+                        readonly from: StringType;
+                        readonly to: StringType;
+                        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                            readonly planned: NullType;
+                            readonly observed: NullType;
+                        }>>;
+                        readonly trigger: OptionType<StringType>;
+                        readonly evidence: OptionType<StructType<{
+                            readonly volume: OptionType<FloatType>;
+                            readonly count: OptionType<IntegerType>;
+                            readonly measuredAt: OptionType<DateTimeType>;
+                            readonly unit: OptionType<StringType>;
+                        }>>;
+                    }>>;
+                    readonly triggers: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: StringType;
+                        readonly letter: OptionType<StringType>;
+                        readonly owner: OptionType<StringType>;
+                        readonly queue: OptionType<ArrayType<StringType>>;
+                        readonly outcomes: OptionType<StringType>;
+                    }>>;
+                }>;
+                after: StructType<{
+                    readonly description: OptionType<StringType>;
+                    readonly lanes: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: OptionType<StringType>;
+                    }>>;
+                    readonly states: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: OptionType<StringType>;
+                        readonly lane: StringType;
+                        readonly members: OptionType<IntegerType>;
+                        readonly notes: OptionType<StringType>;
+                    }>>;
+                    readonly links: ArrayType<StructType<{
+                        readonly key: OptionType<StringType>;
+                        readonly from: StringType;
+                        readonly to: StringType;
+                        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                            readonly planned: NullType;
+                            readonly observed: NullType;
+                        }>>;
+                        readonly trigger: OptionType<StringType>;
+                        readonly evidence: OptionType<StructType<{
+                            readonly volume: OptionType<FloatType>;
+                            readonly count: OptionType<IntegerType>;
+                            readonly measuredAt: OptionType<DateTimeType>;
+                            readonly unit: OptionType<StringType>;
+                        }>>;
+                    }>>;
+                    readonly triggers: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly label: StringType;
+                        readonly letter: OptionType<StringType>;
+                        readonly owner: OptionType<StringType>;
+                        readonly queue: OptionType<ArrayType<StringType>>;
+                        readonly outcomes: OptionType<StringType>;
+                    }>>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly description: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<StringType>;
+                        after: OptionType<StringType>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        none: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: StringType;
+                                after: StringType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly lanes: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: OptionType<StringType>;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: OptionType<StringType>;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly key: StringType;
+                                readonly label: OptionType<StringType>;
+                            }>;
+                            insert: StructType<{
+                                readonly key: StringType;
+                                readonly label: OptionType<StringType>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: OptionType<StringType>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: OptionType<StringType>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly key: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly label: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly states: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: OptionType<StringType>;
+                            readonly lane: StringType;
+                            readonly members: OptionType<IntegerType>;
+                            readonly notes: OptionType<StringType>;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: OptionType<StringType>;
+                            readonly lane: StringType;
+                            readonly members: OptionType<IntegerType>;
+                            readonly notes: OptionType<StringType>;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly key: StringType;
+                                readonly label: OptionType<StringType>;
+                                readonly lane: StringType;
+                                readonly members: OptionType<IntegerType>;
+                                readonly notes: OptionType<StringType>;
+                            }>;
+                            insert: StructType<{
+                                readonly key: StringType;
+                                readonly label: OptionType<StringType>;
+                                readonly lane: StringType;
+                                readonly members: OptionType<IntegerType>;
+                                readonly notes: OptionType<StringType>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: OptionType<StringType>;
+                                        readonly lane: StringType;
+                                        readonly members: OptionType<IntegerType>;
+                                        readonly notes: OptionType<StringType>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: OptionType<StringType>;
+                                        readonly lane: StringType;
+                                        readonly members: OptionType<IntegerType>;
+                                        readonly notes: OptionType<StringType>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly key: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly label: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly lane: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly members: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<IntegerType>;
+                                            after: OptionType<IntegerType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: IntegerType;
+                                                    after: IntegerType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly notes: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly links: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly key: OptionType<StringType>;
+                            readonly from: StringType;
+                            readonly to: StringType;
+                            readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                readonly planned: NullType;
+                                readonly observed: NullType;
+                            }>>;
+                            readonly trigger: OptionType<StringType>;
+                            readonly evidence: OptionType<StructType<{
+                                readonly volume: OptionType<FloatType>;
+                                readonly count: OptionType<IntegerType>;
+                                readonly measuredAt: OptionType<DateTimeType>;
+                                readonly unit: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly key: OptionType<StringType>;
+                            readonly from: StringType;
+                            readonly to: StringType;
+                            readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                readonly planned: NullType;
+                                readonly observed: NullType;
+                            }>>;
+                            readonly trigger: OptionType<StringType>;
+                            readonly evidence: OptionType<StructType<{
+                                readonly volume: OptionType<FloatType>;
+                                readonly count: OptionType<IntegerType>;
+                                readonly measuredAt: OptionType<DateTimeType>;
+                                readonly unit: OptionType<StringType>;
+                            }>>;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly key: OptionType<StringType>;
+                                readonly from: StringType;
+                                readonly to: StringType;
+                                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                    readonly planned: NullType;
+                                    readonly observed: NullType;
+                                }>>;
+                                readonly trigger: OptionType<StringType>;
+                                readonly evidence: OptionType<StructType<{
+                                    readonly volume: OptionType<FloatType>;
+                                    readonly count: OptionType<IntegerType>;
+                                    readonly measuredAt: OptionType<DateTimeType>;
+                                    readonly unit: OptionType<StringType>;
+                                }>>;
+                            }>;
+                            insert: StructType<{
+                                readonly key: OptionType<StringType>;
+                                readonly from: StringType;
+                                readonly to: StringType;
+                                readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                    readonly planned: NullType;
+                                    readonly observed: NullType;
+                                }>>;
+                                readonly trigger: OptionType<StringType>;
+                                readonly evidence: OptionType<StructType<{
+                                    readonly volume: OptionType<FloatType>;
+                                    readonly count: OptionType<IntegerType>;
+                                    readonly measuredAt: OptionType<DateTimeType>;
+                                    readonly unit: OptionType<StringType>;
+                                }>>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly key: OptionType<StringType>;
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                            readonly planned: NullType;
+                                            readonly observed: NullType;
+                                        }>>;
+                                        readonly trigger: OptionType<StringType>;
+                                        readonly evidence: OptionType<StructType<{
+                                            readonly volume: OptionType<FloatType>;
+                                            readonly count: OptionType<IntegerType>;
+                                            readonly measuredAt: OptionType<DateTimeType>;
+                                            readonly unit: OptionType<StringType>;
+                                        }>>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly key: OptionType<StringType>;
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+                                            readonly planned: NullType;
+                                            readonly observed: NullType;
+                                        }>>;
+                                        readonly trigger: OptionType<StringType>;
+                                        readonly evidence: OptionType<StructType<{
+                                            readonly volume: OptionType<FloatType>;
+                                            readonly count: OptionType<IntegerType>;
+                                            readonly measuredAt: OptionType<DateTimeType>;
+                                            readonly unit: OptionType<StringType>;
+                                        }>>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly key: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly from: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly to: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly kind: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<import("@elaraai/east").VariantType<{
+                                                readonly planned: NullType;
+                                                readonly observed: NullType;
+                                            }>>;
+                                            after: OptionType<import("@elaraai/east").VariantType<{
+                                                readonly planned: NullType;
+                                                readonly observed: NullType;
+                                            }>>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: import("@elaraai/east").VariantType<{
+                                                        readonly planned: NullType;
+                                                        readonly observed: NullType;
+                                                    }>;
+                                                    after: import("@elaraai/east").VariantType<{
+                                                        readonly planned: NullType;
+                                                        readonly observed: NullType;
+                                                    }>;
+                                                }>;
+                                                patch: import("@elaraai/east").VariantType<{
+                                                    readonly planned: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: NullType;
+                                                            after: NullType;
+                                                        }>;
+                                                    }>;
+                                                    readonly observed: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: NullType;
+                                                            after: NullType;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly trigger: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly evidence: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StructType<{
+                                                readonly volume: OptionType<FloatType>;
+                                                readonly count: OptionType<IntegerType>;
+                                                readonly measuredAt: OptionType<DateTimeType>;
+                                                readonly unit: OptionType<StringType>;
+                                            }>>;
+                                            after: OptionType<StructType<{
+                                                readonly volume: OptionType<FloatType>;
+                                                readonly count: OptionType<IntegerType>;
+                                                readonly measuredAt: OptionType<DateTimeType>;
+                                                readonly unit: OptionType<StringType>;
+                                            }>>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StructType<{
+                                                        readonly volume: OptionType<FloatType>;
+                                                        readonly count: OptionType<IntegerType>;
+                                                        readonly measuredAt: OptionType<DateTimeType>;
+                                                        readonly unit: OptionType<StringType>;
+                                                    }>;
+                                                    after: StructType<{
+                                                        readonly volume: OptionType<FloatType>;
+                                                        readonly count: OptionType<IntegerType>;
+                                                        readonly measuredAt: OptionType<DateTimeType>;
+                                                        readonly unit: OptionType<StringType>;
+                                                    }>;
+                                                }>;
+                                                patch: StructType<{
+                                                    readonly volume: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: OptionType<FloatType>;
+                                                            after: OptionType<FloatType>;
+                                                        }>;
+                                                        patch: import("@elaraai/east").VariantType<{
+                                                            none: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: NullType;
+                                                                    after: NullType;
+                                                                }>;
+                                                            }>;
+                                                            some: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: FloatType;
+                                                                    after: FloatType;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                    readonly count: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: OptionType<IntegerType>;
+                                                            after: OptionType<IntegerType>;
+                                                        }>;
+                                                        patch: import("@elaraai/east").VariantType<{
+                                                            none: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: NullType;
+                                                                    after: NullType;
+                                                                }>;
+                                                            }>;
+                                                            some: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: IntegerType;
+                                                                    after: IntegerType;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                    readonly measuredAt: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: OptionType<DateTimeType>;
+                                                            after: OptionType<DateTimeType>;
+                                                        }>;
+                                                        patch: import("@elaraai/east").VariantType<{
+                                                            none: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: NullType;
+                                                                    after: NullType;
+                                                                }>;
+                                                            }>;
+                                                            some: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: DateTimeType;
+                                                                    after: DateTimeType;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                    readonly unit: import("@elaraai/east").VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: OptionType<StringType>;
+                                                            after: OptionType<StringType>;
+                                                        }>;
+                                                        patch: import("@elaraai/east").VariantType<{
+                                                            none: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: NullType;
+                                                                    after: NullType;
+                                                                }>;
+                                                            }>;
+                                                            some: import("@elaraai/east").VariantType<{
+                                                                unchanged: NullType;
+                                                                replace: StructType<{
+                                                                    before: StringType;
+                                                                    after: StringType;
+                                                                }>;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+                readonly triggers: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: StringType;
+                            readonly letter: OptionType<StringType>;
+                            readonly owner: OptionType<StringType>;
+                            readonly queue: OptionType<ArrayType<StringType>>;
+                            readonly outcomes: OptionType<StringType>;
+                        }>>;
+                        after: ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly label: StringType;
+                            readonly letter: OptionType<StringType>;
+                            readonly owner: OptionType<StringType>;
+                            readonly queue: OptionType<ArrayType<StringType>>;
+                            readonly outcomes: OptionType<StringType>;
+                        }>>;
+                    }>;
+                    patch: ArrayType<StructType<{
+                        key: IntegerType;
+                        offset: IntegerType;
+                        operation: import("@elaraai/east").VariantType<{
+                            delete: StructType<{
+                                readonly key: StringType;
+                                readonly label: StringType;
+                                readonly letter: OptionType<StringType>;
+                                readonly owner: OptionType<StringType>;
+                                readonly queue: OptionType<ArrayType<StringType>>;
+                                readonly outcomes: OptionType<StringType>;
+                            }>;
+                            insert: StructType<{
+                                readonly key: StringType;
+                                readonly label: StringType;
+                                readonly letter: OptionType<StringType>;
+                                readonly owner: OptionType<StringType>;
+                                readonly queue: OptionType<ArrayType<StringType>>;
+                                readonly outcomes: OptionType<StringType>;
+                            }>;
+                            update: import("@elaraai/east").VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: StringType;
+                                        readonly letter: OptionType<StringType>;
+                                        readonly owner: OptionType<StringType>;
+                                        readonly queue: OptionType<ArrayType<StringType>>;
+                                        readonly outcomes: OptionType<StringType>;
+                                    }>;
+                                    after: StructType<{
+                                        readonly key: StringType;
+                                        readonly label: StringType;
+                                        readonly letter: OptionType<StringType>;
+                                        readonly owner: OptionType<StringType>;
+                                        readonly queue: OptionType<ArrayType<StringType>>;
+                                        readonly outcomes: OptionType<StringType>;
+                                    }>;
+                                }>;
+                                patch: StructType<{
+                                    readonly key: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly label: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StringType;
+                                            after: StringType;
+                                        }>;
+                                    }>;
+                                    readonly letter: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly owner: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly queue: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<ArrayType<StringType>>;
+                                            after: OptionType<ArrayType<StringType>>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: ArrayType<StringType>;
+                                                    after: ArrayType<StringType>;
+                                                }>;
+                                                patch: ArrayType<StructType<{
+                                                    key: IntegerType;
+                                                    offset: IntegerType;
+                                                    operation: import("@elaraai/east").VariantType<{
+                                                        delete: StringType;
+                                                        insert: StringType;
+                                                        update: import("@elaraai/east").VariantType<{
+                                                            unchanged: NullType;
+                                                            replace: StructType<{
+                                                                before: StringType;
+                                                                after: StringType;
+                                                            }>;
+                                                        }>;
+                                                    }>;
+                                                }>>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                    readonly outcomes: import("@elaraai/east").VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: OptionType<StringType>;
+                                            after: OptionType<StringType>;
+                                        }>;
+                                        patch: import("@elaraai/east").VariantType<{
+                                            none: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: NullType;
+                                                    after: NullType;
+                                                }>;
+                                            }>;
+                                            some: import("@elaraai/east").VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                        }>;
+                    }>>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
+export declare const flowsByDescription: import("@elaraai/e3").RecordIndexDef<"flowchart_by_description", DictType<StringType, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+    }>>;
+    readonly states: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+        readonly lane: StringType;
+        readonly members: OptionType<IntegerType>;
+        readonly notes: OptionType<StringType>;
+    }>>;
+    readonly links: ArrayType<StructType<{
+        readonly key: OptionType<StringType>;
+        readonly from: StringType;
+        readonly to: StringType;
+        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+            readonly planned: NullType;
+            readonly observed: NullType;
+        }>>;
+        readonly trigger: OptionType<StringType>;
+        readonly evidence: OptionType<StructType<{
+            readonly volume: OptionType<FloatType>;
+            readonly count: OptionType<IntegerType>;
+            readonly measuredAt: OptionType<DateTimeType>;
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly triggers: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly queue: OptionType<ArrayType<StringType>>;
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>>, OptionType<StringType>, NullType, readonly ["description"]> & {
+    interval: undefined;
+};
+export declare const flowsByStateCount: import("@elaraai/e3").RecordIndexDef<"stateCount", DictType<StringType, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+    }>>;
+    readonly states: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+        readonly lane: StringType;
+        readonly members: OptionType<IntegerType>;
+        readonly notes: OptionType<StringType>;
+    }>>;
+    readonly links: ArrayType<StructType<{
+        readonly key: OptionType<StringType>;
+        readonly from: StringType;
+        readonly to: StringType;
+        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+            readonly planned: NullType;
+            readonly observed: NullType;
+        }>>;
+        readonly trigger: OptionType<StringType>;
+        readonly evidence: OptionType<StructType<{
+            readonly volume: OptionType<FloatType>;
+            readonly count: OptionType<IntegerType>;
+            readonly measuredAt: OptionType<DateTimeType>;
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly triggers: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly queue: OptionType<ArrayType<StringType>>;
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>>, IntegerType, NullType, undefined> & {
+    interval: undefined;
+};
+export declare const flowsByDescriptionStateCount: import("@elaraai/e3").RecordIndexDef<"flowchart_by_description_state_count", DictType<StringType, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+    }>>;
+    readonly states: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+        readonly lane: StringType;
+        readonly members: OptionType<IntegerType>;
+        readonly notes: OptionType<StringType>;
+    }>>;
+    readonly links: ArrayType<StructType<{
+        readonly key: OptionType<StringType>;
+        readonly from: StringType;
+        readonly to: StringType;
+        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+            readonly planned: NullType;
+            readonly observed: NullType;
+        }>>;
+        readonly trigger: OptionType<StringType>;
+        readonly evidence: OptionType<StructType<{
+            readonly volume: OptionType<FloatType>;
+            readonly count: OptionType<IntegerType>;
+            readonly measuredAt: OptionType<DateTimeType>;
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly triggers: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly queue: OptionType<ArrayType<StringType>>;
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>>, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly stateCount: IntegerType;
+}>, NullType, undefined> & {
+    interval: undefined;
+};
+export declare const flowsByLane: import("@elaraai/e3").RecordIndexDef<"lane", DictType<StringType, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+    }>>;
+    readonly states: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+        readonly lane: StringType;
+        readonly members: OptionType<IntegerType>;
+        readonly notes: OptionType<StringType>;
+    }>>;
+    readonly links: ArrayType<StructType<{
+        readonly key: OptionType<StringType>;
+        readonly from: StringType;
+        readonly to: StringType;
+        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+            readonly planned: NullType;
+            readonly observed: NullType;
+        }>>;
+        readonly trigger: OptionType<StringType>;
+        readonly evidence: OptionType<StructType<{
+            readonly volume: OptionType<FloatType>;
+            readonly count: OptionType<IntegerType>;
+            readonly measuredAt: OptionType<DateTimeType>;
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly triggers: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly queue: OptionType<ArrayType<StringType>>;
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>>, StringType, NullType, undefined> & {
+    interval: undefined;
+};
+export declare const flowsByDecisionOwner: import("@elaraai/e3").RecordIndexDef<"decisionOwner", DictType<StringType, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+    }>>;
+    readonly states: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+        readonly lane: StringType;
+        readonly members: OptionType<IntegerType>;
+        readonly notes: OptionType<StringType>;
+    }>>;
+    readonly links: ArrayType<StructType<{
+        readonly key: OptionType<StringType>;
+        readonly from: StringType;
+        readonly to: StringType;
+        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+            readonly planned: NullType;
+            readonly observed: NullType;
+        }>>;
+        readonly trigger: OptionType<StringType>;
+        readonly evidence: OptionType<StructType<{
+            readonly volume: OptionType<FloatType>;
+            readonly count: OptionType<IntegerType>;
+            readonly measuredAt: OptionType<DateTimeType>;
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly triggers: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly queue: OptionType<ArrayType<StringType>>;
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>>, OptionType<StringType>, NullType, undefined> & {
+    interval: undefined;
+};
+export declare const flowchartRecordIndexes: import("@elaraai/east").ExampleDef<[], any>;
+//# sourceMappingURL=flowchart.examples.d.ts.map