spiderly 19.11.9 → 19.12.1

package/lib/components/spiderly-data-table/spiderly-data-table.component.d.ts

@@ -1,16 +1,17 @@
-import { AfterViewInit, ErrorHandler, EventEmitter, OnChanges, OnDestroy, OnInit, QueryList, TemplateRef } from '@angular/core';
+import { AfterViewInit, ErrorHandler, EventEmitter, OnChanges, OnDestroy, OnInit, QueryList, SimpleChanges, TemplateRef } from '@angular/core';
 import { ActivatedRoute, Router } from '@angular/router';
 import { TranslocoService } from '@jsverse/transloco';
-import { SelectItem, SortMeta } from 'primeng/api';
+import { SortMeta } from 'primeng/api';
 import { DialogService, DynamicDialogRef } from 'primeng/dynamicdialog';
-import { Table, TableFilterEvent, TableLazyLoadEvent } from 'primeng/table';
+import { Table, TableLazyLoadEvent } from 'primeng/table';
 import { Observable } from 'rxjs';
 import { CellTemplateContext, SpiderlyCellTemplateDirective } from '../../directives/spiderly-cell-template.directive';
 import { Filter } from '../../entities/filter';
 import { LazyLoadSelectedIdsResult } from '../../entities/lazy-load-selected-ids-result';
 import { PaginatedResult } from '../../entities/paginated-result';
 import { PrimengOption } from '../../entities/primeng-option';
-import { MatchModeCodes } from '../../enums/match-mode-enum-codes';
+import { FilterSource, SortKeyLabel } from '../../filters/filter-store';
+import { SpiderlyFilterTemplateDirective } from '../../directives/spiderly-filter-template.directive';
 import { ConfigServiceBase } from '../../services/config.service.base';
 import { SpiderlyMessageService } from '../../services/spiderly-message.service';
 import { SpiderlyFormControl } from '../spiderly-form-control/spiderly-form-control';
@@ -26,6 +27,52 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
     private locale;
     private readonly destroy$;
     table: Table;
+    private readonly injector;
+    private readonly zone;
+    /**
+     * The selection column's declared share. Under the fixed layout this is a RATIO, not a width.
+     *
+     * 4rem, down from 6: the original reserved room for a five-digit select-all counter sitting at
+     * body text size beside the box, which is the widest thing it can ever hold and not what it
+     * holds on any ordinary screen. The counter is a smaller step now (see the SCSS), so the same
+     * five digits fit in two thirds of the space.
+     */
+    protected readonly selectionColumnWidth = "4rem";
+    /**
+     * The selection column's MEASURED width, which is what the frozen identity column offsets
+     * itself by. Declaring `6rem` on both looked like the one-telling answer and is wrong: widths
+     * are shares, so that column renders at whatever proportion of the table it gets — 148px for a
+     * declared 6rem in one spec — and the identity column would sit 52px inside it, overlapping the
+     * checkboxes the moment anyone scrolled. The spec caught it; nothing about the page would have.
+     */
+    protected frozenOffsetPx: number;
+    private selectionWidthObserver?;
+    /** Aborts an in-flight column resize's document listeners, from `onUp` or from teardown. */
+    private resizeAbort;
+    /**
+     * Whether this column is pinned against the left edge. Only the FIRST column, and only when it
+     * is `lockVisible`: a sticky column in the middle of the grid pins the wrong thing and leaves a
+     * hole where it used to be. Once the grid scrolls sideways a row otherwise loses its identity
+     * — "Intesa, plaćeno, 12.400" with no idea whose order it is — and NN/g's Data Tables is
+     * explicit that the leftmost header column must lock in place. `lockVisible` already names
+     * exactly that column in every table, so this needs no new API (CLAUDE.md -> decision 8).
+     */
+    isColumnFrozen(col: Column): boolean;
+    /**
+     * The rightmost pinned cell, which carries the seam's shadow. It is the identity column when
+     * there is one and the checkbox column otherwise — a fact only this side knows, which is why
+     * the SCSS asking for it as `:last-of-type` drew nothing at all.
+     */
+    isLastFrozenColumn(col: Column): boolean;
+    get isSelectionColumnLastFrozen(): boolean;
+    /** A frozen column starts after the checkbox column, when there is one. */
+    frozenColumnOffset(): string;
+    /**
+     * Tracks the selection column's rendered width. A ResizeObserver rather than a one-off read:
+     * every column drag and every window resize re-splits the shares, so the offset moves without
+     * anything about the selection column itself changing.
+     */
+    private observeSelectionWidth;
     /**
      * Custom toolbar content projected via `<ng-template spiderlyDataTableActions>`.
      * Rendered in the caption action area ahead of the built-in buttons.
@@ -43,6 +90,29 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
     /** Paginator page-size choices; merge rules and persistence: CLAUDE.md → "Rows-per-page". */
     rowsPerPageOptions: number[];
     cols: Column[];
+    /**
+     * The consumer's filter store — the table's WHOLE filter surface, rendered as the chip bar. A
+     * table given none has no filtering at all (`Column.filterType` is only the value's shape; the
+     * legacy header-filter fallback was deleted — CLAUDE.md -> "Operator-owned view").
+     *
+     * READ ONCE, in ngOnInit — a store assigned later is silently ignored: the requery effect
+     * stays subscribed to the first store's `applied()`, and `resolvedStateKey` (which
+     * `additionalFilterIdLong` feeds) is never re-derived either. A consumer that must swap
+     * stores at runtime destroys and recreates the table around the swap — PACMS
+     * `integration-matching-products` nulls its view model for exactly this. Teaching
+     * ngOnChanges to re-arm both is the open upstream fix.
+     */
+    filters?: FilterSource;
+    /** Saved questions for this table, rendered as tabs above the bar. */
+    views?: TableView[];
+    /**
+     * The view currently selected. Seeded from the first view in `ngOnInit` — then overridden by
+     * `restoreActiveView`, so a reload lands where the operator was — and never left null on a
+     * table that has views: `viewScope` keys the layout off it, so an unseeded table writes its
+     * width and order to the SAME key an unmigrated table uses — orphaned the moment the operator
+     * clicks the first tab — and no tab reads as selected until they do.
+     */
+    activeViewId: string | null;
     /** Whether the paginator is shown. Pass only when `hasLazyLoad === false`. Defaults to `true`. */
     showPaginator: boolean;
     /** Whether the table is wrapped in a card container. Defaults to `false`. */
