eru-grid 0.0.50 → 0.0.52

package/package.json

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

package/src/lib/styles/theme.scss

@@ -10,6 +10,16 @@
     // Use Material's color tokens
     --grid-primary: #{mat.get-theme-color($theme, primary, 40)} !important;
     --grid-on-primary: #{mat.get-theme-color($theme, primary, 100)} !important;
+    --grid-primary-container: #{mat.get-theme-color($theme, primary-container)} !important;
+    --grid-on-primary-container: #{mat.get-theme-color($theme, on-primary-container)} !important;
+    --grid-secondary: #{mat.get-theme-color($theme, secondary)} !important;
+    --grid-on-secondary: #{mat.get-theme-color($theme, on-secondary)} !important;
+    --grid-secondary-container: #{mat.get-theme-color($theme, secondary-container)} !important;
+    --grid-on-secondary-container: #{mat.get-theme-color($theme, on-secondary-container)} !important;
+    --grid-tertiary: #{mat.get-theme-color($theme, tertiary)} !important;
+    --grid-on-tertiary: #{mat.get-theme-color($theme, on-tertiary)} !important;
+    --grid-tertiary-container: #{mat.get-theme-color($theme, tertiary-container)} !important;
+    --grid-on-tertiary-container: #{mat.get-theme-color($theme, on-tertiary-container)} !important;
     --grid-surface: #{mat.get-theme-color($theme, surface)} !important;
     --grid-surface-variant: #{mat.get-theme-color($theme, surface-variant)} !important;
     --grid-surface-container: #{mat.get-theme-color($theme, surface-container)} !important;
@@ -20,6 +30,11 @@
     --grid-outline-variant: #{mat.get-theme-color($theme, outline-variant)} !important;
     --grid-error: #{mat.get-theme-color($theme, error)} !important;
     --grid-error-container: #{mat.get-theme-color($theme, error-container)} !important;
