eru-grid 0.0.41 → 0.0.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eru-grid",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "peerDependencies": {
     "@angular/common": "^21.1.2",
     "@angular/core": "^21.1.2",

package/types/eru-grid.d.ts

@@ -68,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;
@@ -98,7 +100,9 @@ interface GridFeatures {
     boardCardSelectedBg?: string;
     boardCardSelectedOutline?: string;
     boardColumnMinWidth?: number;
+    boardColumnMaxWidth?: number;
     boardColumnHeight?: number;
+    boardWrapColumns?: boolean;
 }
 interface ExcelDownloadPayload {
     columns: Record<string, {
@@ -174,6 +178,24 @@ interface ServerValidationNotice {
     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';
@@ -483,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;
@@ -687,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
@@ -715,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
@@ -931,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
@@ -941,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;
@@ -1024,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;
@@ -1336,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
@@ -1441,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;
@@ -1493,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;
@@ -1503,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;
     /**
@@ -1514,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;
@@ -1680,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[]>;
@@ -1693,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; }; "personCardTemplate": { "alias": "personCardTemplate"; "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';
@@ -1704,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;
@@ -2779,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, 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, formatDateWithPattern, matchColorRange, normalizeDatatype, normalizeDateFormat, normalizeDateTimeFormat, parseDateWithPattern };
-export type { ActionClick, AggregationFunction, AttachmentConfig, BoardCardContext, CellValueChange, ColorRangeBand, 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, PersonCardContext, PivotColumnGroupState, PivotColumnHeader, PivotConfiguration, PivotHeaderStructure, PivotMetadata, PivotResult, PivotRow, RatingConfig, Row, RowDataRequest, RowDataResponse, RowGrandTotal, RowGroup, ServerValidationNotice, 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 };