@@ -86,9 +156,6 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
     onIsAllSelectedChange: EventEmitter<AllClickEvent>;
     selectedLazyLoadObservableMethod: (tableFilter: Filter) => Observable<LazyLoadSelectedIdsResult>;
     additionalFilterIdLong: number;
-    matchModeDateOptions: SelectItem[];
-    matchModeNumberOptions: SelectItem[];
-    matchModeTextOptions: SelectItem[];
     /** Whether the "Add" button is shown. Defaults to `true`. */
     showAddButton: boolean;
     /** Whether the "Export to Excel" button is shown. Defaults to `true`. */
@@ -163,7 +230,7 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
      * backend `.Take`s whatever it is sent.
      */
     private mergeActivePageSizesIntoOptions;
-    ngOnChanges(): void;
+    ngOnChanges(changes: SimpleChanges): void;
     ngOnInit(): void;
     /**
      * User visibility choices (field → visible), holding only fields the user explicitly
@@ -171,12 +238,6 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
      * default later flows through to every user who never touched that column.
      */
     private columnVisibilityOverrides;
-    /**
-     * Columns revealed by the load-time reconciliation. Kept apart from
-     * `columnVisibilityOverrides` so persisting a later unrelated toggle can't promote a
-     * transient safety reveal into a durable choice.
-     */
-    private revealedByConstraint;
     /** A data column shows values for a `field`; anything else (the actions column) always renders. */
     private static isDataColumn;
     /**
@@ -185,8 +246,46 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
      * are a transient working set — different natural lifetimes.
      */
     private get columnsStateKey();
-    /** Actions columns always render; data columns follow reveal/override, then declared default. */
+    /** Actions columns always render; data columns follow the override, then declared default. */
     isColumnVisible(col: Column): boolean;
+    /**
+     * `cols` in the operator's order. A field the stored order has never seen — a column added in a
+     * later release — sorts to the END rather than displacing a layout someone built by hand
+     * (CLAUDE.md -> "Operator-owned view", decision 7); the sort is stable, so those keep their
+     * declared order among themselves. Actions columns carry no field and are always last, which is
+     * where every consumer already declares them.
+     */
+    private orderedCols;
+    /**
+     * Whether this column can move one place in `direction` (-1 left, 1 right). A locked column is
+     * the row's anchor — and, once the left edge freezes, the thing a horizontal scroll keeps in
+     * view — so it does not move and nothing moves in front of it.
+     */
+    canMoveColumn(col: Column, direction: -1 | 1): boolean;
+    moveMenuColumn(direction: -1 | 1): void;
+    /** The move itself, shared by the menu and the drag — two entry points, one rule. */
+    private placeColumn;
+    private dataColumnsInOrder;
+    /**
+     * Header drag, ours rather than PrimeNG's `pReorderableColumn`, for two reasons: its
+     * `onMouseDown` arms the th for anything that is not an INPUT, a TEXTAREA or its OWN resizer —
+     * so our menu chevron and our resize grip would each start a column drag, and reaching for a
+     * width would silently reorder the grid — and its `onColumnDrop` reorders blind, with no notion
+     * of a locked column (CLAUDE.md -> decision 6).
+     *
+     * A shortcut for neighbours, never the mechanism: HTML5 dnd has no edge auto-scroll, so a column
+     * scrolled off the right is unreachable this way, and there is no keyboard path at all. The menu
+     * carries both.
+     *
+     * This half is the arming rule; the drop rule is `canDropOn` below.
+     */
+    onHeaderMouseDown(event: MouseEvent): void;
+    onHeaderDragStart(col: Column, event: DragEvent): void;
+    onHeaderDragOver(col: Column, event: DragEvent): void;
+    onHeaderDrop(col: Column, event: DragEvent): void;
+    /** Nothing lands on, or in front of, the locked column. Enforced here as well as in the menu:
+     * a drop is a separate entry point, and the rule is about the grid rather than about a button. */
+    private canDropOn;
     private refreshVisibleCols;
     /**
      * Locked columns can't be toggled; the last visible data column can't be hidden — the
@@ -194,46 +293,109 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
      */
     canToggleColumn(col: Column): boolean;
     toggleColumn(col: Column, visible: boolean): void;
-    /** Restores every column to its declared default and forgets the stored override. */
-    resetColumnVisibility(): void;
     /**
-     * A hidden column contributes nothing to filtering or sorting: the header is the only
-     * filter surface, so a kept constraint would restrict the data invisibly. Reloads (once)
-     * only when a constraint was actually cleared — plain hides don't need a server round-trip.
+     * Restores every column to its declared default and forgets the stored overrides — visibility,
+     * wrap, order and width alike. It undid visibility only until the header menu shipped three
+     * more gestures beside it, and a layout with no way back is worse than one with no knobs.
+     *
+     * On a STORE table, hiding — here or from the menu — never touches filters or sort: the chip
+     * bar names every applied filter and the sort chip names the sort, hidden column or not
+     * (decision 2b). A storeless table keeps the sort half of the legacy invariant instead — see
+     * `dropHiddenColumnSort`.
+     */
+    resetColumnLayout(): void;
+    /**
+     * The sort half of the legacy "hidden contributes nothing" invariant, kept ONLY for storeless
+     * tables (the generated M2M details grids, until spiderly#407 scaffolds their stores): they
+     * have no sort chip, so a hidden column's sort would order the grid with nothing on screen
+     * naming it and no control left to clear it. The filter half needs no heir — `lazyLoad`
+     * overwrites the outgoing filters unconditionally. On a store table this is a no-op:
+     * decision 2b's chips are the visible surface, hidden column or not.
+     */
+    private dropHiddenColumnSort;
+    /**
+     * Per-column wrap, by `field`. A SEPARATE key from the visibility overrides on purpose: folding
+     * both into one object would invalidate every layout already in an operator's localStorage, and
+     * this is the key the width and order overrides will join (decision 5).
      */
