@elaraai/east-ui 1.0.85 → 1.0.87

package/dist/src/platform/slice/local.d.ts

@@ -0,0 +1,743 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/** Typed local authoring over the existing Slice engine and frozen wire. */
+import { ArrayType, BooleanType, DateTimeType, FloatType, FunctionType, IntegerType, SetType, StringType, StructType, type EastType, type ExprType, type SubtypeExprOrValue, type TypeOf } from "@elaraai/east";
+import { SliceSearchMatchType, type SliceFieldUserConfig, type SliceStateOptions } from "./index.js";
+/** The row type inferred from an array expression or an array of values. */
+type RowOf<C> = TypeOf<C> extends ArrayType<infer R> ? Extract<R, StructType> : never;
+type Field<R extends StructType> = Extract<keyof R["fields"], string>;
+type FieldsOf<R extends StructType, T extends EastType> = {
+    [F in Field<R>]: R["fields"][F] extends T ? F : never;
+}[Field<R>];
+type Primitive = StringType | IntegerType | FloatType | DateTimeType | BooleanType;
+type Bounds<T extends EastType> = {
+    from: SubtypeExprOrValue<T>;
+    to: SubtypeExprOrValue<T>;
+};
+type Numeric<T extends IntegerType | FloatType> = Partial<Record<"lt" | "lte" | "gt" | "gte", SubtypeExprOrValue<T>>>;
+type StringChoice = readonly SubtypeExprOrValue<StringType>[] | {
+    eq?: SubtypeExprOrValue<StringType>;
+    neq?: SubtypeExprOrValue<StringType>;
+    in?: SubtypeExprOrValue<SetType<StringType>>;
+    notIn?: SubtypeExprOrValue<SetType<StringType>>;
+    prefix?: SubtypeExprOrValue<StringType>;
+    contains?: SubtypeExprOrValue<StringType>;
+    matches?: SubtypeExprOrValue<StringType>;
+    startsWith?: SubtypeExprOrValue<StringType>;
+    endsWith?: SubtypeExprOrValue<StringType>;
+    isEmpty?: true;
+    isNotEmpty?: true;
+};
+type Choice<T extends EastType> = T extends StringType ? StringChoice : T extends IntegerType ? readonly SubtypeExprOrValue<IntegerType>[] | Bounds<IntegerType> | (Numeric<IntegerType> & {
+    eq?: SubtypeExprOrValue<IntegerType>;
+    neq?: SubtypeExprOrValue<IntegerType>;
+    in?: SubtypeExprOrValue<SetType<IntegerType>>;
+}) : T extends FloatType ? Bounds<FloatType> | Numeric<FloatType> : T extends DateTimeType ? Bounds<DateTimeType> | {
+    before?: SubtypeExprOrValue<DateTimeType>;
+    after?: SubtypeExprOrValue<DateTimeType>;
+} | {
+    preset: "today" | "last7d" | "last30d" | "last90d" | "ytd";
+} : T extends BooleanType ? readonly [SubtypeExprOrValue<BooleanType>] | {
+    is: SubtypeExprOrValue<BooleanType>;
+} : never;
+/** Typed, AND-ed local predicates, using the local engine's existing operators. */
+export type LocalSliceWhere<R extends StructType> = {
+    [F in Field<R>]?: Choice<R["fields"][F]>;
+};
+/** Options for rows in hand; record-only limitations do not leak into this arm. */
+export interface LocalSliceOptions<R extends StructType> {
+    /** Offered fields; omitted means all row fields, with labels inferred from names. */
+    fields?: {
+        [F in Field<R>]?: Omit<SliceFieldUserConfig<R>, "label"> & {
+            label?: string;
+        };
+    };
+    /** Numeric or datetime field shared by the range control and host window. */
+    range?: FieldsOf<R, DateTimeType | IntegerType | FloatType>;
+    /** Search fields; omitted uses the offered String and text-projection fields. */
+    search?: Field<R> | readonly Field<R>[];
+    /** Fields offered by the breakdown control. */
+    breakdown?: readonly FieldsOf<R, Primitive>[];
+    /** Narrowing seeded on the first bind only. */
+    initial?: LocalSliceWhere<R>;
+    /** Named predicates; active presets AND, or OR within a named group. */
+    presets?: readonly {
+        id: string;
+        name: string;
+        where: LocalSliceWhere<R>;
+        group?: string;
+        active?: boolean;
+    }[];
+    /** Reified suggestion projection; receives one original row. */
+    match?: (row: ExprType<R>) => SubtypeExprOrValue<SliceSearchMatchType>;
+    /** Optional initial presentation/selection state, separate from field predicates. */
+    view?: Pick<SliceStateOptions, "compare" | "breakdown" | "search" | "visible" | "selectedIndex" | "resolution">;
+}
+/** A typed authoring handle; component payloads still project to SliceBindType. */
+export declare function LocalSliceHandleType<R extends StructType>(row: R): StructType<{
+    readonly data: FunctionType<[], ArrayType<R>>;
+    readonly key: StringType;
+    readonly read: FunctionType<[], StructType<{
+        readonly range: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+            readonly datetime: StructType<{
+                readonly from: DateTimeType;
+                readonly to: DateTimeType;
+            }>;
+            readonly datetimePreset: import("@elaraai/east").VariantType<{
+                readonly today: import("@elaraai/east").NullType;
+                readonly last7d: import("@elaraai/east").NullType;
+                readonly last30d: import("@elaraai/east").NullType;
+                readonly last90d: import("@elaraai/east").NullType;
+                readonly ytd: import("@elaraai/east").NullType;
+            }>;
+            readonly integer: StructType<{
+                readonly from: IntegerType;
+                readonly to: IntegerType;
+            }>;
+            readonly float: StructType<{
+                readonly from: FloatType;
+                readonly to: FloatType;
+            }>;
+        }>>;
+        readonly compare: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+            readonly previousPeriod: import("@elaraai/east").NullType;
+            readonly previousYear: import("@elaraai/east").NullType;
+        }>>;
+        readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: SetType<StringType>;
+                    readonly notIn: SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                    readonly startsWith: StringType;
+                    readonly endsWith: StringType;
+                    readonly isEmpty: import("@elaraai/east").NullType;
+                    readonly isNotEmpty: import("@elaraai/east").NullType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly lt: FloatType;
+                    readonly lte: FloatType;
+                    readonly gt: FloatType;
+                    readonly gte: FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly before: DateTimeType;
+                    readonly after: DateTimeType;
+                    readonly between: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                }>;
+            }>;
+            readonly boolean: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly is: BooleanType;
+                }>;
+            }>;
+        }>>;
+        readonly cohorts: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly name: StringType;
+            readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: SetType<StringType>;
+                        readonly notIn: SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: import("@elaraai/east").NullType;
+                        readonly isNotEmpty: import("@elaraai/east").NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly lt: FloatType;
+                        readonly lte: FloatType;
+                        readonly gt: FloatType;
+                        readonly gte: FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly before: DateTimeType;
+                        readonly after: DateTimeType;
+                        readonly between: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                    }>;
+                }>;
+                readonly boolean: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>>;
+            readonly group: import("@elaraai/east").OptionType<StringType>;
+        }>>;
+        readonly activeCohorts: SetType<StringType>;
+        readonly breakdown: import("@elaraai/east").OptionType<StructType<{
+            readonly fieldId: StringType;
+            readonly limit: import("@elaraai/east").OptionType<IntegerType>;
+        }>>;
+        readonly search: import("@elaraai/east").OptionType<StringType>;
+        readonly visible: import("@elaraai/east").OptionType<SetType<StringType>>;
+        readonly selectedIndex: import("@elaraai/east").OptionType<IntegerType>;
+        readonly resolution: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+            readonly auto: import("@elaraai/east").NullType;
+            readonly hour: import("@elaraai/east").NullType;
+            readonly day: import("@elaraai/east").NullType;
+            readonly week: import("@elaraai/east").NullType;
+            readonly month: import("@elaraai/east").NullType;
+            readonly quarter: import("@elaraai/east").NullType;
+            readonly year: import("@elaraai/east").NullType;
+        }>>;
+    }>>;
+    readonly write: FunctionType<[StructType<{
+        readonly range: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+            readonly datetime: StructType<{
+                readonly from: DateTimeType;
+                readonly to: DateTimeType;
+            }>;
+            readonly datetimePreset: import("@elaraai/east").VariantType<{
+                readonly today: import("@elaraai/east").NullType;
+                readonly last7d: import("@elaraai/east").NullType;
+                readonly last30d: import("@elaraai/east").NullType;
+                readonly last90d: import("@elaraai/east").NullType;
+                readonly ytd: import("@elaraai/east").NullType;
+            }>;
+            readonly integer: StructType<{
+                readonly from: IntegerType;
+                readonly to: IntegerType;
+            }>;
+            readonly float: StructType<{
+                readonly from: FloatType;
+                readonly to: FloatType;
+            }>;
+        }>>;
+        readonly compare: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+            readonly previousPeriod: import("@elaraai/east").NullType;
+            readonly previousYear: import("@elaraai/east").NullType;
+        }>>;
+        readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: SetType<StringType>;
+                    readonly notIn: SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                    readonly startsWith: StringType;
+                    readonly endsWith: StringType;
+                    readonly isEmpty: import("@elaraai/east").NullType;
+                    readonly isNotEmpty: import("@elaraai/east").NullType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly lt: FloatType;
+                    readonly lte: FloatType;
+                    readonly gt: FloatType;
+                    readonly gte: FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly before: DateTimeType;
+                    readonly after: DateTimeType;
+                    readonly between: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                }>;
+            }>;
+            readonly boolean: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly is: BooleanType;
+                }>;
+            }>;
+        }>>;
+        readonly cohorts: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly name: StringType;
+            readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: SetType<StringType>;
+                        readonly notIn: SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                        readonly startsWith: StringType;
+                        readonly endsWith: StringType;
+                        readonly isEmpty: import("@elaraai/east").NullType;
+                        readonly isNotEmpty: import("@elaraai/east").NullType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly lt: FloatType;
+                        readonly lte: FloatType;
+                        readonly gt: FloatType;
+                        readonly gte: FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly before: DateTimeType;
+                        readonly after: DateTimeType;
+                        readonly between: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                    }>;
+                }>;
+                readonly boolean: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: import("@elaraai/east").VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>>;
+            readonly group: import("@elaraai/east").OptionType<StringType>;
+        }>>;
+        readonly activeCohorts: SetType<StringType>;
+        readonly breakdown: import("@elaraai/east").OptionType<StructType<{
+            readonly fieldId: StringType;
+            readonly limit: import("@elaraai/east").OptionType<IntegerType>;
+        }>>;
+        readonly search: import("@elaraai/east").OptionType<StringType>;
+        readonly visible: import("@elaraai/east").OptionType<SetType<StringType>>;
+        readonly selectedIndex: import("@elaraai/east").OptionType<IntegerType>;
+        readonly resolution: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+            readonly auto: import("@elaraai/east").NullType;
+            readonly hour: import("@elaraai/east").NullType;
+            readonly day: import("@elaraai/east").NullType;
+            readonly week: import("@elaraai/east").NullType;
+            readonly month: import("@elaraai/east").NullType;
+            readonly quarter: import("@elaraai/east").NullType;
+            readonly year: import("@elaraai/east").NullType;
+        }>>;
+    }>], import("@elaraai/east").NullType>;
+    readonly setRange: FunctionType<[import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+        readonly datetime: StructType<{
+            readonly from: DateTimeType;
+            readonly to: DateTimeType;
+        }>;
+        readonly datetimePreset: import("@elaraai/east").VariantType<{
+            readonly today: import("@elaraai/east").NullType;
+            readonly last7d: import("@elaraai/east").NullType;
+            readonly last30d: import("@elaraai/east").NullType;
+            readonly last90d: import("@elaraai/east").NullType;
+            readonly ytd: import("@elaraai/east").NullType;
+        }>;
+        readonly integer: StructType<{
+            readonly from: IntegerType;
+            readonly to: IntegerType;
+        }>;
+        readonly float: StructType<{
+            readonly from: FloatType;
+            readonly to: FloatType;
+        }>;
+    }>>], import("@elaraai/east").NullType>;
+    readonly setCompare: FunctionType<[import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+        readonly previousPeriod: import("@elaraai/east").NullType;
+        readonly previousYear: import("@elaraai/east").NullType;
+    }>>], import("@elaraai/east").NullType>;
+    readonly addFilter: FunctionType<[import("@elaraai/east").VariantType<{
+        readonly string: StructType<{
+            readonly fieldId: StringType;
+            readonly op: import("@elaraai/east").VariantType<{
+                readonly eq: StringType;
+                readonly neq: StringType;
+                readonly in: SetType<StringType>;
+                readonly notIn: SetType<StringType>;
+                readonly contains: StringType;
+                readonly matches: StringType;
+                readonly startsWith: StringType;
+                readonly endsWith: StringType;
+                readonly isEmpty: import("@elaraai/east").NullType;
+                readonly isNotEmpty: import("@elaraai/east").NullType;
+            }>;
+        }>;
+        readonly integer: StructType<{
+            readonly fieldId: StringType;
+            readonly op: import("@elaraai/east").VariantType<{
+                readonly eq: IntegerType;
+                readonly neq: IntegerType;
+                readonly lt: IntegerType;
+                readonly lte: IntegerType;
+                readonly gt: IntegerType;
+                readonly gte: IntegerType;
+                readonly in: SetType<IntegerType>;
+            }>;
+        }>;
+        readonly float: StructType<{
+            readonly fieldId: StringType;
+            readonly op: import("@elaraai/east").VariantType<{
+                readonly lt: FloatType;
+                readonly lte: FloatType;
+                readonly gt: FloatType;
+                readonly gte: FloatType;
+            }>;
+        }>;
+        readonly datetime: StructType<{
+            readonly fieldId: StringType;
+            readonly op: import("@elaraai/east").VariantType<{
+                readonly before: DateTimeType;
+                readonly after: DateTimeType;
+                readonly between: StructType<{
+                    readonly from: DateTimeType;
+                    readonly to: DateTimeType;
+                }>;
+            }>;
+        }>;
+        readonly boolean: StructType<{
+            readonly fieldId: StringType;
+            readonly op: import("@elaraai/east").VariantType<{
+                readonly is: BooleanType;
+            }>;
+        }>;
+    }>], import("@elaraai/east").NullType>;
+    readonly removeFilter: FunctionType<[IntegerType], import("@elaraai/east").NullType>;
+    readonly clearFilters: FunctionType<[], import("@elaraai/east").NullType>;
+    readonly defineCohort: FunctionType<[StructType<{
+        readonly id: StringType;
+        readonly name: StringType;
+        readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: SetType<StringType>;
+                    readonly notIn: SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                    readonly startsWith: StringType;
+                    readonly endsWith: StringType;
+                    readonly isEmpty: import("@elaraai/east").NullType;
+                    readonly isNotEmpty: import("@elaraai/east").NullType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly lt: FloatType;
+                    readonly lte: FloatType;
+                    readonly gt: FloatType;
+                    readonly gte: FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly before: DateTimeType;
+                    readonly after: DateTimeType;
+                    readonly between: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                }>;
+            }>;
+            readonly boolean: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly is: BooleanType;
+                }>;
+            }>;
+        }>>;
+        readonly group: import("@elaraai/east").OptionType<StringType>;
+    }>], import("@elaraai/east").NullType>;
+    readonly updateCohort: FunctionType<[StringType, StructType<{
+        readonly id: StringType;
+        readonly name: StringType;
+        readonly filters: ArrayType<import("@elaraai/east").VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: SetType<StringType>;
+                    readonly notIn: SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                    readonly startsWith: StringType;
+                    readonly endsWith: StringType;
+                    readonly isEmpty: import("@elaraai/east").NullType;
+                    readonly isNotEmpty: import("@elaraai/east").NullType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly lt: FloatType;
+                    readonly lte: FloatType;
+                    readonly gt: FloatType;
+                    readonly gte: FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly before: DateTimeType;
+                    readonly after: DateTimeType;
+                    readonly between: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                }>;
+            }>;
+            readonly boolean: StructType<{
+                readonly fieldId: StringType;
+                readonly op: import("@elaraai/east").VariantType<{
+                    readonly is: BooleanType;
+                }>;
+            }>;
+        }>>;
+        readonly group: import("@elaraai/east").OptionType<StringType>;
+    }>], import("@elaraai/east").NullType>;
+    readonly removeCohort: FunctionType<[StringType], import("@elaraai/east").NullType>;
+    readonly toggleCohort: FunctionType<[StringType], import("@elaraai/east").NullType>;
+    readonly setBreakdown: FunctionType<[import("@elaraai/east").OptionType<StructType<{
+        readonly fieldId: StringType;
+        readonly limit: import("@elaraai/east").OptionType<IntegerType>;
+    }>>], import("@elaraai/east").NullType>;
+    readonly setSearch: FunctionType<[import("@elaraai/east").OptionType<StringType>], import("@elaraai/east").NullType>;
+    readonly setVisible: FunctionType<[import("@elaraai/east").OptionType<SetType<StringType>>], import("@elaraai/east").NullType>;
+    readonly select: FunctionType<[import("@elaraai/east").OptionType<IntegerType>], import("@elaraai/east").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: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+            readonly number: import("@elaraai/east").NullType;
+            readonly currency: StructType<{
+                readonly code: StringType;
+                readonly compact: BooleanType;
+            }>;
+            readonly percent: import("@elaraai/east").NullType;
+            readonly compact: import("@elaraai/east").NullType;
+            readonly date: StringType;
+            readonly time: StringType;
+            readonly datetime: StringType;
+        }>>;
+    }>>>;
+    readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
+    readonly rangeFieldId: FunctionType<[], import("@elaraai/east").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: import("@elaraai/east").VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: DateTimeType;
+            }>;
+            readonly value: FloatType;
+            readonly size: import("@elaraai/east").OptionType<FloatType>;
+            readonly color: import("@elaraai/east").OptionType<StringType>;
+        }>>;
+    }>>>;
+    readonly matches: FunctionType<[], ArrayType<StructType<{
+        readonly id: StringType;
+        readonly label: StringType;
+        readonly meta: import("@elaraai/east").OptionType<StringType>;
+    }>>>;
+    readonly cohortCounts: FunctionType<[], import("@elaraai/east").DictType<StringType, IntegerType>>;
+    readonly toggleFilter: FunctionType<[import("@elaraai/east").VariantType<{
+        readonly string: StructType<{
+            readonly fieldId: StringType;
+            readonly op: import("@elaraai/east").VariantType<{
+                readonly eq: StringType;
+                readonly neq: StringType;
+                readonly in: SetType<StringType>;
+                readonly notIn: SetType<StringType>;
+                readonly contains: StringType;
+                readonly matches: StringType;
+                readonly startsWith: StringType;
+                readonly endsWith: StringType;
+                readonly isEmpty: import("@elaraai/east").NullType;
+                readonly isNotEmpty: import("@elaraai/east").NullType;
+            }>;
+        }>;
+        readonly integer: StructType<{
+            readonly fieldId: StringType;
+            readonly op: import("@elaraai/east").VariantType<{
+                readonly eq: IntegerType;
+                readonly neq: IntegerType;
+                readonly lt: IntegerType;
+                readonly lte: IntegerType;
+                readonly gt: IntegerType;
+                readonly gte: IntegerType;
+                readonly in: SetType<IntegerType>;
+            }>;
+        }>;
+        readonly float: StructType<{
+            readonly fieldId: StringType;
+            readonly op: import("@elaraai/east").VariantType<{
+                readonly lt: FloatType;
+                readonly lte: FloatType;
+                readonly gt: FloatType;
+                readonly gte: FloatType;
+            }>;
+        }>;
+        readonly datetime: StructType<{
+            readonly fieldId: StringType;
+            readonly op: import("@elaraai/east").VariantType<{
+                readonly before: DateTimeType;
+                readonly after: DateTimeType;
+                readonly between: StructType<{
+                    readonly from: DateTimeType;
+                    readonly to: DateTimeType;
+                }>;
+            }>;
+        }>;
+        readonly boolean: StructType<{
+            readonly fieldId: StringType;
+            readonly op: import("@elaraai/east").VariantType<{
+                readonly is: BooleanType;
+            }>;
+        }>;
+    }>], import("@elaraai/east").NullType>;
+    readonly facetGroups: FunctionType<[], ArrayType<StructType<{
+        readonly key: StringType;
+        readonly count: IntegerType;
+        readonly color: StringType;
+    }>>>;
+    readonly setResolution: FunctionType<[import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+        readonly auto: import("@elaraai/east").NullType;
+        readonly hour: import("@elaraai/east").NullType;
+        readonly day: import("@elaraai/east").NullType;
+        readonly week: import("@elaraai/east").NullType;
+        readonly month: import("@elaraai/east").NullType;
+        readonly quarter: import("@elaraai/east").NullType;
+        readonly year: import("@elaraai/east").NullType;
+    }>>], import("@elaraai/east").NullType>;
+}>;
+/**
+ * Bind rows in hand with inferred fields and typed options.
+ * @param key - Stable UI store key.
+ * @param collection - Complete rows the browser may narrow.
+ * @param options - Offered fields, initial narrowing and named presets.
+ * @returns A serializable typed handle; Slice.rows reads its current narrowed rows.
+ */
+export declare function bindLocal<const C extends SubtypeExprOrValue<ArrayType<StructType>>>(key: SubtypeExprOrValue<StringType>, collection: C, options?: LocalSliceOptions<RowOf<C>>): ExprType<ReturnType<typeof LocalSliceHandleType<RowOf<C>>>>;
+export {};
+//# sourceMappingURL=local.d.ts.map