@elaraai/east-ui 1.0.96 → 1.0.98

package/dist/src/component.d.ts

@@ -14780,1005 +14780,6 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             }>>;
         }>>;
     }>;
-    readonly Schematic: StructType<{
-        readonly extent: StructType<{
-            readonly width: FloatType;
-            readonly height: FloatType;
-        }>;
-        readonly items: ArrayType<StructType<{
-            readonly key: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly label: StringType;
-            readonly sublabel: OptionType<StringType>;
-            readonly icon: OptionType<StringType>;
-            readonly status: OptionType<VariantType<{
-                readonly success: NullType;
-                readonly warning: NullType;
-                readonly danger: NullType;
-                readonly info: NullType;
-                readonly neutral: NullType;
-            }>>;
-            readonly meter: OptionType<StructType<{
-                readonly value: FloatType;
-                readonly max: FloatType;
-            }>>;
-            readonly metric: OptionType<StringType>;
-            readonly width: OptionType<FloatType>;
-            readonly footprint: OptionType<VariantType<{
-                readonly rect: NullType;
-                readonly circle: StructType<{
-                    readonly radius: FloatType;
-                }>;
-                readonly polyline: StructType<{
-                    readonly vertices: ArrayType<StructType<{
-                        readonly x: FloatType;
-                        readonly y: FloatType;
-                        readonly bulge: FloatType;
-                    }>>;
-                    readonly width: OptionType<FloatType>;
-                }>;
-                readonly polygon: StructType<{
-                    readonly vertices: ArrayType<StructType<{
-                        readonly x: FloatType;
-                        readonly y: FloatType;
-                        readonly bulge: FloatType;
-                    }>>;
-                }>;
-            }>>;
-            readonly tone: OptionType<VariantType<{
-                readonly brand: NullType;
-                readonly ink: NullType;
-                readonly muted: NullType;
-                readonly success: NullType;
-                readonly warning: NullType;
-                readonly danger: NullType;
-            }>>;
-            readonly color: OptionType<StringType>;
-            readonly bg: OptionType<StringType>;
-            readonly fillOpacity: OptionType<FloatType>;
-            readonly weight: OptionType<FloatType>;
-            readonly excluded: OptionType<BooleanType>;
-            readonly layer: OptionType<StringType>;
-        }>>;
-        readonly zones: ArrayType<StructType<{
-            readonly key: StringType;
-            readonly label: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly width: FloatType;
-            readonly height: FloatType;
-            readonly pattern: VariantType<{
-                readonly outline: StructType<{
-                    readonly tone: OptionType<VariantType<{
-                        readonly brand: NullType;
-                        readonly ink: NullType;
-                        readonly muted: NullType;
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                    }>>;
-                }>;
-                readonly hatch: StructType<{
-                    readonly tone: OptionType<VariantType<{
-                        readonly brand: NullType;
-                        readonly ink: NullType;
-                        readonly muted: NullType;
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                    }>>;
-                    readonly spacing: OptionType<FloatType>;
-                    readonly angle: OptionType<FloatType>;
-                }>;
-            }>;
-            readonly geometry: OptionType<VariantType<{
-                readonly rect: NullType;
-                readonly circle: StructType<{
-                    readonly radius: FloatType;
-                }>;
-                readonly polyline: StructType<{
-                    readonly vertices: ArrayType<StructType<{
-                        readonly x: FloatType;
-                        readonly y: FloatType;
-                        readonly bulge: FloatType;
-                    }>>;
-                    readonly width: OptionType<FloatType>;
-                }>;
-                readonly polygon: StructType<{
-                    readonly vertices: ArrayType<StructType<{
-                        readonly x: FloatType;
-                        readonly y: FloatType;
-                        readonly bulge: FloatType;
-                    }>>;
-                }>;
-            }>>;
-            readonly tone: OptionType<VariantType<{
-                readonly brand: NullType;
-                readonly ink: NullType;
-                readonly muted: NullType;
-                readonly success: NullType;
-                readonly warning: NullType;
-                readonly danger: NullType;
-            }>>;
-            readonly color: OptionType<StringType>;
-            readonly bg: OptionType<StringType>;
-            readonly fillOpacity: OptionType<FloatType>;
-            readonly weight: OptionType<FloatType>;
-            readonly layer: OptionType<StringType>;
-        }>>;
-        readonly links: ArrayType<StructType<{
-            readonly key: StringType;
-            readonly from: StringType;
-            readonly to: StringType;
-            readonly label: OptionType<StringType>;
-            readonly metric: OptionType<StringType>;
-            readonly style: VariantType<{
-                readonly solid: StructType<{
-                    readonly tone: OptionType<VariantType<{
-                        readonly brand: NullType;
-                        readonly ink: NullType;
-                        readonly muted: NullType;
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                    }>>;
-                    readonly weight: OptionType<FloatType>;
-                }>;
-                readonly dashed: StructType<{
-                    readonly tone: OptionType<VariantType<{
-                        readonly brand: NullType;
-                        readonly ink: NullType;
-                        readonly muted: NullType;
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                    }>>;
-                    readonly weight: OptionType<FloatType>;
-                }>;
-            }>;
-            readonly route: VariantType<{
-                readonly orthogonal: StructType<{
-                    readonly corner: OptionType<FloatType>;
-                }>;
-                readonly direct: NullType;
-            }>;
-            readonly via: ArrayType<StructType<{
-                readonly x: FloatType;
-                readonly y: FloatType;
-            }>>;
-            readonly layer: OptionType<StringType>;
-        }>>;
-        readonly nets: ArrayType<StructType<{
-            readonly key: StringType;
-            readonly sources: ArrayType<StringType>;
-            readonly destinations: ArrayType<StringType>;
-            readonly label: OptionType<StringType>;
-            readonly metric: OptionType<StringType>;
-            readonly style: VariantType<{
-                readonly solid: StructType<{
-                    readonly tone: OptionType<VariantType<{
-                        readonly brand: NullType;
-                        readonly ink: NullType;
-                        readonly muted: NullType;
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                    }>>;
-                    readonly weight: OptionType<FloatType>;
-                }>;
-                readonly dashed: StructType<{
-                    readonly tone: OptionType<VariantType<{
-                        readonly brand: NullType;
-                        readonly ink: NullType;
-                        readonly muted: NullType;
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                    }>>;
-                    readonly weight: OptionType<FloatType>;
-                }>;
-            }>;
-            readonly route: VariantType<{
-                readonly orthogonal: StructType<{
-                    readonly corner: OptionType<FloatType>;
-                }>;
-                readonly direct: NullType;
-            }>;
-            readonly via: ArrayType<StructType<{
-                readonly x: FloatType;
-                readonly y: FloatType;
-            }>>;
-            readonly layer: OptionType<StringType>;
-        }>>;
-        readonly scaleUnit: OptionType<StringType>;
-        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: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").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: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").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: import("@elaraai/east").DateTimeType;
-                                    readonly after: import("@elaraai/east").DateTimeType;
-                                    readonly between: StructType<{
-                                        readonly from: import("@elaraai/east").DateTimeType;
-                                        readonly to: import("@elaraai/east").DateTimeType;
-                                    }>;
-                                }>;
-                            }>;
-                            readonly boolean: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: VariantType<{
-                                    readonly is: BooleanType;
-                                }>;
-                            }>;
-                        }>>;
-                        readonly group: OptionType<StringType>;
-                    }>>;
-                    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 resolution: OptionType<VariantType<{
-                        readonly auto: NullType;
-                        readonly hour: NullType;
-                        readonly day: NullType;
-                        readonly week: NullType;
-                        readonly month: NullType;
-                        readonly quarter: NullType;
-                        readonly year: NullType;
-                    }>>;
-                }>>;
-                readonly write: FunctionType<[StructType<{
-                    readonly range: OptionType<VariantType<{
-                        readonly datetime: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").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: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").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: import("@elaraai/east").DateTimeType;
-                                    readonly after: import("@elaraai/east").DateTimeType;
-                                    readonly between: StructType<{
-                                        readonly from: import("@elaraai/east").DateTimeType;
-                                        readonly to: import("@elaraai/east").DateTimeType;
-                                    }>;
-                                }>;
-                            }>;
-                            readonly boolean: StructType<{
-                                readonly fieldId: StringType;
-                                readonly op: VariantType<{
-                                    readonly is: BooleanType;
-                                }>;
-                            }>;
-                        }>>;
-                        readonly group: OptionType<StringType>;
-                    }>>;
-                    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 resolution: OptionType<VariantType<{
-                        readonly auto: NullType;
-                        readonly hour: NullType;
-                        readonly day: NullType;
-                        readonly week: NullType;
-                        readonly month: NullType;
-                        readonly quarter: NullType;
-                        readonly year: NullType;
-                    }>>;
-                }>], NullType>;
-                readonly setRange: FunctionType<[OptionType<VariantType<{
-                    readonly datetime: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").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: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").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: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                    readonly group: OptionType<StringType>;
-                }>], 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: import("@elaraai/east").DateTimeType;
-                                readonly after: import("@elaraai/east").DateTimeType;
-                                readonly between: StructType<{
-                                    readonly from: import("@elaraai/east").DateTimeType;
-                                    readonly to: import("@elaraai/east").DateTimeType;
-                                }>;
-                            }>;
-                        }>;
-                        readonly boolean: StructType<{
-                            readonly fieldId: StringType;
-                            readonly op: VariantType<{
-                                readonly is: BooleanType;
-                            }>;
-                        }>;
-                    }>>;
-                    readonly group: OptionType<StringType>;
-                }>], 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: import("@elaraai/east").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: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").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 setResolution: FunctionType<[OptionType<VariantType<{
-                    readonly auto: NullType;
-                    readonly hour: NullType;
-                    readonly day: NullType;
-                    readonly week: NullType;
-                    readonly month: NullType;
-                    readonly quarter: NullType;
-                    readonly year: NullType;
-                }>>], NullType>;
-            }>;
-            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 resolution: NullType;
-                readonly summary: NullType;
-            }>>;
-        }>>;
-        readonly sliceEffect: OptionType<StructType<{
-            readonly hidden: OptionType<BooleanType>;
-            readonly opacity: OptionType<FloatType>;
-            readonly desaturate: OptionType<BooleanType>;
-            readonly dot: OptionType<BooleanType>;
-            readonly emphasis: OptionType<VariantType<{
-                readonly halo: NullType;
-                readonly pulse: NullType;
-            }>>;
-            readonly frame: OptionType<BooleanType>;
-            readonly frameFit: OptionType<BooleanType>;
-        }>>;
-        readonly layers: OptionType<ArrayType<StructType<{
-            readonly key: StringType;
-            readonly label: StringType;
-            readonly visible: OptionType<BooleanType>;
-            readonly locked: OptionType<BooleanType>;
-            readonly opacity: OptionType<FloatType>;
-            readonly tone: OptionType<VariantType<{
-                readonly brand: NullType;
-                readonly ink: NullType;
-                readonly muted: NullType;
-                readonly success: NullType;
-                readonly warning: NullType;
-                readonly danger: NullType;
-            }>>;
-        }>>>;
-        readonly height: OptionType<StringType>;
-        readonly maxHeight: OptionType<StringType>;
-        readonly onSelect: OptionType<FunctionType<[StringType], NullType>>;
-        readonly selectionMode: OptionType<VariantType<{
-            readonly single: NullType;
-            readonly multiple: NullType;
-        }>>;
-        readonly onSelectionChange: OptionType<FunctionType<[StructType<{
-            readonly key: OptionType<StringType>;
-            readonly selected: BooleanType;
-            readonly selectedKeys: ArrayType<StringType>;
-            readonly additive: BooleanType;
-            readonly region: OptionType<StructType<{
-                readonly minX: FloatType;
-                readonly minY: FloatType;
-                readonly maxX: FloatType;
-                readonly maxY: FloatType;
-            }>>;
-        }>], NullType>>;
-        readonly sliceSelectField: OptionType<StringType>;
-        readonly selectZoomFocus: OptionType<BooleanType>;
-        readonly onViewportChange: OptionType<FunctionType<[StructType<{
-            readonly zoom: FloatType;
-            readonly minX: FloatType;
-            readonly minY: FloatType;
-            readonly maxX: FloatType;
-            readonly maxY: FloatType;
-        }>], NullType>>;
-        readonly onItemOpen: OptionType<FunctionType<[StringType], NullType>>;
-        readonly onSelectZone: OptionType<FunctionType<[StringType], NullType>>;
-        readonly onZoneSelectionChange: OptionType<FunctionType<[StructType<{
-            readonly key: OptionType<StringType>;
-            readonly selected: BooleanType;
-            readonly selectedKeys: ArrayType<StringType>;
-            readonly childItemKeys: ArrayType<StringType>;
-            readonly additive: BooleanType;
-        }>], NullType>>;
-        readonly linkMode: OptionType<VariantType<{
-            readonly draw: NullType;
-            readonly connect: NullType;
-        }>>;
-        readonly onCreateLink: OptionType<FunctionType<[StructType<{
-            readonly link: StructType<{
-                readonly key: StringType;
-                readonly from: StringType;
-                readonly to: StringType;
-            }>;
-            readonly links: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly from: StringType;
-                readonly to: StringType;
-            }>>;
-            readonly net: StructType<{
-                readonly key: StringType;
-                readonly sources: ArrayType<StringType>;
-                readonly destinations: ArrayType<StringType>;
-            }>;
-            readonly additive: BooleanType;
-            readonly existing: ArrayType<StringType>;
-            readonly absorbed: ArrayType<StringType>;
-        }>], NullType>>;
-        readonly onSelectLink: OptionType<FunctionType<[StringType], NullType>>;
-        readonly onEditLink: OptionType<FunctionType<[StructType<{
-            readonly key: StringType;
-            readonly from: StringType;
-            readonly to: StringType;
-        }>], NullType>>;
-        readonly onDeleteLink: OptionType<FunctionType<[StringType], NullType>>;
-        readonly readOnly: OptionType<BooleanType>;
-        readonly readOnlyLinks: OptionType<BooleanType>;
-        readonly readOnlyItems: OptionType<BooleanType>;
-        readonly onMoveItem: OptionType<FunctionType<[StructType<{
-            readonly key: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly keys: ArrayType<StringType>;
-            readonly dx: FloatType;
-            readonly dy: FloatType;
-        }>], NullType>>;
-        readonly itemHover: OptionType<FunctionType<[StringType], import("@elaraai/east").RecursiveTypeMarker>>;
-        readonly zoneHover: OptionType<FunctionType<[StringType], import("@elaraai/east").RecursiveTypeMarker>>;
-        readonly linkHover: OptionType<FunctionType<[StringType], import("@elaraai/east").RecursiveTypeMarker>>;
-        readonly onEditNet: OptionType<FunctionType<[StructType<{
-            readonly key: StringType;
-            readonly sources: ArrayType<StringType>;
-            readonly destinations: ArrayType<StringType>;
-        }>], NullType>>;
-        readonly canConnect: OptionType<FunctionType<[StringType, StringType], BooleanType>>;
-    }>;
     readonly Map: StructType<{
         readonly tiles: VariantType<{
             readonly carto: StructType<{