@elaraai/east-ui 1.0.26 → 1.0.27

package/dist/src/component.d.ts

@@ -1327,6 +1327,29 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
         readonly loading: OptionType<BooleanType>;
         readonly disabled: OptionType<BooleanType>;
         readonly onClick: OptionType<FunctionType<[], NullType>>;
+        readonly badge: OptionType<StringType>;
+        readonly badgeColorPalette: OptionType<VariantType<{
+            readonly gray: NullType;
+            readonly red: NullType;
+            readonly orange: NullType;
+            readonly yellow: NullType;
+            readonly green: NullType;
+            readonly teal: NullType;
+            readonly blue: NullType;
+            readonly cyan: NullType;
+            readonly purple: NullType;
+            readonly pink: NullType;
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>>;
+        readonly attention: OptionType<VariantType<{
+            readonly none: NullType;
+            readonly pulse: NullType;
+            readonly ring: NullType;
+        }>>;
         readonly style: OptionType<StructType<{
             readonly variant: OptionType<VariantType<{
                 readonly solid: NullType;
@@ -3048,6 +3071,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             readonly TagsInput: StructType<{
                 readonly value: ArrayType<StringType>;
                 readonly defaultValue: OptionType<ArrayType<StringType>>;
+                readonly suggestions: OptionType<ArrayType<StringType>>;
                 readonly max: OptionType<IntegerType>;
                 readonly maxLength: OptionType<IntegerType>;
                 readonly disabled: OptionType<BooleanType>;
@@ -3203,6 +3227,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
     readonly TagsInput: StructType<{
         readonly value: ArrayType<StringType>;
         readonly defaultValue: OptionType<ArrayType<StringType>>;
+        readonly suggestions: OptionType<ArrayType<StringType>>;
         readonly max: OptionType<IntegerType>;
         readonly maxLength: OptionType<IntegerType>;
         readonly disabled: OptionType<BooleanType>;
@@ -4904,6 +4929,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
         readonly style: OptionType<StructType<{
             readonly brandColor: OptionType<StringType>;
             readonly nowLineColor: OptionType<StringType>;
+            readonly labelWidth: OptionType<StringType>;
         }>>;
     }>;
     readonly Library: StructType<{
@@ -5445,6 +5471,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 readonly fieldId: StringType;
                 readonly label: StringType;
                 readonly kind: StringType;
+                readonly hints: ArrayType<StringType>;
             }>>>;
             readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
             readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
@@ -5969,6 +5996,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 readonly fieldId: StringType;
                 readonly label: StringType;
                 readonly kind: StringType;
+                readonly hints: ArrayType<StringType>;
             }>>>;
             readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
             readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
@@ -6494,6 +6522,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 readonly fieldId: StringType;
                 readonly label: StringType;
                 readonly kind: StringType;
+                readonly hints: ArrayType<StringType>;
             }>>>;
             readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
             readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
@@ -7024,6 +7053,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 readonly fieldId: StringType;
                 readonly label: StringType;
                 readonly kind: StringType;
+                readonly hints: ArrayType<StringType>;
             }>>>;
             readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
             readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
@@ -7548,6 +7578,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 readonly fieldId: StringType;
                 readonly label: StringType;
                 readonly kind: StringType;
+                readonly hints: ArrayType<StringType>;
             }>>>;
             readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
             readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
@@ -8076,6 +8107,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 readonly fieldId: StringType;
                 readonly label: StringType;
                 readonly kind: StringType;
+                readonly hints: ArrayType<StringType>;
             }>>>;
             readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
             readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
@@ -8606,6 +8638,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 readonly fieldId: StringType;
                 readonly label: StringType;
                 readonly kind: StringType;
+                readonly hints: ArrayType<StringType>;
             }>>>;
             readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
             readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
@@ -9143,6 +9176,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                 readonly fieldId: StringType;
                 readonly label: StringType;
                 readonly kind: StringType;
+                readonly hints: ArrayType<StringType>;
             }>>>;
             readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
             readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
@@ -9220,6 +9254,8 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             readonly headerBackground: OptionType<StringType>;
             readonly footerBackground: OptionType<StringType>;
             readonly accentColor: OptionType<StringType>;