-    private clearHiddenColumnConstraints;
-    /** Whether filter metadata (single or array) carries a real constraint, not just an empty slot. */
-    private static isActiveFilterMeta;
+    private columnWrap;
+    /** Data-column fields in the operator's order. Empty means "as declared". */
+    private columnOrder;
     /**
-     * The one home of the filter-state key rule (sort meta is keyed by `field` instead).
-     * Instance rather than static so the template's `[field]` binding can share it.
+     * Per-column width overrides, as SHARES in the same unit `getColWidth` emits — never pixels.
+     * Under the fixed layout the browser splits surplus in proportion to these, so a pixel would
+     * pin the column and stop it answering the window: the operator on a 1280 laptop and the one
+     * on a 2560 monitor would get the same frozen column (decision 4).
      */
-    filterKey(col: Column): string | undefined;
+    private columnWidths;
     /**
-     * The filter keys the rows on screen were actually narrowed by. Kept apart from
-     * `table.filters` because those are not the same question: PrimeNG's `onModelChange`
-     * writes each keystroke of a text/numeric filter straight into the meta and only calls
-     * `_filter()` for the auto-applying types, so `table.filters` holds PENDING edits too.
-     * Reading it for the header icon marked a column filtered the moment the operator typed
-     * a character, before Apply — claiming the grid was narrowed when it was not.
+     * Layout keys carry the ACTIVE VIEW, which is what makes a view more than a saved filter: a
+     * picking view and a payments view want different COLUMNS, not just different rows. Global
+     * layout would re-create the original complaint one level up — the operator still re-picking
+     * columns every time the job changes.
+     *
+     * A table with no views has no segment, so the twenty-six tables that have not migrated keep
+     * reading exactly the keys they already wrote.
      */
-    private appliedFilterKeys;
+    private get viewScope();
     /**
-     * Whether the rows on screen are narrowed by this column — feeds the projected
-     * `filtericon` template. Why not the template's `let-hasFilter`, and why applied rather
-     * than pending state: CLAUDE.md → "Active-filter header icon".
+     * Where the applied filters live. Follows `stateStorage` rather than the layout's always-local
+     * rule, because that is where they lived before the bar took them off the header: PrimeNG's
+     * stateful table persisted them for free, and nothing replaced it — a refresh dropped every
+     * filter (Filip, on /tags). A filter is a question you are in the middle of asking, not a
+     * durable preference like a column's width.
      */
-    isColumnFiltered(col: Column): boolean;
-    /** Whether the column carries a constraint at all, applied or still being typed. */
-    private columnHasConstraint;
+    private get filtersStateKey();
+    private get filterStorage();
     /**
-     * Records what a just-applied filter set narrows by. Called from every path that commits
-     * one: `(onFilter)` (Apply, auto-apply, a per-column Clear), `lazyLoad` (which also covers
-     * `table.clear()` — it re-queries WITHOUT emitting onFilter), the caption's Clear filters,
-     * and once from `ngOnInit` off persisted state, so a restored filter is marked on first
-     * paint rather than after the first response.
+     * Where the active view id lives. Deliberately NOT view-scoped — it is the input `viewScope`
+     * derives from — and it follows `stateStorage` like the filters rather than the layout's
+     * always-local rule, because the id and the filters it scopes are one question: a durable id
+     * over session-scoped filters would restore a tab with nothing under it.
      */
-    private snapshotAppliedFilters;
+    private get viewStateKey();
+    /** Only `selectView` writes; the `ngOnInit` seed does not — absence means "the default". */
+    private persistActiveView;
+    /**
+     * Puts a reload back on the view the operator was using. Every persisted key carries the view
+     * segment, so before this existed the seed decided what got restored: F5 landed on the first
+     * view and read `…:all:filters` — the tab snapped to "Sve" and the bar came back empty while
+     * the operator's filters sat intact under the old view's segment (Filip, on /porudzbine).
+     *
+     * An id naming no current view keeps the seed AND the stored key: "vanished by deploy" and
+     * "not yet arrived" are indistinguishable here (order-list's catalog-licensed "Za pakovanje"
+     * is literally both), so `adoptStoredView` re-reads the key on every `[views]` change and the
+     * key self-heals on the next explicit click.
+     */
+    private restoreActiveView;
+    /**
+     * The second half of `restoreActiveView`: a stored view that did not exist at init is adopted
+     * when a later `[views]` change brings it — through `selectView`, so it gets the same
+     * stored-wins/transient/layout/requery semantics a click would have had. There is no parked
+     * copy of the stored id — the key itself is re-read, and because every explicit pick
+     * overwrites it, the operator's own choice wins by construction. Accepted cost of adopting
+     * late instead of holding the first request: a brief flash of the seeded view's rows and a
+     * second request when the late view lands.
+     */
+    private adoptStoredView;
+    private viewById;
+    private persistAppliedFilters;
+    /**
+     * Applies the right filters for entering `view` — the transient rule's one home. A TRANSIENT
+     * view's `apply` is a function of NOW, so it always re-derives; restoring would put
+     * yesterday's date under a tab claiming "today" (`persistAppliedFilters` has no transient
+     * guard, so storage holds the LAST answer). A non-transient view's own stored answer wins
+     * over its `apply`. The semantics argument is the one deliberate difference between the
+     * callers: a 'click' re-asks the view's question when nothing is stored, a 'refresh' returns
+     * the empty state the operator left — they cleared it, and F5 must give the cleared state
+     * back. On a table with no views, `view` is null and this is a plain restore of the
+     * `persistAppliedFilters` snapshot.
+     */
+    private enterViewFilters;
+    private get layoutStateKey();
+    /** One key for the whole layout — wrap now, widths next (decision 5). */
+    private persistColumnLayout;
+    private restoreColumnLayout;
     private persistColumnVisibility;
     private restoreColumnVisibility;
     /**
@@ -241,20 +403,74 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
      * because we need it before PrimeNG's restoreState() runs on the first [value] change.
      */
     private persistedTableState;
