@elaraai/east-ui 1.0.74 → 1.0.76

package/dist/src/component.d.ts

@@ -20821,6 +20821,2506 @@ declare const UIComponentTypeImpl: RecursiveType<VariantType<{
             }>;
         }>], NullType>>;
     }>;
+    readonly Sheet: StructType<{
+        readonly rows: VariantType<{
+            readonly inline: ArrayType<StructType<{
+                readonly id: StringType;
+                readonly owned: BooleanType;
+                readonly cells: DictType<StringType, VariantType<{
+                    readonly Null: NullType;
+                    readonly Boolean: BooleanType;
+                    readonly Integer: IntegerType;
+                    readonly Float: FloatType;
+                    readonly String: StringType;
+                    readonly DateTime: import("@elaraai/east").DateTimeType;
+                    readonly Link: StructType<{
+                        readonly from: ArrayType<VariantType<{
+                            readonly identified: StructType<{
+                                readonly key: StringType;
+                            }>;
+                            readonly range: StructType<{
+                                readonly from: StringType;
+                                readonly to: StringType;
+                            }>;
+                            readonly counted: StructType<{
+                                readonly n: IntegerType;
+                                readonly key: StringType;
+                            }>;
+                            readonly placeholder: NullType;
+                            readonly text: StringType;
+                        }>>;
+                        readonly to: ArrayType<VariantType<{
+                            readonly identified: StructType<{
+                                readonly key: StringType;
+                            }>;
+                            readonly range: StructType<{
+                                readonly from: StringType;
+                                readonly to: StringType;
+                            }>;
+                            readonly counted: StructType<{
+                                readonly n: IntegerType;
+                                readonly key: StringType;
+                            }>;
+                            readonly placeholder: NullType;
+                            readonly text: StringType;
+                        }>>;
+                    }>;
+                }>>;
+            }>>;
+            readonly paged: StructType<{
+                readonly id: StringType;
+                readonly page: FunctionType<[IntegerType, IntegerType], OptionType<ArrayType<StructType<{
+                    readonly id: StringType;
+                    readonly owned: BooleanType;
+                    readonly cells: DictType<StringType, VariantType<{
+                        readonly Null: NullType;
+                        readonly Boolean: BooleanType;
+                        readonly Integer: IntegerType;
+                        readonly Float: FloatType;
+                        readonly String: StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Link: StructType<{
+                            readonly from: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                            readonly to: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                        }>;
+                    }>>;
+                }>>>>;
+                readonly total: FunctionType<[], OptionType<IntegerType>>;
+                readonly seek: OptionType<FunctionType<[VariantType<{
+                    readonly key: StringType;
+                    readonly prefix: StringType;
+                    readonly fields: StructType<{
+                        readonly values: ArrayType<StringType>;
+                        readonly prefix: OptionType<StringType>;
+                    }>;
+                }>], OptionType<StructType<{
+                    readonly found: BooleanType;
+                    readonly row: IntegerType;
+                    readonly count: IntegerType;
+                }>>>>;
+            }>;
+        }>;
+        readonly columns: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly header: StringType;
+            readonly sub: OptionType<StringType>;
+            readonly width: OptionType<StringType>;
+            readonly kind: VariantType<{
+                readonly text: NullType;
+                readonly date: StructType<{
+                    readonly base: OptionType<StringType>;
+                    readonly format: OptionType<StringType>;
+                }>;
+                readonly quantity: StructType<{
+                    readonly uom: OptionType<DictType<StringType, StringType>>;
+                    readonly format: OptionType<VariantType<{
+                        readonly number: StructType<{
+                            readonly minimumFractionDigits: OptionType<IntegerType>;
+                            readonly maximumFractionDigits: OptionType<IntegerType>;
+                            readonly signDisplay: OptionType<VariantType<{
+                                readonly auto: NullType;
+                                readonly never: NullType;
+                                readonly always: NullType;
+                                readonly exceptZero: NullType;
+                            }>>;
+                        }>;
+                        readonly currency: StructType<{
+                            readonly currency: VariantType<{
+                                readonly USD: NullType;
+                                readonly EUR: NullType;
+                                readonly GBP: NullType;
+                                readonly JPY: NullType;
+                                readonly CHF: NullType;
+                                readonly CAD: NullType;
+                                readonly AUD: NullType;
+                                readonly NZD: NullType;
+                                readonly CNY: NullType;
+                                readonly HKD: NullType;
+                                readonly SGD: NullType;
+                                readonly KRW: NullType;
+                                readonly INR: NullType;
+                                readonly TWD: NullType;
+                                readonly THB: NullType;
+                                readonly MYR: NullType;
+                                readonly IDR: NullType;
+                                readonly PHP: NullType;
+                                readonly VND: NullType;
+                                readonly SEK: NullType;
+                                readonly NOK: NullType;
+                                readonly DKK: NullType;
+                                readonly PLN: NullType;
+                                readonly CZK: NullType;
+                                readonly HUF: NullType;
+                                readonly RUB: NullType;
+                                readonly UAH: NullType;
+                                readonly RON: NullType;
+                                readonly MXN: NullType;
+                                readonly BRL: NullType;
+                                readonly ARS: NullType;
+                                readonly CLP: NullType;
+                                readonly COP: NullType;
+                                readonly PEN: NullType;
+                                readonly AED: NullType;
+                                readonly SAR: NullType;
+                                readonly ILS: NullType;
+                                readonly ZAR: NullType;
+                                readonly TRY: NullType;
+                                readonly EGP: NullType;
+                                readonly NGN: NullType;
+                                readonly KES: NullType;
+                            }>;
+                            readonly display: OptionType<VariantType<{
+                                readonly code: NullType;
+                                readonly symbol: NullType;
+                                readonly narrowSymbol: NullType;
+                                readonly name: NullType;
+                            }>>;
+                            readonly compact: OptionType<VariantType<{
+                                readonly short: NullType;
+                                readonly long: NullType;
+                            }>>;
+                            readonly minimumFractionDigits: OptionType<IntegerType>;
+                            readonly maximumFractionDigits: OptionType<IntegerType>;
+                        }>;
+                        readonly percent: StructType<{
+                            readonly minimumFractionDigits: OptionType<IntegerType>;
+                            readonly maximumFractionDigits: OptionType<IntegerType>;
+                            readonly signDisplay: OptionType<VariantType<{
+                                readonly auto: NullType;
+                                readonly never: NullType;
+                                readonly always: NullType;
+                                readonly exceptZero: NullType;
+                            }>>;
+                        }>;
+                        readonly compact: StructType<{
+                            readonly display: OptionType<VariantType<{
+                                readonly short: NullType;
+                                readonly long: NullType;
+                            }>>;
+                        }>;
+                        readonly unit: StructType<{
+                            readonly unit: VariantType<{
+                                readonly bit: NullType;
+                                readonly byte: NullType;
+                                readonly kilobit: NullType;
+                                readonly kilobyte: NullType;
+                                readonly megabit: NullType;
+                                readonly megabyte: NullType;
+                                readonly gigabit: NullType;
+                                readonly gigabyte: NullType;
+                                readonly terabit: NullType;
+                                readonly terabyte: NullType;
+                                readonly petabyte: NullType;
+                                readonly nanosecond: NullType;
+                                readonly microsecond: NullType;
+                                readonly millisecond: NullType;
+                                readonly second: NullType;
+                                readonly minute: NullType;
+                                readonly hour: NullType;
+                                readonly day: NullType;
+                                readonly week: NullType;
+                                readonly month: NullType;
+                                readonly year: NullType;
+                                readonly millimeter: NullType;
+                                readonly centimeter: NullType;
+                                readonly meter: NullType;
+                                readonly kilometer: NullType;
+                                readonly inch: NullType;
+                                readonly foot: NullType;
+                                readonly yard: NullType;
+                                readonly mile: NullType;
+                                readonly gram: NullType;
+                                readonly kilogram: NullType;
+                                readonly milligram: NullType;
+                                readonly ounce: NullType;
+                                readonly pound: NullType;
+                                readonly stone: NullType;
+                                readonly celsius: NullType;
+                                readonly fahrenheit: NullType;
+                                readonly milliliter: NullType;
+                                readonly liter: NullType;
+                                readonly gallon: NullType;
+                                readonly fluidOunce: NullType;
+                                readonly acre: NullType;
+                                readonly hectare: NullType;
+                                readonly meterPerSecond: NullType;
+                                readonly kilometerPerHour: NullType;
+                                readonly milePerHour: NullType;
+                                readonly percent: NullType;
+                                readonly degree: NullType;
+                            }>;
+                            readonly display: OptionType<VariantType<{
+                                readonly short: NullType;
+                                readonly narrow: NullType;
+                                readonly long: NullType;
+                            }>>;
+                        }>;
+                        readonly scientific: NullType;
+                        readonly engineering: NullType;
+                        readonly date: StructType<{
+                            readonly format: StringType;
+                        }>;
+                        readonly time: StructType<{
+                            readonly format: StringType;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly format: StringType;
+                        }>;
+                    }>>;
+                }>;
+                readonly integer: NullType;
+                readonly lookup: StructType<{
+                    readonly register: StringType;
+                }>;
+                readonly reference: StructType<{
+                    readonly register: StringType;
+                }>;
+                readonly enum: StructType<{
+                    readonly register: StringType;
+                }>;
+                readonly set: StructType<{
+                    readonly register: StringType;
+                    readonly members: ArrayType<StructType<{
+                        readonly kind: StringType;
+                        readonly identified: BooleanType;
+                        readonly countable: BooleanType;
+                        readonly resolvesTo: OptionType<StringType>;
+                    }>>;
+                    readonly multiple: OptionType<StructType<{
+                        readonly forms: ArrayType<StringType>;
+                        readonly ops: ArrayType<StringType>;
+                        readonly appliesTo: StringType;
+                    }>>;
+                    readonly store: VariantType<{
+                        readonly asTyped: NullType;
+                        readonly canonical: NullType;
+                    }>;
+                }>;
+                readonly link: StructType<{
+                    readonly register: StringType;
+                    readonly members: ArrayType<StructType<{
+                        readonly kind: StringType;
+                        readonly identified: BooleanType;
+                        readonly countable: BooleanType;
+                        readonly resolvesTo: OptionType<StringType>;
+                    }>>;
+                    readonly multiple: OptionType<StructType<{
+                        readonly forms: ArrayType<StringType>;
+                        readonly ops: ArrayType<StringType>;
+                        readonly appliesTo: StringType;
+                    }>>;
+                    readonly sides: OptionType<StructType<{
+                        readonly byDriver: DictType<StringType, VariantType<{
+                            readonly both: NullType;
+                            readonly from: NullType;
+                            readonly to: NullType;
+                            readonly in: NullType;
+                        }>>;
+                        readonly locks: ArrayType<StructType<{
+                            readonly half: VariantType<{
+                                readonly from: NullType;
+                                readonly to: NullType;
+                            }>;
+                            readonly when: VariantType<{
+                                readonly both: NullType;
+                                readonly from: NullType;
+                                readonly to: NullType;
+                                readonly in: NullType;
+                            }>;
+                            readonly label: StringType;
+                        }>>;
+                    }>>;
+                    readonly arity: OptionType<StructType<{
+                        readonly half: VariantType<{
+                            readonly from: NullType;
+                            readonly to: NullType;
+                        }>;
+                        readonly implied: FunctionType<[StructType<{
+                            readonly rowIndex: IntegerType;
+                            readonly rowId: StringType;
+                            readonly offset: IntegerType;
+                            readonly row: DictType<StringType, VariantType<{
+                                readonly Null: NullType;
+                                readonly Boolean: BooleanType;
+                                readonly Integer: IntegerType;
+                                readonly Float: FloatType;
+                                readonly String: StringType;
+                                readonly DateTime: import("@elaraai/east").DateTimeType;
+                                readonly Link: StructType<{
+                                    readonly from: ArrayType<VariantType<{
+                                        readonly identified: StructType<{
+                                            readonly key: StringType;
+                                        }>;
+                                        readonly range: StructType<{
+                                            readonly from: StringType;
+                                            readonly to: StringType;
+                                        }>;
+                                        readonly counted: StructType<{
+                                            readonly n: IntegerType;
+                                            readonly key: StringType;
+                                        }>;
+                                        readonly placeholder: NullType;
+                                        readonly text: StringType;
+                                    }>>;
+                                    readonly to: ArrayType<VariantType<{
+                                        readonly identified: StructType<{
+                                            readonly key: StringType;
+                                        }>;
+                                        readonly range: StructType<{
+                                            readonly from: StringType;
+                                            readonly to: StringType;
+                                        }>;
+                                        readonly counted: StructType<{
+                                            readonly n: IntegerType;
+                                            readonly key: StringType;
+                                        }>;
+                                        readonly placeholder: NullType;
+                                        readonly text: StringType;
+                                    }>>;
+                                }>;
+                            }>>;
+                            readonly rows: ArrayType<StructType<{
+                                readonly id: StringType;
+                                readonly owned: BooleanType;
+                                readonly cells: DictType<StringType, VariantType<{
+                                    readonly Null: NullType;
+                                    readonly Boolean: BooleanType;
+                                    readonly Integer: IntegerType;
+                                    readonly Float: FloatType;
+                                    readonly String: StringType;
+                                    readonly DateTime: import("@elaraai/east").DateTimeType;
+                                    readonly Link: StructType<{
+                                        readonly from: ArrayType<VariantType<{
+                                            readonly identified: StructType<{
+                                                readonly key: StringType;
+                                            }>;
+                                            readonly range: StructType<{
+                                                readonly from: StringType;
+                                                readonly to: StringType;
+                                            }>;
+                                            readonly counted: StructType<{
+                                                readonly n: IntegerType;
+                                                readonly key: StringType;
+                                            }>;
+                                            readonly placeholder: NullType;
+                                            readonly text: StringType;
+                                        }>>;
+                                        readonly to: ArrayType<VariantType<{
+                                            readonly identified: StructType<{
+                                                readonly key: StringType;
+                                            }>;
+                                            readonly range: StructType<{
+                                                readonly from: StringType;
+                                                readonly to: StringType;
+                                            }>;
+                                            readonly counted: StructType<{
+                                                readonly n: IntegerType;
+                                                readonly key: StringType;
+                                            }>;
+                                            readonly placeholder: NullType;
+                                            readonly text: StringType;
+                                        }>>;
+                                    }>;
+                                }>>;
+                            }>>;
+                            readonly rowsOffset: IntegerType;
+                            readonly partial: BooleanType;
+                            readonly driver: OptionType<StringType>;
+                            readonly today: import("@elaraai/east").DateTimeType;
+                        }>], OptionType<StructType<{
+                            readonly n: IntegerType;
+                            readonly key: StringType;
+                        }>>>;
+                    }>>;
+                    readonly check: ArrayType<VariantType<{
+                        readonly exists: NullType;
+                        readonly custom: FunctionType<[StructType<{
+                            readonly rowIndex: IntegerType;
+                            readonly rowId: StringType;
+                            readonly offset: IntegerType;
+                            readonly row: DictType<StringType, VariantType<{
+                                readonly Null: NullType;
+                                readonly Boolean: BooleanType;
+                                readonly Integer: IntegerType;
+                                readonly Float: FloatType;
+                                readonly String: StringType;
+                                readonly DateTime: import("@elaraai/east").DateTimeType;
+                                readonly Link: StructType<{
+                                    readonly from: ArrayType<VariantType<{
+                                        readonly identified: StructType<{
+                                            readonly key: StringType;
+                                        }>;
+                                        readonly range: StructType<{
+                                            readonly from: StringType;
+                                            readonly to: StringType;
+                                        }>;
+                                        readonly counted: StructType<{
+                                            readonly n: IntegerType;
+                                            readonly key: StringType;
+                                        }>;
+                                        readonly placeholder: NullType;
+                                        readonly text: StringType;
+                                    }>>;
+                                    readonly to: ArrayType<VariantType<{
+                                        readonly identified: StructType<{
+                                            readonly key: StringType;
+                                        }>;
+                                        readonly range: StructType<{
+                                            readonly from: StringType;
+                                            readonly to: StringType;
+                                        }>;
+                                        readonly counted: StructType<{
+                                            readonly n: IntegerType;
+                                            readonly key: StringType;
+                                        }>;
+                                        readonly placeholder: NullType;
+                                        readonly text: StringType;
+                                    }>>;
+                                }>;
+                            }>>;
+                            readonly half: VariantType<{
+                                readonly from: NullType;
+                                readonly to: NullType;
+                            }>;
+                            readonly member: VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>;
+                        }>], OptionType<StringType>>;
+                    }>>;
+                    readonly store: VariantType<{
+                        readonly asTyped: NullType;
+                        readonly canonical: NullType;
+                    }>;
+                }>;
+                readonly stamped: StructType<{
+                    readonly owner: OptionType<StringType>;
+                }>;
+                readonly custom: StructType<{
+                    readonly accepts: StringType;
+                    readonly parse: FunctionType<[StringType, StructType<{
+                        readonly rowIndex: IntegerType;
+                        readonly rowId: StringType;
+                        readonly offset: IntegerType;
+                        readonly row: DictType<StringType, VariantType<{
+                            readonly Null: NullType;
+                            readonly Boolean: BooleanType;
+                            readonly Integer: IntegerType;
+                            readonly Float: FloatType;
+                            readonly String: StringType;
+                            readonly DateTime: import("@elaraai/east").DateTimeType;
+                            readonly Link: StructType<{
+                                readonly from: ArrayType<VariantType<{
+                                    readonly identified: StructType<{
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly range: StructType<{
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                    }>;
+                                    readonly counted: StructType<{
+                                        readonly n: IntegerType;
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly placeholder: NullType;
+                                    readonly text: StringType;
+                                }>>;
+                                readonly to: ArrayType<VariantType<{
+                                    readonly identified: StructType<{
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly range: StructType<{
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                    }>;
+                                    readonly counted: StructType<{
+                                        readonly n: IntegerType;
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly placeholder: NullType;
+                                    readonly text: StringType;
+                                }>>;
+                            }>;
+                        }>>;
+                        readonly rows: ArrayType<StructType<{
+                            readonly id: StringType;
+                            readonly owned: BooleanType;
+                            readonly cells: DictType<StringType, VariantType<{
+                                readonly Null: NullType;
+                                readonly Boolean: BooleanType;
+                                readonly Integer: IntegerType;
+                                readonly Float: FloatType;
+                                readonly String: StringType;
+                                readonly DateTime: import("@elaraai/east").DateTimeType;
+                                readonly Link: StructType<{
+                                    readonly from: ArrayType<VariantType<{
+                                        readonly identified: StructType<{
+                                            readonly key: StringType;
+                                        }>;
+                                        readonly range: StructType<{
+                                            readonly from: StringType;
+                                            readonly to: StringType;
+                                        }>;
+                                        readonly counted: StructType<{
+                                            readonly n: IntegerType;
+                                            readonly key: StringType;
+                                        }>;
+                                        readonly placeholder: NullType;
+                                        readonly text: StringType;
+                                    }>>;
+                                    readonly to: ArrayType<VariantType<{
+                                        readonly identified: StructType<{
+                                            readonly key: StringType;
+                                        }>;
+                                        readonly range: StructType<{
+                                            readonly from: StringType;
+                                            readonly to: StringType;
+                                        }>;
+                                        readonly counted: StructType<{
+                                            readonly n: IntegerType;
+                                            readonly key: StringType;
+                                        }>;
+                                        readonly placeholder: NullType;
+                                        readonly text: StringType;
+                                    }>>;
+                                }>;
+                            }>>;
+                        }>>;
+                        readonly rowsOffset: IntegerType;
+                        readonly partial: BooleanType;
+                        readonly driver: OptionType<StringType>;
+                        readonly today: import("@elaraai/east").DateTimeType;
+                    }>], OptionType<VariantType<{
+                        readonly Null: NullType;
+                        readonly Boolean: BooleanType;
+                        readonly Integer: IntegerType;
+                        readonly Float: FloatType;
+                        readonly String: StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Link: StructType<{
+                            readonly from: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                            readonly to: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                        }>;
+                    }>>>;
+                    readonly print: FunctionType<[VariantType<{
+                        readonly Null: NullType;
+                        readonly Boolean: BooleanType;
+                        readonly Integer: IntegerType;
+                        readonly Float: FloatType;
+                        readonly String: StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Link: StructType<{
+                            readonly from: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                            readonly to: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                        }>;
+                    }>], StringType>;
+                }>;
+            }>;
+            readonly dataType: RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly payloadType: RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly editable: BooleanType;
+            readonly fill: ArrayType<VariantType<{
+                readonly sync: FunctionType<[StructType<{
+                    readonly rowIndex: IntegerType;
+                    readonly rowId: StringType;
+                    readonly offset: IntegerType;
+                    readonly row: DictType<StringType, VariantType<{
+                        readonly Null: NullType;
+                        readonly Boolean: BooleanType;
+                        readonly Integer: IntegerType;
+                        readonly Float: FloatType;
+                        readonly String: StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Link: StructType<{
+                            readonly from: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                            readonly to: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                        }>;
+                    }>>;
+                    readonly rows: ArrayType<StructType<{
+                        readonly id: StringType;
+                        readonly owned: BooleanType;
+                        readonly cells: DictType<StringType, VariantType<{
+                            readonly Null: NullType;
+                            readonly Boolean: BooleanType;
+                            readonly Integer: IntegerType;
+                            readonly Float: FloatType;
+                            readonly String: StringType;
+                            readonly DateTime: import("@elaraai/east").DateTimeType;
+                            readonly Link: StructType<{
+                                readonly from: ArrayType<VariantType<{
+                                    readonly identified: StructType<{
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly range: StructType<{
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                    }>;
+                                    readonly counted: StructType<{
+                                        readonly n: IntegerType;
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly placeholder: NullType;
+                                    readonly text: StringType;
+                                }>>;
+                                readonly to: ArrayType<VariantType<{
+                                    readonly identified: StructType<{
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly range: StructType<{
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                    }>;
+                                    readonly counted: StructType<{
+                                        readonly n: IntegerType;
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly placeholder: NullType;
+                                    readonly text: StringType;
+                                }>>;
+                            }>;
+                        }>>;
+                    }>>;
+                    readonly rowsOffset: IntegerType;
+                    readonly partial: BooleanType;
+                    readonly driver: OptionType<StringType>;
+                    readonly today: import("@elaraai/east").DateTimeType;
+                }>], OptionType<StructType<{
+                    readonly value: VariantType<{
+                        readonly Null: NullType;
+                        readonly Boolean: BooleanType;
+                        readonly Integer: IntegerType;
+                        readonly Float: FloatType;
+                        readonly String: StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Link: StructType<{
+                            readonly from: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                            readonly to: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                        }>;
+                    }>;
+                    readonly meta: StringType;
+                }>>>;
+                readonly async: AsyncFunctionType<[StructType<{
+                    readonly rowIndex: IntegerType;
+                    readonly rowId: StringType;
+                    readonly offset: IntegerType;
+                    readonly row: DictType<StringType, VariantType<{
+                        readonly Null: NullType;
+                        readonly Boolean: BooleanType;
+                        readonly Integer: IntegerType;
+                        readonly Float: FloatType;
+                        readonly String: StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Link: StructType<{
+                            readonly from: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                            readonly to: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                        }>;
+                    }>>;
+                    readonly rows: ArrayType<StructType<{
+                        readonly id: StringType;
+                        readonly owned: BooleanType;
+                        readonly cells: DictType<StringType, VariantType<{
+                            readonly Null: NullType;
+                            readonly Boolean: BooleanType;
+                            readonly Integer: IntegerType;
+                            readonly Float: FloatType;
+                            readonly String: StringType;
+                            readonly DateTime: import("@elaraai/east").DateTimeType;
+                            readonly Link: StructType<{
+                                readonly from: ArrayType<VariantType<{
+                                    readonly identified: StructType<{
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly range: StructType<{
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                    }>;
+                                    readonly counted: StructType<{
+                                        readonly n: IntegerType;
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly placeholder: NullType;
+                                    readonly text: StringType;
+                                }>>;
+                                readonly to: ArrayType<VariantType<{
+                                    readonly identified: StructType<{
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly range: StructType<{
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                    }>;
+                                    readonly counted: StructType<{
+                                        readonly n: IntegerType;
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly placeholder: NullType;
+                                    readonly text: StringType;
+                                }>>;
+                            }>;
+                        }>>;
+                    }>>;
+                    readonly rowsOffset: IntegerType;
+                    readonly partial: BooleanType;
+                    readonly driver: OptionType<StringType>;
+                    readonly today: import("@elaraai/east").DateTimeType;
+                }>], OptionType<StructType<{
+                    readonly value: VariantType<{
+                        readonly Null: NullType;
+                        readonly Boolean: BooleanType;
+                        readonly Integer: IntegerType;
+                        readonly Float: FloatType;
+                        readonly String: StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Link: StructType<{
+                            readonly from: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                            readonly to: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                        }>;
+                    }>;
+                    readonly meta: StringType;
+                }>>>;
+            }>>;
+        }>>;
+        readonly registers: DictType<StringType, StructType<{
+            readonly members: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly kind: StringType;
+                readonly aliases: ArrayType<StringType>;
+                readonly meta: OptionType<StringType>;
+                readonly parent: OptionType<StringType>;
+                readonly tone: OptionType<VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>>;
+            }>>;
+        }>>;
+        readonly driver: OptionType<StructType<{
+            readonly column: StringType;
+            readonly members: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly kind: StringType;
+                readonly aliases: ArrayType<StringType>;
+                readonly meta: OptionType<StringType>;
+                readonly parent: OptionType<StringType>;
+                readonly tone: OptionType<VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>>;
+            }>>;
+        }>>;
+        readonly suggest: OptionType<StructType<{
+            readonly ahead: IntegerType;
+            readonly triggers: ArrayType<StringType>;
+            readonly ghost: BooleanType;
+            readonly propose: ArrayType<VariantType<{
+                readonly sync: FunctionType<[StructType<{
+                    readonly rowIndex: IntegerType;
+                    readonly rowId: StringType;
+                    readonly offset: IntegerType;
+                    readonly row: DictType<StringType, VariantType<{
+                        readonly Null: NullType;
+                        readonly Boolean: BooleanType;
+                        readonly Integer: IntegerType;
+                        readonly Float: FloatType;
+                        readonly String: StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Link: StructType<{
+                            readonly from: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                            readonly to: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                        }>;
+                    }>>;
+                    readonly rows: ArrayType<StructType<{
+                        readonly id: StringType;
+                        readonly owned: BooleanType;
+                        readonly cells: DictType<StringType, VariantType<{
+                            readonly Null: NullType;
+                            readonly Boolean: BooleanType;
+                            readonly Integer: IntegerType;
+                            readonly Float: FloatType;
+                            readonly String: StringType;
+                            readonly DateTime: import("@elaraai/east").DateTimeType;
+                            readonly Link: StructType<{
+                                readonly from: ArrayType<VariantType<{
+                                    readonly identified: StructType<{
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly range: StructType<{
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                    }>;
+                                    readonly counted: StructType<{
+                                        readonly n: IntegerType;
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly placeholder: NullType;
+                                    readonly text: StringType;
+                                }>>;
+                                readonly to: ArrayType<VariantType<{
+                                    readonly identified: StructType<{
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly range: StructType<{
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                    }>;
+                                    readonly counted: StructType<{
+                                        readonly n: IntegerType;
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly placeholder: NullType;
+                                    readonly text: StringType;
+                                }>>;
+                            }>;
+                        }>>;
+                    }>>;
+                    readonly rowsOffset: IntegerType;
+                    readonly partial: BooleanType;
+                    readonly driver: OptionType<StringType>;
+                    readonly today: import("@elaraai/east").DateTimeType;
+                }>], ArrayType<StructType<{
+                    readonly cells: DictType<StringType, VariantType<{
+                        readonly Null: NullType;
+                        readonly Boolean: BooleanType;
+                        readonly Integer: IntegerType;
+                        readonly Float: FloatType;
+                        readonly String: StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Link: StructType<{
+                            readonly from: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                            readonly to: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                        }>;
+                    }>>;
+                    readonly meta: StringType;
+                }>>>;
+                readonly async: AsyncFunctionType<[StructType<{
+                    readonly rowIndex: IntegerType;
+                    readonly rowId: StringType;
+                    readonly offset: IntegerType;
+                    readonly row: DictType<StringType, VariantType<{
+                        readonly Null: NullType;
+                        readonly Boolean: BooleanType;
+                        readonly Integer: IntegerType;
+                        readonly Float: FloatType;
+                        readonly String: StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Link: StructType<{
+                            readonly from: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                            readonly to: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                        }>;
+                    }>>;
+                    readonly rows: ArrayType<StructType<{
+                        readonly id: StringType;
+                        readonly owned: BooleanType;
+                        readonly cells: DictType<StringType, VariantType<{
+                            readonly Null: NullType;
+                            readonly Boolean: BooleanType;
+                            readonly Integer: IntegerType;
+                            readonly Float: FloatType;
+                            readonly String: StringType;
+                            readonly DateTime: import("@elaraai/east").DateTimeType;
+                            readonly Link: StructType<{
+                                readonly from: ArrayType<VariantType<{
+                                    readonly identified: StructType<{
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly range: StructType<{
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                    }>;
+                                    readonly counted: StructType<{
+                                        readonly n: IntegerType;
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly placeholder: NullType;
+                                    readonly text: StringType;
+                                }>>;
+                                readonly to: ArrayType<VariantType<{
+                                    readonly identified: StructType<{
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly range: StructType<{
+                                        readonly from: StringType;
+                                        readonly to: StringType;
+                                    }>;
+                                    readonly counted: StructType<{
+                                        readonly n: IntegerType;
+                                        readonly key: StringType;
+                                    }>;
+                                    readonly placeholder: NullType;
+                                    readonly text: StringType;
+                                }>>;
+                            }>;
+                        }>>;
+                    }>>;
+                    readonly rowsOffset: IntegerType;
+                    readonly partial: BooleanType;
+                    readonly driver: OptionType<StringType>;
+                    readonly today: import("@elaraai/east").DateTimeType;
+                }>], ArrayType<StructType<{
+                    readonly cells: DictType<StringType, VariantType<{
+                        readonly Null: NullType;
+                        readonly Boolean: BooleanType;
+                        readonly Integer: IntegerType;
+                        readonly Float: FloatType;
+                        readonly String: StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Link: StructType<{
+                            readonly from: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                            readonly to: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                        }>;
+                    }>>;
+                    readonly meta: StringType;
+                }>>>;
+            }>>;
+        }>>;
+        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 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 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;
+                            }>;
+                        }>;
+                    }>>;
+                }>], 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;
+                            }>;
+                        }>;
+                    }>>;
+                }>], 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 views: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly name: StringType;
+            readonly narrowing: 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 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 context: IntegerType;
+            readonly reveals: ArrayType<IntegerType>;
+        }>>;
+        readonly activeView: OptionType<StringType>;
+        readonly onViewsChange: OptionType<FunctionType<[ArrayType<StructType<{
+            readonly id: StringType;
+            readonly name: StringType;
+            readonly narrowing: 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 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 context: IntegerType;
+            readonly reveals: ArrayType<IntegerType>;
+        }>>], NullType>>;
+        readonly onEdit: OptionType<FunctionType<[VariantType<{
+            readonly commit: StructType<{
+                readonly rowId: StringType;
+                readonly offset: IntegerType;
+                readonly key: StringType;
+                readonly row: StructType<{
+                    readonly id: StringType;
+                    readonly owned: BooleanType;
+                    readonly cells: DictType<StringType, VariantType<{
+                        readonly Null: NullType;
+                        readonly Boolean: BooleanType;
+                        readonly Integer: IntegerType;
+                        readonly Float: FloatType;
+                        readonly String: StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Link: StructType<{
+                            readonly from: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                            readonly to: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                        }>;
+                    }>>;
+                }>;
+                readonly source: VariantType<{
+                    readonly typed: NullType;
+                    readonly pasted: NullType;
+                    readonly fill: NullType;
+                    readonly row: NullType;
+                    readonly pattern: NullType;
+                }>;
+            }>;
+            readonly insert: StructType<{
+                readonly afterRowId: OptionType<StringType>;
+                readonly row: StructType<{
+                    readonly id: StringType;
+                    readonly owned: BooleanType;
+                    readonly cells: DictType<StringType, VariantType<{
+                        readonly Null: NullType;
+                        readonly Boolean: BooleanType;
+                        readonly Integer: IntegerType;
+                        readonly Float: FloatType;
+                        readonly String: StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Link: StructType<{
+                            readonly from: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                            readonly to: ArrayType<VariantType<{
+                                readonly identified: StructType<{
+                                    readonly key: StringType;
+                                }>;
+                                readonly range: StructType<{
+                                    readonly from: StringType;
+                                    readonly to: StringType;
+                                }>;
+                                readonly counted: StructType<{
+                                    readonly n: IntegerType;
+                                    readonly key: StringType;
+                                }>;
+                                readonly placeholder: NullType;
+                                readonly text: StringType;
+                            }>>;
+                        }>;
+                    }>>;
+                }>;
+                readonly source: VariantType<{
+                    readonly typed: NullType;
+                    readonly pasted: NullType;
+                    readonly fill: NullType;
+                    readonly row: NullType;
+                    readonly pattern: NullType;
+                }>;
+            }>;
+            readonly remove: StructType<{
+                readonly rowIds: ArrayType<StringType>;
+            }>;
+        }>], NullType>>;
+        readonly onSelect: OptionType<FunctionType<[StructType<{
+            readonly rowId: OptionType<StringType>;
+            readonly key: OptionType<StringType>;
+        }>], NullType>>;
+        readonly selection: OptionType<StructType<{
+            readonly rowId: OptionType<StringType>;
+            readonly key: OptionType<StringType>;
+        }>>;
+        readonly newRowId: OptionType<FunctionType<[], StringType>>;
+        readonly readOnly: OptionType<BooleanType>;
+        readonly blanks: OptionType<IntegerType>;
+        readonly density: OptionType<VariantType<{
+            readonly comfortable: NullType;
+            readonly compact: NullType;
+            readonly condensed: NullType;
+        }>>;
+        readonly footer: ArrayType<StructType<{
+            readonly text: StringType;
+            readonly tone: OptionType<VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>>;
+        }>>;
+        readonly style: OptionType<StructType<{
+            readonly height: OptionType<StringType>;
+            readonly maxHeight: OptionType<StringType>;
+            readonly gutterWidth: OptionType<StringType>;
+        }>>;
+    }>;
     /**
      * Accordion — collapsible content panels. `trigger` on each item is a
      * UIComponentType (strings coerce to `Text.Root` at the factory).