@elaraai/east-ui 1.0.26 → 1.0.28

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

@@ -193,6 +193,7 @@ export declare function sliceConfigTypeFor<T extends EastType>(rowType: T): Stru
     readonly rangeFieldId: OptionType<StringType>;
     readonly searchFieldIds: ArrayType<StringType>;
     readonly breakdownFieldIds: ArrayType<StringType>;
+    readonly fieldHints: DictType<StringType, ArrayType<StringType>>;
 }>;
 export declare const SliceConfigType: StructType<{
     readonly fields: DictType<StringType, VariantType<{
@@ -220,6 +221,7 @@ export declare const SliceConfigType: StructType<{
     readonly rangeFieldId: OptionType<StringType>;
     readonly searchFieldIds: ArrayType<StringType>;
     readonly breakdownFieldIds: ArrayType<StringType>;
+    readonly fieldHints: DictType<StringType, ArrayType<StringType>>;
 }>;
 /**
  * One field declaration in `Slice.config`. Only the label is required —
@@ -228,9 +230,11 @@ export declare const SliceConfigType: StructType<{
  * row's struct field type.
  *
  * @property label - Human-readable label shown in filter / breakdown UI
+ * @property hints - Optional candidate values surfaced as autocomplete in the filter's `in` / `notIn` / `eq` / `neq` controls
  */
 export interface SliceFieldUserConfig {
     label: string;
+    hints?: ReadonlyArray<string>;
 }
 /**
  * Plain TS config for `Slice.config`. The row type is passed as the first
@@ -308,6 +312,7 @@ declare function createSliceConfig<RowType extends EastType, Fields extends Reco
     readonly rangeFieldId: OptionType<StringType>;
     readonly searchFieldIds: ArrayType<StringType>;
     readonly breakdownFieldIds: ArrayType<StringType>;
+    readonly fieldHints: DictType<StringType, ArrayType<StringType>>;
 }>;
 /**
  * Optional fields for `Slice.state`. Each field carries either a plain
@@ -864,11 +869,13 @@ export type SliceDimensionArrayType = typeof SliceDimensionArrayType;
  * @property fieldId - Field id (key into `config.fields`)
  * @property label   - Human label
  * @property kind    - Primitive kind: `string` / `integer` / `float` / `datetime` / `boolean`
+ * @property hints   - Explicit autocomplete candidate values (from `Slice.config`); empty when none
  */
 export declare const SliceFieldDescriptorType: StructType<{
     readonly fieldId: StringType;
     readonly label: StringType;
     readonly kind: StringType;
+    readonly hints: ArrayType<StringType>;
 }>;
 export type SliceFieldDescriptorType = typeof SliceFieldDescriptorType;
 /** Array of {@link SliceFieldDescriptorType}. */
@@ -876,6 +883,7 @@ export declare const SliceFieldDescriptorArrayType: ArrayType<StructType<{
     readonly fieldId: StringType;
     readonly label: StringType;
     readonly kind: StringType;
+    readonly hints: ArrayType<StringType>;
 }>>;
 export type SliceFieldDescriptorArrayType = typeof SliceFieldDescriptorArrayType;
 /**
@@ -1537,6 +1545,7 @@ export declare const SliceBindType: StructType<{
         readonly fieldId: StringType;
         readonly label: StringType;
         readonly kind: StringType;
+        readonly hints: ArrayType<StringType>;
     }>>>;
     /** Field ids the typeahead searches over — the chrome rail shows Search when non-empty. */
     readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
@@ -1584,6 +1593,537 @@ export declare const SliceBindType: StructType<{
     readonly cohortCounts: FunctionType<[], DictType<StringType, IntegerType>>;
 }>;
 export type SliceBindType = typeof SliceBindType;
+/**
+ * Low-level platform primitives that back {@link Slice.bind}'s handle methods.
+ *
+ * @internal Not for direct use — author against {@link Slice.bind}. These exist
+ * so each handle method can be an IR-bearing `East.function` (serializable)
+ * rather than a raw host closure. Keyed entirely by the slice's store key; the
+ * data-derived primitives resolve the bound rows / config / `toMatch` from a host
+ * registry that `Slice.bind` refreshes on every bind.
+ */
+export declare const SliceBindPrimitives: {
+    readonly read: import("@elaraai/east").PlatformDefinition<[StringType], StructType<{
+        readonly range: OptionType<VariantType<{
+            readonly datetime: StructType<{
+                readonly from: DateTimeType;
+                readonly to: DateTimeType;
+            }>;
+            readonly datetimePreset: VariantType<{
+                readonly today: NullType;
+                readonly last7d: NullType;
+                readonly last30d: NullType;
+                readonly last90d: NullType;
+                readonly ytd: NullType;
+            }>;
+            readonly integer: StructType<{
+                readonly from: IntegerType;
+                readonly to: IntegerType;
+            }>;
+            readonly float: StructType<{
+                readonly from: FloatType;
+                readonly to: FloatType;
+            }>;
+        }>>;
+        readonly compare: OptionType<VariantType<{
+            readonly previousPeriod: NullType;
+            readonly previousYear: NullType;
+        }>>;
+        readonly filters: ArrayType<VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: SetType<StringType>;
+                    readonly notIn: SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: FloatType;
+                    readonly lte: FloatType;
+                    readonly gt: FloatType;
+                    readonly gte: FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly before: DateTimeType;
+                    readonly after: DateTimeType;
+                    readonly between: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                }>;
+            }>;
+            readonly boolean: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly is: BooleanType;
+                }>;
+            }>;
+        }>>;
+        readonly cohorts: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly name: StringType;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: SetType<StringType>;
+                        readonly notIn: SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: FloatType;
+                        readonly lte: FloatType;
+                        readonly gt: FloatType;
+                        readonly gte: FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: DateTimeType;
+                        readonly after: DateTimeType;
+                        readonly between: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                    }>;
+                }>;
+                readonly boolean: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>>;
+        }>>;
+        readonly activeCohorts: SetType<StringType>;
+        readonly breakdown: OptionType<StructType<{
+            readonly fieldId: StringType;
+            readonly limit: OptionType<IntegerType>;
+        }>>;
+        readonly search: OptionType<StringType>;
+        readonly visible: OptionType<SetType<StringType>>;
+        readonly selectedIndex: OptionType<IntegerType>;
+    }>>;
+    readonly write: import("@elaraai/east").PlatformDefinition<[StringType, StructType<{
+        readonly range: OptionType<VariantType<{
+            readonly datetime: StructType<{
+                readonly from: DateTimeType;
+                readonly to: DateTimeType;
+            }>;
+            readonly datetimePreset: VariantType<{
+                readonly today: NullType;
+                readonly last7d: NullType;
+                readonly last30d: NullType;
+                readonly last90d: NullType;
+                readonly ytd: NullType;
+            }>;
+            readonly integer: StructType<{
+                readonly from: IntegerType;
+                readonly to: IntegerType;
+            }>;
+            readonly float: StructType<{
+                readonly from: FloatType;
+                readonly to: FloatType;
+            }>;
+        }>>;
+        readonly compare: OptionType<VariantType<{
+            readonly previousPeriod: NullType;
+            readonly previousYear: NullType;
+        }>>;
+        readonly filters: ArrayType<VariantType<{
+            readonly string: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: StringType;
+                    readonly neq: StringType;
+                    readonly in: SetType<StringType>;
+                    readonly notIn: SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: FloatType;
+                    readonly lte: FloatType;
+                    readonly gt: FloatType;
+                    readonly gte: FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly before: DateTimeType;
+                    readonly after: DateTimeType;
+                    readonly between: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                }>;
+            }>;
+            readonly boolean: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly is: BooleanType;
+                }>;
+            }>;
+        }>>;
+        readonly cohorts: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly name: StringType;
+            readonly filters: ArrayType<VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: SetType<StringType>;
+                        readonly notIn: SetType<StringType>;
+                        readonly contains: StringType;
+                        readonly matches: StringType;
+                    }>;
+                }>;
+                readonly integer: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: IntegerType;
+                        readonly neq: IntegerType;
+                        readonly lt: IntegerType;
+                        readonly lte: IntegerType;
+                        readonly gt: IntegerType;
+                        readonly gte: IntegerType;
+                        readonly in: SetType<IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: FloatType;
+                        readonly lte: FloatType;
+                        readonly gt: FloatType;
+                        readonly gte: FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: DateTimeType;
+                        readonly after: DateTimeType;
+                        readonly between: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                    }>;
+                }>;
+                readonly boolean: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>>;
+        }>>;
+        readonly activeCohorts: SetType<StringType>;
+        readonly breakdown: OptionType<StructType<{
+            readonly fieldId: StringType;
+            readonly limit: OptionType<IntegerType>;
+        }>>;
+        readonly search: OptionType<StringType>;
+        readonly visible: OptionType<SetType<StringType>>;
+        readonly selectedIndex: OptionType<IntegerType>;
+    }>], NullType>;
+    readonly setRange: import("@elaraai/east").PlatformDefinition<[StringType, OptionType<VariantType<{
+        readonly datetime: StructType<{
+            readonly from: DateTimeType;
+            readonly to: DateTimeType;
+        }>;
+        readonly datetimePreset: VariantType<{
+            readonly today: NullType;
+            readonly last7d: NullType;
+            readonly last30d: NullType;
+            readonly last90d: NullType;
+            readonly ytd: NullType;
+        }>;
+        readonly integer: StructType<{
+            readonly from: IntegerType;
+            readonly to: IntegerType;
+        }>;
+        readonly float: StructType<{
+            readonly from: FloatType;
+            readonly to: FloatType;
+        }>;
+    }>>], NullType>;
+    readonly setCompare: import("@elaraai/east").PlatformDefinition<[StringType, OptionType<VariantType<{
+        readonly previousPeriod: NullType;
+        readonly previousYear: NullType;
+    }>>], NullType>;
+    readonly addFilter: import("@elaraai/east").PlatformDefinition<[StringType, VariantType<{
+        readonly string: StructType<{
+            readonly fieldId: StringType;
+            readonly op: VariantType<{
+                readonly eq: StringType;
+                readonly neq: StringType;
+                readonly in: SetType<StringType>;
+                readonly notIn: SetType<StringType>;
+                readonly contains: StringType;
+                readonly matches: StringType;
+            }>;
+        }>;
+        readonly integer: StructType<{
+            readonly fieldId: StringType;
+            readonly op: VariantType<{
+                readonly eq: IntegerType;
+                readonly neq: IntegerType;
+                readonly lt: IntegerType;
+                readonly lte: IntegerType;
+                readonly gt: IntegerType;
+                readonly gte: IntegerType;
+                readonly in: SetType<IntegerType>;
+            }>;
+        }>;
+        readonly float: StructType<{
+            readonly fieldId: StringType;
+            readonly op: VariantType<{
+                readonly lt: FloatType;
+                readonly lte: FloatType;
+                readonly gt: FloatType;
+                readonly gte: FloatType;
+            }>;
+        }>;
+        readonly datetime: StructType<{
+            readonly fieldId: StringType;
+            readonly op: VariantType<{
+                readonly before: DateTimeType;
+                readonly after: DateTimeType;
+                readonly between: StructType<{
+                    readonly from: DateTimeType;
+                    readonly to: DateTimeType;
+                }>;
+            }>;
+        }>;
+        readonly boolean: StructType<{
+            readonly fieldId: StringType;
+            readonly op: VariantType<{
+                readonly is: BooleanType;
+            }>;
+        }>;
+    }>], NullType>;
+    readonly removeFilter: import("@elaraai/east").PlatformDefinition<[StringType, IntegerType], NullType>;
+    readonly clearFilters: import("@elaraai/east").PlatformDefinition<[StringType], NullType>;
+    readonly defineCohort: import("@elaraai/east").PlatformDefinition<[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: SetType<StringType>;
+                    readonly notIn: SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: FloatType;
+                    readonly lte: FloatType;
+                    readonly gt: FloatType;
+                    readonly gte: FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly before: DateTimeType;
+                    readonly after: DateTimeType;
+                    readonly between: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                }>;
+            }>;
+            readonly boolean: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly is: BooleanType;
+                }>;
+            }>;
+        }>>;
+    }>], NullType>;
+    readonly updateCohort: import("@elaraai/east").PlatformDefinition<[StringType, 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: SetType<StringType>;
+                    readonly notIn: SetType<StringType>;
+                    readonly contains: StringType;
+                    readonly matches: StringType;
+                }>;
+            }>;
+            readonly integer: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly eq: IntegerType;
+                    readonly neq: IntegerType;
+                    readonly lt: IntegerType;
+                    readonly lte: IntegerType;
+                    readonly gt: IntegerType;
+                    readonly gte: IntegerType;
+                    readonly in: SetType<IntegerType>;
+                }>;
+            }>;
+            readonly float: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly lt: FloatType;
+                    readonly lte: FloatType;
+                    readonly gt: FloatType;
+                    readonly gte: FloatType;
+                }>;
+            }>;
+            readonly datetime: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly before: DateTimeType;
+                    readonly after: DateTimeType;
+                    readonly between: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                }>;
+            }>;
+            readonly boolean: StructType<{
+                readonly fieldId: StringType;
+                readonly op: VariantType<{
+                    readonly is: BooleanType;
+                }>;
+            }>;
+        }>>;
+    }>], NullType>;
+    readonly removeCohort: import("@elaraai/east").PlatformDefinition<[StringType, StringType], NullType>;
+    readonly toggleCohort: import("@elaraai/east").PlatformDefinition<[StringType, StringType], NullType>;
+    readonly setBreakdown: import("@elaraai/east").PlatformDefinition<[StringType, OptionType<StructType<{
+        readonly fieldId: StringType;
+        readonly limit: OptionType<IntegerType>;
+    }>>], NullType>;
+    readonly setSearch: import("@elaraai/east").PlatformDefinition<[StringType, OptionType<StringType>], NullType>;
+    readonly setVisible: import("@elaraai/east").PlatformDefinition<[StringType, OptionType<SetType<StringType>>], NullType>;
+    readonly select: import("@elaraai/east").PlatformDefinition<[StringType, OptionType<IntegerType>], NullType>;
+    readonly isActive: import("@elaraai/east").PlatformDefinition<[StringType], BooleanType>;
+    readonly activeCount: import("@elaraai/east").PlatformDefinition<[StringType], IntegerType>;
+    readonly dimensions: import("@elaraai/east").PlatformDefinition<[StringType], ArrayType<StructType<{
+        readonly fieldId: StringType;
+        readonly label: StringType;
+    }>>>;
+    readonly fields: import("@elaraai/east").PlatformDefinition<[StringType], ArrayType<StructType<{
+        readonly fieldId: StringType;
+        readonly label: StringType;
+        readonly kind: StringType;
+        readonly hints: ArrayType<StringType>;
+    }>>>;
+    readonly searchFieldIds: import("@elaraai/east").PlatformDefinition<[StringType], ArrayType<StringType>>;
+    readonly rangeFieldId: import("@elaraai/east").PlatformDefinition<[StringType], OptionType<StringType>>;
+    readonly totalCount: import("@elaraai/east").PlatformDefinition<[StringType], IntegerType>;
+    readonly resultCount: import("@elaraai/east").PlatformDefinition<[StringType], IntegerType>;
+    readonly groups: import("@elaraai/east").PlatformDefinition<[StringType], ArrayType<StructType<{
+        readonly key: StringType;
+        readonly count: IntegerType;
+        readonly color: StringType;
+    }>>>;
+    readonly series: import("@elaraai/east").PlatformDefinition<[StringType, StringType, StringType], ArrayType<StructType<{
+        readonly key: StringType;
+        readonly color: StringType;
+        readonly points: ArrayType<StructType<{
+            readonly x: VariantType<{
+                readonly category: StringType;
+                readonly number: FloatType;
+                readonly time: DateTimeType;
+            }>;
+            readonly value: FloatType;
+            readonly size: OptionType<FloatType>;
+            readonly color: OptionType<StringType>;
+        }>>;
+    }>>>;
+    readonly matches: import("@elaraai/east").PlatformDefinition<[StringType], ArrayType<StructType<{
+        readonly id: StringType;
+        readonly label: StringType;
+        readonly meta: OptionType<StringType>;
+    }>>>;
+    readonly cohortCounts: import("@elaraai/east").PlatformDefinition<[StringType], DictType<StringType, IntegerType>>;
+};
 /**
  * The slice-chrome payload every slice-accepting component carries — the
  * bound handle plus the affordances its rail mounts. Chrome only: the
@@ -2101,6 +2641,7 @@ export declare const SliceChromeType: StructType<{
             readonly fieldId: StringType;
             readonly label: StringType;
             readonly kind: StringType;
+            readonly hints: ArrayType<StringType>;
         }>>>;
         /** Field ids the typeahead searches over — the chrome rail shows Search when non-empty. */
         readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