+    private activeView;
+    /**
+     * Where the operator's per-view sort override lives. Null on a table without views — those
+     * keep the pure PrimeNG sort persistence they always had — and null on a STORELESS table:
+     * there "hidden contributes nothing" retires a hidden column's sort (`dropHiddenColumnSort`)
+     * with no persist call at the hide site, so an override restored blind at the next init
+     * would re-impose a sort no chip can name. Store tables — where every viewed consumer
+     * lives — have the chip. Follows `stateStorage` like the filters and the view id: the sort
+     * is part of the same question they scope.
+     */
+    private get viewSortStateKey();
+    /** The operator's stored sort for the active view, sanitized like any persisted sort. */
+    private persistedViewSort;
+    /** The sort this view asks for: the operator's stored override, else its declared sort. */
+    private viewSort;
+    /**
+     * Records the current sort as the active view's override — called from the EXPLICIT sort
+     * gestures only (header click, menu sort, Clear filters), never from a load: a sort merely
+     * inherited at init must not crystallize into an override, or a later change to the view's
+     * declared sort would stop flowing to operators who never touched sort — the same
+     * flows-through rule `columnVisibilityOverrides` documents. A sort equal to the declared
+     * default is stored as ABSENCE for the same reason.
+     */
+    private persistActiveViewSort;
+    /**
+     * Puts the entering view's sort on the grid — stored override first, then the declared sort;
+     * a view stating no preference keeps the ordering already there (the pre-decision-10-sort
+     * behavior, and the least surprising for the tab an operator never sorted). Broadcast only —
+     * the caller owns the refetch, because which request carries the new sort differs between the
+     * store and storeless paths.
+     */
+    private applyViewSort;
+    /**
+     * Rewrites the sort inside PrimeNG's persisted state to the one `ngOnInit` resolved. The two
+     * can disagree only on a viewed table — PrimeNG's state is table-global while the resolved
+     * sort is the view's — and PrimeNG's restoreState() applies its copy on the first [value]
+     * change, AFTER the initial request already left with ours: without this line the grid's
+     * arrows and every later request silently fall back to the other view's sort. Handed the
+     * already-parsed state: `ngOnInit` reads the blob once for the whole init pass.
+     */
+    private alignPersistedTableStateSort;
+    /**
+     * The DECLARED default in the current context: the active view's own sort when it declares
+     * one, else the table-level `defaultSortField`. Every "fall back to the declared default"
+     * site — tri-state un-sort, Clear filters, the unsorted-load safety net — reads this, so
+     * un-sorting inside a view lands on the view's ordering, not the table's.
+     */
+    private defaultMultiSortMeta;
     /**
-     * Guards the "hidden contributes nothing" invariant against state this component didn't
-     * write (older blobs, hand-edited storage): a hidden column the persisted table state
-     * still filters or sorts by is revealed rather than constraining the data invisibly.
-     * In-memory only — once the constraint is gone, the user's stored choice reapplies.
+     * The active view's declared sort, sanitized: a non-sortable field would answer every load
+     * with a 400 (`keepSortableMeta`'s rationale), so it is dropped rather than sent; a view
+     * whose declaration sanitizes to nothing falls through to the table default.
      */
-    private reconcileVisibilityWithPersistedConstraints;
+    private viewDeclaredMultiSortMeta;
     /**
-     * The declared default as PrimeNG sort meta, or null when none is declared — or when its
-     * column is hidden ("hidden contributes nothing"): the table then falls back to the
-     * backend's implicit Id DESC, exactly as if no default were declared.
+     * The table-level declared default as PrimeNG sort meta, or null when none is declared. On a
+     * store table it applies even while its column is hidden — the sort chip names the ordering
+     * whether or not the column is on screen (decision 2b). A STORELESS table has no chip, so a
+     * hidden default would order the grid with nothing on screen naming it; there the default
+     * dies with the column, exactly as the legacy invariant had it (see `dropHiddenColumnSort`).
      */
-    private defaultMultiSortMeta;
-    private persistedMultiSortMeta;
+    private tableDefaultMultiSortMeta;
+    /**
+     * `keepSortableMeta` with "sanitized to nothing" surfaced as null — the rule every sort
+     * SOURCE shares ("a sort that sanitizes to nothing is no sort"), so the resolution chains
+     * can `??` past an empty answer instead of stopping on an empty array.
+     */
+    private sanitizedSortMeta;
     /**
      * Drops sort meta the backend has no sort case for. Persisted state outlives the rule that
      * produced it — a sort stored before a column became non-sortable (or before the library
@@ -265,21 +481,9 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
      * declares no column for.
      */
     private keepSortableMeta;
-    /**
-     * The filter twin of `keepSortableMeta` — persisted state outlives the rule that produced
-     * it, here a match mode stored before the column declared `matchModes`. It has to REWRITE
-     * storage rather than filter a value on the way past: `ColumnFilter.ngOnInit` skips
-     * `initFieldFilterConstraint()` whenever the field already carries a constraint, so our
-     * `[matchMode]` never applies to a restored one. Left alone, the column keeps filtering by
-     * a mode it no longer offers while its match-mode `<p-select>` renders blank (the stored
-     * value is not among the options). Runs before PrimeNG's `restoreState()`, which reads this
-     * same key on the first `[value]` change.
-     *
-     * Deliberately narrow: it touches only constraints whose mode the declaring column no
-     * longer offers, so every other byte of the persisted blob survives.
-     */
-    private reconcilePersistedMatchModes;
     private applyDefaultSortIfUnsorted;
+    /** Puts `meta` on the grid and tells the header icons — no fetch; the caller owns that. */
+    private broadcastSort;
     onPageChange(container: HTMLElement): void;
     /**
      * The one pending predicate: PrimeNG's overlay and the container's `aria-busy` must never
@@ -300,8 +504,6 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
      */
     private reconcileSelectionForLoadedPage;
     clientLoad(): void;
-    private clientFilterCount;
-    filter(event: TableFilterEvent): void;
     private loadFormArrayItems;
     /**
      * Single source for whether a column header offers click-to-sort (drives both
@@ -311,6 +513,148 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
      * sort fields are rejected with a 400, a clickable header here would be a guaranteed error toast.
      */
     isColumnSortable(col: Column): boolean;
