eru-grid 0.0.40 → 0.0.42

package/types/eru-grid.d.ts

@@ -3,6 +3,7 @@ import * as _angular_core from '@angular/core';
 import { OnInit, AfterViewInit, OnDestroy, QueryList, ElementRef, TemplateRef, EventEmitter, ChangeDetectorRef, Provider } from '@angular/core';
 import { FixedSizeVirtualScrollStrategy, CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
 import { MatDatepicker } from '@angular/material/datepicker';
+import { ConnectedPosition } from '@angular/cdk/overlay';
 
 interface Row {
     entity_id: string;
@@ -67,6 +68,8 @@ interface GridFeatures {
     allowSelection?: boolean;
     actionColumn?: boolean;
     actionColumnPosition?: 'before' | 'after';
+    actions?: GridAction[];
+    action_display_type?: 'icons' | 'kebab';
     designMode?: boolean;
     groupBar?: boolean;
     excel_download?: boolean;
@@ -97,7 +100,9 @@ interface GridFeatures {
     boardCardSelectedBg?: string;
     boardCardSelectedOutline?: string;
     boardColumnMinWidth?: number;
+    boardColumnMaxWidth?: number;
     boardColumnHeight?: number;
+    boardWrapColumns?: boolean;
 }
 interface ExcelDownloadPayload {
     columns: Record<string, {
@@ -157,6 +162,40 @@ interface ExcelDownloadRequest extends ExcelDownloadPayload {
     id: number;
     timestamp: number;
 }
+/**
+ * A message from a cell's server-side validation check, queued for the consumer
+ * to display. eru-grid does not render a snackbar — it delegates chrome to the
+ * consumer, the same way it delegates data fetching — so this follows the
+ * enqueue/drain pattern of ExcelDownloadRequest: the consumer watches
+ * `EruGridStore.serverValidationNotices()`, shows its own snackbar (red when
+ * status is 'error'), and calls removeServerValidationNotice(id).
+ */
+interface ServerValidationNotice {
+    id: string;
+    timestamp: number;
+    rowId: string;
+    fieldName: string;
+    status: 'success' | 'error';
+    msg: string;
+}
+/**
+ * One action offered on every row, rendered in the action column.
+ *
+ * `action_name` is both the tooltip (icon mode) / label (kebab mode) and the
+ * identity the consumer matches on when the click comes back — eru-studio keys
+ * its configured 'Custom Action' subscription off it — so it has to be unique
+ * within a grid.
+ *
+ * `action_visible_condition` is a row-scoped expression in the same language
+ * eru-studio uses for its logic (`@field is not 'closed' AND @amount > 1000`),
+ * evaluated per row against that row's column values. Blank means always
+ * visible; see evaluateRowCondition().
+ */
+interface GridAction {
+    action_name: string;
+    action_icon?: string;
+    action_visible_condition?: string;
+}
 interface GridStyles {
     subTotalStyle?: 'bold' | 'italic' | 'highlighted';
     grandTotalStyle?: 'bold' | 'italic' | 'highlighted';
@@ -200,6 +239,7 @@ interface DynamicDataRequest {
     apiName?: string;
     apiField?: string;
     search?: string;
+    filter?: Record<string, any>;
 }
 interface Field {
     name: string;
@@ -207,8 +247,8 @@ interface Field {
     datatype: DataTypes;
     field_size: number;
     grid_index: number;
-    required?: boolean;
     mandatory?: boolean;
+    required?: boolean;
     minWidth?: number;
     maxWidth?: number;
     symbol?: string;
@@ -245,24 +285,159 @@ interface Field {
     data_length?: number;
     start_value?: number;
     end_value?: number;
+    is_perc?: boolean;
     emoji_value?: string;
     max_files?: number;
     allowed_file_types?: any[];
-    maxFileSize?: number;
+    max_file_size?: number;
     default_country?: string;
     date_format?: string;
     dateTimeFormat?: string;
     allow_days?: string[];
+    /**
+     * Dependent-dropdown mapping, for `option_type: 'ENTITY_DATA'`.
+     *
+     * Each pair links a field on the CURRENT record to the field it filters on in
+     * the option-source entity: `def` is the key in the current entity supplying
+     * the value, `dpef` is the key in the mapped entity to match it against.
+     * Several pairs mean the list is scoped by all of them.
+     *
+     * Replaces the earlier single `dpef` string, which could only express one
+     * dependency and conflated the two sides. A lone `dpef` is still read as
+     * `{ def: dpef, dpef: dpef }` for fields saved before this existed.
+     */
+    df_fields?: {
+        def: string;
+        dpef: string;
+    }[];
+    /** Legacy single dependency. Prefer `df_fields`. */
+    dpef?: string;
+    /** Legacy: key in the current entity paired with `dpef`. */
+    def?: string;
+    multiple?: boolean;
+    searchable?: boolean;
+    max_avatars?: number;
+    people_card?: string;
+    show_people_card?: 'none' | 'hover' | 'click';
+    value_true?: string;
+    value_false?: string;
     rich_text?: boolean;
     is_hyp?: boolean;
     hypl_nm?: string;
+    is_pii?: boolean;
+    is_ephi?: boolean;
+    to_encrypt?: boolean;
+    is_pf?: boolean;
+    is_unique?: boolean;
+    unq_sa?: boolean;
+    system_validate?: string;
+    ssv_api?: string;
+    can_group?: boolean;
+    default_group?: boolean;
+    mapped_entity?: string;
+    mapped_field?: string;
     tool_tip?: string;
     description?: string;
     default?: any;
     editable?: boolean | string;
     is_hidden?: boolean;
 }
-type DataTypes = 'number' | 'textbox' | 'currency' | 'date' | 'datetime' | 'duration' | 'dropdown_single_select' | 'dropdown_multi_select' | 'location' | 'email' | 'people' | 'checkbox' | 'phone' | 'priority' | 'status' | 'progress' | 'attachment' | 'tag' | 'rating' | 'website';
+/**
+ * Field attributes a mapped column inherits from the data model.
+ *
+ * Single source of truth for two things that must agree: what
+ * `buildMappedColumnPatch()` merges onto the column on every load, and what the
+ * column design panel renders read-only. If a key is inherited but not locked,
+ * a user's edit is silently discarded on reload; if it is locked but not
+ * inherited, the control is dead. Keep both behaviours driven from this list.
+ *
+ * The rule: anything the data model authors belongs here; anything that is a
+ * property of *this view* of the field does not. Deliberately excluded —
+ *   field_size, grid_index  layout, set by column resize/reorder
+ *   tool_tip                per-grid header help text
+ *   is_hidden               hiding a column in one grid should not require
+ *                           hiding the field in the data model
+ *   dateTimeFormat          legacy alias; the model writes `date_format`
+ */
+declare const INHERITED_FIELD_KEYS: readonly string[];
+type DataTypes = 'number' | 'textbox' | 'textarea' | 'currency' | 'date' | 'datetime' | 'duration' | 'time' | 'dropdown_single_select' | 'dropdown_multi_select' | 'location' | 'email' | 'people' | 'checkbox' | 'phone' | 'priority' | 'status' | 'progress' | 'attachment' | 'tag' | 'rating' | 'website';
+/** Resolve a data-model datatype to the canonical DataTypes value. */
+declare function normalizeDatatype(datatype: any): DataTypes;
+/** Short month names, for the `MMM` token. */
+declare const MONTH_SHORT_NAMES: string[];
+/**
+ * The date formats offered to users, in every layer.
+ *
+ * One list so eru-studio, eru-grid and the processo data model present the same
+ * choices — previously studio offered eight, while the grid's panel and processo
+ * offered three, so a format could be picked on a page and had no equivalent on
+ * a field.
+ *
+ * Values are in token form: `dd` day, `MM` month number, `MMM` month name,
+ * `yyyy` year. Casing is significant — lowercase `mm` means minutes in a
+ * datetime — so values are normalised rather than lowercased on read.
+ */
+declare const DATE_FORMATS: {
+    value: string;
+    label: string;
+}[];
+/** The same orderings with a 24-hour time part, for datetime fields. */
+declare const DATETIME_FORMATS: {
+    value: string;
+    label: string;
+}[];
+/**
+ * Normalise a date format to token casing, so a value saved in any casing
+ * matches the canonical option. The data model uppercases on save
+ * (`DD-MMM-YYYY`) and older UIs stored lowercase.
+ *
+ * `mmm` is handled before `mm`, or the longer token would be half-consumed and
+ * `dd-mmm-yyyy` would come out as `dd-MMm-yyyy`.
+ */
+declare function normalizeDateFormat(format: string | null | undefined): string;
+/**
+ * Normalise a datetime format. Only the date half is token-cased — `mm` in the
+ * time half is minutes and must stay lowercase, which is why this cannot just
+ * reuse normalizeDateFormat over the whole string. The date half is everything
+ * before the time, located by the `hh` token rather than by whitespace, since a
+ * date pattern may itself contain a space (`dd MMM yyyy`).
+ */
+declare function normalizeDateTimeFormat(format: string | null | undefined): string;
+/**
+ * Render a date with a token pattern (`dd`, `MM`, `MMM`, `yyyy`).
+ *
+ * Shared by both libraries so a date reads identically on a page and in a grid.
+ * The alternation lists longer tokens first, so `MMM` is matched before `MM`
+ * and `yyyy` is never partly consumed — the bug that a chain of string
+ * replacements invites.
+ */
+declare function formatDateWithPattern(date: Date | null, pattern: string): string;
+/**
+ * Parse text written in a token pattern back to a Date, or null.
+ *
+ * Built as a regex from the pattern rather than by splitting on a separator:
+ * a month name is not numeric, and patterns may use a space or a comma, so
+ * splitting cannot recover the field order on its own.
+ */
+declare function parseDateWithPattern(text: string, pattern: string): Date | null;
+/** One value band and the colours it paints. Either bound may be open-ended. */
+interface ColorRangeBand {
+    from?: number | null;
+    to?: number | null;
+    color?: string | null;
+    background?: string | null;
+}
+/**
+ * Resolve a numeric value against a column's `color_ranges`, returning the
+ * first matching band or null.
+ *
+ * Shared by the progress, number and currency cells so a value falling in the
+ * same band paints the same way whichever datatype renders it. A blank or
+ * absent bound is open-ended — data-model bands are authored that way ("80 and
+ * above"), and coercing a missing bound to 0 would stop such a band matching.
+ * Bands are checked in order, so the author controls precedence.
+ */
+declare function matchColorRange(value: any, ranges: any): ColorRangeBand | null;
 declare const DATA_TYPES: DataTypes[];
 type AggregationFunction = 'sum' | 'count' | 'avg' | 'min' | 'max';
 interface PivotColumnGroupState {
@@ -330,16 +505,67 @@ interface PivotResult {
     headerStructure?: PivotHeaderStructure;
     columnGroupState?: PivotColumnGroupState;
 }
+/**
+ * A drill click on a data cell, in either table or pivot mode.
+ *
+ * `columnName` is the key the consumer matches on to decide what to do: a
+ * column name in table mode, and in pivot mode the leaf name — which for an
+ * aggregated cell is the aggregation's name. `pivotPath` carries the column
+ * dimension values that located the cell, and those are also merged into
+ * `rowData` so the whole coordinate of the clicked cell reads off one object.
+ */
+/**
+ * What kind of pivot row a drilled cell sits on. A total aggregates rows the
+ * cell does not name, so a consumer has to treat it differently from a data
+ * cell — see Drilldown.scope.
+ */
+type PivotRowKind = 'data' | 'row_subtotal' | 'row_grand_total';
+/** What kind of pivot column a drilled cell sits in. */
+type PivotColumnKind = 'data' | 'column_grand_total';
 interface Drilldown {
     frozenGrandTotalCell: boolean;
     columnName: string;
     rowId: string;
     rowData?: any;
     columnValue: any;
+    /** 'table' | 'pivot' — which surface the click came from. */
+    mode?: GridMode;
+    /** Pivot column-dimension values leading to this cell, outermost first. */
+    pivotPath?: string[];
+    /** The full leaf column name, pivot path included (pivot mode only). */
+    leafColumnName?: string;
+    /**
+     * Which row and column the cell belongs to, in total terms. A subtotal or
+     * grand-total cell is otherwise indistinguishable from a data cell — same
+     * column name, same shape of value — so a consumer could not tell that the
+     * number covers rows beyond the ones the cell names.
+     */
+    rowKind?: PivotRowKind;
+    columnKind?: PivotColumnKind;
+    /**
+     * The dimension values this cell is actually scoped to — what a consumer
+     * should filter the source by to reach the rows behind it.
+     *
+     * For a data cell that is every row and column dimension. For a row subtotal
+     * only the dimensions fixed at that level appear, because the rest are rolled
+     * up; for a grand total it is empty, meaning "everything". This is why the
+     * raw row cannot be used: on a total the transform overwrites the leading
+     * dimension with its label ("Subtotal - Rolling Test 2019") and blanks the
+     * rest, so filtering by the row's own fields would produce nonsense.
+     */
+    scope?: Record<string, any>;
+    /** How many source rows the cell aggregates, when the pivot reports it. */
+    sourceCount?: number;
 }
 interface ActionClick {
     rowId: string;
     rowData?: any;
+    /** Name of the configured action that was clicked; absent for the fallback icon. */
+    action_name?: string;
+    /** The full action descriptor, for consumers that need the icon/condition too. */
+    action?: GridAction | null;
+    mode?: 'table' | 'board';
+    group?: RowGroup;
 }
 interface RowDataRequest {
     groupId: string;
@@ -380,6 +606,25 @@ interface CellValueChange {
  *   </ng-template>
  *   <eru-grid [boardCardTemplate]="myCard" [gridConfig]="cfg"></eru-grid>
  */
+/**
+ * Template context injected into a personCardTemplate on EruGridComponent.
+ *
+ * eru-studio renders a whole studio page as the person card. eru-grid cannot do
+ * that — it has no page renderer, and the dependency runs studio -> grid — so it
+ * follows the same pattern as boardCardTemplate: the grid owns the trigger,
+ * positioning and dismissal, and the consumer supplies the content.
+ *
+ *   <ng-template #personCard let-userId let-column="column">…</ng-template>
+ *   <eru-grid [personCardTemplate]="personCard" [gridConfig]="cfg"></eru-grid>
+ */
+interface PersonCardContext {
+    /** The selected person's id ($implicit — bind with let-userId) */
+    $implicit: string;
+    /** The people column this avatar belongs to */
+    column: Field | null;
+    /** Page the field names as the card, from the data model's people_card */
+    cardPage?: string;
+}
 interface BoardCardContext {
     /** Row data for this card ($implicit — bind with let-row) */
     $implicit: Row;
@@ -515,6 +760,17 @@ declare class PivotTransformService {
     /**
      * Add interleaved subtotals within column groups
      */
+    /**
+     * The column-dimension values a generated pivot column belongs to.
+     *
+     * Prefers the `parentPath` the generator already recorded. The fallback parses
+     * the name, which is "<dim>|<dim>|<aggregation>" — so the dimensions are every
+     * segment but the last. This used to be read as `name.split('_')[0]`, which
+     * only worked while no dimension value and no leading part of an aggregation
+     * name contained an underscore; one underscore in a dimension value silently
+     * grouped the columns wrongly.
+     */
+    private dimensionPartsOf;
     private addInterleavedSubtotals;
     /**
      * Group pivot columns by dimension prefixes for subtotal insertion
@@ -543,6 +799,48 @@ declare class PivotTransformService {
     /**
      * Apply aggregation function to array of values
      */
+    /**
+     * The function that combines already-aggregated cell values into a subtotal
+     * or grand total.
+     *
+     * Rolling a total up is NOT the same operation as computing the cells. A
+     * subtotal over `count` cells must ADD the counts; applying `count` again
+     * counts how many pivot rows contributed, which is why every subtotal read 1
+     * and the grand total read 7 (the number of pivot rows) instead of the real
+     * record counts. `sum`, `min` and `max` are associative so they roll up as
+     * themselves — which is why sums looked right and hid the bug.
+     *
+     * `avg` has no correct roll-up from the averages alone: the mean of means is
+     * only the true mean when every group has the same number of records. It is
+     * left as-is rather than silently reported as exact — see the note at the
+     * call sites.
+     */
+    private rollUpFunction;
+    /**
+     * The source records a pivot row covers, or null when they cannot be worked
+     * out and the caller must fall back to rolling up cells.
+     *
+     * A grand-total row covers everything; a subtotal row covers the records
+     * matching the dimension prefix in its key ("subtotal_<value>"); a data row
+     * covers the records matching all of its dimension values. Row keys are the
+     * dimension values joined by '|', which is what makes this recoverable — the
+     * row's own display fields are not usable on a total, where the transform has
+     * replaced the leading dimension with a label and blanked the rest.
+     */
+    /** Escape a value so it can be embedded in a RegExp as a literal. */
+    private escapeForRegExp;
+    private rowScope;
+    /**
+     * The source records a grand-total cell covers, or null when they cannot be
+     * determined and the caller should fall back to rolling up cells.
+     *
+     * `columnKey` is a generated column name. A data cell is
+     * "<dimValue>|…|<measure>", so the column-dimension values are the segments
+     * before the measure and the total spans every record matching them. A
+     * subtotal or column-grand-total column has no such coordinate — it is itself
+     * a roll-up — so those return null.
+     */
+    private grandTotalScope;
     private applyAggregationFunction;
     /**
      * Group rows by dimension values
@@ -687,6 +985,10 @@ declare class EruGridStore {
     private readonly _dataRequest;
     private readonly _requestQueue;
     private readonly _excelDownloadRequest;
+    private readonly _serverValidationNotices;
+    readonly serverValidationNotices: _angular_core.Signal<ServerValidationNotice[]>;
+    setServerValidationNotice(notice: Omit<ServerValidationNotice, 'id' | 'timestamp'>): void;
+    removeServerValidationNotice(id: string): void;
     private readonly _selectedDesignColumn;
     readonly selectedDesignColumn: _angular_core.Signal<string | null>;
     private readonly _columnDesignUpdate;
@@ -755,6 +1057,30 @@ declare class EruGridStore {
     getConfiguration(): GridConfiguration;
     reorderColumns(fromIndex: number, toIndex: number): void;
     updateColumnRequired(columnName: string, required: boolean): void;
+    /**
+     * The field the design panel is editing.
+     *
+     * A pivot aggregation is a real, author-configured field but it is not in
+     * `columns()` — that holds the source columns the dimensions come from. The
+     * panel resolved only against those, so an aggregation header had nothing to
+     * open. Checked after columns so a dimension always wins, which is what an
+     * author clicking a row-dimension header means.
+     */
+    readonly designField: _angular_core.Signal<Field | null>;
+    /**
+     * Everything the design panel can edit, grouped for its target picker.
+     *
+     * Needed because not every designable field has a header to click. With a
+     * single measure the pivot omits the measure-name row, so the one header cell
+     * stands for the column dimension AND the measure fused together — clicking
+     * it can only open one of them, leaving the dimension unreachable. Rather
+     * than overload that header, the panel lets you switch target directly.
+     * Narrow headers and hidden columns are reachable the same way.
+     */
+    readonly designTargets: _angular_core.Signal<{
+        group: string;
+        fields: Field[];
+    }[]>;
     updateColumnMeta(columnName: string, patch: Partial<Field>): void;
     /**
      * Apply metadata resolved from a mapped entity field. Unlike
@@ -765,6 +1091,29 @@ declare class EruGridStore {
      */
     applyResolvedColumnMeta(columnName: string, patch: Partial<Field>): void;
     selectDesignColumn(columnName: string | null): void;
+    /**
+     * The field a generated pivot column belongs to.
+     *
+     * A pivot leaf ("<dimValue>|…|<measure>", or a "_…_subtotal_<measure>" /
+     * "_…_column_grand_total_<measure>" roll-up) is a cell position, not a field,
+     * and exists in neither `columns()` nor the aggregation list under that name.
+     * Anything keyed off the leaf name therefore matched nothing. Resolving to the
+     * owning measure — or leaving a real column name untouched — is what lets
+     * width and design edits land somewhere that survives the next transform.
+     *
+     * Longest name first so a measure whose name is a suffix of another
+     * ("amount" vs "net_amount") cannot claim the wrong leaf.
+     */
+    pivotOwnerName(columnName: string): string;
+    /**
+     * Set a column's width, at the level the width is actually configured.
+     *
+     * In pivot mode the resized header is a generated leaf, so the width is
+     * stored on the measure (or the dimension) it came from and inherited by
+     * every column that measure produces — resizing one value's column resizes
+     * them all. Writing it per generated column would be lost as soon as the
+     * data changed which dimension values exist.
+     */
     updateColumnWidth(columnName: string, field_size: number): void;
     setCellValueChange(change: CellValueChange): void;
     setGroups(groups: RowGroup[]): void;
@@ -848,7 +1197,29 @@ declare class EruGridStore {
      * Check if freeze grand total is enabled
      */
     isFreezeGrandTotalEnabled(): boolean;
-    setDrilldown(drilldown: Drilldown, columnValues: string): void;
+    /**
+     * Record a drill click. `pivotPath` is the list of column-dimension values
+     * that located the cell (empty in table mode).
+     *
+     * The caller supplies `rowData` — the cell already holds the row it renders,
+     * so there is nothing to look up. Only the frozen grand-total cell is
+     * resolved here, because that row is not passed to a cell at all. Previously
+     * this reconstructed the row from an index parsed out of the cell id, which
+     * in table mode read `rows()[index - 2]` and so returned the wrong row, or
+     * undefined for the first two.
+     */
+    setDrilldown(drilldown: Drilldown, pivotPath?: string[]): void;
+    /**
+     * Say what kind of pivot cell was drilled, and what it is scoped to.
+     *
+     * Without this a subtotal reports exactly like a data cell and a consumer
+     * would filter the source by the row's own fields — which on a total row hold
+     * the label ("Subtotal - Rolling Test 2019", "Grand Total") rather than the
+     * dimension values, and blanks for the dimensions that were rolled up.
+     */
+    private describePivotCell;
+    /** Drain the drill signal once a consumer has handled it. */
+    clearDrilldown(): void;
     clearPivotDrilldown(): void;
     setActionClick(actionClick: ActionClick): void;
     setColumnResize(columnResize: ColumnResize): void;
@@ -1118,6 +1489,13 @@ declare class EruGridComponent implements OnInit, AfterViewInit, OnDestroy {
      *   <eru-grid [boardCardTemplate]="myCard" [gridConfig]="cfg"></eru-grid>
      */
     boardCardTemplate?: TemplateRef<BoardCardContext>;
+    /**
+     * Content for a people cell's person card. The grid owns the trigger,
+     * placement and dismissal; the consumer renders the content, because the card
+     * is an eru-studio page and only the consumer can render one. Omit it and the
+     * card trigger stays inert.
+     */
+    personCardTemplate?: TemplateRef<PersonCardContext>;
     /**
      * Height in pixels of each board card slot.
      * Must match the fixed height of the card rendered by boardCardTemplate (or the default card).
@@ -1153,6 +1531,21 @@ declare class EruGridComponent implements OnInit, AfterViewInit, OnDestroy {
         mode: "table" | "board";
         group?: RowGroup;
     }>;
+    /**
+     * Fires when a user clicks a row action in the action column.
+     *
+     * Carries the same row/mode/group shape as `rowSelect` — the consumer that
+     * handles a row click is the one that handles an action on it — plus the
+     * action that was clicked, which is what tells the consumer which of its
+     * configured handlers to run. `action` is null for the fallback more_horiz
+     * icon shown when no `config.actions` were configured.
+     */
+    actionClick: EventEmitter<{
+        action: GridAction | null;
+        row: Row;
+        mode: "table" | "board";
+        group?: RowGroup;
+    }>;
     emitRowSelect(row: Row, mode: 'table' | 'board', group?: RowGroup): void;
     /**
      * Fires when the user clicks the excel download icon (shown when
@@ -1258,6 +1651,14 @@ declare class EruGridComponent implements OnInit, AfterViewInit, OnDestroy {
     private readonly SCROLL_THRESHOLD;
     /** Rows per lazy page: grid config `pageSize` if set, else ROWS_PER_PAGE. */
     private get rowsPerPage();
+    /** Pages requested per group by the pivot loader; the anti-runaway counter. */
+    private pivotPagesRequested;
+    /**
+     * How many rows pivot mode will pull before it stops asking for more. Beyond
+     * this the pivot transform would not process client-side anyway, so pulling
+     * further pages only costs round-trips.
+     */
+    private pivotRowCeiling;
     private lastLoadedGroupIds;
     private requestedGroupIds;
     private columnsInitialized;
@@ -1310,6 +1711,30 @@ declare class EruGridComponent implements OnInit, AfterViewInit, OnDestroy {
     private requestRowsForGroup;
     isDesignMode(): boolean;
     onHeaderDesignClick(event: Event, column: Field): void;
+    /**
+     * The field a header's design control should edit.
+     *
+     * In table mode that is the column itself. In pivot mode a leaf column is a
+     * generated cell position, not a field: "<dimValue>|<agg>" for an aggregated
+     * cell, or a "_..._grand_total_<agg>" roll-up. Designing one of those would
+     * format a single pivot cell and be lost the moment the data changed the set
+     * of dimension values. What the author means is the AGGREGATION — format the
+     * measure everywhere it appears — so the leaf resolves back to it. A row
+     * dimension header is already a real source column and resolves to itself.
+     */
+    designTargetFor(column: Field): string;
+    /**
+     * Whether a pivot header can be resized.
+     *
+     * Only headers that stand for one field: a row dimension, or a header that
+     * resolves to a measure. A column-dimension group header spans several
+     * measures, so dragging it has no single width to set — and since widths are
+     * now held per measure, resizing any one of that group's leaves widens the
+     * matching column under every other dimension value anyway.
+     */
+    isResizablePivotHeader(header: any): boolean;
+    /** True when this header's design control would edit a pivot aggregation. */
+    isAggregationHeader(column: Field): boolean;
     trackByColumnFn(index: number, column: Field): string;
     trackByGroupItemFn(index: number, groupItem: GroupItem): string;
     trackByPivotRowFn(index: number, pivotRow: PivotRow): string;
@@ -1320,6 +1745,16 @@ declare class EruGridComponent implements OnInit, AfterViewInit, OnDestroy {
     trackByHeaderFn(index: number, header: any): string;
     hasNestedHeaders(): boolean;
     getHeaderRows(): any[][];
+    /**
+     * What a pivot leaf inherits from the field it was generated from.
+     *
+     * Presentation plus `enableDrilldown` — everything the author configures on
+     * the measure or the dimension. Identity and layout (name, label,
+     * grid_index, field_size, aggregationFunction) belong to the generated leaf
+     * and are deliberately absent: a leaf's label is its pivot dimension value,
+     * not the measure's name.
+     */
+    private static readonly PIVOT_INHERITED_KEYS;
     getLeafColumns(): Field[];
     isRowDimensionHeader(header: any): boolean;
     /**
@@ -1331,7 +1766,41 @@ declare class EruGridComponent implements OnInit, AfterViewInit, OnDestroy {
     private initializeColumnWidths;
     toggleRowSelection(event: Event, row: any): void;
     toggleGroupSelection(event: Event, groupId: string): void;
-    onActionClick(event: Event, row: any): void;
+    /**
+     * A row action was clicked. Announced two ways, because the two kinds of
+     * consumer read the grid differently: the store signal is what processo's
+     * data viewer already drains, and the output event carries the same shape as
+     * `rowSelect` so an eru-studio page can wire it up with the event framework.
+     *
+     * `action` is absent when the column is showing its fallback more_horiz icon
+     * — i.e. no `config.actions` were configured.
+     */
+    onActionClick(event: Event, row: any, action?: GridAction, mode?: 'table' | 'board', group?: RowGroup): void;
+    /**
+     * Row actions for the action column: blank names discarded, and at most one
+     * entry per name.
+     *
+     * The name is what comes back on the click, so two entries sharing one are
+     * indistinguishable to the consumer — they would draw two icons that do the
+     * same thing. Collapsing them here also keeps the template's
+     * `track action.action_name` keys unique; duplicates would otherwise abort
+     * the render. Matching is case-insensitive and ignores surrounding space, so
+     * the grouping agrees with how a consumer is likely to compare the name.
+     */
+    readonly gridActions: _angular_core.Signal<GridAction[]>;
+    readonly hasConfiguredActions: _angular_core.Signal<boolean>;
+    readonly actionDisplayType: _angular_core.Signal<"icons" | "kebab">;
+    /**
+     * The actions that apply to one row, after each action's
+     * `action_visible_condition` is evaluated against that row's values.
+     */
+    visibleActionsFor(row: any): GridAction[];
+    /**
+     * Width of the action column. Icons sit side by side, so the column has to
+     * grow with the number configured or they wrap; a kebab is always one icon.
+     * Capped so a long action list scrolls the icons rather than eating the grid.
+     */
+    readonly actionColumnWidth: _angular_core.Signal<number>;
     onSortColumn(event: Event, column: Field, direction: 'asc' | 'desc'): void;
     getSortDirection(fieldName: string): 'asc' | 'desc' | null;
     getSortPriority(fieldName: string): number | null;
@@ -1497,6 +1966,12 @@ declare class EruGridComponent implements OnInit, AfterViewInit, OnDestroy {
     groupSeperatorColSpan(): number;
     readonly BOARD_CARD_ITEM_HEIGHT = 208;
     readonly isBoardMode: _angular_core.Signal<boolean>;
+    /**
+     * Whether board columns wrap onto further rows once they no longer fit, or
+     * stay on one horizontally scrolling row. Defaults to wrapping, which is the
+     * behaviour that lets a narrow viewport stack its columns.
+     */
+    readonly boardWrapColumns: _angular_core.Signal<boolean>;
     readonly visibleBoardFields: _angular_core.Signal<Field[]>;
     readonly visibleColumns: _angular_core.Signal<Field[]>;
     readonly hiddenColumns: _angular_core.Signal<Field[]>;
@@ -1510,7 +1985,7 @@ declare class EruGridComponent implements OnInit, AfterViewInit, OnDestroy {
     requestBoardRowsForGroup(group: RowGroup): void;
     loadBoardAll(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<EruGridComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EruGridComponent, "eru-grid", never, { "gridConfig": { "alias": "gridConfig"; "required": false; }; "boardCardTemplate": { "alias": "boardCardTemplate"; "required": false; }; "boardCardHeight": { "alias": "boardCardHeight"; "required": false; }; "boardCardGap": { "alias": "boardCardGap"; "required": false; }; "boardCardPadding": { "alias": "boardCardPadding"; "required": false; }; }, { "rowSelect": "rowSelect"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EruGridComponent, "eru-grid", never, { "gridConfig": { "alias": "gridConfig"; "required": false; }; "boardCardTemplate": { "alias": "boardCardTemplate"; "required": false; }; "personCardTemplate": { "alias": "personCardTemplate"; "required": false; }; "boardCardHeight": { "alias": "boardCardHeight"; "required": false; }; "boardCardGap": { "alias": "boardCardGap"; "required": false; }; "boardCardPadding": { "alias": "boardCardPadding"; "required": false; }; }, { "rowSelect": "rowSelect"; "actionClick": "actionClick"; }, never, never, true, never>;
 }
 interface GroupItem {
     type: 'header' | 'row' | 'table-header' | 'row-place-holder' | 'ghost-loading';
@@ -1521,6 +1996,36 @@ interface GroupItem {
 declare const MATERIAL_PROVIDERS: Provider[];
 declare const MATERIAL_MODULES: any[];
 
+/**
+ * Row-scoped condition evaluation, used by the action column to decide whether
+ * an action's icon applies to a given row.
+ *
+ * The authoring language is the one eru-studio already uses for page logic —
+ * `@field` names a value, AND/OR/NOT join clauses, and the `is` / `is empty` /
+ * `contains` / `in` / `between` phrases read the same way — so an author moving
+ * between a page and a grid writes one language. The studio service itself
+ * cannot be reused here: the dependency runs studio -> grid, and it resolves
+ * names against page data and state, neither of which a grid row has. Here a
+ * name is a column of the row being rendered.
+ *
+ * Expressions are compiled once and cached by their text, because a condition
+ * is re-evaluated for every visible row on every change detection pass. A
+ * condition that fails to compile or throws is treated as visible, matching how
+ * the studio evaluator defaults on error — an authoring mistake should not
+ * silently remove an action from every row.
+ */
+/**
+ * Read a field off a row. A grid row keeps its values under `entity_data`, but
+ * the array-backed sources (query rows, pivot rows) put them at the top level,
+ * so both are checked before falling back to walking a dotted path.
+ */
+declare function resolveRowValue(row: any, fieldName: string): any;
+/**
+ * Evaluate a visibility condition against one row. A blank or absent
+ * expression means always visible.
+ */
+declare function evaluateRowCondition(expression: string | null | undefined, row: any): boolean;
+
 interface AttachmentConfig {
     disabled?: boolean;
     required?: boolean;
@@ -1549,6 +2054,15 @@ declare class AttachmentComponent implements OnInit {
     fileDeleted: EventEmitter<string>;
     fileViewed: EventEmitter<string>;
     currentValue: _angular_core.WritableSignal<string[]>;
+    /**
+     * Why the last attempted file was refused, or '' when none.
+     *
+     * The checks were already here but only reached console.warn, so a user
+     * dropping an oversized file saw nothing happen at all. Shown in the panel,
+     * matching how eru-studio's attachment reports a rejection.
+     */
+    rejectionMessage: _angular_core.WritableSignal<string>;
+    private rejectFile;
     isOverlayOpen: _angular_core.WritableSignal<boolean>;
     isDragging: _angular_core.WritableSignal<boolean>;
     fileInput: ElementRef<HTMLInputElement>;
@@ -1581,25 +2095,38 @@ declare class AttachmentComponent implements OnInit {
 }
 
 declare class CheckboxComponent {
-    value: _angular_core.InputSignal<boolean>;
+    value: _angular_core.InputSignal<any>;
+    /** Column config; supplies value_true / value_false when the field uses literals. */
+    config: _angular_core.InputSignal<Field | null>;
     isEditable: _angular_core.InputSignal<boolean>;
     isActive: _angular_core.InputSignal<boolean>;
     isDrillable: _angular_core.InputSignal<boolean>;
     label: _angular_core.InputSignal<string>;
-    valueChange: EventEmitter<boolean>;
-    change: EventEmitter<boolean>;
-    blur: EventEmitter<boolean>;
+    valueChange: EventEmitter<any>;
+    change: EventEmitter<any>;
+    blur: EventEmitter<any>;
     focus: EventEmitter<void>;
-    drilldownClick: EventEmitter<boolean>;
+    drilldownClick: EventEmitter<any>;
     editModeChange: EventEmitter<boolean>;
     currentValue: _angular_core.WritableSignal<boolean>;
     constructor();
+    private toBool;
+    private literals;
+    /**
+     * Stored representation -> checked state. When the field configures
+     * value_true / value_false the backend may hold arbitrary literals ('Y'/'N',
+     * 'Yes'/'No'); left blank, both fall through to the generic coercion. Ported
+     * from the eru-studio checkbox so the two agree on what a stored value means.
+     */
+    private resolveCheckboxState;
+    /** Inverse: checked state -> the representation to store. */
+    private checkboxValueFor;
     onValueChange(event: boolean): void;
     onActivate(): void;
     onBlur(): void;
     onDrillableClick(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "eru-checkbox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "change": "change"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "editModeChange": "editModeChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "eru-checkbox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "change": "change"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "editModeChange": "editModeChange"; }, never, never, true, never>;
 }
 
 interface CurrencyValidationResult {
@@ -1615,6 +2142,12 @@ declare class CurrencyComponent {
     isDrillable: _angular_core.InputSignal<boolean>;
     replaceZeroValue: _angular_core.InputSignal<string | undefined>;
     placeholder: _angular_core.InputSignal<string>;
+    /**
+     * The row this cell belongs to. Needed for `symbol_field`, which names another
+     * field on the SAME record supplying the currency symbol — so a multi-currency
+     * column renders each row with its own symbol instead of one column-wide one.
+     */
+    row: _angular_core.InputSignal<any>;
     valueChange: EventEmitter<string | number | null>;
     blur: EventEmitter<string | number | null>;
     focus: EventEmitter<void>;
@@ -1623,6 +2156,20 @@ declare class CurrencyComponent {
     editModeChange: EventEmitter<boolean>;
     currentValue: _angular_core.WritableSignal<string | number | null>;
     error: _angular_core.WritableSignal<string>;
+    /**
+     * Colours from the column's configured value ranges, applied over the cell's
+     * normal appearance. View mode only — tinting an active input reads as a
+     * validation state rather than a value. Null when no band matches, matching
+     * the eru-studio currency component so a value paints the same on a page and here.
+     */
+    /**
+     * Symbol to show. `symbol_field` wins when set — read from this row, so each
+     * record can carry its own currency — otherwise the column's static `symbol`.
+     * Rows may nest their values under entity_data.
+     */
+    resolvedSymbol: _angular_core.Signal<string>;
+    rangeColor: _angular_core.Signal<string | null>;
+    rangeBackground: _angular_core.Signal<string | null>;
     constructor();
     formatNumberSignal: _angular_core.Signal<string | undefined>;
     onActivate(): void;
@@ -1632,7 +2179,7 @@ declare class CurrencyComponent {
     private validateField;
     private focusAndPositionCursor;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CurrencyComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CurrencyComponent, "eru-currency", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "replaceZeroValue": { "alias": "replaceZeroValue"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "validationError": "validationError"; "editModeChange": "editModeChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CurrencyComponent, "eru-currency", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "replaceZeroValue": { "alias": "replaceZeroValue"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "row": { "alias": "row"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "validationError": "validationError"; "editModeChange": "editModeChange"; }, never, never, true, never>;
 }
 
 declare class DateComponent {
@@ -1644,7 +2191,7 @@ declare class DateComponent {
     isActive: _angular_core.InputSignal<boolean>;
     isDrillable: _angular_core.InputSignal<boolean>;
     placeholder: _angular_core.InputSignal<string>;
-    readonly dateFormat: _angular_core.Signal<any>;
+    readonly dateFormat: _angular_core.Signal<string>;
     readonly allowDays: _angular_core.Signal<string[]>;
     readonly dayFilter: _angular_core.Signal<(d: Date | null) => boolean>;
     valueChange: EventEmitter<string | null>;
@@ -1653,10 +2200,22 @@ declare class DateComponent {
     editModeChange: EventEmitter<boolean>;
     currentValue: _angular_core.WritableSignal<Date | null>;
     private shouldOpenPicker;
+    /**
+     * The column's configured default, resolved to a real date.
+     *
+     * The data model expresses it as a rule rather than a fixed value: the
+     * `Current_Date` sentinel in `default`, optionally shifted by
+     * `default_value_offset_days` (negative goes back). Resolving it here means a
+     * cell with no stored value shows what the field defines, matching eru-studio
+     * — previously the grid ignored both and showed an empty cell.
+     */
+    private resolveDefaultDate;
     constructor();
     onActivate(): void;
     onDateChange(date: Date | null): void;
     onDrillableClick(event: Event): void;
+    /** Render a date in the column's configured format, via the shared token
+     *  formatter so a page and a grid read identically. */
     formatDate(date: Date | null): string;
     parseDateString(dateString: string): Date | null;
     getDisplayValue(): string;
@@ -1876,6 +2435,14 @@ declare class NumberComponent {
     editModeChange: EventEmitter<boolean>;
     currentValue: _angular_core.WritableSignal<string | number | null>;
     error: _angular_core.WritableSignal<string>;
+    /**
+     * Colours from the column's configured value ranges, applied over the cell's
+     * normal appearance. View mode only — tinting an active input reads as a
+     * validation state rather than a value. Null when no band matches, matching
+     * the eru-studio number component so a value paints the same on a page and here.
+     */
+    rangeColor: _angular_core.Signal<string | null>;
+    rangeBackground: _angular_core.Signal<string | null>;
     constructor();
     formatNumberSignal: _angular_core.Signal<string | undefined>;
     onActivate(): void;
@@ -1904,11 +2471,47 @@ declare class PeopleComponent implements OnInit {
     isDrillable: _angular_core.InputSignal<boolean>;
     columnWidth: _angular_core.InputSignal<number>;
     eruGridStore: _angular_core.InputSignal<EruGridStore | null>;
+    /**
+     * Content for the person card, supplied by the consumer. The grid owns the
+     * trigger, positioning and dismissal; only the consumer can render a page,
+     * which is what eru-studio's card is. Without a template the trigger is inert.
+     */
+    personCardTemplate: _angular_core.InputSignal<TemplateRef<PersonCardContext> | null | undefined>;
     valueChange: EventEmitter<string[] | null>;
     blur: EventEmitter<string[] | null>;
     focus: EventEmitter<void>;
     drilldownClick: EventEmitter<string[] | null>;
     editModeChange: EventEmitter<boolean>;
+    /**
+     * Whether more than one person may be picked. From the column config, so a
+     * field declared single-select in the data model is enforced here too. The
+     * stored value stays a list either way — the flag only limits how many may be
+     * chosen, so no consumer has to handle a shape change.
+     */
+    isMultiple: _angular_core.Signal<boolean>;
+    /** Show the filter box inside the dropdown. Configurable, as in eru-studio. */
+    isSearchable: _angular_core.Signal<boolean>;
+    /** mat-select holds a list when multiple, a single id otherwise. */
+    selectValue: _angular_core.Signal<any>;
+    /** Page the field names as the card. Blank means no card. */
+    cardPage: _angular_core.Signal<string>;
+    /** 'none' | 'hover' | 'click' — 'none' whenever no card page is mapped. */
+    cardTrigger: _angular_core.Signal<"none" | "hover" | "click">;
+    /** The card is a view-mode affordance, and needs content to show. */
+    cardEnabled: _angular_core.Signal<boolean>;
+    /** Beside the avatar first (right, then left), dropping below only when
+     *  neither side fits. Offsets stay small: on hover the cursor has to cross the
+     *  gap to reach the card, and a wide one makes that a miss. */
+    readonly cardPositions: ConnectedPosition[];
+    /** Person whose card is open, or null. */
+    openCardUserId: _angular_core.WritableSignal<string | null>;
+    private static readonly CARD_CLOSE_DELAY_MS;
+    private closeCardTimer;
+    onAvatarEnter(userId: string): void;
+    onAvatarLeave(): void;
+    onAvatarCardClick(event: Event, userId: string): void;
+    closeCard(): void;
+    private cancelPendingClose;
     currentValue: _angular_core.WritableSignal<string[]>;
     searchText: _angular_core.WritableSignal<string>;
     selectContainer: ElementRef<HTMLElement>;
@@ -1925,6 +2528,13 @@ declare class PeopleComponent implements OnInit {
     onActivate(): void;
     onBlur(event: Event): void;
     onValueChange(value: string[]): void;
+    /**
+     * mat-select emits a list when multiple and a bare id otherwise. The stored
+     * value is a list in both cases, so a single selection is re-wrapped here —
+     * that way turning cardinality off never changes the value's shape for
+     * consumers or for the data model.
+     */
+    onSelectionChange(value: any): void;
     onSearchChange(searchValue: string): void;
     onDrillableClick(event: Event): void;
     onOpenedChange(opened: boolean): void;
@@ -1935,7 +2545,7 @@ declare class PeopleComponent implements OnInit {
     selectedMultiSelect(value: string[]): void;
     trackByValueAndIndex(index: number, option: any): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PeopleComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PeopleComponent, "eru-people", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "columnWidth": { "alias": "columnWidth"; "required": false; "isSignal": true; }; "eruGridStore": { "alias": "eruGridStore"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "editModeChange": "editModeChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PeopleComponent, "eru-people", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "columnWidth": { "alias": "columnWidth"; "required": false; "isSignal": true; }; "eruGridStore": { "alias": "eruGridStore"; "required": false; "isSignal": true; }; "personCardTemplate": { "alias": "personCardTemplate"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "editModeChange": "editModeChange"; }, never, never, true, never>;
 }
 
 interface CountryCode {
@@ -2075,6 +2685,14 @@ declare class ProgressComponent implements OnInit {
     currentValue: _angular_core.WritableSignal<number>;
     displayValue: _angular_core.Signal<number>;
     barColor: _angular_core.Signal<string | null>;
+    /**
+     * Whether to show the value as a percentage. `is_perc` is the data model's
+     * flag; it only reads as a percentage on a 0-100 scale, so a column with a
+     * custom scale shows the raw value against its bound instead.
+     */
+    showPercent: _angular_core.Signal<boolean>;
+    /** Label beside the bar: "45%" on a percentage scale, "3 / 5" otherwise. */
+    valueLabel: _angular_core.Signal<string>;
     constructor();
     ngOnInit(): void;
     onActivate(): void;
@@ -2121,6 +2739,12 @@ declare class SelectComponent implements OnInit, AfterViewInit {
     fieldSize: _angular_core.InputSignal<number>;
     multiple: _angular_core.InputSignal<boolean>;
     eruGridStore: _angular_core.InputSignal<EruGridStore | null>;
+    /**
+     * The row this cell belongs to. Needed for a dependent dropdown: `dpef` names
+     * another field on the SAME record whose value scopes this list, so the list
+     * differs per row and cannot be resolved from the column config alone.
+     */
+    row: _angular_core.InputSignal<any>;
     valueChange: EventEmitter<any>;
     blur: EventEmitter<any>;
     focus: EventEmitter<void>;
@@ -2142,6 +2766,34 @@ declare class SelectComponent implements OnInit, AfterViewInit {
     onBlur(event: Event): void;
     onValueChange(value: any | any[] | null): void;
     toggleSelectAll(checked: boolean): void;
+    /**
+     * Dependency pairs for a cascading dropdown, normalised.
+     *
+     * `def` names the field on THIS ROW supplying a value; `dpef` names the field
+     * in the option-source entity to match it against. A column saved before
+     * `df_fields` existed carries a single `dpef`, read as `{ def: dpef, dpef }`.
+     */
+    dependencyPairs: _angular_core.Signal<{
+        def: string;
+        dpef: string;
+    }[]>;
+    /** Legacy single-dependency value from this row, for API sources. */
+    private legacyDpefValue;
+    /** True when this column's options are scoped by another field on the row. */
+    isDependent: _angular_core.Signal<boolean>;
+    /**
+     * Filter sent with the options request: keys are fields in the option-source
+     * entity, values read from this row. A pair whose source value is absent is
+     * omitted rather than sent blank, since filtering on a blank would narrow the
+     * list to nothing.
+     */
+    dependencyFilter: _angular_core.Signal<Record<string, any>>;
+    /**
+     * Map key the option list is cached under. Must be identical at request time
+     * and at lookup time, or the response is written under one key and read from
+     * another — so both go through this.
+     */
+    optionsCacheKey: _angular_core.Signal<string>;
     onSearchChange(searchValue: string): void;
     onOpenedChange(opened: boolean): void;
     ngAfterViewInit(): void;
@@ -2162,7 +2814,7 @@ declare class SelectComponent implements OnInit, AfterViewInit {
      */
     private firstPrimitiveValue;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectComponent, "eru-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "columnWidth": { "alias": "columnWidth"; "required": false; "isSignal": true; }; "fieldSize": { "alias": "fieldSize"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "eruGridStore": { "alias": "eruGridStore"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "editModeChange": "editModeChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectComponent, "eru-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "columnWidth": { "alias": "columnWidth"; "required": false; "isSignal": true; }; "fieldSize": { "alias": "fieldSize"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "eruGridStore": { "alias": "eruGridStore"; "required": false; "isSignal": true; }; "row": { "alias": "row"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "editModeChange": "editModeChange"; }, never, never, true, never>;
 }
 
 declare class StatusComponent implements OnInit {
@@ -2449,5 +3101,5 @@ declare class ThemeToggleComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThemeToggleComponent, "eru-theme-toggle", never, {}, {}, never, never, true, never>;
 }
 
-export { AttachmentComponent, CheckboxComponent, ColumnConstraintsService, CurrencyComponent, CustomVirtualScrollStrategy, DATA_TYPES, DateComponent, DatetimeComponent, DurationComponent, EmailComponent, EruGridComponent, EruGridService, EruGridStore, LocationComponent, MATERIAL_MODULES, MATERIAL_PROVIDERS, NumberComponent, PRESET_CONFIG_DEFAULTS, PRESET_MANAGED_FIELDS, PeopleComponent, PhoneComponent, PriorityComponent, ProgressComponent, RatingComponent, SelectComponent, StatusComponent, TagComponent, TextareaComponent, TextboxComponent, ThemeService, ThemeToggleComponent, WebsiteComponent };
-export type { ActionClick, AggregationFunction, AttachmentConfig, BoardCardContext, CellValueChange, ColumnReorder, ColumnResize, ColumnWidthConstraints, CurrencyValidationResult, DataTypes, Drilldown, DurationValue, DynamicDataRequest, EmailValidationResult, ExcelDownloadPayload, ExcelDownloadRequest, Field, GridConfiguration, GridFeatures, GridMode, GridPreset, GridStyles, GridTokens, GroupItem$1 as GroupItem, LocationConfig, LocationValidationResult, NumberValidationResult, PeopleOption, PivotColumnGroupState, PivotColumnHeader, PivotConfiguration, PivotHeaderStructure, PivotMetadata, PivotResult, PivotRow, RatingConfig, Row, RowDataRequest, RowDataResponse, RowGrandTotal, RowGroup, TextareaValidationResult, TextboxValidationResult, Theme, WebsiteValidationResult };
+export { AttachmentComponent, CheckboxComponent, ColumnConstraintsService, CurrencyComponent, CustomVirtualScrollStrategy, DATA_TYPES, DATETIME_FORMATS, DATE_FORMATS, DateComponent, DatetimeComponent, DurationComponent, EmailComponent, EruGridComponent, EruGridService, EruGridStore, INHERITED_FIELD_KEYS, LocationComponent, MATERIAL_MODULES, MATERIAL_PROVIDERS, MONTH_SHORT_NAMES, NumberComponent, PRESET_CONFIG_DEFAULTS, PRESET_MANAGED_FIELDS, PeopleComponent, PhoneComponent, PriorityComponent, ProgressComponent, RatingComponent, SelectComponent, StatusComponent, TagComponent, TextareaComponent, TextboxComponent, ThemeService, ThemeToggleComponent, WebsiteComponent, evaluateRowCondition, formatDateWithPattern, matchColorRange, normalizeDatatype, normalizeDateFormat, normalizeDateTimeFormat, parseDateWithPattern, resolveRowValue };
+export type { ActionClick, AggregationFunction, AttachmentConfig, BoardCardContext, CellValueChange, ColorRangeBand, ColumnReorder, ColumnResize, ColumnWidthConstraints, CurrencyValidationResult, DataTypes, Drilldown, DurationValue, DynamicDataRequest, EmailValidationResult, ExcelDownloadPayload, ExcelDownloadRequest, Field, GridAction, GridConfiguration, GridFeatures, GridMode, GridPreset, GridStyles, GridTokens, GroupItem$1 as GroupItem, LocationConfig, LocationValidationResult, NumberValidationResult, PeopleOption, PersonCardContext, PivotColumnGroupState, PivotColumnHeader, PivotColumnKind, PivotConfiguration, PivotHeaderStructure, PivotMetadata, PivotResult, PivotRow, PivotRowKind, RatingConfig, Row, RowDataRequest, RowDataResponse, RowGrandTotal, RowGroup, ServerValidationNotice, TextareaValidationResult, TextboxValidationResult, Theme, WebsiteValidationResult };