@@ -2253,6 +2794,7 @@ export declare const Slice: {
         readonly rangeFieldId: OptionType<StringType>;
         readonly searchFieldIds: ArrayType<StringType>;
         readonly breakdownFieldIds: ArrayType<StringType>;
+        readonly fieldHints: DictType<StringType, ArrayType<StringType>>;
     }>, StructType<{
         readonly range: OptionType<VariantType<{
             readonly datetime: StructType<{
@@ -2908,6 +3450,7 @@ export declare const Slice: {
             readonly fieldId: StringType;
             readonly label: StringType;
             readonly kind: StringType;
+            readonly hints: ArrayType<StringType>;
         }>>>;
         /** Field ids the typeahead searches over — the chrome rail shows Search when non-empty. */
         readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
@@ -3466,6 +4009,7 @@ export declare const Slice: {
             readonly fieldId: StringType;
             readonly label: StringType;
             readonly kind: StringType;
+            readonly hints: ArrayType<StringType>;
         }>>>;
         /** Field ids the typeahead searches over — the chrome rail shows Search when non-empty. */
         readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
@@ -3684,6 +4228,7 @@ export declare const Slice: {
             readonly rangeFieldId: OptionType<StringType>;
             readonly searchFieldIds: ArrayType<StringType>;
             readonly breakdownFieldIds: ArrayType<StringType>;
+            readonly fieldHints: DictType<StringType, ArrayType<StringType>>;
         }>, "T"], BooleanType>;
         /** Array filter: returns the subset of `data` that passes. */
         readonly where: import("@elaraai/east").GenericPlatformDefinition<readonly ["T"], readonly [StructType<{
@@ -3852,6 +4397,7 @@ export declare const Slice: {
             readonly rangeFieldId: OptionType<StringType>;
             readonly searchFieldIds: ArrayType<StringType>;
             readonly breakdownFieldIds: ArrayType<StringType>;
+            readonly fieldHints: DictType<StringType, ArrayType<StringType>>;
         }>, ArrayType<"T">], ArrayType<"T">>;
         /** Active breakdown key for a row, if any. */
         readonly breakdownKey: import("@elaraai/east").GenericPlatformDefinition<readonly ["T"], readonly [StructType<{
@@ -4020,6 +4566,7 @@ export declare const Slice: {
             readonly rangeFieldId: OptionType<StringType>;
             readonly searchFieldIds: ArrayType<StringType>;
             readonly breakdownFieldIds: ArrayType<StringType>;
+            readonly fieldHints: DictType<StringType, ArrayType<StringType>>;
         }>, "T"], OptionType<StringType>>;
         /** Group the narrowed data by the active breakdown → `[{ key, count }]`. */
         readonly breakdown: import("@elaraai/east").GenericPlatformDefinition<readonly ["T"], readonly [StructType<{
@@ -4188,6 +4735,7 @@ export declare const Slice: {
             readonly rangeFieldId: OptionType<StringType>;
             readonly searchFieldIds: ArrayType<StringType>;
             readonly breakdownFieldIds: ArrayType<StringType>;
+            readonly fieldHints: DictType<StringType, ArrayType<StringType>>;
         }>, ArrayType<"T">], ArrayType<StructType<{
             readonly key: StringType;
             readonly count: IntegerType;
@@ -5042,6 +5590,7 @@ export declare const Slice: {
                 readonly fieldId: StringType;
                 readonly label: StringType;
                 readonly kind: StringType;
+                readonly hints: ArrayType<StringType>;
             }>>>;
             /** Field ids the typeahead searches over — the chrome rail shows Search when non-empty. */
             readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
@@ -5125,6 +5674,7 @@ export declare const Slice: {
             readonly fieldId: StringType;
             readonly label: StringType;
             readonly kind: StringType;
+            readonly hints: ArrayType<StringType>;
         }>;
         readonly SearchMatch: StructType<{
             readonly id: StringType;