@elaraai/east-ui 1.0.30 → 1.0.32

package/dist/src/component.d.ts

@@ -2214,6 +2214,22 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             readonly background: OptionType<StringType>;
         }>>;
     }>;
+    /**
+     * Expandable — region that expands in place (CSS takeover, no portal)
+     * to fill the app container and collapses back into the layout.
+     * Distinct from Collapsible (in-flow show/hide) and Dialog/Drawer
+     * (portalled overlays). See `layout/expandable/`.
+     */
+    readonly Expandable: StructType<{
+        readonly content: import("@elaraai/east").RecursiveTypeMarker;
+        readonly expanded: OptionType<BooleanType>;
+        readonly onExpandedChange: OptionType<FunctionType<[BooleanType], NullType>>;
+        readonly label: OptionType<StringType>;
+        readonly style: OptionType<StructType<{
+            readonly zIndex: OptionType<IntegerType>;
+            readonly background: OptionType<StringType>;
+        }>>;
+    }>;
     /**
      * ChipRail — horizontal chip row with density + separator + overflow
      * control. Shared primitive under `MetricRail`, `AssumptionsBar`,
@@ -4976,11 +4992,9 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 }>;
             }>>;
             readonly draggable: BooleanType;
+            readonly filtered: BooleanType;
             readonly search: OptionType<StringType>;
-            readonly groups: DictType<StringType, StructType<{
-                readonly value: StringType;
-                readonly summary: OptionType<StringType>;
-            }>>;
+            readonly groups: DictType<StringType, StringType>;
             readonly dims: DictType<StringType, VariantType<{
                 readonly meter: StructType<{
                     readonly value: FloatType;
@@ -4995,6 +5009,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             readonly key: StringType;
             readonly label: StringType;
         }>>;
+        readonly groupSummaries: DictType<StringType, DictType<StringType, StringType>>;
         readonly dimOptions: ArrayType<StructType<{
             readonly key: StringType;
             readonly label: StringType;
@@ -5003,94 +5018,35 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
         readonly searchable: BooleanType;
         readonly addLabel: OptionType<StringType>;
         readonly onAdd: OptionType<FunctionType<[], NullType>>;
-    }>;
-    readonly SliceSummary: StructType<{
-        readonly slice: StructType<{
-            readonly key: StringType;
-            readonly read: FunctionType<[], StructType<{
-                readonly range: OptionType<VariantType<{
-                    readonly datetime: StructType<{
-                        readonly from: DateTimeType;
-                        readonly to: DateTimeType;
-                    }>;
-                    readonly datetimePreset: VariantType<{
-                        readonly today: NullType;
-                        readonly last7d: NullType;
-                        readonly last30d: NullType;
-                        readonly last90d: NullType;
-                        readonly ytd: NullType;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly from: IntegerType;
-                        readonly to: IntegerType;
-                    }>;
-                    readonly float: StructType<{
-                        readonly from: FloatType;
-                        readonly to: FloatType;
-                    }>;
-                }>>;
-                readonly compare: OptionType<VariantType<{
-                    readonly previousPeriod: NullType;
-                    readonly previousYear: NullType;
-                }>>;
-                readonly filters: ArrayType<VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: IntegerType;
-                            readonly neq: IntegerType;
-                            readonly lt: IntegerType;
-                            readonly lte: IntegerType;
-                            readonly gt: IntegerType;
-                            readonly gte: IntegerType;
-                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+        readonly slice: OptionType<StructType<{
+            readonly slice: StructType<{
+                readonly key: StringType;
+                readonly read: FunctionType<[], StructType<{
+                    readonly range: OptionType<VariantType<{
+                        readonly datetime: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
                         }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly lt: FloatType;
-                            readonly lte: FloatType;
-                            readonly gt: FloatType;
-                            readonly gte: FloatType;
+                        readonly datetimePreset: VariantType<{
+                            readonly today: NullType;
+                            readonly last7d: NullType;
+                            readonly last30d: NullType;
+                            readonly last90d: NullType;
+                            readonly ytd: NullType;
                         }>;
-                    }>;
-                    readonly datetime: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly before: DateTimeType;
-                            readonly after: DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: DateTimeType;
-                                readonly to: DateTimeType;
-                            }>;
+                        readonly integer: StructType<{
+                            readonly from: IntegerType;
+                            readonly to: IntegerType;
                         }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly is: BooleanType;
+                        readonly float: StructType<{
+                            readonly from: FloatType;
+                            readonly to: FloatType;
                         }>;
-                    }>;
-                }>>;
-                readonly cohorts: ArrayType<StructType<{
-                    readonly id: StringType;
-                    readonly name: StringType;
+                    }>>;
+                    readonly compare: OptionType<VariantType<{
+                        readonly previousPeriod: NullType;
+                        readonly previousYear: NullType;
+                    }>>;
                     readonly filters: ArrayType<VariantType<{
                         readonly string: StructType<{
                             readonly fieldId: StringType;
@@ -5146,116 +5102,815 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                             }>;
                         }>;
                     }>>;
-                }>>;
-                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-                readonly breakdown: OptionType<StructType<{
-                    readonly fieldId: StringType;
-                    readonly limit: OptionType<IntegerType>;
-                }>>;
-                readonly search: OptionType<StringType>;
-                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-                readonly selectedIndex: OptionType<IntegerType>;
-            }>>;
-            readonly write: FunctionType<[StructType<{
-                readonly range: OptionType<VariantType<{
-                    readonly datetime: StructType<{
-                        readonly from: DateTimeType;
-                        readonly to: DateTimeType;
-                    }>;
-                    readonly datetimePreset: VariantType<{
-                        readonly today: NullType;
-                        readonly last7d: NullType;
-                        readonly last30d: NullType;
-                        readonly last90d: NullType;
-                        readonly ytd: NullType;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly from: IntegerType;
-                        readonly to: IntegerType;
-                    }>;
-                    readonly float: StructType<{
-                        readonly from: FloatType;
-                        readonly to: FloatType;
-                    }>;
-                }>>;
-                readonly compare: OptionType<VariantType<{
-                    readonly previousPeriod: NullType;
-                    readonly previousYear: NullType;
-                }>>;
-                readonly filters: ArrayType<VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: IntegerType;
-                            readonly neq: IntegerType;
-                            readonly lt: IntegerType;
-                            readonly lte: IntegerType;
-                            readonly gt: IntegerType;
-                            readonly gte: IntegerType;
-                            readonly in: import("@elaraai/east").SetType<IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly lt: FloatType;
-                            readonly lte: FloatType;
-                            readonly gt: FloatType;
-                            readonly gte: FloatType;
-                        }>;
-                    }>;
-                    readonly datetime: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly before: DateTimeType;
-                            readonly after: DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: DateTimeType;
-                                readonly to: DateTimeType;
+                    readonly cohorts: ArrayType<StructType<{
+                        readonly id: StringType;
+                        readonly name: StringType;
+                        readonly filters: ArrayType<VariantType<{
+                            readonly string: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly eq: StringType;
+                                    readonly neq: StringType;
+                                    readonly in: import("@elaraai/east").SetType<StringType>;
+                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                    readonly contains: StringType;
+                                    readonly matches: StringType;
+                                    readonly startsWith: StringType;
+                                    readonly endsWith: StringType;
+                                    readonly isEmpty: NullType;
+                                    readonly isNotEmpty: NullType;
+                                }>;
                             }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly is: BooleanType;
-                        }>;
-                    }>;
-                }>>;
-                readonly cohorts: ArrayType<StructType<{
-                    readonly id: StringType;
-                    readonly name: StringType;
-                    readonly filters: ArrayType<VariantType<{
-                        readonly string: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly eq: StringType;
-                                readonly neq: StringType;
-                                readonly in: import("@elaraai/east").SetType<StringType>;
-                                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                                readonly contains: StringType;
-                                readonly matches: StringType;
-                                readonly startsWith: StringType;
-                                readonly endsWith: StringType;
-                                readonly isEmpty: NullType;
-                                readonly isNotEmpty: NullType;
+                            readonly integer: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly eq: IntegerType;
+                                    readonly neq: IntegerType;
+                                    readonly lt: IntegerType;
+                                    readonly lte: IntegerType;
+                                    readonly gt: IntegerType;
+                                    readonly gte: IntegerType;
+                                    readonly in: import("@elaraai/east").SetType<IntegerType>;
+                                }>;
                             }>;
-                        }>;
+                            readonly float: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly lt: FloatType;
+                                    readonly lte: FloatType;
+                                    readonly gt: FloatType;
+                                    readonly gte: FloatType;
+                                }>;
+                            }>;
+                            readonly datetime: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly before: DateTimeType;
+                                    readonly after: DateTimeType;
+                                    readonly between: StructType<{
+                                        readonly from: DateTimeType;
+                                        readonly to: DateTimeType;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly boolean: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly is: BooleanType;
+                                }>;
+                            }>;
+                        }>>;
+                    }>>;
+                    readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                    readonly breakdown: OptionType<StructType<{
+                        readonly fieldId: StringType;
+                        readonly limit: OptionType<IntegerType>;
+                    }>>;
+                    readonly search: OptionType<StringType>;
+                    readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                    readonly selectedIndex: OptionType<IntegerType>;
+                }>>;
+                readonly write: FunctionType<[StructType<{
+                    readonly range: OptionType<VariantType<{
+                        readonly datetime: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                        readonly datetimePreset: VariantType<{
+                            readonly today: NullType;
+                            readonly last7d: NullType;
+                            readonly last30d: NullType;
+                            readonly last90d: NullType;
+                            readonly ytd: NullType;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly from: IntegerType;
+                            readonly to: IntegerType;
+                        }>;
+                        readonly float: StructType<{
+                            readonly from: FloatType;
+                            readonly to: FloatType;
+                        }>;
+                    }>>;
+                    readonly compare: OptionType<VariantType<{
+                        readonly previousPeriod: NullType;
+                        readonly previousYear: NullType;
+                    }>>;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: IntegerType;
+                                readonly neq: IntegerType;
+                                readonly lt: IntegerType;
+                                readonly lte: IntegerType;
+                                readonly gt: IntegerType;
+                                readonly gte: IntegerType;
+                                readonly in: import("@elaraai/east").SetType<IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                    readonly cohorts: ArrayType<StructType<{
+                        readonly id: StringType;
+                        readonly name: StringType;
+                        readonly filters: ArrayType<VariantType<{
+                            readonly string: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly eq: StringType;
+                                    readonly neq: StringType;
+                                    readonly in: import("@elaraai/east").SetType<StringType>;
+                                    readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                    readonly contains: StringType;
+                                    readonly matches: StringType;
+                                    readonly startsWith: StringType;
+                                    readonly endsWith: StringType;
+                                    readonly isEmpty: NullType;
+                                    readonly isNotEmpty: NullType;
+                                }>;
+                            }>;
+                            readonly integer: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly eq: IntegerType;
+                                    readonly neq: IntegerType;
+                                    readonly lt: IntegerType;
+                                    readonly lte: IntegerType;
+                                    readonly gt: IntegerType;
+                                    readonly gte: IntegerType;
+                                    readonly in: import("@elaraai/east").SetType<IntegerType>;
+                                }>;
+                            }>;
+                            readonly float: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly lt: FloatType;
+                                    readonly lte: FloatType;
+                                    readonly gt: FloatType;
+                                    readonly gte: FloatType;
+                                }>;
+                            }>;
+                            readonly datetime: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly before: DateTimeType;
+                                    readonly after: DateTimeType;
+                                    readonly between: StructType<{
+                                        readonly from: DateTimeType;
+                                        readonly to: DateTimeType;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly boolean: StructType<{
+                                readonly fieldId: StringType;
+                                readonly op: VariantType<{
+                                    readonly is: BooleanType;
+                                }>;
+                            }>;
+                        }>>;
+                    }>>;
+                    readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                    readonly breakdown: OptionType<StructType<{
+                        readonly fieldId: StringType;
+                        readonly limit: OptionType<IntegerType>;
+                    }>>;
+                    readonly search: OptionType<StringType>;
+                    readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                    readonly selectedIndex: OptionType<IntegerType>;
+                }>], NullType>;
+                readonly setRange: FunctionType<[OptionType<VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                    readonly datetimePreset: VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: IntegerType;
+                        readonly to: IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: FloatType;
+                        readonly to: FloatType;
+                    }>;
+                }>>], NullType>;
+                readonly setCompare: FunctionType<[OptionType<VariantType<{
+                    readonly previousPeriod: NullType;
+                    readonly previousYear: NullType;
+                }>>], NullType>;
+                readonly addFilter: FunctionType<[VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>], NullType>;
+                readonly removeFilter: FunctionType<[IntegerType], NullType>;
+                readonly clearFilters: FunctionType<[], NullType>;
+                readonly defineCohort: FunctionType<[StructType<{
+                    readonly id: StringType;
+                    readonly name: StringType;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: IntegerType;
+                                readonly neq: IntegerType;
+                                readonly lt: IntegerType;
+                                readonly lte: IntegerType;
+                                readonly gt: IntegerType;
+                                readonly gte: IntegerType;
+                                readonly in: import("@elaraai/east").SetType<IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                }>], NullType>;
+                readonly updateCohort: FunctionType<[StringType, StructType<{
+                    readonly id: StringType;
+                    readonly name: StringType;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: IntegerType;
+                                readonly neq: IntegerType;
+                                readonly lt: IntegerType;
+                                readonly lte: IntegerType;
+                                readonly gt: IntegerType;
+                                readonly gte: IntegerType;
+                                readonly in: import("@elaraai/east").SetType<IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                }>], NullType>;
+                readonly removeCohort: FunctionType<[StringType], NullType>;
+                readonly toggleCohort: FunctionType<[StringType], NullType>;
+                readonly setBreakdown: FunctionType<[OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<IntegerType>;
+                }>>], NullType>;
+                readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
+                readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
+                readonly select: FunctionType<[OptionType<IntegerType>], NullType>;
+                readonly isActive: FunctionType<[], BooleanType>;
+                readonly activeCount: FunctionType<[], IntegerType>;
+                readonly dimensions: FunctionType<[], ArrayType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly label: StringType;
+                }>>>;
+                readonly fields: FunctionType<[], ArrayType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly label: StringType;
+                    readonly kind: StringType;
+                    readonly hints: ArrayType<StringType>;
+                    readonly format: OptionType<VariantType<{
+                        readonly number: NullType;
+                        readonly currency: StructType<{
+                            readonly code: StringType;
+                            readonly compact: BooleanType;
+                        }>;
+                        readonly percent: NullType;
+                        readonly compact: NullType;
+                        readonly date: StringType;
+                        readonly time: StringType;
+                        readonly datetime: StringType;
+                    }>>;
+                }>>>;
+                readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
+                readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
+                readonly totalCount: FunctionType<[], IntegerType>;
+                readonly resultCount: FunctionType<[], IntegerType>;
+                readonly groups: FunctionType<[], ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly count: IntegerType;
+                    readonly color: StringType;
+                }>>>;
+                readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly color: StringType;
+                    readonly points: ArrayType<StructType<{
+                        readonly x: VariantType<{
+                            readonly category: StringType;
+                            readonly number: FloatType;
+                            readonly time: DateTimeType;
+                        }>;
+                        readonly value: FloatType;
+                        readonly size: OptionType<FloatType>;
+                        readonly color: OptionType<StringType>;
+                    }>>;
+                }>>>;
+                readonly matches: FunctionType<[], ArrayType<StructType<{
+                    readonly id: StringType;
+                    readonly label: StringType;
+                    readonly meta: OptionType<StringType>;
+                }>>>;
+                readonly cohortCounts: FunctionType<[], DictType<StringType, IntegerType>>;
+                readonly toggleFilter: FunctionType<[VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>], NullType>;
+                readonly facetGroups: FunctionType<[], ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly count: IntegerType;
+                    readonly color: StringType;
+                }>>>;
+            }>;
+            readonly affordances: ArrayType<VariantType<{
+                readonly filter: NullType;
+                readonly search: NullType;
+                readonly breakdown: NullType;
+                readonly range: NullType;
+                readonly cohort: NullType;
+                readonly brush: NullType;
+                readonly presets: NullType;
+                readonly legend: NullType;
+            }>>;
+        }>>;
+        readonly style: OptionType<StructType<{
+            readonly height: OptionType<StringType>;
+            readonly maxHeight: OptionType<StringType>;
+            readonly virtualization: OptionType<BooleanType>;
+        }>>;
+    }>;
+    readonly SliceSummary: StructType<{
+        readonly slice: StructType<{
+            readonly key: StringType;
+            readonly read: FunctionType<[], StructType<{
+                readonly range: OptionType<VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                    readonly datetimePreset: VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: IntegerType;
+                        readonly to: IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: FloatType;
+                        readonly to: FloatType;
+                    }>;
+                }>>;
+                readonly compare: OptionType<VariantType<{
+                    readonly previousPeriod: NullType;
+                    readonly previousYear: NullType;
+                }>>;
+                readonly filters: ArrayType<VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly cohorts: ArrayType<StructType<{
+                    readonly id: StringType;
+                    readonly name: StringType;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
+                        readonly integer: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: IntegerType;
+                                readonly neq: IntegerType;
+                                readonly lt: IntegerType;
+                                readonly lte: IntegerType;
+                                readonly gt: IntegerType;
+                                readonly gte: IntegerType;
+                                readonly in: import("@elaraai/east").SetType<IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                }>>;
+                readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
+                readonly breakdown: OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<IntegerType>;
+                }>>;
+                readonly search: OptionType<StringType>;
+                readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
+                readonly selectedIndex: OptionType<IntegerType>;
+            }>>;
+            readonly write: FunctionType<[StructType<{
+                readonly range: OptionType<VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                    readonly datetimePreset: VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: IntegerType;
+                        readonly to: IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: FloatType;
+                        readonly to: FloatType;
+                    }>;
+                }>>;
+                readonly compare: OptionType<VariantType<{
+                    readonly previousPeriod: NullType;
+                    readonly previousYear: NullType;
+                }>>;
+                readonly filters: ArrayType<VariantType<{
+                    readonly string: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: StringType;
+                            readonly neq: StringType;
+                            readonly in: import("@elaraai/east").SetType<StringType>;
+                            readonly notIn: import("@elaraai/east").SetType<StringType>;
+                            readonly contains: StringType;
+                            readonly matches: StringType;
+                            readonly startsWith: StringType;
+                            readonly endsWith: StringType;
+                            readonly isEmpty: NullType;
+                            readonly isNotEmpty: NullType;
+                        }>;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly eq: IntegerType;
+                            readonly neq: IntegerType;
+                            readonly lt: IntegerType;
+                            readonly lte: IntegerType;
+                            readonly gt: IntegerType;
+                            readonly gte: IntegerType;
+                            readonly in: import("@elaraai/east").SetType<IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly cohorts: ArrayType<StructType<{
+                    readonly id: StringType;
+                    readonly name: StringType;
+                    readonly filters: ArrayType<VariantType<{
+                        readonly string: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly eq: StringType;
+                                readonly neq: StringType;
+                                readonly in: import("@elaraai/east").SetType<StringType>;
+                                readonly notIn: import("@elaraai/east").SetType<StringType>;
+                                readonly contains: StringType;
+                                readonly matches: StringType;
+                                readonly startsWith: StringType;
+                                readonly endsWith: StringType;
+                                readonly isEmpty: NullType;
+                                readonly isNotEmpty: NullType;
+                            }>;
+                        }>;
                         readonly integer: StructType<{
                             readonly fieldId: StringType;
                             readonly op: VariantType<{
@@ -11715,6 +12370,32 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 readonly desc: NullType;
             }>;
         }>], NullType>>;
+        readonly review: OptionType<StructType<{
+            readonly columnLabel: StringType;
+            readonly summary: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly onApprove: OptionType<FunctionType<[StructType<{
+                readonly rowIndex: IntegerType;
+            }>], NullType>>;
+            readonly onReject: OptionType<FunctionType<[StructType<{
+                readonly rowIndex: IntegerType;
+            }>], NullType>>;
+            readonly onApproveAll: OptionType<FunctionType<[], NullType>>;
+            readonly onRejectAll: OptionType<FunctionType<[], NullType>>;
+            readonly onRerun: OptionType<FunctionType<[], NullType>>;
+            readonly rerunLabel: StringType;
+        }>>;
+        readonly reviewStatus: OptionType<FunctionType<[IntegerType], OptionType<VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>>>>;
+        readonly reviewApproval: OptionType<FunctionType<[IntegerType], OptionType<VariantType<{
+            readonly approved: NullType;
+            readonly pending: NullType;
+            readonly rejected: NullType;
+        }>>>>;
         readonly slice: OptionType<StructType<{
             readonly slice: StructType<{
                 readonly key: StringType;
@@ -12442,10 +13123,21 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                     }>>;
                 }>>;
                 readonly progress: OptionType<FloatType>;
-                readonly status: OptionType<VariantType<{
+                readonly state: VariantType<{
                     readonly committed: NullType;
-                    readonly proposed: NullType;
-                    readonly atRisk: NullType;
+                    readonly proposed: VariantType<{
+                        readonly added: NullType;
+                        readonly model: NullType;
+                        readonly removed: NullType;
+                    }>;
+                    readonly rejected: NullType;
+                }>;
+                readonly status: OptionType<VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
                 }>>;
                 readonly popover: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
             }>>;
@@ -12488,6 +13180,18 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 }>>;
                 readonly popover: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
             }>>;
+            readonly status: OptionType<VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>>;
+            readonly approval: OptionType<VariantType<{
+                readonly approved: NullType;
+                readonly pending: NullType;
+                readonly rejected: NullType;
+            }>>;
         }>>;
         readonly columns: ArrayType<StructType<{
             readonly key: StringType;
@@ -12656,46 +13360,140 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 readonly Blob: BlobType;
             }>;
         }>], NullType>>;
-        readonly onRowClick: OptionType<FunctionType<[StructType<{
-            readonly rowIndex: IntegerType;
-        }>], NullType>>;
-        readonly onRowDoubleClick: OptionType<FunctionType<[StructType<{
-            readonly rowIndex: IntegerType;
-        }>], NullType>>;
-        readonly onSortChange: OptionType<FunctionType<[StructType<{
-            readonly columnKey: StringType;
-            readonly sortIndex: IntegerType;
-            readonly sortDirection: VariantType<{
-                readonly asc: NullType;
-                readonly desc: NullType;
+        readonly onRowClick: OptionType<FunctionType<[StructType<{
+            readonly rowIndex: IntegerType;
+        }>], NullType>>;
+        readonly onRowDoubleClick: OptionType<FunctionType<[StructType<{
+            readonly rowIndex: IntegerType;
+        }>], NullType>>;
+        readonly onSortChange: OptionType<FunctionType<[StructType<{
+            readonly columnKey: StringType;
+            readonly sortIndex: IntegerType;
+            readonly sortDirection: VariantType<{
+                readonly asc: NullType;
+                readonly desc: NullType;
+            }>;
+        }>], NullType>>;
+        readonly onTaskClick: OptionType<FunctionType<[StructType<{
+            readonly rowIndex: IntegerType;
+            readonly taskIndex: IntegerType;
+            readonly taskStart: DateTimeType;
+            readonly taskEnd: DateTimeType;
+        }>], NullType>>;
+        readonly onTaskDoubleClick: OptionType<FunctionType<[StructType<{
+            readonly rowIndex: IntegerType;
+            readonly taskIndex: IntegerType;
+            readonly taskStart: DateTimeType;
+            readonly taskEnd: DateTimeType;
+        }>], NullType>>;
+        readonly id: StringType;
+        readonly sources: ArrayType<StringType>;
+        readonly onDrag: OptionType<FunctionType<[VariantType<{
+            readonly add: StructType<{
+                readonly from: StructType<{
+                    readonly library: StringType;
+                    readonly key: StringType;
+                }>;
+                readonly into: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly duplicate: BooleanType;
+            }>;
+            readonly move: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+            }>;
+            readonly remove: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: VariantType<{
+                    readonly trash: NullType;
+                    readonly source: NullType;
+                }>;
+            }>;
+            readonly resize: StructType<{
+                readonly event: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly edge: VariantType<{
+                    readonly start: NullType;
+                    readonly end: NullType;
+                }>;
+            }>;
+        }>], NullType>>;
+        readonly canDrop: OptionType<FunctionType<[VariantType<{
+            readonly add: StructType<{
+                readonly from: StructType<{
+                    readonly library: StringType;
+                    readonly key: StringType;
+                }>;
+                readonly into: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly duplicate: BooleanType;
             }>;
-        }>], NullType>>;
-        readonly onTaskClick: OptionType<FunctionType<[StructType<{
-            readonly rowIndex: IntegerType;
-            readonly taskIndex: IntegerType;
-            readonly taskStart: DateTimeType;
-            readonly taskEnd: DateTimeType;
-        }>], NullType>>;
-        readonly onTaskDoubleClick: OptionType<FunctionType<[StructType<{
-            readonly rowIndex: IntegerType;
-            readonly taskIndex: IntegerType;
-            readonly taskStart: DateTimeType;
-            readonly taskEnd: DateTimeType;
-        }>], NullType>>;
-        readonly onTaskDrag: OptionType<FunctionType<[StructType<{
-            readonly rowIndex: IntegerType;
-            readonly taskIndex: IntegerType;
-            readonly previousStart: DateTimeType;
-            readonly previousEnd: DateTimeType;
-            readonly newStart: DateTimeType;
-            readonly newEnd: DateTimeType;
-        }>], NullType>>;
-        readonly onTaskDurationChange: OptionType<FunctionType<[StructType<{
-            readonly rowIndex: IntegerType;
-            readonly taskIndex: IntegerType;
-            readonly previousEnd: DateTimeType;
-            readonly newEnd: DateTimeType;
-        }>], NullType>>;
+            readonly move: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+            }>;
+            readonly remove: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: VariantType<{
+                    readonly trash: NullType;
+                    readonly source: NullType;
+                }>;
+            }>;
+            readonly resize: StructType<{
+                readonly event: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly edge: VariantType<{
+                    readonly start: NullType;
+                    readonly end: NullType;
+                }>;
+            }>;
+        }>], BooleanType>>;
         readonly onTaskProgressChange: OptionType<FunctionType<[StructType<{
             readonly rowIndex: IntegerType;
             readonly taskIndex: IntegerType;
@@ -12712,12 +13510,20 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             readonly milestoneIndex: IntegerType;
             readonly milestoneDate: DateTimeType;
         }>], NullType>>;
-        readonly onMilestoneDrag: OptionType<FunctionType<[StructType<{
-            readonly rowIndex: IntegerType;
-            readonly milestoneIndex: IntegerType;
-            readonly previousDate: DateTimeType;
-            readonly newDate: DateTimeType;
-        }>], NullType>>;
+        readonly review: OptionType<StructType<{
+            readonly columnLabel: StringType;
+            readonly summary: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly onApprove: OptionType<FunctionType<[StructType<{
+                readonly rowIndex: IntegerType;
+            }>], NullType>>;
+            readonly onReject: OptionType<FunctionType<[StructType<{
+                readonly rowIndex: IntegerType;
+            }>], NullType>>;
+            readonly onApproveAll: OptionType<FunctionType<[], NullType>>;
+            readonly onRejectAll: OptionType<FunctionType<[], NullType>>;
+            readonly onRerun: OptionType<FunctionType<[], NullType>>;
+            readonly rerunLabel: StringType;
+        }>>;
         readonly slice: OptionType<StructType<{
             readonly slice: StructType<{
                 readonly key: StringType;
@@ -13502,61 +14308,169 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                     readonly number: FloatType;
                     readonly ordinal: StringType;
                 }>;
-                readonly status: VariantType<{
-                    readonly success: NullType;
-                    readonly warning: NullType;
-                    readonly danger: NullType;
-                    readonly info: NullType;
-                    readonly neutral: NullType;
+                readonly status: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly message: StringType;
+            }>>;
+            readonly status: OptionType<VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>>;
+            readonly approval: OptionType<VariantType<{
+                readonly approved: NullType;
+                readonly pending: NullType;
+                readonly rejected: NullType;
+            }>>;
+        }>>;
+        readonly now: OptionType<VariantType<{
+            readonly time: DateTimeType;
+            readonly number: FloatType;
+            readonly ordinal: StringType;
+        }>>;
+        readonly density: OptionType<VariantType<{
+            readonly comfortable: NullType;
+            readonly compact: NullType;
+            readonly condensed: NullType;
+        }>>;
+        readonly slotMinWidth: OptionType<StringType>;
+        readonly plotGutter: OptionType<StructType<{
+            readonly left: OptionType<StringType>;
+            readonly right: OptionType<StringType>;
+        }>>;
+        readonly onSelectRow: OptionType<FunctionType<[StructType<{
+            readonly rowIndex: IntegerType;
+        }>], NullType>>;
+        readonly review: OptionType<StructType<{
+            readonly columnLabel: StringType;
+            readonly summary: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly onApprove: OptionType<FunctionType<[StructType<{
+                readonly rowIndex: IntegerType;
+            }>], NullType>>;
+            readonly onReject: OptionType<FunctionType<[StructType<{
+                readonly rowIndex: IntegerType;
+            }>], NullType>>;
+            readonly onApproveAll: OptionType<FunctionType<[], NullType>>;
+            readonly onRejectAll: OptionType<FunctionType<[], NullType>>;
+            readonly onRerun: OptionType<FunctionType<[], NullType>>;
+            readonly rerunLabel: StringType;
+        }>>;
+        readonly rowHover: OptionType<BooleanType>;
+        readonly id: StringType;
+        readonly sources: ArrayType<StringType>;
+        readonly onDrag: OptionType<FunctionType<[VariantType<{
+            readonly add: StructType<{
+                readonly from: StructType<{
+                    readonly library: StringType;
+                    readonly key: StringType;
+                }>;
+                readonly into: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly duplicate: BooleanType;
+            }>;
+            readonly move: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+            }>;
+            readonly remove: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: VariantType<{
+                    readonly trash: NullType;
+                    readonly source: NullType;
+                }>;
+            }>;
+            readonly resize: StructType<{
+                readonly event: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly edge: VariantType<{
+                    readonly start: NullType;
+                    readonly end: NullType;
+                }>;
+            }>;
+        }>], NullType>>;
+        readonly canDrop: OptionType<FunctionType<[VariantType<{
+            readonly add: StructType<{
+                readonly from: StructType<{
+                    readonly library: StringType;
+                    readonly key: StringType;
+                }>;
+                readonly into: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly duplicate: BooleanType;
+            }>;
+            readonly move: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+            }>;
+            readonly remove: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: VariantType<{
+                    readonly trash: NullType;
+                    readonly source: NullType;
+                }>;
+            }>;
+            readonly resize: StructType<{
+                readonly event: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly edge: VariantType<{
+                    readonly start: NullType;
+                    readonly end: NullType;
                 }>;
-                readonly message: StringType;
-            }>>;
-            readonly status: OptionType<VariantType<{
-                readonly success: NullType;
-                readonly warning: NullType;
-                readonly danger: NullType;
-                readonly info: NullType;
-                readonly neutral: NullType;
-            }>>;
-            readonly approval: OptionType<VariantType<{
-                readonly approved: NullType;
-                readonly pending: NullType;
-                readonly rejected: NullType;
-            }>>;
-        }>>;
-        readonly now: OptionType<VariantType<{
-            readonly time: DateTimeType;
-            readonly number: FloatType;
-            readonly ordinal: StringType;
-        }>>;
-        readonly density: OptionType<VariantType<{
-            readonly comfortable: NullType;
-            readonly compact: NullType;
-            readonly condensed: NullType;
-        }>>;
-        readonly slotMinWidth: OptionType<StringType>;
-        readonly plotGutter: OptionType<StructType<{
-            readonly left: OptionType<StringType>;
-            readonly right: OptionType<StringType>;
-        }>>;
-        readonly onSelectRow: OptionType<FunctionType<[StructType<{
-            readonly rowIndex: IntegerType;
-        }>], NullType>>;
-        readonly review: OptionType<StructType<{
-            readonly columnLabel: StringType;
-            readonly summary: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
-            readonly onApprove: OptionType<FunctionType<[StructType<{
-                readonly rowIndex: IntegerType;
-            }>], NullType>>;
-            readonly onReject: OptionType<FunctionType<[StructType<{
-                readonly rowIndex: IntegerType;
-            }>], NullType>>;
-            readonly onApproveAll: OptionType<FunctionType<[], NullType>>;
-            readonly onRejectAll: OptionType<FunctionType<[], NullType>>;
-            readonly onRerun: OptionType<FunctionType<[], NullType>>;
-            readonly rerunLabel: StringType;
-        }>>;
-        readonly rowHover: OptionType<BooleanType>;
+            }>;
+        }>], BooleanType>>;
     }>;
     readonly Roster: StructType<{
         readonly id: StringType;
@@ -13572,6 +14486,18 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             readonly key: StringType;
             readonly label: StringType;
             readonly sublabel: OptionType<StringType>;
+            readonly status: OptionType<VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>>;
+            readonly approval: OptionType<VariantType<{
+                readonly approved: NullType;
+                readonly pending: NullType;
+                readonly rejected: NullType;
+            }>>;
         }>>;
         readonly shifts: ArrayType<StructType<{
             readonly key: StringType;
@@ -13647,6 +14573,59 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 }>;
             }>;
         }>], NullType>>;
+        readonly canDrop: OptionType<FunctionType<[VariantType<{
+            readonly add: StructType<{
+                readonly from: StructType<{
+                    readonly library: StringType;
+                    readonly key: StringType;
+                }>;
+                readonly into: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly duplicate: BooleanType;
+            }>;
+            readonly move: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+            }>;
+            readonly remove: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: VariantType<{
+                    readonly trash: NullType;
+                    readonly source: NullType;
+                }>;
+            }>;
+            readonly resize: StructType<{
+                readonly event: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly edge: VariantType<{
+                    readonly start: NullType;
+                    readonly end: NullType;
+                }>;
+            }>;
+        }>], BooleanType>>;
         readonly onSelect: OptionType<FunctionType<[StructType<{
             readonly surface: StringType;
             readonly row: StringType;
@@ -13665,6 +14644,20 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             readonly slot: StringType;
             readonly event: OptionType<StringType>;
         }>], NullType>>;
+        readonly review: OptionType<StructType<{
+            readonly columnLabel: StringType;
+            readonly summary: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly onApprove: OptionType<FunctionType<[StructType<{
+                readonly rowIndex: IntegerType;
+            }>], NullType>>;
+            readonly onReject: OptionType<FunctionType<[StructType<{
+                readonly rowIndex: IntegerType;
+            }>], NullType>>;
+            readonly onApproveAll: OptionType<FunctionType<[], NullType>>;
+            readonly onRejectAll: OptionType<FunctionType<[], NullType>>;
+            readonly onRerun: OptionType<FunctionType<[], NullType>>;
+            readonly rerunLabel: StringType;
+        }>>;
     }>;
     readonly Board: StructType<{
         readonly id: StringType;
@@ -13717,7 +14710,59 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
         }>>;
         readonly maxVisible: OptionType<IntegerType>;
         readonly summary: OptionType<StringType>;
-        readonly canAssign: OptionType<FunctionType<[StringType, StringType, StringType], BooleanType>>;
+        readonly canDrop: OptionType<FunctionType<[VariantType<{
+            readonly add: StructType<{
+                readonly from: StructType<{
+                    readonly library: StringType;
+                    readonly key: StringType;
+                }>;
+                readonly into: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly duplicate: BooleanType;
+            }>;
+            readonly move: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+            }>;
+            readonly remove: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: VariantType<{
+                    readonly trash: NullType;
+                    readonly source: NullType;
+                }>;
+            }>;
+            readonly resize: StructType<{
+                readonly event: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly edge: VariantType<{
+                    readonly start: NullType;
+                    readonly end: NullType;
+                }>;
+            }>;
+        }>], BooleanType>>;
         readonly onDrag: OptionType<FunctionType<[VariantType<{
             readonly add: StructType<{
                 readonly from: StructType<{
@@ -13789,6 +14834,20 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             readonly slot: StringType;
             readonly event: OptionType<StringType>;
         }>], NullType>>;
+        readonly review: OptionType<StructType<{
+            readonly columnLabel: StringType;
+            readonly summary: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly onApprove: OptionType<FunctionType<[StructType<{
+                readonly rowIndex: IntegerType;
+            }>], NullType>>;
+            readonly onReject: OptionType<FunctionType<[StructType<{
+                readonly rowIndex: IntegerType;
+            }>], NullType>>;
+            readonly onApproveAll: OptionType<FunctionType<[], NullType>>;
+            readonly onRejectAll: OptionType<FunctionType<[], NullType>>;
+            readonly onRerun: OptionType<FunctionType<[], NullType>>;
+            readonly rerunLabel: StringType;
+        }>>;
     }>;
     readonly Calendar: StructType<{
         readonly legend: StringType;
@@ -15106,6 +16165,59 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 }>;
             }>;
         }>], NullType>>;
+        readonly canDrop: OptionType<FunctionType<[VariantType<{
+            readonly add: StructType<{
+                readonly from: StructType<{
+                    readonly library: StringType;
+                    readonly key: StringType;
+                }>;
+                readonly into: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly duplicate: BooleanType;
+            }>;
+            readonly move: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+            }>;
+            readonly remove: StructType<{
+                readonly from: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly to: VariantType<{
+                    readonly trash: NullType;
+                    readonly source: NullType;
+                }>;
+            }>;
+            readonly resize: StructType<{
+                readonly event: StructType<{
+                    readonly surface: StringType;
+                    readonly row: StringType;
+                    readonly slot: StringType;
+                    readonly event: OptionType<StringType>;
+                }>;
+                readonly edge: VariantType<{
+                    readonly start: NullType;
+                    readonly end: NullType;
+                }>;
+            }>;
+        }>], BooleanType>>;
         readonly onAmountChange: OptionType<FunctionType<[StructType<{
             readonly target: StringType;
             readonly source: StringType;