+    /** The column the header menu is currently open for, and its header cell. */
+    menuColumn: Column | null;
+    private menuHeaderCell;
+    private draggedColumn;
+    /** False while a gesture that began on the menu chevron or the resize grip is in flight. */
+    private headerDragArmed;
+    /**
+     * A ViewChild rather than a template reference passed in from the header. The popover lives in
+     * the CAPTION template and the button that opens it in the HEADER one, and a reference variable
+     * does not cross an ng-template boundary — it arrived as undefined, and the click did nothing
+     * at all.
+     */
+    private readonly columnMenu;
+    private readonly filterBar;
+    /**
+     * Consumer-projected filter controls, forwarded to the bar. Collected here rather than by the
+     * bar itself because the bar is OURS: a consumer's template is projected at the table, and
+     * content queries only see what was projected into the component that declares them.
+     */
+    filterTemplates: QueryList<SpiderlyFilterTemplateDirective>;
+    private readonly selectionHeader;
+    openColumnMenu(col: Column, event: Event): void;
+    /**
+     * Switches to a view. Clears first, always: a view is a STATE rather than an addition, and two
+     * of them composed produce a question nobody asked. The clear runs through the store directly
+     * rather than through `clear(table)`, which would also wipe the sort and the persisted state a
+     * view is entitled to keep.
+     */
+    selectView(view: TableView): void;
+    /**
+     * The filter this column stands for. Defaults to the column's own `field`, because a store id
+     * IS a backend property name — `toFilterPayload` emits it straight into `Filter.filters`. So
+     * `filterId` is an escape hatch for the rare mismatch, not something every column restates:
+     * all eight of the first migrated table's declarations were the field name written a second
+     * time.
+     */
+    private filterIdFor;
+    /**
+     * Asks the STORE, not the column. Checking only that an id was declared let a typo through to
+     * `store.get(id)`, which reads `definitions[id].label` — so a mistyped id threw on click rather
+     * than greying the item out. With 195 declarations to migrate, that is the failure mode worth
+     * closing here rather than in each consumer.
+     */
+    canFilterColumn(col: Column): boolean;
+    /**
+     * Opens the bar's editor for this column's filter. The bar took the filter off the header and
+     * the header is still where an operator reaches for it, which is twenty-seven tables' worth of
+     * habit; this is the shortcut back rather than a second filter surface — it drives the same
+     * editor, on the same bar, that `+ Filter` opens.
+     */
+    filterMenuColumn(): void;
+    /**
+     * Sorts by this column in the NAMED direction. Clicking a header cycles asc, desc and off,
+     * which is fine for one column and a guess for a direction someone wants now — you click, look,
+     * and click again if it went the other way. This is also the only sort path that works from a
+     * keyboard.
+     *
+     * A column the generated paginator has no sort case for answers every load with a 400, so the
+     * items are disabled by the same predicate that keeps its header from being clickable.
+     */
+    sortMenuColumn(order: 1 | -1): void;
+    /**
+     * Sizes the column to the widest thing in it. The cheaper escape from a cramped column: no
+     * drag, no aim. Unlike a drag it does NOT trade with the neighbour — a minimum that grew is
+     * exactly the case decision 4 lets push the table past its container and start scrolling.
+     *
+     * Measures the CELL CONTENT, not the cell: the clamp lives on the inner span, so a `td` reports
+     * a scrollWidth that fits while the text inside it does not.
+     */
+    fitMenuColumn(): void;
+    /**
+     * The share that actually yields `needed` pixels — not `needed` scaled by the column's current
+     * px-per-share, which is the obvious answer and the wrong one. Shares are a PROPORTION of
+     * whatever width the table has, so growing this column's share also shrinks the realized width
+     * of every other column, and the naive figure lands short. The spec caught it as a cell that
+     * was still clipped after being told to fit.
+     *
+     * While the columns fit, the table keeps the container's width and the proportion has to solve
+     *   needed / tableWidth = newShare / (otherShares + newShare)
+     * with `otherShares` recovered from what this column currently renders at. Once `needed` is the
+     * whole container the proportional regime has no answer: the table is about to overrun its
+     * container and scroll (decision 4), and there a share IS its own length, so the pixels convert
+     * straight through the root font size.
+     */
+    private shareThatFits;
+    hideMenuColumn(): void;
+    /**
+     * Whether this column's cells give up the one-line clamp. The DEFAULT stays clamped
+     * (CLAUDE.md -> "Operator-owned view", decision 9); what changes is that the operator picks
+     * which column pays the row height, not whoever wrote `cols`.
+     *
+     * Lands on the td as `.cell-wrap`, whose inherited `--spiderly-cell-*` properties are how the
+     * toggle crosses into a projected `spiderlyCellTemplate` too — the contract's one telling is
+     * on that SCSS rule; a consumer clamp that hard-codes its values opts out.
+     */
+    isColumnWrapped(col: Column): boolean;
+    get isMenuColumnWrapped(): boolean;
+    toggleWrapForMenuColumn(): void;
+    /** Exposed for the template: actions columns carry no field and get no menu. */
+    isDataColumn(col: Column): boolean;
+    /**
+     * What the grid is ordered by, resolved to COLUMN NAMES for the bar. Read off PrimeNG's live
+     * meta rather than mirrored into a field, so it cannot fall out of step with the sort the table
+     * is actually applying. A field with no column left (hidden, or removed in a later release)
+     * falls back to its own name rather than vanishing from the list.
+     */
+    /**
+     * What the grid is ordered by, resolved to COLUMN NAMES for the bar.
+     *
+     * A field refreshed per fetch, not a getter: it is bound to the bar's `sort`, which is a SIGNAL
+     * input, so a freshly mapped array failed `Object.is` on every change-detection pass and marked
+     * the bar's consumers dirty forever — for a value that changes once per request. Same reason
+     * `tableStyle` is a field.
+     */
+    sortKeys: SortKeyLabel[];
+    /**
+     * Read off the last REQUEST's sort, not `table._multiSortMeta`. On a first load with a declared
+     * default that field is still null: `applyDefaultSortIfUnsorted` writes the default onto the
+     * lazy-load event, and PrimeNG fills its own meta only once someone clicks a header. Reading the
+     * table there showed no sort on exactly the tables that always have one. A field with no column
+     * left falls back to its own name rather than vanishing.
+     */
+    private refreshSortKeys;
+    /** This column's share, override first, then its declared width, then the per-type default. */
+    columnShare(col: Column): number;
+    /**
+     * A declared width expressed in SHARE units. rem IS the share unit and px converts; any other
+     * unit falls back to the per-type default rather than being read as a bare number.
+     *
+     * `parseFloat` alone shipped here first, so `width: '150px'` resolved to share 150 against
+     * neighbours at 12 — one column eating the grid on the first drag or fit. Every declared width
+     * in the consumer happens to be rem today, which is exactly why nothing would have caught it.
+     */
+    private shareOfDeclaredWidth;
+    private defaultShare;
+    /**
+     * Trades share between the column being dragged and the one on its right, so the table keeps
+     * its total: widening a column never starts a horizontal scroll by itself, which only happens
+     * once the SUM of the minimums stops fitting. The px delta is converted through the column's
+     * own rendered width, which is the only place the share-to-pixel scale is actually known.
+     */
+    startColumnResize(col: Column, event: MouseEvent, th: HTMLElement): void;
     /**
      * The column's declared {@link Column.width}, or the default for its filter type.
      *
@@ -320,51 +664,6 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
      * per-type defaults say — a boolean holds "Da"/"Ne", a text column holds a name.
      */
     getColWidth(col: Column): string;