+            readonly bodyPadding: OptionType<StringType>;
+            readonly flush: OptionType<BooleanType>;
         }>>;
     }>;
     readonly DataList: StructType<{
@@ -9967,6 +10003,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                         readonly fieldId: StringType;
                         readonly label: StringType;
                         readonly kind: StringType;
+                        readonly hints: ArrayType<StringType>;
                     }>>>;
                     readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
                     readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
@@ -10307,6 +10344,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             readonly radius: OptionType<FloatType>;
             readonly opacity: OptionType<FloatType>;
             readonly legend: OptionType<BooleanType>;
+            readonly tooltip: OptionType<BooleanType>;
         }>;
     }>>;
     readonly TreeView: StructType<{
@@ -11208,6 +11246,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                     readonly fieldId: StringType;
                     readonly label: StringType;
                     readonly kind: StringType;
+                    readonly hints: ArrayType<StringType>;
                 }>>>;
                 readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
                 readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
@@ -11287,6 +11326,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             readonly selectedBackground: OptionType<StringType>;
             readonly selectedBorderColor: OptionType<StringType>;
             readonly footerBackground: OptionType<StringType>;
+            readonly rowHeight: OptionType<IntegerType>;
         }>>;
     }>;
     readonly Gantt: StructType<{
@@ -12106,6 +12146,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                     readonly fieldId: StringType;
                     readonly label: StringType;
                     readonly kind: StringType;
+                    readonly hints: ArrayType<StringType>;
                 }>>>;
                 readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
                 readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
@@ -12166,6 +12207,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             readonly stickyHeader: OptionType<BooleanType>;
             readonly showColumnBorder: OptionType<BooleanType>;
             readonly showToday: OptionType<BooleanType>;
+            readonly rowHeight: OptionType<IntegerType>;
         }>>;
     }>;
     readonly Planner: StructType<{
@@ -12236,6 +12278,35 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
                     readonly rejected: NullType;
                 }>;
                 readonly popover: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly stretch: OptionType<VariantType<{
+                    readonly horizontal: NullType;
+                    readonly vertical: NullType;
+                    readonly both: NullType;
+                }>>;
+                readonly content: OptionType<StructType<{
+                    readonly horizontal: OptionType<VariantType<{
+                        readonly start: NullType;
+                        readonly center: NullType;
+                        readonly end: NullType;
+                    }>>;
+                    readonly vertical: OptionType<VariantType<{
+                        readonly start: NullType;
+                        readonly center: NullType;
+                        readonly end: NullType;
+                    }>>;
+                }>>;
+                readonly tone: OptionType<VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>>;
+                readonly animation: OptionType<VariantType<{
+                    readonly none: NullType;
+                    readonly pulse: NullType;
+                }>>;
+                readonly hovercard: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
             }>>;
             readonly markers: ArrayType<StructType<{
                 readonly slot: VariantType<{
@@ -12293,6 +12364,7 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             readonly onRerun: OptionType<FunctionType<[], NullType>>;
             readonly rerunLabel: StringType;
         }>>;
+        readonly rowHover: OptionType<BooleanType>;
     }>;
     readonly Roster: StructType<{
         readonly id: StringType;
@@ -12424,6 +12496,11 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             readonly week: StringType;
             readonly day: StringType;
         }>], NullType>>;
+        readonly density: OptionType<VariantType<{
+            readonly comfortable: NullType;
+            readonly compact: NullType;
+            readonly condensed: NullType;
+        }>>;
     }>;
     readonly Schematic: StructType<{
         readonly extent: StructType<{
@@ -12592,6 +12669,539 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
         readonly grid: OptionType<BooleanType>;
         readonly navigator: OptionType<BooleanType>;
         readonly minimap: OptionType<BooleanType>;
+        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 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 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 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 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 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 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 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 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 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 affordances: ArrayType<VariantType<{
+                readonly filter: NullType;
+                readonly search: NullType;
+                readonly breakdown: NullType;
+                readonly range: NullType;
+                readonly cohort: NullType;
+                readonly brush: NullType;
+            }>>;
+        }>>;
         readonly height: OptionType<StringType>;
         readonly onSelect: OptionType<FunctionType<[StringType], NullType>>;
     }>;