+
+    // Base tokens — flip pure white/black (and a neutral border) by light/dark.
+    --grid-base-surface: light-dark(#ffffff, #1a1a1a) !important;
+    --grid-base-on-surface: light-dark(#000000, #ffffff) !important;
+    --grid-base-border: light-dark(#e5e7eb, #3a3a3a) !important;
     
     // Use Material's typography tokens - OVERRIDE fallback values
     --grid-font-family: #{mat.get-theme-typography($theme, body-large, font-family)} !important;
@@ -50,6 +65,16 @@
   // Color tokens
   --grid-primary: var(--mat-sys-primary, #6750a4);
   --grid-on-primary: var(--mat-sys-on-primary, #ffffff);
+  --grid-primary-container: var(--mat-sys-primary-container, #eaddff);
+  --grid-on-primary-container: var(--mat-sys-on-primary-container, #21005d);
+  --grid-secondary: var(--mat-sys-secondary, #625b71);
+  --grid-on-secondary: var(--mat-sys-on-secondary, #ffffff);
+  --grid-secondary-container: var(--mat-sys-secondary-container, #e8def8);
+  --grid-on-secondary-container: var(--mat-sys-on-secondary-container, #1d192b);
+  --grid-tertiary: var(--mat-sys-tertiary, #7d5260);
+  --grid-on-tertiary: var(--mat-sys-on-tertiary, #ffffff);
+  --grid-tertiary-container: var(--mat-sys-tertiary-container, #ffd8e4);
+  --grid-on-tertiary-container: var(--mat-sys-on-tertiary-container, #31111d);
   --grid-surface: var(--mat-sys-surface, #fef7ff);
   --grid-surface-variant: var(--mat-sys-surface-variant, #e7e0ec);
   --grid-surface-container: var(--mat-sys-surface-container, #f3edf7);
@@ -60,6 +85,11 @@
   --grid-outline-variant: var(--mat-sys-outline-variant, #cac4d0);
   --grid-error: var(--mat-sys-error, #ba1a1a);
   --grid-error-container: var(--mat-sys-error-container, #ffdad6);
+
+  // Base tokens — fixed white/black flip; host can override per mode.
+  --grid-base-surface: #ffffff;
+  --grid-base-on-surface: #000000;
+  --grid-base-border: #e5e7eb;
   --grid-outline-width: 1px;
 
   // Typography tokens
@@ -87,6 +117,19 @@
 .eru-grid-high-contrast {
   --grid-primary: #000000;
   --grid-on-primary: #ffffff;
+  --grid-primary-container: #e0e0e0;
+  --grid-on-primary-container: #000000;
+  --grid-secondary: #000000;
+  --grid-on-secondary: #ffffff;
+  --grid-secondary-container: #e0e0e0;
+  --grid-on-secondary-container: #000000;
+  --grid-tertiary: #000000;
+  --grid-on-tertiary: #ffffff;
+  --grid-tertiary-container: #e0e0e0;
+  --grid-on-tertiary-container: #000000;
+  --grid-base-surface: #ffffff;
+  --grid-base-on-surface: #000000;
+  --grid-base-border: #000000;
   --grid-surface: #ffffff;
   --grid-surface-variant: #f8f8f8;
   --grid-on-surface: #000000;

package/types/eru-grid.d.ts

@@ -256,6 +256,8 @@ interface DynamicDataRequest {
     apiName?: string;
     apiField?: string;
     search?: string;
+    limit?: number;
+    skip?: number;
     filter?: Record<string, any>;
 }
 interface Field {
@@ -301,6 +303,7 @@ interface Field {
         to?: number | null;
         color?: string | null;
     }[];
+    cell_rules?: CellFormatRule[];
     data_length?: number;
     start_value?: number;
     end_value?: number;
@@ -385,6 +388,8 @@ interface Field {
  *   searchable              whether a picker needs a filter box depends on how
  *                           many options this grid shows, not on the field
  *   dateTimeFormat          legacy alias; the model writes `date_format`
+ *   cell_rules              conditional formatting is a grid feature; it
+ *                           overrides the field's `color_ranges` per grid
  *
  * See SEEDED_FIELD_KEYS for the middle ground: keys the data model supplies a
  * starting value for, which this grid may then override.
@@ -645,6 +650,26 @@ declare function cellStatAlias(field: string, stat: CellStatVerb, args?: {
  * rule stops the request without anyone remembering to.
  */
 declare function collectColumnStatRequests(columns: Field[] | null | undefined): ColumnStatRequest[];
+/**
+ * True when this grid's column carries conditional formatting of its own.
+ *
+ * The test for "configured" is a non-empty list: an empty `cell_rules` is what
+ * removing the last rule leaves behind, and that has to read as "nothing
+ * configured here" so the data model's bands come back rather than the column
+ * being stuck with no formatting at all.
+ */
+declare function hasOwnCellRules(column: Field | null | undefined): boolean;
+/**
+ * The rules in force on a column: its own conditional formatting if configured,
+ * otherwise the data model's `color_ranges` bands.
+ *
+ * Conditional formatting is a property of this grid's view, `color_ranges` a
+ * property of the field — so the two are separate keys and this is the one place
+ * that decides between them. Every consumer (cell painting, stat requests, the
+ * design pane) reads through here, so they cannot disagree about which list is
+ * live.
+ */
+declare function columnCellRules(column: Field | null | undefined): CellFormatRule[];
 /** A statistic's value, or null when it has not come back (or cannot apply). */
 declare function resolveStatValue(field: string, ref: CellStatRef | null | undefined, stats: Record<string, number> | null | undefined): number | null;
 /**
@@ -887,6 +912,19 @@ interface CellTextStyle {
  * the grid's own `--grid-*` set — a column styled with a token keeps tracking
  * the preset/theme instead of freezing one hex.
  */
+/**
+ * Theme colours offerable on a column or a conditional-format rule.
+ *
+ * A one-for-one mirror of eru-studio's `colorTokens`, label for label, with
+ * `--studio-` swapped for `--grid-`: the two libraries dress the same page, so a
+ * colour chosen on a field and the same colour chosen on a grid column have to
+ * mean the same thing. Keep the two lists in step when either changes.
+ *
+ * 'Primary Light' used to sit in here and was never part of that set — nor was
+ * `--grid-primary-light` ever defined, so picking it produced an invalid
+ * `var()` and silently dropped whatever it was applied to. Its M3 equivalent is
+ * Primary Container, which is what studio calls it.
+ */
 declare const GRID_COLOR_TOKENS: {
     label: string;
     value: string;
@@ -928,6 +966,16 @@ declare function cellTextStyleToCss(style: CellTextStyle | null | undefined): Re
  * and currency.component — byte-identical, and two places to fix.
  */
 declare function abbreviateNumber(num: number, system: 'lacs' | 'mn', decimals: number): string;
+/**
+ * Which scale a value abbreviates on when no `display_number_as` is chosen:
+ * the one its digit grouping already implies.
+ *
+ * `seperator` and `display_number_as` were asking the same question twice — the
+ * data model already says whether a field reads Indian or Western, and a column
+ * grouped 1,00,00,000 that abbreviates to 'mn' is a contradiction. So the
+ * grouping supplies the scale and 'Display as' stays editable to override it.
+ */
+declare function abbreviationScaleFor(seperator: string | null | undefined): 'lacs' | 'mn';
 /**
  * Render a number or currency value the way its column configures it —
  * decimals, separator locale, abbreviation, optional symbol prefix.
@@ -2469,6 +2517,50 @@ declare function resolveRowValue(row: any, fieldName: string): any;
  */
 declare function evaluateRowCondition(expression: string | null | undefined, row: any): boolean;
 
+/**
+ * Restricts an `<input type="text">` to a numeric value.
+ *
+ * Lives in eru-grid and is exported from its public API so the grid's cells and
+ * eru-studio's page controls share one implementation — the same value typed in
+ * a grid and on a page has to be accepted or rejected identically.
+ *
+ * Text rather than `type="number"` on purpose: a number input reformats the
+ * value on its own, refuses to show a grouped or symbol-prefixed value, and
+ * renders spinners the design does not use. Every eru-studio numeric field is
+ * therefore a text input — which accepted any string at all until this.
+ *
+ * Filtering happens at `beforeinput`, so the character is judged in the context
+ * it would land in: this is what tells a second '.' from the first, and a '-'
+ * typed at the start from one typed mid-value. A `keypress` filter cannot see
+ * either, and blur-time validation lets the user type a whole wrong value first.
+ */
+declare class NumericInputDirective {
+    private el;
+    /** Allow a decimal point. Off for an integer-only field. */
+    readonly allowDecimal: _angular_core.InputSignal<boolean>;
+    /** Allow a leading minus. Off where a negative makes no sense. */
+    readonly allowNegative: _angular_core.InputSignal<boolean>;
+    /**
+     * Would this be a valid numeric string, allowing the in-progress forms a
+     * user necessarily passes through — '', '-', '1.' — none of which parse as a
+     * number but all of which are on the way to one.
+     */
+    private isAcceptable;
+    /** The value the input would hold if this event were allowed through. */
+    private projectedValue;
+    onBeforeInput(event: InputEvent): void;
+    /**
+     * A paste is filtered rather than blocked: pasting a formatted amount
+     * ("$1,234.50") is a normal thing to do, and stripping it to 1234.50 is what
+     * the user meant. Only a paste with no digits at all is rejected outright.
+     */
+    onPaste(event: ClipboardEvent): void;
+    /** Digits, at most one decimal point, and a single leading minus. */
+    private clean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumericInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NumericInputDirective, "input[eruNumericInput]", never, { "allowDecimal": { "alias": "eruAllowDecimal"; "required": false; "isSignal": true; }; "allowNegative": { "alias": "eruAllowNegative"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 interface AttachmentConfig {
     disabled?: boolean;
     required?: boolean;
@@ -2572,6 +2664,80 @@ declare class CheckboxComponent {
     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>;
 }
 
+/** One chip. `color`/`background`/`dot` are optional: without them the chip
+ *  takes the neutral surface, which is what a plain value wants. */
+interface ChipListItem {
+    label: string;
+    color?: string | null;
+    background?: string | null;
+    dot?: string | null;
+}
+/**
+ * A row of chips that fits its container, with a `+N` for the rest.
+ *
+ * Shared by the grid's and eru-studio's multi-selects so a set of values reads
+ * the same in a cell, on a page and inside a select's trigger.
+ *
+ * Widths are MEASURED, not estimated. The tag cell assumes ~30px per chip,
+ * which is close enough for short tags and wrong for the entity names a select
+ * holds ("Acme Industries Pvt Ltd" is four times that) — it either wraps or
+ * hides chips that would have fitted. Measuring with a canvas rather than by
+ * rendering avoids the two-pass flicker of laying every chip out and then
+ * hiding the overflow.
+ */
+declare class ChipListComponent implements OnDestroy {
+    private host;
+    private readonly _chips;
+    /** Plain labels — the neutral chip. */
+    set labels(value: string[] | null | undefined);
+    /**
+     * Chips that carry their own colours — a tag or a status, where the colour is
+     * part of the value's meaning rather than decoration. Takes precedence over
+     * `labels`; set one or the other.
+     */
+    set chips(value: ChipListItem[] | null | undefined);
+    private readonly _compact;
+    set compact(value: boolean | null | undefined);
+    /**
+     * Width to fit into. 0 means "measure the host", which is what a page control
+     * wants; a grid cell passes its column width, which is known before layout.
+     */
+    private readonly _availableWidth;
+    set availableWidth(value: number | null | undefined);
+    readonly isCompact: _angular_core.Signal<boolean>;
+    /** Width assumed when nothing above the row constrains it. */
+    private static readonly UNCONSTRAINED_WIDTH;
+    private readonly measuredWidth;
+    private observer;
+    constructor();
+    private observe;
+    ngOnDestroy(): void;
+    /**
+     * The width to fit into.
+     *
+     * A grid cell hands us its column width and that is the constraint. A page
+     * control does not: eru-studio sizes every field shell with `width:
+     * fit-content`, so the host hugs whatever we just rendered — measuring the
+     * host would mean measuring our own output, and the row could never grow past
+     * the chip it happens to be showing. That is why view mode sat at one chip
+     * while edit mode, which gets Material's fixed infix width, showed three.
+     *
+     * So when no width is given, look UP for the first ancestor that is wider
+     * than the host: that is the box actually constraining the layout, and it
+     * does not change when our content does.
+     */
+    private measure;
+    /** Chip text width for the host's actual font, via a shared canvas. */
+    private static canvas;
+    private textWidth;
+    private readonly fit;
+    readonly visible: _angular_core.Signal<ChipListItem[]>;
+    readonly hiddenCount: _angular_core.Signal<number>;
+    readonly hiddenLabels: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChipListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChipListComponent, "eru-chip-list", never, { "labels": { "alias": "labels"; "required": false; }; "chips": { "alias": "chips"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "availableWidth": { "alias": "availableWidth"; "required": false; }; }, {}, never, never, true, never>;
+}
+
 interface CompositePart {
     name: string;
     label: string;
@@ -3231,6 +3397,15 @@ declare class SelectComponent implements OnInit, AfterViewInit {
     editModeChange: EventEmitter<boolean>;
     currentValue: _angular_core.WritableSignal<any>;
     searchText: _angular_core.WritableSignal<string>;
+    private static readonly OPTIONS_PAGE_SIZE;
+    /** The rendered mat-select, for its `panel` element once the overlay opens. */
+    private matSelect?;
+    /** Debounced search text, sent to the consumer as `search` (→ field_str). */
+    private readonly serverSearch;
+    private readonly optionsSkip;
+    /** Set when a short page comes back — nothing more to ask for. */
+    private readonly optionsExhausted;
+    private searchDebounce;
     error: _angular_core.WritableSignal<string>;
     isAllSelected: _angular_core.Signal<boolean>;
     isIndeterminate: _angular_core.Signal<boolean>;
@@ -3274,11 +3449,31 @@ declare class SelectComponent implements OnInit, AfterViewInit {
      */
     optionsCacheKey: _angular_core.Signal<string>;
     onSearchChange(searchValue: string): void;
+    /**
+     * Ask the consumer for the next page when the panel nears its end.
+     *
+     * Options are appended, never recycled: mat-select addresses MatOption
+     * instances for its selection, trigger text and keyboard navigation, so a
+     * virtual scroller destroying them as they leave the viewport breaks all
+     * three. Paging the data while keeping the DOM is what is wanted here.
+     */
+    private panelScrollTeardown;
+    /** Attach the paging listener to mat-select's panel once the overlay exists. */
+    private attachPanelScroll;
+    private detachPanelScroll;
+    private onPanelScroll;
     onOpenedChange(opened: boolean): void;
     ngAfterViewInit(): void;
     onDrillableClick(event: Event): void;
     getProperty(property: string): any;
     hasRequiredValidation(): boolean;
+    /**
+     * Selected values as their option labels, for the chip row.
+     *
+     * Same resolution as formatDisplayValue — the chip list only changes how they
+     * are laid out, so the two must never disagree about what a value is called.
+     */
+    readonly selectedLabels: _angular_core.Signal<string[]>;
     formatDisplayValue(): string;
     trackByValueAndIndex(index: number, option: any): string;
     /**
@@ -3417,6 +3612,13 @@ declare class TagComponent implements OnInit {
         label: any;
         color: any;
     }[]>;
+    /**
+     * Selected tags as coloured chips for the shared chip row.
+     *
+     * The colour is part of a tag's meaning, so it travels with the label rather
+     * than the chip list assuming a neutral pill.
+     */
+    readonly tagChips: _angular_core.Signal<ChipListItem[]>;
     maxDisplayTags: _angular_core.Signal<number>;
     tagDisplay: _angular_core.Signal<{
         displayTags: string[];
@@ -3585,5 +3787,5 @@ declare class ThemeToggleComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThemeToggleComponent, "eru-theme-toggle", never, {}, {}, never, never, true, never>;
 }
 
-export { ACTION_COLUMN_MIN_WIDTH, AttachmentComponent, CELL_RULE_OPERATORS, CheckboxComponent, ColumnConstraintsService, CompositeComponent, CurrencyComponent, CustomVirtualScrollStrategy, DATA_TYPES, DATETIME_FORMATS, DATE_FORMATS, DateComponent, DatetimeComponent, DurationComponent, EmailComponent, EruGridComponent, EruGridService, EruGridStore, GRID_COLOR_TOKENS, INHERITED_FIELD_KEYS, LocationComponent, MATERIAL_MODULES, MATERIAL_PROVIDERS, MONTH_SHORT_NAMES, NumberComponent, PRESENTATION_DATATYPES, PRESET_CONFIG_DEFAULTS, PRESET_MANAGED_FIELDS, PeopleComponent, PhoneComponent, PriorityComponent, ProgressComponent, RatingComponent, SEEDED_FIELD_KEYS, SELF_COLOURED_DATATYPES, SelectComponent, StatusComponent, TagComponent, TextareaComponent, TextboxComponent, ThemeService, ThemeToggleComponent, WebsiteComponent, abbreviateNumber, cellRuleBarPercent, cellRuleMatches, cellRuleToCss, cellStatAlias, cellTextStyleToCss, collectColumnStatRequests, composeColorValue, evaluateRowCondition, formatCellValue, formatDateWithPattern, formatNumberValue, matchCellRule, matchColorRange, normalizeDatatype, normalizeDateFormat, normalizeDateTimeFormat, parseCellDate, parseColorValue, parseDateWithPattern, readRowValue, resolveColumnRules, resolveRowValue, resolveStatValue, statusPillColors, tagPillColors };
-export type { ActionClick, AggregationFunction, AttachmentConfig, BoardCardContext, CellFormatRule, CellRuleOperator, CellStatRef, CellStatVerb, CellTemplateContext, CellTextStyle, CellValueChange, ColorRangeBand, ColumnReorder, ColumnResize, ColumnStatRequest, ColumnWidthConstraints, CompositePart, CurrencyValidationResult, DataTypes, Drilldown, DurationValue, DynamicDataRequest, EmailValidationResult, ExcelDownloadPayload, ExcelDownloadRequest, ExcelPivotConfig, Field, GridAction, GridConfiguration, GridFeatures, GridMode, GridPreset, GridStyles, GridTokens, GroupItem$1 as GroupItem, LocationConfig, LocationValidationResult, NumberValidationResult, ParsedColorValue, PeopleOption, PersonCardContext, PivotColumnGroupState, PivotColumnHeader, PivotColumnKind, PivotConfiguration, PivotHeaderStructure, PivotMetadata, PivotResult, PivotRow, PivotRowKind, RatingConfig, Row, RowDataRequest, RowDataResponse, RowGrandTotal, RowGroup, ServerValidationNotice, StatusPillColors, TagPillColors, TextareaValidationResult, TextboxValidationResult, Theme, WebsiteValidationResult };
+export { ACTION_COLUMN_MIN_WIDTH, AttachmentComponent, CELL_RULE_OPERATORS, CheckboxComponent, ChipListComponent, ColumnConstraintsService, CompositeComponent, CurrencyComponent, CustomVirtualScrollStrategy, DATA_TYPES, DATETIME_FORMATS, DATE_FORMATS, DateComponent, DatetimeComponent, DurationComponent, EmailComponent, EruGridComponent, EruGridService, EruGridStore, GRID_COLOR_TOKENS, INHERITED_FIELD_KEYS, LocationComponent, MATERIAL_MODULES, MATERIAL_PROVIDERS, MONTH_SHORT_NAMES, NumberComponent, NumericInputDirective, PRESENTATION_DATATYPES, PRESET_CONFIG_DEFAULTS, PRESET_MANAGED_FIELDS, PeopleComponent, PhoneComponent, PriorityComponent, ProgressComponent, RatingComponent, SEEDED_FIELD_KEYS, SELF_COLOURED_DATATYPES, SelectComponent, StatusComponent, TagComponent, TextareaComponent, TextboxComponent, ThemeService, ThemeToggleComponent, WebsiteComponent, abbreviateNumber, abbreviationScaleFor, cellRuleBarPercent, cellRuleMatches, cellRuleToCss, cellStatAlias, cellTextStyleToCss, collectColumnStatRequests, columnCellRules, composeColorValue, evaluateRowCondition, formatCellValue, formatDateWithPattern, formatNumberValue, hasOwnCellRules, matchCellRule, matchColorRange, normalizeDatatype, normalizeDateFormat, normalizeDateTimeFormat, parseCellDate, parseColorValue, parseDateWithPattern, readRowValue, resolveColumnRules, resolveRowValue, resolveStatValue, statusPillColors, tagPillColors };
+export type { ActionClick, AggregationFunction, AttachmentConfig, BoardCardContext, CellFormatRule, CellRuleOperator, CellStatRef, CellStatVerb, CellTemplateContext, CellTextStyle, CellValueChange, ChipListItem, ColorRangeBand, ColumnReorder, ColumnResize, ColumnStatRequest, ColumnWidthConstraints, CompositePart, CurrencyValidationResult, DataTypes, Drilldown, DurationValue, DynamicDataRequest, EmailValidationResult, ExcelDownloadPayload, ExcelDownloadRequest, ExcelPivotConfig, Field, GridAction, GridConfiguration, GridFeatures, GridMode, GridPreset, GridStyles, GridTokens, GroupItem$1 as GroupItem, LocationConfig, LocationValidationResult, NumberValidationResult, ParsedColorValue, PeopleOption, PersonCardContext, PivotColumnGroupState, PivotColumnHeader, PivotColumnKind, PivotConfiguration, PivotHeaderStructure, PivotMetadata, PivotResult, PivotRow, PivotRowKind, RatingConfig, Row, RowDataRequest, RowDataResponse, RowGrandTotal, RowGroup, ServerValidationNotice, StatusPillColors, TagPillColors, TextareaValidationResult, TextboxValidationResult, Theme, WebsiteValidationResult };