@elaraai/east-ui 1.0.42 → 1.0.44

package/dist/src/component.d.ts

@@ -17069,6 +17069,733 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
         }>], NullType>>;
         readonly canConnect: OptionType<FunctionType<[StringType, StringType], BooleanType>>;
     }>;
+    readonly Flowchart: StructType<{
+        readonly states: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: OptionType<StringType>;
+            readonly lane: StringType;
+            readonly members: OptionType<IntegerType>;
+            readonly notes: OptionType<StringType>;
+        }>>;
+        readonly links: ArrayType<StructType<{
+            readonly key: OptionType<StringType>;
+            readonly from: StringType;
+            readonly to: StringType;
+            readonly kind: OptionType<VariantType<{
+                readonly planned: NullType;
+                readonly observed: NullType;
+            }>>;
+            readonly trigger: OptionType<StringType>;
+            readonly evidence: OptionType<StructType<{
+                readonly volume: OptionType<FloatType>;
+                readonly count: OptionType<IntegerType>;
+                readonly measuredAt: OptionType<DateTimeType>;
+                readonly unit: OptionType<StringType>;
+            }>>;
+        }>>;
+        readonly lanes: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: OptionType<StringType>;
+        }>>;
+        readonly triggers: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly letter: OptionType<StringType>;
+            readonly owner: OptionType<StringType>;
+            readonly queue: OptionType<ArrayType<StringType>>;
+            readonly outcomes: OptionType<StringType>;
+        }>>;
+        readonly orientation: OptionType<VariantType<{
+            readonly LR: NullType;
+            readonly TD: NullType;
+        }>>;
+        readonly freshness: OptionType<StructType<{
+            readonly label: StringType;
+            readonly date: OptionType<DateTimeType>;
+        }>>;
+        readonly minimap: OptionType<BooleanType>;
+        readonly legend: OptionType<BooleanType>;
+        readonly density: OptionType<VariantType<{
+            readonly comfortable: NullType;
+            readonly compact: NullType;
+            readonly condensed: NullType;
+        }>>;
+        readonly height: OptionType<StringType>;
+        readonly maxHeight: OptionType<StringType>;
+        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 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<{
+                                    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 stateHover: OptionType<FunctionType<[StringType], import("@elaraai/east").RecursiveTypeMarker>>;
+        readonly linkHover: OptionType<FunctionType<[StringType], import("@elaraai/east").RecursiveTypeMarker>>;
+        readonly triggerHover: OptionType<FunctionType<[StringType], import("@elaraai/east").RecursiveTypeMarker>>;
+        readonly onSelectState: OptionType<FunctionType<[StringType], NullType>>;
+        readonly onSelectLink: OptionType<FunctionType<[StringType], NullType>>;
+        readonly onSelectTrigger: OptionType<FunctionType<[StringType], NullType>>;
+        readonly onTracePath: OptionType<FunctionType<[StringType], NullType>>;
+        readonly linkMode: OptionType<VariantType<{
+            readonly draw: NullType;
+            readonly connect: NullType;
+        }>>;
+        readonly onCreateLink: OptionType<FunctionType<[StructType<{
+            readonly from: StringType;
+            readonly to: StringType;
+        }>], NullType>>;
+        readonly onDeleteLink: OptionType<FunctionType<[StringType], NullType>>;
+        readonly canConnect: OptionType<FunctionType<[StringType, StringType], BooleanType>>;
+        readonly onAddLane: OptionType<FunctionType<[], NullType>>;
+        readonly onRenameLane: OptionType<FunctionType<[StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+        }>], NullType>>;
+        readonly onDeleteLane: OptionType<FunctionType<[StringType], NullType>>;
+        readonly onAddState: OptionType<FunctionType<[StructType<{
+            readonly lane: StringType;
+            readonly key: StringType;
+            readonly label: StringType;
+        }>], NullType>>;
+        readonly onEditState: OptionType<FunctionType<[StructType<{
+            readonly key: StringType;
+            readonly code: StringType;
+            readonly label: StringType;
+        }>], NullType>>;
+        readonly onMoveState: OptionType<FunctionType<[StructType<{
+            readonly key: StringType;
+            readonly lane: StringType;
+        }>], NullType>>;
+        readonly readOnly: OptionType<BooleanType>;
+    }>;
     readonly Map: StructType<{
         readonly tiles: VariantType<{
             readonly carto: StructType<{