-    /**
-     * Memo for the resolution below. Two jobs: the narrowing maps to a NEW array and a
-     * template binding must not hand PrimeNG a fresh reference every CD pass, and both
-     * halves (offered list, default mode) must come from ONE computation so they cannot
-     * disagree. Keyed on the declared array's identity, so reassigning `col.matchModes`
-     * recomputes — note PrimeNG itself reads `matchModeOptions` only in its own `ngOnInit`,
-     * so a post-init change still never reaches the rendered dropdown.
-     */
-    private matchModeResolutions;
-    getColMatchModeOptions(col: Column): SelectItem[] | null;
-    getColMatchMode(col: Column): any;
-    private resolveMatchModes;
-    /**
-     * Applies `Column.matchModes`, and refuses to half-apply it. Both ways a declaration can
-     * be wrong are consumer mistakes that PrimeNG would otherwise turn into a broken filter
-     * rather than an error: it reads `matchModeOptions || <type defaults>`, so handing it
-     * `[]` renders an EMPTY dropdown (an empty array is truthy) while the default mode still
-     * seeds the constraint, and handing it `null` silently restores PrimeNG's own list. So an
-     * unusable narrowing falls back to the full list and says so, instead of shipping a
-     * dropdown the user cannot pick from.
-     */
-    private computeMatchModes;
-    private matchModeOptionsForType;
-    private defaultMatchModeForType;
-    isDropOrMulti(filterType: string): boolean;
-    /**
-     * Whether the filter type applies on every value change, which hides the menu's Apply
-     * button — an Apply there would promise a pending state that cannot exist. Boolean
-     * auto-applies through PrimeNG's own `onModelChange`; date and dropdown/multiselect
-     * through the filter templates THIS component projects, which call `filterCallback`
-     * directly (PrimeNG's built-in element, and with it its `onModelChange`, is only
-     * rendered when no template is projected — so the date path is ours, not PrimeNG's).
-     * With showApplyButton off, PrimeNG also auto-applies match-mode, operator and
-     * constraint-removal changes, so the whole menu stays consistent. Typed input
-     * (text/numeric) is deliberately NOT here — it commits on Enter/Apply, since applying
-     * per keystroke would fire a lazy load per key. Listing the auto types (not the typed
-     * ones) is the safe polarity: an unlisted future type keeps its Apply button rather
-     * than silently losing its commit.
-     *
-     * Known gap this does not close, and it predates the flag: the projected date template
-     * binds `[ngModel]` one-way and commits on `(onSelect)`, which the datepicker raises for
-     * a calendar pick but not for `onUserInput` — so a date TYPED into the field never
-     * reaches the constraint at all, with or without an Apply button.
-     */
-    filterAppliesOnChange(filterType: string): boolean;
     navigateToDetails(rowId: number): void;
     /**
      * Handle row click event. Arbitration between "this click navigates the row" and "this click
@@ -384,6 +683,28 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
     ngOnDestroy(): void;
     get showSelectAllCheckbox(): boolean;
     private resetSelection;
+    /**
+     * A COMMITTED filter re-queries; a draft does not. Re-fetching per keystroke would be the same
+     * lie the chip bar exists to prevent, only paid for in requests rather than in credibility.
+     *
+     * Back to page one first, and off FRESH metadata rather than `reload()`: that one replays the
+     * cached lazy-load event, whose `first` was copied when the event was built, so a filter applied
+     * from page 3 would keep asking the server to skip 50 rows a narrower result set does not have.
+     * The grid comes back empty for a value that is definitely in it.
+     *
+     * The first run is PrimeNG's: it fires the initial lazy load itself, and re-querying here would
+     * make every table load twice.
+     */
+    private requeryOnAppliedFilters;
+    /**
+     * Back to page one, state saved, one fetch off FRESH metadata — the shared tail of the
+     * requery effect and `selectView`'s sort-only switch. The save is load-bearing: PrimeNG
+     * saves state only from its own interactions, so without it the pre-change page offset
+     * survives in storage and the NEXT visit replays it against a narrowed result set — the
+     * backend answers data=[] for an offset the filtered total no longer reaches, and the grid
+     * renders empty under chips claiming matches.
+     */
+    private refetchFromFirstPage;
     reload(): void;
     showActions(): boolean;
     getStyleForBodyColumn(col: Column<any>): string;
@@ -394,6 +715,11 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
     colTrackByFn(index: any, item: any): any;
     actionTrackByFn(index: any, item: Action): string;
     exportListToExcel(): void;
+    /**
+     * Clears everything that narrows the grid. With a store supplied it has to reach BOTH — the
+     * store holds the constraints and PrimeNG holds the persisted state and sort — or the bar goes
+     * empty while a reload brings the old filters back.
+     */
     clear(table: Table): void;
     setFakeIsAllSelected(): void;
     selectAll(checked: boolean): void;
