@aquera/ngx-smart-table 0.0.28 → 0.0.32

package/types/aquera-ngx-smart-table.d.ts

@@ -529,6 +529,14 @@ declare class TableState {
     readonly requestAddRow$: Observable<{
         focusColumn: number;
     }>;
+    private _requestFocusTabs$;
+    readonly requestFocusTabs$: Observable<void>;
+    private _requestEditFocusedCell$;
+    readonly requestEditFocusedCell$: Observable<void>;
+    private _requestFocusRowActions$;
+    readonly requestFocusRowActions$: Observable<number>;
+    private _requestFocusHeader$;
+    readonly requestFocusHeader$: Observable<number>;
     private _pendingFocusAfterRowAdd;
     private _rowCount;
     private _columnCount;
@@ -731,6 +739,9 @@ declare class TableState {
      * Focus a cell by position
      */
     focusCell(rowIndex: number, columnIndex: number): void;
+    get rowCount(): number;
+    get columnCount(): number;
+    requestEditFocusedCell(): void;
     /**
      * Get currently focused position
      */
@@ -761,6 +772,8 @@ declare class TableState {
      * Clear focus
      */
     clearFocus(): void;
+    /** Emit requestFocusTabs$ to signal that focus should return to the sheet tabs/headers. */
+    requestFocusTabs(): void;
     /**
      * Check if navigation is active
      */
@@ -976,6 +989,12 @@ interface ColumnConfig<T = any> {
      * Edit mode trigger
      */
     readonly editMode?: EditMode;
+    /**
+     * When `true` with {@link CellDataType.BOOLEAN}, the cell shows a `nile-checkbox` in display mode (inline toggle).
+     * When `false` or unset on other column setups, display uses the formatter (e.g. Yes/No).
+     * With `Columns.nileCheckbox(...)`, defaults to `true` unless you pass `booleanDisplayAsCheckbox: false`.
+     */
+    readonly booleanDisplayAsCheckbox?: boolean;
     /**
      * Whether this column is sortable
      */
@@ -1081,6 +1100,11 @@ interface ColumnConfig<T = any> {
      * @default true
      */
     readonly showStickyShadow?: boolean;
+    /**
+     * Background for this column’s cells when `sticky` is set (header + body).
+     * Falls back to `TableConfig.display.stickyColumnBackground` when omitted.
+     */
+    readonly stickyBackground?: string;
     /**
      * Cell content alignment
      */
@@ -1361,6 +1385,11 @@ declare class Cell<T = any> {
      * @param newValue The new value from editor
      */
     saveEdit(newValue: T): boolean;
+    /**
+     * Apply a new value from an inline display control (e.g. `nile-checkbox`) without entering edit mode.
+     * Runs the same validation, dirty-state, history, and save hooks as {@link saveEdit}.
+     */
+    commitDisplayValue(newValue: T): boolean;
     /**
      * Cancel edit and revert to previous value
      */
@@ -1591,7 +1620,11 @@ declare enum NavigationKey {
     /**
      * Escape key
      */
-    ESCAPE = "Escape"
+    ESCAPE = "Escape",
+    /**
+     * Space key — starts cell editing
+     */
+    SPACE = " "
 }
 /**
  * Navigation directions
@@ -1958,6 +1991,10 @@ interface RowActionContext {
  * Provides a single source of truth for pagination, sorting, filtering, and display options
  */
 
+/** Context passed to `TableConfig.display.rowBackground`. */
+interface TableRowBackgroundContext {
+    rowIndex: number;
+}
 /**
  * Comprehensive table configuration interface
  */
@@ -2061,6 +2098,11 @@ interface TableConfig {
      * Display configuration
      */
     display?: {
+        /**
+         * Accessible label for the table element (exposed as `aria-label`).
+         * Used by screen readers to identify the table. Defaults to `'Data table'`.
+         */
+        ariaLabel?: string;
         /**
          * Make table header sticky on scroll
          * @default true
@@ -2072,10 +2114,73 @@ interface TableConfig {
          */
         hover?: boolean;
         /**
-         * Max height of the table in pixels
+         * Max height of the table body scroll area in pixels (standard / non–virtual-scroll mode).
+         * Applied as `max-height` on the `.st-table` wrapper. Ignored for that sizing when `visibleBodyRows` is set.
+         * The host uses `min-height: 0` so flex parents (e.g. workbook tabs) honor the cap.
          * @default 300
          */
         maxHeight?: number;
+        /**
+         * Number of **data** (body) rows to keep visible before vertical scroll (standard mode only).
+         * Use **`0`** to show **all** rows: no row-count viewport and no `display.maxHeight` cap on `.st-table`
+         * (natural table height; page/parent may still scroll).
+         * For **positive** N, the table measures the header and the sum of the first N body row heights (capped
+         * by actual row count) and sets that viewport; it takes precedence over `maxHeight` for that wrapper.
+         * Not used when virtual scroll is enabled.
+         */
+        visibleBodyRows?: number;
+        /**
+         * Default background for sticky columns (row #, sticky-left / sticky-right cells) when the column has no `stickyBackground`.
+         */
+        stickyColumnBackground?: string;
+        /**
+         * When true, applies the sticky row background to every cell in each row (not only sticky-positioned columns).
+         * Each cell uses `column.stickyBackground` when set, otherwise `stickyColumnBackground`.
+         * @default false
+         */
+        stickyColumnBackgroundFullRow?: boolean;
+        /**
+         * Per-row background from row data. When a non-empty string is returned, it applies to every body cell in that row
+         * (row number, data cells, settings column). Return `undefined` / `null` / `''` to fall back to sticky / default styling.
+         * Not serializable in JSON configs (TypeScript only).
+         */
+        rowBackground?: (rowData: any, context: TableRowBackgroundContext) => string | null | undefined;
+        /**
+         * Optional icon shown next to the row number from row data — useful for status badges
+         * like "disabled", "warning", "locked". Return a Nile icon name to render the icon next
+         * to the row number inside the same sticky row-number cell. Return `null` / `undefined` / `''`
+         * to show no icon for that row. Has no effect when `showRowNumber` is `false`.
+         *
+         * Optionally return `{ name, tooltip }` to also surface a hover tooltip on the icon.
+         * Not serializable in JSON configs (TypeScript only).
+         *
+         * @example
+         * display: {
+         *   showRowNumber: true,
+         *   rowNumberIcon: (row) => row.disabled ? 'disabled' : null,
+         * }
+         */
+        rowNumberIcon?: (rowData: any, context: TableRowBackgroundContext) => string | {
+            name: string;
+            tooltip?: string;
+        } | null | undefined;
+        /**
+         * Explicit pixel width of the row-number column. Defaults to `30` when no
+         * `rowNumberIcon` is configured, and `60` when one is — auto-sized to fit
+         * triple-digit numbers plus the trailing status icon. Override if you have
+         * very large row counts (4+ digits) or want a wider gutter.
+         */
+        rowNumberWidth?: number;
+        /**
+         * Customize the keyboard-focused cell outline (`.cell-focused` when keyboard navigation is enabled).
+         * Any property omitted keeps the library default.
+         */
+        focusedCell?: {
+            outlineColor?: string;
+            outlineWidth?: string;
+            boxShadow?: string;
+            editingBoxShadow?: string;
+        };
         /**
          * Virtual scroll configuration for large datasets
          * Enables efficient rendering by only showing visible rows
@@ -2262,10 +2367,286 @@ interface SheetActionContext {
     actions: SheetAction[];
 }
 
+/**
+ * Condition builder operator types.
+ *
+ * Operator definitions are consumer-provided via ConditionBuilderConfig.operators.
+ * The library does not ship a default operator set.
+ */
+/**
+ * Arity of an operator — how many value inputs the operator needs.
+ *  - 'none'   : operator takes no value (e.g. IS_CHANGED, IS_EMPTY)
+ *  - 'single' : operator takes one value
+ *  - 'multi'  : operator takes a list of values
+ */
+type OperatorArity = 'none' | 'single' | 'multi';
+/**
+ * Logical connector between two adjacent conditions.
+ * The first condition in a list has an unused connector (defaults to 'AND').
+ */
+type LogicalConnector = 'AND' | 'OR';
+/**
+ * Group type — how subConditions inside a group are combined.
+ *  - 'all' : all subConditions must be true (AND)
+ *  - 'any' : at least one subCondition must be true (OR)
+ */
+type GroupType = 'all' | 'any';
+/**
+ * Declarative definition of one comparison operator.
+ */
+interface OperatorDefinition {
+    /** Stable identifier used in the saved condition (e.g. 'EQUAL'). */
+    key: string;
+    /** User-visible label (e.g. 'Equals to'). */
+    label: string;
+    /** Whether this operator needs a value, a single value, or multiple values. */
+    arity: OperatorArity;
+}
+
+/**
+ * Field (attribute) schema for the condition builder.
+ *
+ * Fields are consumer-provided via ConditionBuilderConfig.fields.
+ * The library does not ship default fields.
+ */
+/**
+ * Editor variant used to render a field's value input.
+ *  - 'text'         : free-form text, single value
+ *  - 'chip'         : free-form text, multi-value (chips)
+ *  - 'select'       : dropdown of predefined options, single value
+ *  - 'multi-select' : dropdown of predefined options, multi value
+ */
+type FieldValueEditor = 'text' | 'chip' | 'select' | 'multi-select';
+/**
+ * A predefined option for select / multi-select editors.
+ */
+interface FieldOption {
+    /** Stable value stored in the condition. */
+    value: string;
+    /** User-visible label. */
+    label: string;
+}
+/**
+ * Declarative definition of one attribute the user can build conditions against.
+ */
+interface FieldDefinition {
+    /** Stable identifier stored in the condition (e.g. 'userStatus'). */
+    attribute: string;
+    /** User-visible label (e.g. 'User Status'). */
+    screenName: string;
+    /** Which value editor to render once the user picks this field. */
+    valueEditor: FieldValueEditor;
+    /**
+     * Operator keys this field supports. If omitted, all operators from the
+     * builder config are allowed. Operator keys must match an OperatorDefinition.key.
+     */
+    operators?: string[];
+    /** Predefined options — required when valueEditor is 'select' or 'multi-select'. */
+    options?: FieldOption[];
+    /**
+     * Placeholder text shown in the value editor when nothing is selected.
+     * Falls back to a sensible default per editor type when omitted.
+     */
+    valuePlaceholder?: string;
+}
+/**
+ * Grouped fields shown as a submenu in the field picker. Matches the v1 admin-ui
+ * pattern where top-level options ("Groups Membership", "Operation") sit alongside
+ * a nested "Attributes" category whose entries (often dozens or hundreds, fetched
+ * dynamically per tenant) live behind a searchable submenu.
+ */
+interface FieldCategory {
+    /** Stable identifier for the category. */
+    id: string;
+    /** User-visible label (e.g. 'Attributes'). */
+    label: string;
+    /** Fields shown inside this category's submenu. */
+    fields: FieldDefinition[];
+    /**
+     * Show a search input above the field list. Recommended for categories
+     * with more than a handful of fields.
+     * @default true
+     */
+    searchable?: boolean;
+}
+
+/**
+ * Condition builder configuration — provided by the consuming application.
+ *
+ * The library ships no defaults. The consumer is responsible for supplying
+ * the field schema, operator catalogue, and feature flags.
+ */
+
+interface ConditionBuilderConfig {
+    /** Top-level fields, shown directly in the field picker. */
+    fields: FieldDefinition[];
+    /**
+     * Optional grouped fields. Each category shows as one entry in the top-level
+     * picker with a chevron — clicking it opens a submenu containing the
+     * category's fields (with optional search).
+     */
+    categories?: FieldCategory[];
+    /** Available comparison operators. */
+    operators: OperatorDefinition[];
+    /**
+     * Allow toggling between condition-builder UI and raw expression mode.
+     * When false, the expression-mode toggle is hidden.
+     * @default false
+     */
+    allowExpressionMode?: boolean;
+    /**
+     * Allow adding group conditions (1-level nesting).
+     * When false, only flat single conditions can be added.
+     * @default true
+     */
+    allowGroups?: boolean;
+    /**
+     * Maximum number of top-level conditions. Add buttons disable once reached.
+     * @default 10
+     */
+    maxConditions?: number;
+    /**
+     * Language token-set for syntax highlighting in expression mode.
+     * Passed to nile-code-editor's `language` prop.
+     * @default 'javascript'
+     */
+    expressionLanguage?: 'javascript' | 'sql' | 'json' | 'html';
+    /**
+     * Nested autocompletion tree forwarded to nile-code-editor's
+     * `customAutoCompletions`. Same shape v1 used in admin-ui — typically a
+     * nested object describing variable hierarchies, e.g.:
+     *   { DEST: { target: {...}, projected: {...}, meta: {...} } }
+     * Pair with `expressionAutoCompletionPaths` to control which paths show up.
+     */
+    expressionAutoCompletions?: Record<string, unknown>;
+    /**
+     * Dot-separated paths exposed by the autocompletion engine, forwarded to
+     * nile-code-editor's `customCompletionsPaths`. Example:
+     *   ['DEST.target.email', 'DEST.projected.email', 'DEST.config.operation']
+     */
+    expressionAutoCompletionPaths?: string[];
+}
+/**
+ * Validation error reported by the condition builder.
+ */
+interface ConditionValidationError {
+    /** Stable error code (e.g. 'empty-attribute'). */
+    code: string;
+    /** Human-readable message. */
+    message: string;
+    /** Index of the offending top-level condition, if applicable. */
+    index?: number;
+    /** Index of the offending subCondition within a group, if applicable. */
+    subIndex?: number;
+}
+/**
+ * Validity payload emitted by the condition builder.
+ */
+interface ConditionBuilderValidity {
+    valid: boolean;
+    errors: ConditionValidationError[];
+}
+
+/**
+ * Strict types for the condition tree the builder produces.
+ *
+ * The shape is a discriminated union: a node is either a 'single' condition
+ * (one field/operator/value triple) or a 'group' (a list of subConditions
+ * combined by the group's groupType).
+ *
+ * Nesting depth is one level — groups contain only single subConditions,
+ * not other groups. This matches the v1 admin-ui implementation.
+ */
+
+/**
+ * Value held by a single condition. Shape depends on the operator's arity:
+ *  - 'none'   → empty array
+ *  - 'single' → single-element array (or scalar — the builder normalises to array)
+ *  - 'multi'  → array of strings
+ */
+type ConditionValue = string[];
+/**
+ * One leaf condition: field · operator · value, plus the logical connector
+ * that ties it to the previous condition in its parent list.
+ */
+interface SingleCondition {
+    type: 'single';
+    /** Logical connector to the previous condition in the parent list. First condition's connector is ignored. */
+    connector: LogicalConnector;
+    /** Field attribute key — references FieldDefinition.attribute. */
+    attribute: string;
+    /** Operator key — references OperatorDefinition.key. */
+    operator: string;
+    /** Value(s) for this condition. Empty array when operator arity is 'none'. */
+    value: ConditionValue;
+}
+/**
+ * A condition that lives inside a group. Same shape as SingleCondition but
+ * typed separately to make the 1-level nesting rule explicit at compile time.
+ */
+interface SubCondition {
+    /** Logical connector to the previous subCondition in the parent group. First subCondition's connector is ignored. */
+    connector: LogicalConnector;
+    attribute: string;
+    operator: string;
+    value: ConditionValue;
+}
+/**
+ * A group condition: bundles a list of subConditions combined by groupType.
+ */
+interface GroupCondition {
+    type: 'group';
+    /** Logical connector to the previous condition in the parent list. */
+    connector: LogicalConnector;
+    /** How the subConditions are combined: 'all' = AND, 'any' = OR. */
+    groupType: GroupType;
+    /** List of subConditions in this group. Always at least one. */
+    subConditions: SubCondition[];
+}
+/**
+ * Discriminated union — a top-level condition is either single or a group.
+ */
+type ConditionNode = SingleCondition | GroupCondition;
+/**
+ * Builder mode for a rule.
+ *  - 'builder'    : GUI condition builder (the default)
+ *  - 'expression' : raw expression text editor
+ * The two modes are mutually exclusive per rule.
+ */
+type ConditionBuilderMode = 'builder' | 'expression';
+/**
+ * The full value the condition builder reads and writes.
+ * Either `conditions` (when mode is 'builder') or `expression` (when mode is 'expression')
+ * is the authoritative source — the unused one is preserved as-is.
+ */
+interface ConditionBuilderValue {
+    /** Current mode of this rule. */
+    mode: ConditionBuilderMode;
+    /** Condition tree — authoritative when mode is 'builder'. */
+    conditions: ConditionNode[];
+    /** Raw expression text — authoritative when mode is 'expression'. */
+    expression: string;
+}
+
 /**
  * Sheet configuration interface - wraps table with sheet-level settings
  */
 
+/**
+ * Discriminator for the sheet's content type. Defaults to 'table' for back-compat.
+ */
+type SheetContentType = 'table' | 'condition-builder';
+/**
+ * Condition-builder branch of a sheet. Present when contentType is 'condition-builder'.
+ */
+interface SheetConditionBuilder {
+    /** Builder configuration — fields, operators, feature flags. */
+    config: ConditionBuilderConfig;
+    /** Current rule value — mode, conditions, expression. */
+    value: ConditionBuilderValue;
+    /** Whether the rule is enabled. Surface as a sheet-level toggle action. */
+    isEnabled?: boolean;
+}
 /**
  * Comprehensive sheet configuration interface
  */
@@ -2279,9 +2660,19 @@ interface SheetConfig {
      */
     name: string;
     /**
-     * Table configuration (existing TableConfig)
+     * Sheet content type. When omitted, defaults to 'table' (back-compat).
      */
-    tableConfig: TableConfig;
+    contentType?: SheetContentType;
+    /**
+     * Table configuration (existing TableConfig).
+     * Required when contentType is 'table' (or omitted).
+     */
+    tableConfig?: TableConfig;
+    /**
+     * Condition builder configuration + value.
+     * Required when contentType is 'condition-builder'.
+     */
+    conditionBuilder?: SheetConditionBuilder;
     /**
      * Sheet-level actions (similar to RowAction pattern)
      */
@@ -2537,9 +2928,17 @@ interface AutosaveConfig {
      * - 'eager': Saves on every change (100ms debounce)
      */
     strategy: AutosaveStrategy;
+    /**
+     * Whether to render the small save / spinner indicator in the workbook
+     * toolbar. Independent of `enabled` so a consumer can autosave silently
+     * without surfacing it to the user.
+     * @default false
+     */
+    showIndicator?: boolean;
 }
 /**
- * Default autosave configuration
+ * Default autosave configuration. Autosave itself is on by default but the
+ * UI indicator is hidden — consumers must opt in via `showIndicator: true`.
  */
 declare const DEFAULT_AUTOSAVE_CONFIG: AutosaveConfig;
 
@@ -2560,9 +2959,19 @@ interface WorkbookSheetConfig {
      */
     name: string;
     /**
-     * Table configuration for this sheet
+     * Sheet content type. When omitted, defaults to 'table' (back-compat).
      */
-    tableConfig: TableConfig;
+    contentType?: SheetContentType;
+    /**
+     * Table configuration for this sheet.
+     * Required when contentType is 'table' (or omitted).
+     */
+    tableConfig?: TableConfig;
+    /**
+     * Condition builder configuration + value.
+     * Required when contentType is 'condition-builder'.
+     */
+    conditionBuilder?: SheetConditionBuilder;
     /**
      * Optional per-sheet tab actions (overrides workbook defaults)
      */
@@ -3495,11 +3904,36 @@ declare class NileSelectEditor<T = string> implements CellEditor<T> {
     private select?;
     private eventListeners;
     private optionsSubscription?;
+    private dropdownOpen;
+    private documentKeyForwarder;
+    private wheelLockHandler;
+    private highlightedOptionIndex;
     private currentOptions;
     private trackedValues;
     private hasChangeOccurred;
     constructor(options: NileSelectEditorOptions);
     edit(context: CellEditorContext<T>): void;
+    private setupDocumentKeyForwarder;
+    /** Dispatch mouseup on the currently highlighted virtual-scroll portal option */
+    private selectHighlightedVirtualOption;
+    /** Navigate options — delegates to virtual or regular path */
+    private navigateOption;
+    /** Virtual-scroll: options live in the portal DOM, queried directly */
+    private navigateVirtualOption;
+    /** Regular (non-virtual) select: options are in nile-select's light DOM */
+    private navigateRegularOption;
+    /** Apply data-kb-active on the portal option matching highlightedOptionIndex */
+    private syncPortalHighlight;
+    /** Return the active portal element for the current select mode */
+    private getActivePortal;
+    private getPortalOptions;
+    /**
+     * Prevent the table (and page) from scrolling while the dropdown is open.
+     * Wheel events that originate inside the portal are allowed (so the dropdown
+     * list can still be scrolled); all others are cancelled.
+     */
+    private setupScrollLock;
+    private teardownScrollLock;
     private activateSelectAfterMount;
     /** Lit @query('nile-popup') / .select — must exist before handleOpenChange touches this.popup.popup */
     private isNileSelectPopupMounted;
@@ -3911,8 +4345,15 @@ declare class NileChipEditor implements CellEditor<string[]> {
     private eventListeners;
     private trackedValues;
     private hasChangeOccurred;
+    private focusRetryHandle;
     constructor(options?: NileChipEditorOptions | undefined);
     edit(context: CellEditorContext<string[]>): void;
+    /**
+     * Retry focusing the chip's internal text input using requestAnimationFrame until
+     * nile-chip's Lit shadow DOM has finished rendering (avoids fixed-timeout races).
+     * Reads nile-chip's internal autoComplete reference for the most reliable access.
+     */
+    private scheduleFocusRetry;
     private positionPopover;
     private setInitialValue;
     private applyOptions;
@@ -4035,6 +4476,8 @@ declare class NileCodeEditor<T = string> implements CellEditor<T> {
     private context?;
     private dialogOpen;
     private expandButtonClicked;
+    /** Pointer is down on a CodeMirror tooltip — skip blur-save so completion clicks are not treated as leaving the cell */
+    private codeMirrorUiPointerDown;
     private documentClickHandler?;
     private trackedValue;
     private syncingFromDialog;
@@ -4042,6 +4485,13 @@ declare class NileCodeEditor<T = string> implements CellEditor<T> {
     private dialogOriginalValue;
     private dialogCurrentValue;
     constructor(options?: NileCodeEditorOptions | undefined);
+    /**
+     * Parent CodeMirror tooltips to `document.body` so autocomplete is not clipped by the table/cell
+     * overflow chain. Uses runtime `import()` only — no extra entries in this library's package.json;
+     * modules resolve from the app via `@aquera/nile-elements` / `codemirror` (unchanged consumer graph).
+     */
+    private attachCodeMirrorTooltipsToBody;
+    private onNileCodeMirrorAfterUpdate;
     edit(context: CellEditorContext<T>): void;
     /**
      * Focus the editor and place cursor
@@ -4102,6 +4552,38 @@ declare class NileCodeEditor<T = string> implements CellEditor<T> {
     getEditorInstance(): any;
 }
 
+/**
+ * Boolean cell editor using `<nile-checkbox>` from @aquera/nile-elements`.
+ *
+ * For display (inline checkbox vs Yes/No text), set `booleanDisplayAsCheckbox` on the column config
+ * (`Columns.nileCheckbox` defaults it to `true`; pass `booleanDisplayAsCheckbox: false` for text until edit).
+ */
+
+interface NileCheckboxEditorOptions {
+    /** Checkbox size (default `small` for compact table cells) */
+    size?: 'small' | 'medium' | 'large';
+    disabled?: boolean;
+    /** Optional label text (Nile `label` attribute); leave empty for icon-only in-cell */
+    label?: string;
+    /** When true (default), each toggle calls `onSave` immediately */
+    saveOnChange?: boolean;
+    autoFocus?: boolean;
+}
+/**
+ * Uses Nile checkbox styling/behavior instead of a native `<input type="checkbox">`.
+ */
+declare class NileCheckboxEditor implements CellEditor<boolean> {
+    private readonly options?;
+    readonly acceptsInitialKeypress = false;
+    private checkbox?;
+    private readonly listeners;
+    constructor(options?: NileCheckboxEditorOptions | undefined);
+    edit(context: CellEditorContext<boolean>): void;
+    destroy(): void;
+    focus(): void;
+    getCurrentValue(): boolean;
+}
+
 /**
  * Column configuration factory
  * Simplifies creation of common column types with sensible defaults
@@ -4141,6 +4623,19 @@ declare class ColumnConfigFactory {
         trueValue?: string;
         falseValue?: string;
     }): ColumnConfig<boolean>;
+    /**
+     * Boolean column using {@link NileCheckboxEditor} (`<nile-checkbox>`) instead of a native checkbox.
+     *
+     * Display mode:
+     * - `booleanDisplayAsCheckbox` omitted or `true` — inline `nile-checkbox` in the cell (toggle without opening editor).
+     * - `booleanDisplayAsCheckbox: false` — show formatted text (`trueValue` / `falseValue`, default Yes/No) until the user edits the cell.
+     */
+    static nileCheckbox(key: string, options?: Partial<ColumnConfig<boolean>> & {
+        trueValue?: string;
+        falseValue?: string;
+        /** Options passed to {@link NileCheckboxEditor} */
+        nileCheckbox?: NileCheckboxEditorOptions;
+    }): ColumnConfig<boolean>;
     /**
      * Create a select/dropdown column
      */
@@ -4205,6 +4700,9 @@ declare class StCellComponent implements OnInit, OnDestroy, AfterViewInit {
         rowData: any;
         rowIndex: number | undefined;
     } | null>;
+    /** Boolean column: show `nile-checkbox` in display mode instead of Yes/No text */
+    readonly showBooleanCheckboxDisplay: _angular_core.Signal<boolean>;
+    readonly booleanCheckboxChecked: _angular_core.Signal<boolean>;
     ngOnInit(): void;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
@@ -4215,6 +4713,7 @@ declare class StCellComponent implements OnInit, OnDestroy, AfterViewInit {
     private startEditWithKey;
     onCellClick(): void;
     onCellDoubleClick(): void;
+    onBooleanCheckboxDisplayChange(event: Event): void;
     private startEdit;
     private renderEditor;
     private saveEdit;
@@ -4314,6 +4813,7 @@ declare class VirtualScrollService {
 
 declare class StTableComponent implements OnInit, OnChanges, OnDestroy, AfterViewInit {
     private destroyRef;
+    private injector;
     private schemaValidator;
     private logger;
     private virtualScrollService;
@@ -4341,6 +4841,7 @@ declare class StTableComponent implements OnInit, OnChanges, OnDestroy, AfterVie
     readonly requestAddRow: _angular_core.OutputEmitterRef<{
         focusColumn?: number;
     }>;
+    readonly requestFocusTabs: _angular_core.OutputEmitterRef<void>;
     readonly mergedConfig: _angular_core.WritableSignal<TableConfig | null>;
     readonly visibleColumns: _angular_core.WritableSignal<ColumnConfig<any>[]>;
     readonly visibleCellGrid: _angular_core.WritableSignal<Cell<any>[][]>;
@@ -4353,6 +4854,7 @@ declare class StTableComponent implements OnInit, OnChanges, OnDestroy, AfterVie
         triggerTop?: number;
     }>;
     readonly dropdownContext: _angular_core.WritableSignal<RowActionContext | null>;
+    private dropdownTriggerEl;
     readonly columnMenuIsOpen: _angular_core.WritableSignal<boolean>;
     readonly columnMenuPosition: _angular_core.WritableSignal<{
         x: number;
@@ -4383,12 +4885,12 @@ declare class StTableComponent implements OnInit, OnChanges, OnDestroy, AfterVie
         };
         context: ColumnActionContext | null;
     }>;
+    skeletonColumns?: number[];
+    skeletonRows?: number[];
     readonly virtualScrollTotalHeight$: BehaviorSubject<number>;
     readonly virtualScrollOffsetY$: BehaviorSubject<number>;
     readonly virtualScrollOffsetYNeg$: BehaviorSubject<number>;
     readonly visibleRows$: BehaviorSubject<Cell<any>[][]>;
-    skeletonColumns?: number[];
-    skeletonRows?: number[];
     private internalTableState?;
     private internalCellGrid?;
     private stateSubscription?;
@@ -4401,6 +4903,12 @@ declare class StTableComponent implements OnInit, OnChanges, OnDestroy, AfterVie
     private scrollContainer?;
     private scrollSubscription?;
     scrollViewport?: ElementRef<HTMLElement>;
+    /** Pixel height for `.st-table` when `display.visibleBodyRows` is set (measured from DOM). */
+    private readonly scrollViewportHeightPx;
+    private viewportMeasureRaf;
+    private tableResizeObserver;
+    private observedTableElement;
+    private readonly fallbackBodyRowPx;
     constructor();
     ngOnInit(): void;
     ngAfterViewInit(): void;
@@ -4454,8 +4962,18 @@ declare class StTableComponent implements OnInit, OnChanges, OnDestroy, AfterVie
     getRowActions(): RowAction[];
     getRowData(rowIndex: number): any;
     openRowActionsDropdown(event: MouseEvent, rowData: any, rowIndex: number): void;
-    closeRowActionsDropdown(): void;
+    closeRowActionsDropdown(returnFocus?: boolean): void;
+    /** Tab pressed inside the row-actions dropdown: close + exit the table. */
+    onDropdownTabbed(payload: {
+        shift: boolean;
+    }): void;
     onRowActionClicked(event: RowActionEvent): void;
+    onSettingsTriggerKeydown(event: KeyboardEvent, rowData: any, rowIndex: number): void;
+    /** Move focus to the first focusable element after the table host. */
+    private focusNextOutsideTable;
+    /** Move focus to the last focusable element before the table host. */
+    private focusPrevOutsideTable;
+    openColumnMenuFromKeyboard(columnIndex: number, isFirst: boolean, isLast: boolean): void;
     openColumnMenu(event: MouseEvent, column: ColumnConfig<any>, columnIndex: number, isFirst: boolean, isLast: boolean): void;
     closeColumnMenu(): void;
     onColumnActionClicked(event: ColumnActionEvent): void;
@@ -4470,6 +4988,67 @@ declare class StTableComponent implements OnInit, OnChanges, OnDestroy, AfterVie
     scrollToLastRow(focusFirstCell?: boolean): void;
     private getScrollContainerElement;
     private calculateStickyWidths;
+    /**
+     * Resolved CSS color from `display.rowBackground` for this row index, if any.
+     */
+    resolveRowBackground(rowIndex: number): string | undefined;
+    /**
+     * Pixel width of the row-number column. Honors `display.rowNumberWidth` when
+     * set, else defaults to 60 when an icon function is configured (room for
+     * triple-digit + icon), else 30 (matches the historical narrow gutter).
+     * `table-layout: fixed` makes this width authoritative for the column.
+     */
+    get rowNumberColumnWidth(): number;
+    /**
+     * True when `display.rowNumberIcon` is configured. Toggles the
+     * `--with-icon` CSS modifier on the row-number cells, switching the layout
+     * from "centered single number" to "right-aligned slot + trailing icon" so
+     * the icon's x position stays stable across digit counts.
+     */
+    get hasRowNumberIcon(): boolean;
+    /**
+     * Resolved row-number icon descriptor for this row, or `null` if the row has none.
+     * Supports both shorthand (`'iconName'`) and object (`{ name, tooltip }`) return values
+     * from `display.rowNumberIcon`.
+     */
+    resolveRowNumberIcon(rowIndex: number): {
+        name: string;
+        tooltip?: string;
+    } | null;
+    /**
+     * Body cell background: `rowBackground` wins when set; otherwise sticky / full-row tint via `stickyColumnBackground`.
+     */
+    bodyCellBackground(column: ColumnConfig | undefined, rowIndex: number): string | undefined;
+    /**
+     * Row-number cell background: conditional row color, else table sticky row-number tint.
+     */
+    rowNumberCellBackground(rowIndex: number): string | undefined;
+    /**
+     * Trailing settings / row-actions body cell background.
+     */
+    settingsColumnBodyBackground(rowIndex: number): string | undefined;
+    /**
+     * Cell background from sticky styling: per-column `stickyBackground`, else `display.stickyColumnBackground`.
+     * When `display.stickyColumnBackgroundFullRow` is true, applies to every data cell (not only sticky columns).
+     */
+    stickyColumnBackground(column: ColumnConfig | undefined): string | undefined;
+    /** Row # column is sticky-left; uses table-level `display.stickyColumnBackground` only. */
+    rowNumberStickyBackground(): string | undefined;
+    /** Positive row counts only (caller must ensure `raw > 0`). */
+    private clampPositiveVisibleBodyRows;
+    private fallbackViewportPxForRowCount;
+    /** Effective body rows for viewport math: never more than rows actually rendered. */
+    private effectiveVisibleBodyRows;
+    private scheduleScrollViewportMeasure;
+    /**
+     * Sets `scrollViewportHeightPx` from measured thead/tbody row heights so `visibleBodyRows` maps to real pixels.
+     */
+    private updateScrollViewportMeasurement;
+    private ensureTableResizeObserver;
+    private detachTableResizeObserver;
+    /** Host styles: max-height plus CSS variables for keyboard-focused cell (see `display.focusedCell`). */
+    tableWrapperStyle(): Record<string, string | number | null>;
+    getColumnAriaSort(column: ColumnConfig<any>): string | null;
     onCellClick(rowIndex: number, columnIndex: number): void;
     onCellEdit(event: CellEditEvent): void;
     onCellSave(event: CellSaveEvent): void;
@@ -4478,13 +5057,24 @@ declare class StTableComponent implements OnInit, OnChanges, OnDestroy, AfterVie
         event: KeyboardEvent;
         direction: NavigationDirection;
     }): void;
+    onHeaderTabOut(): void;
+    /** Get the column-action button at a given column index, if it exists. */
+    private getHeaderMenuButton;
+    /**
+     * Focus the column-action button at colIndex, or — if that column has no
+     * action button — the nearest column to its right (then left) that does.
+     */
+    private focusHeader;
+    /** Focus the next/previous column-action button after colIndex, skipping columns without actions. */
+    private focusAdjacentHeader;
+    onHeaderNavigate(direction: 'left' | 'right' | 'up' | 'down', colIndex: number): void;
     onTableContainerFocus(event: FocusEvent): void;
     isKeyboardNavigationEnabled(): boolean;
     getEditModeForCells(): EditMode;
     onDocumentClick(event: MouseEvent): void;
     ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StTableComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StTableComponent, "st-table", never, { "tableConfig": { "alias": "tableConfig"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "data$": { "alias": "data$"; "required": false; "isSignal": true; }; "tableState": { "alias": "tableState"; "required": false; "isSignal": true; }; "enableSorting": { "alias": "enableSorting"; "required": false; "isSignal": true; }; "enableFiltering": { "alias": "enableFiltering"; "required": false; "isSignal": true; }; "validateConfig": { "alias": "validateConfig"; "required": false; "isSignal": true; }; }, { "stateChange": "stateChange"; "dataChange": "dataChange"; "cellEdit": "cellEdit"; "cellSave": "cellSave"; "cellCancel": "cellCancel"; "cellChange": "cellChange"; "columnResized": "columnResized"; "columnMoved": "columnMoved"; "configValidationErrors": "configValidationErrors"; "columnAdded": "columnAdded"; "rowAction": "rowAction"; "validationStateChange": "validationStateChange"; "requestAddRow": "requestAddRow"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StTableComponent, "st-table", never, { "tableConfig": { "alias": "tableConfig"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "data$": { "alias": "data$"; "required": false; "isSignal": true; }; "tableState": { "alias": "tableState"; "required": false; "isSignal": true; }; "enableSorting": { "alias": "enableSorting"; "required": false; "isSignal": true; }; "enableFiltering": { "alias": "enableFiltering"; "required": false; "isSignal": true; }; "validateConfig": { "alias": "validateConfig"; "required": false; "isSignal": true; }; }, { "stateChange": "stateChange"; "dataChange": "dataChange"; "cellEdit": "cellEdit"; "cellSave": "cellSave"; "cellCancel": "cellCancel"; "cellChange": "cellChange"; "columnResized": "columnResized"; "columnMoved": "columnMoved"; "configValidationErrors": "configValidationErrors"; "columnAdded": "columnAdded"; "rowAction": "rowAction"; "validationStateChange": "validationStateChange"; "requestAddRow": "requestAddRow"; "requestFocusTabs": "requestFocusTabs"; }, never, never, true, never>;
 }
 
 /**
@@ -4537,10 +5127,26 @@ declare class StHeaderComponent implements OnDestroy {
      * Emits when column menu button is clicked
      */
     menuClick: EventEmitter<MouseEvent>;
+    /**
+     * Emits when Tab is pressed on the header cell itself (not on child elements),
+     * signalling the table should receive focus next.
+     */
+    tabOut: EventEmitter<void>;
+    /** Emits ArrowLeft / ArrowRight / ArrowUp / ArrowDown pressed on the header itself. */
+    headerNavigate: EventEmitter<"left" | "right" | "up" | "down">;
+    /** Emits when Space is pressed on the header to open the column menu via keyboard. */
+    menuKeyboard: EventEmitter<void>;
     /**
      * Cleanup on destroy
      */
     ngOnDestroy(): void;
+    /**
+     * Tab pressed directly on the header div (not bubbled from a child):
+     * forward focus to the table body so the flow is sheet-tab → header → cells.
+     */
+    onHeaderKeyDown(event: KeyboardEvent): void;
+    /** Arrow key navigation from the column-menu-trigger button — mirrors header nav. */
+    onMenuTriggerKeyDown(event: KeyboardEvent): void;
     /**
      * Handle column menu button click
      */
@@ -4574,7 +5180,7 @@ declare class StHeaderComponent implements OnDestroy {
      */
     onMoveRight(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StHeaderComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StHeaderComponent, "st-header", never, { "column": { "alias": "column"; "required": false; }; "columnIndex": { "alias": "columnIndex"; "required": false; }; "isFirstColumn": { "alias": "isFirstColumn"; "required": false; }; "isLastColumn": { "alias": "isLastColumn"; "required": false; }; "tableState": { "alias": "tableState"; "required": false; }; "enableSorting": { "alias": "enableSorting"; "required": false; }; "enableFiltering": { "alias": "enableFiltering"; "required": false; }; }, { "sortToggle": "sortToggle"; "filterChange": "filterChange"; "columnMoved": "columnMoved"; "menuClick": "menuClick"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StHeaderComponent, "st-header", never, { "column": { "alias": "column"; "required": false; }; "columnIndex": { "alias": "columnIndex"; "required": false; }; "isFirstColumn": { "alias": "isFirstColumn"; "required": false; }; "isLastColumn": { "alias": "isLastColumn"; "required": false; }; "tableState": { "alias": "tableState"; "required": false; }; "enableSorting": { "alias": "enableSorting"; "required": false; }; "enableFiltering": { "alias": "enableFiltering"; "required": false; }; }, { "sortToggle": "sortToggle"; "filterChange": "filterChange"; "columnMoved": "columnMoved"; "menuClick": "menuClick"; "tabOut": "tabOut"; "headerNavigate": "headerNavigate"; "menuKeyboard": "menuKeyboard"; }, never, never, true, never>;
 }
 
 /**
@@ -4778,6 +5384,7 @@ declare class StColumnMenuDropdownComponent implements OnChanges {
      * Close dropdown when clicking backdrop
      */
     onBackdropClick(event: MouseEvent): void;
+    onKeydown(event: KeyboardEvent): void;
     onFilterClosed(): void;
     onFilterApplied(event: {
         operator: any;
@@ -5081,6 +5688,14 @@ declare class StRowActionsDropdownComponent implements OnChanges {
      * Emitted when the dropdown should close
      */
     closed: EventEmitter<void>;
+    /**
+     * Emitted when Tab / Shift+Tab is pressed while the dropdown is open.
+     * The parent should close the dropdown WITHOUT returning focus to the trigger
+     * and instead move focus to the next/previous element outside the table.
+     */
+    tabbed: EventEmitter<{
+        shift: boolean;
+    }>;
     dropdownPanel?: ElementRef<HTMLElement>;
     /**
      * Visible actions (filtered by hidden property)
@@ -5115,12 +5730,22 @@ declare class StRowActionsDropdownComponent implements OnChanges {
      * Handle ESC key press
      */
     onEscapeKey(event: Event): void;
+    /**
+     * Space closes the dropdown (focus is on a menu item after open, so the trigger
+     * button's keydown never fires — handle it here at the document level instead).
+     */
+    onSpaceKey(event: Event): void;
+    /**
+     * Tab / Shift+Tab: close the dropdown AND tell the parent to move focus
+     * outside the table (skipping subsequent rows' settings buttons).
+     */
+    onTabKey(event: Event): void;
     /**
      * Prevent dropdown click from closing
      */
     onDropdownClick(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StRowActionsDropdownComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StRowActionsDropdownComponent, "st-row-actions-dropdown", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "position": { "alias": "position"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, { "actionClicked": "actionClicked"; "closed": "closed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StRowActionsDropdownComponent, "st-row-actions-dropdown", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "position": { "alias": "position"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, { "actionClicked": "actionClicked"; "closed": "closed"; "tabbed": "tabbed"; }, never, never, true, never>;
 }
 
 declare class StSheetComponent implements OnInit, OnChanges {
@@ -5161,6 +5786,14 @@ declare class StSheetComponent implements OnInit, OnChanges {
      * Emitted when data changes (via Observable)
      */
     dataChange: EventEmitter<DataChangeEvent>;
+    /**
+     * Emitted when the condition-builder value changes (only when contentType is 'condition-builder').
+     */
+    conditionBuilderValueChange: EventEmitter<ConditionBuilderValue>;
+    /**
+     * Emitted when the condition-builder validity changes (only when contentType is 'condition-builder').
+     */
+    conditionBuilderValidityChange: EventEmitter<ConditionBuilderValidity>;
     /**
      * Internal state instance
      */
@@ -5174,9 +5807,14 @@ declare class StSheetComponent implements OnInit, OnChanges {
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
     /**
-     * Initialize sheet state
+     * Initialize sheet state. Only table-typed sheets need SheetState — condition-builder
+     * sheets don't have pagination/columns, so we skip state creation for them.
      */
     private initializeState;
+    /** Resolved content type — defaults to 'table' when unset. */
+    get contentType(): 'table' | 'condition-builder';
+    onConditionBuilderValueChange(value: ConditionBuilderValue): void;
+    onConditionBuilderValidityChange(validity: ConditionBuilderValidity): void;
     /**
      * Get active state (external or internal)
      */
@@ -5210,7 +5848,7 @@ declare class StSheetComponent implements OnInit, OnChanges {
      */
     get headerVariant(): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StSheetComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StSheetComponent, "st-sheet", never, { "config": { "alias": "config"; "required": false; }; "data": { "alias": "data"; "required": false; }; "data$": { "alias": "data$"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "sheetActionClicked": "sheetActionClicked"; "stateChange": "stateChange"; "cellChange": "cellChange"; "tableStateChange": "tableStateChange"; "dataChange": "dataChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StSheetComponent, "st-sheet", never, { "config": { "alias": "config"; "required": false; }; "data": { "alias": "data"; "required": false; }; "data$": { "alias": "data$"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "sheetActionClicked": "sheetActionClicked"; "stateChange": "stateChange"; "cellChange": "cellChange"; "tableStateChange": "tableStateChange"; "dataChange": "dataChange"; "conditionBuilderValueChange": "conditionBuilderValueChange"; "conditionBuilderValidityChange": "conditionBuilderValidityChange"; }, never, never, true, never>;
 }
 
 declare class StSheetActionsComponent {
@@ -5273,6 +5911,7 @@ declare class StWorkbookComponent implements OnInit, OnChanges, OnDestroy {
     private destroyRef;
     private autosaveService;
     private cdr;
+    private injector;
     readonly config: _angular_core.InputSignal<WorkbookConfig>;
     readonly sheetsData: _angular_core.InputSignal<BehaviorSubject<Map<string, any[]>>>;
     readonly state: _angular_core.InputSignal<WorkbookState | undefined>;
@@ -5288,7 +5927,16 @@ declare class StWorkbookComponent implements OnInit, OnChanges, OnDestroy {
         sheetId: string;
         focusColumn?: number;
     }>;
+    readonly conditionBuilderValueChange: _angular_core.OutputEmitterRef<{
+        sheetId: string;
+        value: ConditionBuilderValue;
+    }>;
+    readonly conditionBuilderValidityChange: _angular_core.OutputEmitterRef<{
+        sheetId: string;
+        validity: ConditionBuilderValidity;
+    }>;
     tableComponent?: StTableComponent;
+    workbookTabGroup?: ElementRef<HTMLElement>;
     readonly sheets: _angular_core.WritableSignal<WorkbookSheetConfig[]>;
     readonly activeSheetIndex: _angular_core.WritableSignal<number>;
     readonly currentTableConfig: _angular_core.WritableSignal<TableConfig | null>;
@@ -5300,11 +5948,18 @@ declare class StWorkbookComponent implements OnInit, OnChanges, OnDestroy {
     readonly selectedSheet: _angular_core.WritableSignal<WorkbookSheetConfig | null>;
     readonly selectedSheetIndex: _angular_core.WritableSignal<number>;
     readonly tabActionsPosition: _angular_core.WritableSignal<any>;
+    /**
+     * The sheet currently rendered in the workbook panel. Derived from sheets +
+     * activeSheetIndex so it stays stable even while the tab-actions dropdown
+     * is opening/closing (which mutates `selectedSheet`).
+     */
+    readonly activeSheet: _angular_core.Signal<WorkbookSheetConfig | null>;
     readonly workbookActionsOpen: _angular_core.WritableSignal<boolean>;
     readonly workbookActionsPosition: _angular_core.WritableSignal<any>;
     readonly visibleWorkbookActions: _angular_core.WritableSignal<WorkbookAction[]>;
     readonly toolbarWorkbookActions: _angular_core.WritableSignal<WorkbookAction[]>;
     readonly autosaveEnabled: _angular_core.WritableSignal<boolean>;
+    readonly autosaveIndicatorVisible: _angular_core.WritableSignal<boolean>;
     readonly lastSaveTime: _angular_core.WritableSignal<Date | null>;
     readonly isSaving: _angular_core.WritableSignal<boolean>;
     readonly isFullscreen$: BehaviorSubject<boolean>;
@@ -5312,13 +5967,39 @@ declare class StWorkbookComponent implements OnInit, OnChanges, OnDestroy {
     private internalState?;
     private autosaveStrategy;
     private beforeUnloadHandler;
+    /** Sheet ID rendered in the last updateActiveSheet — used to skip key bumps that would otherwise re-mount the content on every config update. */
+    private lastRenderedSheetId;
     constructor();
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
     private initializeComponent;
     get activeState(): WorkbookState;
     onTabChange(event: any): void;
+    onSheetTabKeydown(event: KeyboardEvent, index: number): void;
+    private openTabActionsForFocusedTab;
+    private lockBodyScroll;
+    private unlockBodyScroll;
+    onTabActionsKeydown(event: KeyboardEvent): void;
+    private focusToolbar;
+    onToolbarKeydown(event: KeyboardEvent): void;
+    private focusSheetTab;
+    private focusTablePanel;
     private updateActiveSheet;
+    /** Content type of the currently-active sheet. Defaults to 'table'. */
+    get activeSheetContentType(): 'table' | 'condition-builder';
+    onConditionBuilderValueChange(value: ConditionBuilderValue): void;
+    onConditionBuilderValidityChange(validity: ConditionBuilderValidity): void;
+    /**
+     * After a new sheet is appended, scroll the tab strip so the new tab clears the sticky toolbar overlay
+     * and move keyboard focus to that tab.
+     */
+    private scheduleScrollAndFocusNewSheetTab;
+    /**
+     * Scroll the active sheet tab into the visible part of the nav (left of the sticky toolbar).
+     * No extra flex margin — avoids a permanent gap between the last sheet tab and the toolbar.
+     */
+    private queueScrollActiveSheetTabClearOfToolbar;
+    private scrollSheetTabIntoNav;
     onAddSheet(): void;
     trackByKey(index: number, key: string): string;
     get canAddSheet(): boolean;
@@ -5329,16 +6010,23 @@ declare class StWorkbookComponent implements OnInit, OnChanges, OnDestroy {
     onTabActionClick(action: any, event: Event): void;
     toggleWorkbookActions(event: MouseEvent): void;
     closeWorkbookActions(): void;
+    onWorkbookActionsKeydown(event: KeyboardEvent): void;
     private updateVisibleWorkbookActions;
     isActionDisabled(action: WorkbookAction): boolean;
     onWorkbookActionClick(action: WorkbookAction, event: Event): void;
     toggleFullscreen(): void;
+    /**
+     * Keeps `sheetsData` in sync with the grid: patches `row[columnKey]` from the cell event then `next()`s the map.
+     * Initial rows still come from the host (e.g. demo `loadSheetsData`); edits persist here in memory.
+     */
     onCellChange(event: CellChangeEvent): void;
+    /** Same row patch as {@link onCellChange}; host apps receive this output after data is updated. */
     onCellSave(event: any): void;
     onTableStateChange(event: TableStateChangeEvent): void;
     onRequestAddRow(event: {
         focusColumn?: number;
     }): void;
+    onRequestFocusTabs(): void;
     ngOnDestroy(): void;
     private initializeAutosave;
     private performAutosave;
@@ -5347,7 +6035,370 @@ declare class StWorkbookComponent implements OnInit, OnChanges, OnDestroy {
     scrollToRow(rowIndex: number, focusFirstCell?: boolean): void;
     scrollToLastRow(focusFirstCell?: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StWorkbookComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StWorkbookComponent, "st-workbook", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; "sheetsData": { "alias": "sheetsData"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; }, { "sheetChanged": "sheetChanged"; "addSheet": "addSheet"; "sheetTabAction": "sheetTabAction"; "workbookAction": "workbookAction"; "cellChange": "cellChange"; "cellSave": "cellSave"; "tableStateChange": "tableStateChange"; "fullscreenToggle": "fullscreenToggle"; "requestAddRow": "requestAddRow"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StWorkbookComponent, "st-workbook", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; "sheetsData": { "alias": "sheetsData"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; }, { "sheetChanged": "sheetChanged"; "addSheet": "addSheet"; "sheetTabAction": "sheetTabAction"; "workbookAction": "workbookAction"; "cellChange": "cellChange"; "cellSave": "cellSave"; "tableStateChange": "tableStateChange"; "fullscreenToggle": "fullscreenToggle"; "requestAddRow": "requestAddRow"; "conditionBuilderValueChange": "conditionBuilderValueChange"; "conditionBuilderValidityChange": "conditionBuilderValidityChange"; }, never, never, true, never>;
+}
+
+/**
+ * Root condition builder. Renders either:
+ *  - the GUI condition list (single conditions + groups), or
+ *  - a raw expression code editor,
+ * depending on `value.mode`. The mode toggle itself is surfaced at the sheet
+ * level via SheetAction; consumers flip `value.mode` and the builder reacts.
+ *
+ * Owns the editable copy of the tree and emits the full ConditionBuilderValue
+ * on every change. Persistence is the consumer's concern.
+ */
+declare class StConditionBuilderComponent implements OnInit, OnChanges {
+    private validator;
+    private cdr;
+    private host;
+    private injector;
+    config: ConditionBuilderConfig;
+    value: ConditionBuilderValue;
+    disabled: boolean;
+    readonly valueChange: EventEmitter<ConditionBuilderValue>;
+    readonly validityChange: EventEmitter<ConditionBuilderValidity>;
+    /** Local editable copy of the value — the source of truth between input changes. */
+    internalValue: ConditionBuilderValue;
+    /** Latest validation summary, rendered into the aria-live region for SR users. */
+    validityAnnouncement: string;
+    /**
+     * Flag set the moment we emit a valueChange. The parent typically feeds
+     * the new value back through @Input (controlled-component pattern), which
+     * triggers ngOnChanges → re-clone → re-render. That re-render destroys the
+     * focused <nile-input> mid-typing. When this flag is true, ngOnChanges
+     * recognises the inbound value as our own echo and skips the re-clone.
+     */
+    private skipNextValueChange;
+    get maxConditions(): number;
+    get allowGroups(): boolean;
+    get canAddCondition(): boolean;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    trackByIndex(index: number): number;
+    isSingle(node: ConditionNode): node is SingleCondition;
+    isGroup(node: ConditionNode): node is GroupCondition;
+    onSingleChange(index: number, next: SubCondition): void;
+    onGroupChange(index: number, next: GroupCondition): void;
+    onRemoveCondition(index: number): void;
+    /**
+     * Insert a fresh single condition directly below `index`. Triggered by the
+     * hover "+" → Condition menu option on a top-level rule or group row.
+     * Honours `maxConditions`.
+     */
+    onInsertBelow(index: number): void;
+    /**
+     * Insert a fresh group directly below `index`. Triggered by the hover "+"
+     * → Group menu option on a top-level rule or group row. Honours both
+     * `maxConditions` and `allowGroups`.
+     */
+    onInsertGroupBelow(index: number): void;
+    /**
+     * Wait for the next render pass, then move keyboard focus into the row at
+     * `index`. Focus lands on the first interactive element of the row — the
+     * field-picker chip trigger — so a screen-reader user is taken straight to
+     * the new condition's editable state.
+     */
+    private focusRowAfterRender;
+    onAddCondition(): void;
+    onAddGroup(): void;
+    onExpressionInput(event: Event): void;
+    get expressionLanguage(): 'javascript' | 'sql' | 'json' | 'html';
+    /** Autocompletion tree forwarded to nile-code-editor — empty object when unset. */
+    get expressionAutoCompletions(): Record<string, unknown>;
+    /** Autocompletion paths forwarded to nile-code-editor — empty array when unset. */
+    get expressionAutoCompletionPaths(): string[];
+    /** Toggle between builder and expression mode. Triggered by the footer "Use advanced expression" link. */
+    onToggleMode(): void;
+    get isExpressionMode(): boolean;
+    get expressionToggleLabel(): string;
+    get allowExpressionMode(): boolean;
+    private patchConditions;
+    private emitValidity;
+    /** Build an aria-label for a top-level node — read aloud when the row gains focus. */
+    ariaLabelForNode(node: ConditionNode, index: number): string;
+    private cloneValue;
+    private cloneNode;
+    private buildEmptySingle;
+    private buildEmptyGroup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StConditionBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StConditionBuilderComponent, "st-condition-builder", never, { "config": { "alias": "config"; "required": true; }; "value": { "alias": "value"; "required": true; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; "validityChange": "validityChange"; }, never, never, true, never>;
+}
+
+/**
+ * One group condition: a connector, a group-type selector (any/all of),
+ * and a list of subConditions rendered via st-condition-rule.
+ *
+ * Groups do not nest further — this matches v1 (1-level nesting).
+ */
+declare class StConditionGroupComponent {
+    group: GroupCondition;
+    config: ConditionBuilderConfig;
+    /** When true, hide the leading connector (first top-level condition). */
+    isFirst: boolean;
+    canRemove: boolean;
+    disabled: boolean;
+    readonly groupChange: EventEmitter<GroupCondition>;
+    readonly remove: EventEmitter<void>;
+    /** User asked to insert a fresh peer Condition directly below this group. */
+    readonly insertBelow: EventEmitter<void>;
+    /** User asked to insert a fresh peer Group directly below this group. */
+    readonly insertGroupBelow: EventEmitter<void>;
+    readonly connectorOptions: LogicalConnector[];
+    readonly groupTypeOptions: GroupType[];
+    groupTypeLabel(type: GroupType): string;
+    trackBySubIndex(index: number): number;
+    onConnectorChange(event: Event): void;
+    onGroupTypeChange(event: Event): void;
+    onSubConditionChange(index: number, next: SubCondition): void;
+    onSubConditionRemove(index: number): void;
+    onSubConditionInsertBelow(index: number): void;
+    onAddSubCondition(): void;
+    onRemoveGroup(): void;
+    onInsertBelowGroup(): void;
+    onAddMenuSelect(event: Event): void;
+    private buildEmptySubCondition;
+    private emit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StConditionGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StConditionGroupComponent, "st-condition-group", never, { "group": { "alias": "group"; "required": true; }; "config": { "alias": "config"; "required": true; }; "isFirst": { "alias": "isFirst"; "required": false; }; "canRemove": { "alias": "canRemove"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "groupChange": "groupChange"; "remove": "remove"; "insertBelow": "insertBelow"; "insertGroupBelow": "insertGroupBelow"; }, never, never, true, never>;
+}
+
+/**
+ * One condition row: connector · field · operator · value · delete.
+ *
+ * Works with the structural `SubCondition` shape (no `type: 'single'` discriminator)
+ * so the same component renders both top-level single conditions and subConditions
+ * inside a group. The parent container wraps/unwraps the discriminator.
+ */
+declare class StConditionRuleComponent {
+    rule: SubCondition;
+    config: ConditionBuilderConfig;
+    /** When true, hide the connector picker — the first condition has no preceding peer. */
+    isFirst: boolean;
+    /** When false, hide the delete button (e.g. last remaining condition in a group). */
+    canRemove: boolean;
+    disabled: boolean;
+    /**
+     * When true, clicking the hover "+" opens a menu offering Condition or Group.
+     * When false, clicking the hover "+" directly inserts a Condition (used for
+     * sub-rules inside a group — v1's 1-level nesting forbids groups-in-groups).
+     */
+    canInsertGroup: boolean;
+    readonly ruleChange: EventEmitter<SubCondition>;
+    readonly remove: EventEmitter<void>;
+    /** User asked to insert a fresh peer Condition directly below this row. */
+    readonly insertBelow: EventEmitter<void>;
+    /** User asked to insert a fresh peer Group directly below this row. Only fired when `canInsertGroup` is true. */
+    readonly insertGroupBelow: EventEmitter<void>;
+    readonly connectorOptions: LogicalConnector[];
+    /** Resolve the FieldDefinition for the currently selected attribute — looks across top-level fields and nested categories. */
+    get field(): FieldDefinition | undefined;
+    /** Resolve the OperatorDefinition for the currently selected operator. */
+    get operator(): OperatorDefinition | undefined;
+    /** Operators allowed for the current field (or all operators if field has no restriction). */
+    get availableOperators(): OperatorDefinition[];
+    onConnectorChange(event: Event): void;
+    onAttributeChange(nextAttr: string): void;
+    /** Look up a field by attribute key across flat fields and nested categories. */
+    private findField;
+    onOperatorChange(event: Event): void;
+    onValueChange(value: ConditionValue): void;
+    onRemoveClick(): void;
+    onInsertBelowClick(): void;
+    onAddMenuSelect(event: Event): void;
+    /** Pick a sensible default operator for a given field: first allowed operator. */
+    private pickDefaultOperator;
+    private emit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StConditionRuleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StConditionRuleComponent, "st-condition-rule", never, { "rule": { "alias": "rule"; "required": true; }; "config": { "alias": "config"; "required": true; }; "isFirst": { "alias": "isFirst"; "required": false; }; "canRemove": { "alias": "canRemove"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "canInsertGroup": { "alias": "canInsertGroup"; "required": false; }; }, { "ruleChange": "ruleChange"; "remove": "remove"; "insertBelow": "insertBelow"; "insertGroupBelow": "insertGroupBelow"; }, never, never, true, never>;
+}
+
+/**
+ * Renders the value input for a single condition row. Picks the editor variant
+ * based on the field's `valueEditor` and the operator's arity:
+ *  - operator arity 'none' → no input rendered
+ *  - 'text'                → single nile-input (text)
+ *  - 'chip'                → nile-chip multi-value input
+ *  - 'select'              → nile-select single
+ *  - 'multi-select'        → nile-select multi
+ *
+ * Value is always handled as `string[]`. Single-value editors use the first array
+ * element; empty array means "no value".
+ */
+declare class StConditionValueEditorComponent implements OnInit, OnDestroy {
+    field?: FieldDefinition;
+    operator?: OperatorDefinition;
+    value: ConditionValue;
+    disabled: boolean;
+    readonly valueChange: EventEmitter<ConditionValue>;
+    private elementRef;
+    /** Open/close + highlighted-option state for the slotted-trigger select. */
+    private dropdownOpen;
+    private highlightedIndex;
+    private kbForwarder;
+    /** The slot trigger that owns the open dropdown — used to refocus on close. */
+    private activeSlot;
+    /** The <nile-select> host that owns the open dropdown. */
+    private activeHost;
+    constructor();
+    ngOnInit(): void;
+    /**
+     * Host class flag — when true, the value editor host stretches to take the
+     * remaining flex space in the rule (so the chip can grow up to the row's
+     * right edge, then scroll internally). For other variants we keep the host
+     * content-sized so the inner select/input renders at its constant width.
+     */
+    get isChipMode(): boolean;
+    /** True when operator arity is 'none' — input is hidden. */
+    get hidden(): boolean;
+    /** Placeholder for the current editor — field override wins, else a sensible default per editor type. */
+    get placeholder(): string;
+    /** Convenience: first element for single-value editors. */
+    get singleValue(): string;
+    /**
+     * Convenience: array for multi-value editors. Returns the input array directly
+     * — NOT a clone. Cloning here returns a new reference on every CD cycle, which
+     * makes Angular rebind `[value]` on nile-select even when nothing changed,
+     * causing the multi-select chip to flicker on every keystroke / selection.
+     * The component never mutates this array in place, so sharing the ref is safe.
+     */
+    get multiValue(): string[];
+    /**
+     * Label shown for the first selected value in the multi-select chip's
+     * custom display. Resolves the option's `label`; falls back to the raw value
+     * if no matching option exists.
+     */
+    get firstSelectedLabel(): string;
+    /** Count of additional selected values beyond the first — used for "+N More". */
+    get overflowCount(): number;
+    onTextInput(event: Event): void;
+    onChipChange(event: Event): void;
+    onSelectChange(event: Event): void;
+    /**
+     * Open Nile's dropdown using the most reliable path available. `host.show()`
+     * is the documented Nile API; if it's missing or throws, fall back to
+     * dispatching a real mouse-down on the host (Nile's own mousedown handler
+     * opens the popup). Then dispatching a click event ensures any other Nile
+     * listeners on the host get the expected sequence.
+     *
+     * State (activeHost / activeSlot / dropdownOpen) is set here so the doc
+     * forwarder is responsive immediately — `nile-show` from Nile will run
+     * `onSelectShow` shortly after and re-confirm the same state.
+     */
+    private openHost;
+    /**
+     * Nile emits `nile-show` when its dropdown opens — whether from our
+     * `openHost()`, a click on the trigger, or any other path. We use it to
+     * keep `dropdownOpen` truthful even when the user opens via mouse (skipping
+     * `openHost()` entirely). The doc-level forwarder is already installed
+     * (it lives for the component's lifetime).
+     */
+    onSelectShow(event: Event): void;
+    /**
+     * Nile emits `nile-hide` when its dropdown closes — for any reason (Esc,
+     * click-outside, single-select pick, programmatic .hide()). Returning focus
+     * to the slot is what makes Tab continue cleanly to the row's hover actions.
+     * The document forwarder stays installed (it lives for the whole component
+     * lifetime); only the open-state flags reset.
+     */
+    onSelectAfterHide(_event: Event): void;
+    /**
+     * Document-level keydown forwarder, installed for the lifetime of this
+     * component instance. Runs in CAPTURE phase so it fires BEFORE any
+     * bubble-phase listener — including Nile's internal listeners inside the
+     * shadow DOM that would otherwise stop the event from ever reaching our
+     * template-bound (keydown).
+     *
+     * Two distinct flows, gated by `dropdownOpen`:
+     *
+     *  - Closed + focus is inside this component's host: Enter / Space / ↓ / ↑
+     *    opens our nile-select via `openHost()`.
+     *  - Open: ↑/↓ navigate options regardless of where focus has moved
+     *    (Nile may have taken focus into its portal listbox). PageUp/PageDown/
+     *    Home/End are swallowed so the page behind the dropdown doesn't scroll.
+     *    Enter, Space, Esc, Tab, type-to-search all pass through to Nile.
+     *
+     * The `focusIsInOurComponent` check ensures that across many co-existing
+     * value-editor instances (one per condition row), only the editor the user
+     * is actually interacting with reacts to the keystroke.
+     */
+    private installKeyForwarder;
+    /**
+     * True when document focus is on (or inside) our component's host element.
+     * Shadow-DOM focus reports the SHADOW HOST in `document.activeElement` (it
+     * does not pierce shadow boundaries), so `host.contains(...)` works even
+     * when the user is actually focused on an element inside nile-select's
+     * shadow root.
+     */
+    private focusIsInOurComponent;
+    private removeKeyForwarder;
+    /**
+     * Walk options by `direction` (+1 or -1), update `highlightedIndex`, and
+     * synchronise the visual highlight on both the light-DOM `<nile-option>` and
+     * its portal counterpart.
+     *
+     * Strategies (matches `NileSelectEditor`):
+     *  - `setCurrentOption()` — preferred; Nile's documented API to mark the
+     *    "current" option so its native Enter handler picks the right one.
+     *  - `[data-kb-active]` attribute — the visual highlight, styled by our
+     *    injected CSS (matches the cell-editor look).
+     *  - `scrollIntoView` — keeps the highlighted option in view for long lists.
+     *
+     * We do NOT move DOM focus to the option — that would blur the trigger and
+     * some Nile builds auto-close on blur. Focus stays on the trigger; Nile's
+     * Enter handler reads `currentOption` from `setCurrentOption` to commit.
+     */
+    private navigateOption;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StConditionValueEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StConditionValueEditorComponent, "st-condition-value-editor", never, { "field": { "alias": "field"; "required": false; }; "operator": { "alias": "operator"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Field picker — direct port of v1's `criteriaDropdown` template
+ * (advanced-filter.component.html:533-629).
+ *
+ * Structure:
+ *   <nile-dropdown>                    ← outer dropdown anchored to the chip
+ *     <button slot="trigger">          ← the chip-style trigger
+ *     <nile-menu>                      ← main menu list
+ *       <nile-menu-item>flat field</nile-menu-item>
+ *       <nile-menu-item>               ← one per category
+ *         <nile-dropdown placement="right-end">    ← nested flyout submenu
+ *           <span slot="trigger">{{ label }} ›</span>
+ *           <nile-menu searchEnabled>            ← built-in search input
+ *             <nile-menu-item>category field</nile-menu-item>
+ *           </nile-menu>
+ *         </nile-dropdown>
+ *       </nile-menu-item>
+ *     </nile-menu>
+ *   </nile-dropdown>
+ *
+ * Nile handles positioning, click-outside, keyboard nav, and the search box —
+ * we just emit valueChange when a field is picked.
+ */
+declare class StConditionFieldPickerComponent {
+    private cdr;
+    /** Currently selected attribute key. */
+    value: string;
+    /** Top-level fields. */
+    fields: FieldDefinition[];
+    /** Optional grouped fields rendered as flyout submenus. */
+    categories: FieldCategory[];
+    disabled: boolean;
+    placeholder: string;
+    readonly valueChange: EventEmitter<string>;
+    dropdownRef?: ElementRef<HTMLElement>;
+    /** Resolved display label for the chip — searches flat fields, then category fields. */
+    get displayLabel(): string;
+    trackByAttribute: (_: number, f: FieldDefinition) => string;
+    trackByCategoryId: (_: number, c: FieldCategory) => string;
+    onFieldSelect(attribute: string, event?: Event): void;
+    /** Swallow the click on a category menu-item so the outer dropdown stays open. */
+    onCategoryItemClick(event: Event): void;
+    private closeOuter;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StConditionFieldPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StConditionFieldPickerComponent, "st-condition-field-picker", never, { "value": { "alias": "value"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "categories": { "alias": "categories"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
 }
 
 declare class ClickOutsideDirective {
@@ -5409,12 +6460,14 @@ declare class StColumnResizeDirective implements OnDestroy {
  * Directive to handle keyboard navigation in table cells
  */
 declare class StKeyboardNavigationDirective {
+    private readonly el;
     tableState: TableState;
     /**
      * When enabled, pressing arrow down at the last row will emit requestAddRow event
      */
     addRowOnNavigatePastEnd: boolean;
     onKeyDown(event: KeyboardEvent): void;
+    private focusNextOutside;
     /**
      * Convert navigation key to direction using enums
      */
@@ -5431,7 +6484,7 @@ declare class SharedTableComponentsModule {
 
 declare class SmartTableModule {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmartTableModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<SmartTableModule, never, [typeof SharedTableComponentsModule, typeof StCellComponent, typeof StTableComponent, typeof StHeaderComponent, typeof StColumnMenuDropdownComponent, typeof StColumnVisibilityComponent, typeof StColumnFilterComponent, typeof StPaginationComponent, typeof StAddColumnButtonComponent, typeof StColumnEditorModalComponent, typeof StTableActionsComponent, typeof StRowActionsDropdownComponent, typeof StSheetComponent, typeof StSheetActionsComponent, typeof StWorkbookComponent, typeof ClickOutsideDirective, typeof StColumnResizeDirective, typeof StKeyboardNavigationDirective], [typeof StCellComponent, typeof StTableComponent, typeof StHeaderComponent, typeof StColumnMenuDropdownComponent, typeof StColumnVisibilityComponent, typeof StColumnFilterComponent, typeof StPaginationComponent, typeof StAddColumnButtonComponent, typeof StColumnEditorModalComponent, typeof StTableActionsComponent, typeof StRowActionsDropdownComponent, typeof StSheetComponent, typeof StSheetActionsComponent, typeof StWorkbookComponent, typeof ClickOutsideDirective, typeof StColumnResizeDirective, typeof StKeyboardNavigationDirective]>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<SmartTableModule, never, [typeof SharedTableComponentsModule, typeof StCellComponent, typeof StTableComponent, typeof StHeaderComponent, typeof StColumnMenuDropdownComponent, typeof StColumnVisibilityComponent, typeof StColumnFilterComponent, typeof StPaginationComponent, typeof StAddColumnButtonComponent, typeof StColumnEditorModalComponent, typeof StTableActionsComponent, typeof StRowActionsDropdownComponent, typeof StSheetComponent, typeof StSheetActionsComponent, typeof StWorkbookComponent, typeof StConditionBuilderComponent, typeof StConditionGroupComponent, typeof StConditionRuleComponent, typeof StConditionValueEditorComponent, typeof StConditionFieldPickerComponent, typeof ClickOutsideDirective, typeof StColumnResizeDirective, typeof StKeyboardNavigationDirective], [typeof StCellComponent, typeof StTableComponent, typeof StHeaderComponent, typeof StColumnMenuDropdownComponent, typeof StColumnVisibilityComponent, typeof StColumnFilterComponent, typeof StPaginationComponent, typeof StAddColumnButtonComponent, typeof StColumnEditorModalComponent, typeof StTableActionsComponent, typeof StRowActionsDropdownComponent, typeof StSheetComponent, typeof StSheetActionsComponent, typeof StWorkbookComponent, typeof StConditionBuilderComponent, typeof StConditionGroupComponent, typeof StConditionRuleComponent, typeof StConditionValueEditorComponent, typeof StConditionFieldPickerComponent, typeof ClickOutsideDirective, typeof StColumnResizeDirective, typeof StKeyboardNavigationDirective]>;
     static ɵinj: _angular_core.ɵɵInjectorDeclaration<SmartTableModule>;
 }
 
@@ -6278,5 +7331,29 @@ declare class AutosaveService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<AutosaveService>;
 }
 
-export { ArrayFormatter, AutosaveService, BaseColumnConfig, BooleanEditor, BooleanFormatter, BuilderPreviewComponent, BuilderToolbarComponent, Cell, CellAlignment, CellDataType, CellLifecycleState, CellVerticalAlignment, ChainValidator, ClickOutsideDirective, ColumnConfigFactory, ColumnEditorComponent, ColumnListComponent, Columns, CurrencyFormatter, DEFAULT_AUTOSAVE_CONFIG, DEFAULT_COLUMN_CONFIG, DEFAULT_TABLE_CONFIG, DateEditor, DateFormatter, DateRangeValidator, DefaultFormatter, DefinitionBuilderComponent, DefinitionBuilderModule, DefinitionBuilderService, DefinitionExportService, DefinitionImportService, EditMode, EmailValidator, FilterOperator, FunctionFormatter, FunctionValidator, JsonSchemaValidatorService, LengthValidator, NavigationDirection, NavigationKey, NileAutoCompleteEditor, NileCalendarEditor, NileChipEditor, NileCodeEditor, NileDatePickerEditor, NileInputEditor, NileSelectEditor, NumberEditor, NumberFormatter, OUFormatter, PatternValidators, PercentageFormatter, RangeValidator, RegexValidator, RequiredValidator, RowValidationService, SampleDataGeneratorService, SelectEditor, SharedTableComponentsModule, SheetState, SimpleColumnConfig, SmartTableModule, SortDirection, StAddColumnButtonComponent, StCellComponent, StColumnEditorModalComponent, StColumnFilterComponent, StColumnMenuDropdownComponent, StColumnResizeDirective, StColumnVisibilityComponent, StHeaderComponent, StKeyboardNavigationDirective, StPaginationComponent, StRowActionsDropdownComponent, StSheetActionsComponent, StSheetComponent, StTableActionsComponent, StTableComponent, StWorkbookComponent, StringFormatter, TableConfigEditorComponent, TableState, TableZIndex, TemplateFormatter, TextAreaEditor, TextEditor, UrlValidator, ValidationLoggerService, VirtualScrollService, WorkbookState, canEdit, createCellState, createMemento, dnToHumanReadable, isCellValid, isDisplayMode, isNullOrUndefined, isValidDate, isValidationSuccess, mergeTableConfig, registerFormatter, resolveFormatter, restoreFromMemento };
-export type { AllowedDatesRange, AsyncCellValidator, AutoCompleteOption, AutoCompleteStyle, AutosaveConfig, AutosaveData, AutosaveStrategy, BuilderState, CellCancelEvent, CellChangeEvent, CellEditEvent, CellEditor, CellEditorContext, CellEvent, CellEventHandler, CellFocusPosition, CellFormatter, CellLifecycleHooks, CellParser, CellSaveEvent, CellState, CellStateMemento, CellValidator, CellValue, ChipOption, CodeEditorCompletion, ColumnAction, ColumnActionContext, ColumnActionEvent, ColumnAddEvent, ColumnConfig, ColumnConfigOptions, ColumnConfigWithKey, ColumnFilterEvent, ColumnFilterState, ColumnMoveEvent, ColumnResizeEvent, ColumnSortEvent, ColumnSortState, CompositeValidator, DataChangeEvent, DateRange, ExportOptions, FilterContext, FilterOptions, ImportResult, NileAutoCompleteEditorOptions, NileCalendarEditorOptions, NileChipEditorOptions, NileCodeEditorOptions, NileDatePickerEditorOptions, NileInputEditorOptions, NileSelectEditorOptions, OUFormatterOptions, PaginationState, PartialColumnConfig, RowAction, RowActionContext, RowActionEvent, RowManagementConfig, RowValidationState, SelectOption, SheetAction, SheetActionContext, SheetActionEvent, SheetConfig, SheetMetadata, SheetStateConfig, SheetStateSnapshot, SheetTabAction, SheetTabActionEvent, TableConfig, TableStateChangeEvent, TableStateConfig, TableStateSnapshot, TableValidationState, ValidationError, ValidationLogEntry, ValidationResult, VirtualScrollState, WorkbookAction, WorkbookActionEvent, WorkbookConfig, WorkbookMetadata, WorkbookSheetConfig, WorkbookStateConfig, WorkbookStateSnapshot };
+/**
+ * Stateless validator for ConditionBuilderValue. Ported from v1's `conditionsValidator`.
+ *
+ * Rules:
+ *  - In 'expression' mode: the expression string must be non-empty.
+ *  - In 'builder' mode:
+ *      - At least one top-level condition.
+ *      - For every single condition and subCondition:
+ *          - `attribute` must be set.
+ *          - `operator` must be set.
+ *          - `value` must be non-empty unless the operator's arity is 'none'.
+ *      - For every group: must have at least one subCondition.
+ */
+declare class ConditionValidationService {
+    validate(value: ConditionBuilderValue, config: ConditionBuilderConfig): ConditionBuilderValidity;
+    private validateExpression;
+    private validateBuilder;
+    private validateGroup;
+    private validateRule;
+    private locator;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConditionValidationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ConditionValidationService>;
+}
+
+export { ArrayFormatter, AutosaveService, BaseColumnConfig, BooleanEditor, BooleanFormatter, BuilderPreviewComponent, BuilderToolbarComponent, Cell, CellAlignment, CellDataType, CellLifecycleState, CellVerticalAlignment, ChainValidator, ClickOutsideDirective, ColumnConfigFactory, ColumnEditorComponent, ColumnListComponent, Columns, ConditionValidationService, CurrencyFormatter, DEFAULT_AUTOSAVE_CONFIG, DEFAULT_COLUMN_CONFIG, DEFAULT_TABLE_CONFIG, DateEditor, DateFormatter, DateRangeValidator, DefaultFormatter, DefinitionBuilderComponent, DefinitionBuilderModule, DefinitionBuilderService, DefinitionExportService, DefinitionImportService, EditMode, EmailValidator, FilterOperator, FunctionFormatter, FunctionValidator, JsonSchemaValidatorService, LengthValidator, NavigationDirection, NavigationKey, NileAutoCompleteEditor, NileCalendarEditor, NileCheckboxEditor, NileChipEditor, NileCodeEditor, NileDatePickerEditor, NileInputEditor, NileSelectEditor, NumberEditor, NumberFormatter, OUFormatter, PatternValidators, PercentageFormatter, RangeValidator, RegexValidator, RequiredValidator, RowValidationService, SampleDataGeneratorService, SelectEditor, SharedTableComponentsModule, SheetState, SimpleColumnConfig, SmartTableModule, SortDirection, StAddColumnButtonComponent, StCellComponent, StColumnEditorModalComponent, StColumnFilterComponent, StColumnMenuDropdownComponent, StColumnResizeDirective, StColumnVisibilityComponent, StConditionBuilderComponent, StConditionFieldPickerComponent, StConditionGroupComponent, StConditionRuleComponent, StConditionValueEditorComponent, StHeaderComponent, StKeyboardNavigationDirective, StPaginationComponent, StRowActionsDropdownComponent, StSheetActionsComponent, StSheetComponent, StTableActionsComponent, StTableComponent, StWorkbookComponent, StringFormatter, TableConfigEditorComponent, TableState, TableZIndex, TemplateFormatter, TextAreaEditor, TextEditor, UrlValidator, ValidationLoggerService, VirtualScrollService, WorkbookState, canEdit, createCellState, createMemento, dnToHumanReadable, isCellValid, isDisplayMode, isNullOrUndefined, isValidDate, isValidationSuccess, mergeTableConfig, registerFormatter, resolveFormatter, restoreFromMemento };
+export type { AllowedDatesRange, AsyncCellValidator, AutoCompleteOption, AutoCompleteStyle, AutosaveConfig, AutosaveData, AutosaveStrategy, BuilderState, CellCancelEvent, CellChangeEvent, CellEditEvent, CellEditor, CellEditorContext, CellEvent, CellEventHandler, CellFocusPosition, CellFormatter, CellLifecycleHooks, CellParser, CellSaveEvent, CellState, CellStateMemento, CellValidator, CellValue, ChipOption, CodeEditorCompletion, ColumnAction, ColumnActionContext, ColumnActionEvent, ColumnAddEvent, ColumnConfig, ColumnConfigOptions, ColumnConfigWithKey, ColumnFilterEvent, ColumnFilterState, ColumnMoveEvent, ColumnResizeEvent, ColumnSortEvent, ColumnSortState, CompositeValidator, ConditionBuilderConfig, ConditionBuilderMode, ConditionBuilderValidity, ConditionBuilderValue, ConditionNode, ConditionValidationError, ConditionValue, DataChangeEvent, DateRange, ExportOptions, FieldCategory, FieldDefinition, FieldOption, FieldValueEditor, FilterContext, FilterOptions, GroupCondition, GroupType, ImportResult, LogicalConnector, NileAutoCompleteEditorOptions, NileCalendarEditorOptions, NileCheckboxEditorOptions, NileChipEditorOptions, NileCodeEditorOptions, NileDatePickerEditorOptions, NileInputEditorOptions, NileSelectEditorOptions, OUFormatterOptions, OperatorArity, OperatorDefinition, PaginationState, PartialColumnConfig, RowAction, RowActionContext, RowActionEvent, RowManagementConfig, RowValidationState, SelectOption, SheetAction, SheetActionContext, SheetActionEvent, SheetConditionBuilder, SheetConfig, SheetContentType, SheetMetadata, SheetStateConfig, SheetStateSnapshot, SheetTabAction, SheetTabActionEvent, SingleCondition, SubCondition, TableConfig, TableRowBackgroundContext, TableStateChangeEvent, TableStateConfig, TableStateSnapshot, TableValidationState, ValidationError, ValidationLogEntry, ValidationResult, VirtualScrollState, WorkbookAction, WorkbookActionEvent, WorkbookConfig, WorkbookMetadata, WorkbookSheetConfig, WorkbookStateConfig, WorkbookStateSnapshot };