@@ -426,7 +752,7 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
     rowUnselect(id: number): void;
     getFormArrayControlByIndex(formControlName: string, index: number): SpiderlyFormControl;
     static ɵfac: i0.ɵɵFactoryDeclaration<SpiderlyDataTableComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SpiderlyDataTableComponent, "spiderly-data-table", never, { "tableTitle": { "alias": "tableTitle"; "required": false; }; "tableIcon": { "alias": "tableIcon"; "required": false; }; "items": { "alias": "items"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "rowsPerPageOptions": { "alias": "rowsPerPageOptions"; "required": false; }; "cols": { "alias": "cols"; "required": false; }; "showPaginator": { "alias": "showPaginator"; "required": false; }; "showCardWrapper": { "alias": "showCardWrapper"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "idField": { "alias": "idField"; "required": false; }; "getPaginatedListObservableMethod": { "alias": "getPaginatedListObservableMethod"; "required": false; }; "exportListToExcelObservableMethod": { "alias": "exportListToExcelObservableMethod"; "required": false; }; "deleteItemFromTableObservableMethod": { "alias": "deleteItemFromTableObservableMethod"; "required": false; }; "deleteListFromTableObservableMethod": { "alias": "deleteListFromTableObservableMethod"; "required": false; }; "newlySelectedItems": { "alias": "newlySelectedItems"; "required": false; }; "unselectedItems": { "alias": "unselectedItems"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "selectedLazyLoadObservableMethod": { "alias": "selectedLazyLoadObservableMethod"; "required": false; }; "additionalFilterIdLong": { "alias": "additionalFilterIdLong"; "required": false; }; "showAddButton": { "alias": "showAddButton"; "required": false; }; "showExportToExcelButton": { "alias": "showExportToExcelButton"; "required": false; }; "showReloadTableButton": { "alias": "showReloadTableButton"; "required": false; }; "getFormArrayItems": { "alias": "getFormArrayItems"; "required": false; }; "hasLazyLoad": { "alias": "hasLazyLoad"; "required": false; }; "stateKey": { "alias": "stateKey"; "required": false; }; "stateStorage": { "alias": "stateStorage"; "required": false; }; "defaultSortField": { "alias": "defaultSortField"; "required": false; }; "defaultSortOrder": { "alias": "defaultSortOrder"; "required": false; }; "getAlreadySelectedItemIds": { "alias": "getAlreadySelectedItemIds"; "required": false; }; "getAlreadySelectedItems": { "alias": "getAlreadySelectedItems"; "required": false; }; "getFormControl": { "alias": "getFormControl"; "required": false; }; "additionalIndexes": { "alias": "additionalIndexes"; "required": false; }; "navigateOnRowClick": { "alias": "navigateOnRowClick"; "required": false; }; "rowNavigationPath": { "alias": "rowNavigationPath"; "required": false; }; }, { "onTotalRecordsChange": "onTotalRecordsChange"; "onLazyLoad": "onLazyLoad"; "onIsAllSelectedChange": "onIsAllSelectedChange"; "onRowSelect": "onRowSelect"; "onRowUnselect": "onRowUnselect"; }, ["actionsTemplate", "cellTemplates"], never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpiderlyDataTableComponent, "spiderly-data-table", never, { "tableTitle": { "alias": "tableTitle"; "required": false; }; "tableIcon": { "alias": "tableIcon"; "required": false; }; "items": { "alias": "items"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "rowsPerPageOptions": { "alias": "rowsPerPageOptions"; "required": false; }; "cols": { "alias": "cols"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "views": { "alias": "views"; "required": false; }; "showPaginator": { "alias": "showPaginator"; "required": false; }; "showCardWrapper": { "alias": "showCardWrapper"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "idField": { "alias": "idField"; "required": false; }; "getPaginatedListObservableMethod": { "alias": "getPaginatedListObservableMethod"; "required": false; }; "exportListToExcelObservableMethod": { "alias": "exportListToExcelObservableMethod"; "required": false; }; "deleteItemFromTableObservableMethod": { "alias": "deleteItemFromTableObservableMethod"; "required": false; }; "deleteListFromTableObservableMethod": { "alias": "deleteListFromTableObservableMethod"; "required": false; }; "newlySelectedItems": { "alias": "newlySelectedItems"; "required": false; }; "unselectedItems": { "alias": "unselectedItems"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "selectedLazyLoadObservableMethod": { "alias": "selectedLazyLoadObservableMethod"; "required": false; }; "additionalFilterIdLong": { "alias": "additionalFilterIdLong"; "required": false; }; "showAddButton": { "alias": "showAddButton"; "required": false; }; "showExportToExcelButton": { "alias": "showExportToExcelButton"; "required": false; }; "showReloadTableButton": { "alias": "showReloadTableButton"; "required": false; }; "getFormArrayItems": { "alias": "getFormArrayItems"; "required": false; }; "hasLazyLoad": { "alias": "hasLazyLoad"; "required": false; }; "stateKey": { "alias": "stateKey"; "required": false; }; "stateStorage": { "alias": "stateStorage"; "required": false; }; "defaultSortField": { "alias": "defaultSortField"; "required": false; }; "defaultSortOrder": { "alias": "defaultSortOrder"; "required": false; }; "getAlreadySelectedItemIds": { "alias": "getAlreadySelectedItemIds"; "required": false; }; "getAlreadySelectedItems": { "alias": "getAlreadySelectedItems"; "required": false; }; "getFormControl": { "alias": "getFormControl"; "required": false; }; "additionalIndexes": { "alias": "additionalIndexes"; "required": false; }; "navigateOnRowClick": { "alias": "navigateOnRowClick"; "required": false; }; "rowNavigationPath": { "alias": "rowNavigationPath"; "required": false; }; }, { "onTotalRecordsChange": "onTotalRecordsChange"; "onLazyLoad": "onLazyLoad"; "onIsAllSelectedChange": "onIsAllSelectedChange"; "onRowSelect": "onRowSelect"; "onRowUnselect": "onRowUnselect"; }, ["actionsTemplate", "cellTemplates", "filterTemplates"], never, true, never>;
 }
 export declare class Action {
     name?: string;
@@ -452,29 +778,77 @@ export declare class Action {
         onClick?: (event: ActionClickEvent) => void;
     });
 }
+/**
+ * A saved question. The bar lets an operator BUILD one; a view is the one they ask every morning,
+ * asked in a click — and without them the whole column-and-filter rework is a pile of knobs
+ * someone re-sets daily (CLAUDE.md -> "Operator-owned view", decision 10).
+ *
+ * Declared in consumer code, not stored per user: with a handful of operators and a handful of
+ * fixed daily jobs, shared built-in views cover the work, while personal saved views would drift
+ * into five variants of the same question. Personal LAYOUT choices still persist on top, per view.
+ */
+export interface TableView<TFilters = any> {
+    id: string;
+    label: string;
+    /**
+     * Sets the filters this view asks for. Receives the table's own store, so a consumer writes it
+     * with the store's typing. Called on a CLEARED store: a view is a state, not an addition.
+     */
+    apply?: (filters: TFilters) => void;
+    /**
+     * A view whose `apply` is a function of NOW — "Danas primljene", "this week". Selecting it
+     * always re-runs `apply` instead of restoring what an earlier visit stored: under the normal
+     * stored-wins rule a relative-date view clicked yesterday would restore yesterday's date under
+     * a tab claiming "today". Layout (columns, widths, wrap) still persists per view as usual —
+     * transience is about the QUESTION, not the furniture.
+     */
+    transient?: boolean;
+    /**
+     * The view's declared ordering — for the view whose question includes one ("oldest shipped
+     * first" IS the work list, not a reading preference). Entering the view applies it; the
+     * tri-state un-sort and Clear filters return to it instead of the table default; an operator's
+     * own sort overrides it, persisted per view on store tables (decision 10's sort half). A view
+     * declaring none keeps whatever ordering the grid already has, exactly as before this field
+     * existed.
+     */
+    sort?: SortMeta[];
+}
 export declare class Column<T = any> {
     name?: string;
     field?: string & keyof T;
-    filterField?: string & keyof T;
+    /**
+     * The column's VALUE SHAPE: it sizes the column (`getColWidth`), picks the cell rendering
+     * (`getRowData`, the blob branch) and the numeric right-align. The name is a fossil of the
+     * header-filter era — filtering lives in the store handed to `[filters]` — kept because
+     * renaming it would be a 195-declaration migration for zero behavior.
+     */
     filterType?: 'text' | 'date' | 'multiselect' | 'boolean' | 'numeric' | 'blob';
-    filterPlaceholder?: string;
-    showMatchModes?: boolean;
     /**
-     * Narrows the match modes this column's filter menu offers. Declaration order is display
-     * order, and the FIRST entry becomes the column's default match mode. Omit for the filter
-     * type's full list and standard default. Example — a datetime column where an exact-equals
-     * match can never hit: `matchModes: [MatchModeCodes.GreaterThan, MatchModeCodes.LessThan]`.
-     *
-     * Read at declaration time: PrimeNG generates the dropdown once in its own `ngOnInit`, so
-     * reassigning this later never reaches the rendered menu.
+     * The id of the filter in the table's store that this column stands for, which is what the
+     * header menu's `Filter…` opens. A LINK, not a declaration: the filter exists in the store
+     * whether or not any column names it, and a column needs this only to offer the shortcut.
      *
-     * The OFFERED list needs `showMatchModes: true` to be visible, but the default mode applies
-     * either way — declaring `matchModes` on a column with no picker is the supported way to
-     * change just that column's default. Only modes the filter type actually has are honored;
-     * anything else is logged and ignored (`computeMatchModes`).
+     * Untyped against the store on purpose — a `Column<T>` knows its row type and nothing about
+     * which store it will be rendered beside, so the compile-time key check lives where the store
+     * is declared (`createFilterStore`), not here.
      */
-    matchModes?: MatchModeCodes[];
-    showAddButton?: boolean;
+    filterId?: string;
+    /**
+     * @deprecated Dead since the header-filter deletion: NOTHING reads it. It survives on the type
+     * only so details-table cols emitted by an OLDER Spiderly.SourceGenerators (which wrote
+     * `showMatchModes: true`) still compile against this library during a mixed-version window —
+     * a consumer on published NuGet generators plus an npm-linked library build. Delete it once
+     * every consumer regenerates with a generator from this release or later (spiderly#407).
+     */
+    showMatchModes?: boolean;
+    /**
+     * @deprecated The same version-skew bridge as {@link showMatchModes}, and nothing else: older
+     * generators emit `filterField: 'xxxId'` for every dropdown-typed details-table column, so
+     * deleting it breaks the mixed window the moment a consumer adds one. NOTHING reads it —
+     * filter ids live in the store, linked from a column via {@link filterId}. Delete with
+     * `showMatchModes` (spiderly#407).
+     */
+    filterField?: string & keyof T;
     dropdownOrMultiselectValues?: PrimengOption[];
     actions?: Action[];
     editable?: boolean;
@@ -493,9 +867,8 @@ export declare class Column<T = any> {
      */
     lockVisible?: boolean;
     /**
-     * CSS length fixing this column's width (e.g. `'8rem'`). Overrides the per-filter-type default,
-     * which is sized for the HEADER — filter input plus match-mode dropdown — and so is generous
-     * for a column of short values.
+     * CSS length fixing this column's width (e.g. `'8rem'`). Overrides the per-type default,
+     * which is generous for a column of short values.
      *
      * Declare a width on the columns that must stay NARROW and leave the flexible one undeclared:
      * the table distributes its surplus in proportion to the declared widths, so a column carrying
@@ -512,15 +885,13 @@ export declare class Column<T = any> {
      * Not applied to editable cells — those belong to their inline input.
      */
     onCellClick?: (event: CellClickEvent) => void;
-    constructor({ name, field, filterField, filterType, filterPlaceholder, showMatchModes, matchModes, showAddButton, dropdownOrMultiselectValues, actions, editable, showTime, decimalPlaces, sortable, visible, lockVisible, width, onCellClick, }?: {
+    constructor({ name, field, filterType, filterId, showMatchModes, filterField, dropdownOrMultiselectValues, actions, editable, showTime, decimalPlaces, sortable, visible, lockVisible, width, onCellClick, }?: {
         name?: string;
         field?: string & keyof T;
-        filterField?: string & keyof T;
         filterType?: 'text' | 'date' | 'multiselect' | 'boolean' | 'numeric' | 'blob';
-        filterPlaceholder?: string;
+        filterId?: string;
         showMatchModes?: boolean;
-        matchModes?: MatchModeCodes[];
-        showAddButton?: boolean;
+        filterField?: string & keyof T;
         dropdownOrMultiselectValues?: PrimengOption[];
         actions?: Action[];
         editable?: boolean;