@openziti/ziti-console-lib 1.7.2 → 1.8.0

package/table-core/index.d.ts

@@ -0,0 +1,981 @@
+import * as rxjs from 'rxjs';
+import { BehaviorSubject } from 'rxjs';
+import { Router, ActivatedRoute } from '@angular/router';
+import { Location } from '@angular/common';
+import * as i0 from '@angular/core';
+import { Type, OnInit, OnDestroy, EventEmitter, ElementRef, NgZone, AfterViewInit, AfterViewChecked, OnChanges } from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { SafeHtml, DomSanitizer } from '@angular/platform-browser';
+import { MatDateRangePicker } from '@angular/material/datepicker';
+
+type FilterObj = {
+    filterName: string;
+    columnId: string;
+    value: any;
+    label: string;
+    type?: string;
+    hidden?: boolean;
+    verb?: string;
+};
+declare class DataTableFilterService {
+    private location;
+    private router;
+    private activatedRoute;
+    filters: FilterObj[];
+    currentPage: number;
+    /** Rows requested per page. Defaults to the legacy page size; the list-table's
+     *  rows-per-page control changes it via {@link changePageSize}. */
+    pageSize: number;
+    filtersChanged: BehaviorSubject<FilterObj[]>;
+    filtering: BehaviorSubject<boolean>;
+    pageChanged: BehaviorSubject<any>;
+    pageSizeChanged: BehaviorSubject<number>;
+    currentQueryParams: any[];
+    private static readonly URL_FILTER_PREFIX;
+    constructor(location: Location, router: Router, activatedRoute: ActivatedRoute);
+    updateFilter(filterObj: FilterObj): void;
+    removeFilter(filterObj: FilterObj): void;
+    getFilterString(key: string): string;
+    changePage(page: any): void;
+    changePageSize(size: number): void;
+    clearFilters(): void;
+    /**
+     * Remove every active filter (the toolbar/empty-state "clear filters" action).
+     * clearFilters() above re-reads the URL and so is really a load-time sync; this one
+     * passes the active filters to updateUrlParameters so they are dropped from the URL
+     * and storage instead of being restored, then emits the now-empty list.
+     */
+    clearAllFilters(): void;
+    storeFilters(): void;
+    getStoredFilters(): any;
+    updateUrlParameters(filtersToRemove?: any[]): void;
+    getUrlFiltersMap(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataTableFilterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataTableFilterService>;
+}
+
+type ListSortDir = 'asc' | 'desc' | undefined;
+/**
+ * Context handed to component-cell input mappers.
+ */
+interface ListCellContext<T = any> {
+    row: T;
+    value: any;
+    colId: string;
+    rowIndex: number;
+    /** Emit a row action (flows to the table's `actionRequested` → the page handler). */
+    emitAction: (action: string, item?: any) => void;
+}
+/**
+ * Shim shape passed to legacy `cellHtml` / `valueFormatter` functions so the existing
+ * ag-grid-era renderer bodies (which read `row.data`, `row.column.colId`, `row.value`)
+ * keep working unchanged.
+ */
+interface ListLegacyCellShim {
+    data: any;
+    value?: any;
+    column: {
+        colId: string;
+    };
+    rowIndex?: number;
+}
+/**
+ * Declarative column definition for {@link ListTableComponent}. Replaces the ag-grid
+ * `ColDef` shape used by the legacy `lib-data-table`. Rendering precedence for a cell is:
+ * `cell` (a component) > `cellHtml` (sanitized markup) > `valueFormatter` (plain text) >
+ * the raw value at `field`.
+ */
+interface ListColumn<T = any> {
+    /** Stable column id (was ag-grid `colId`). Used for persistence + tracking. */
+    key: string;
+    /** Dot-path used to read the raw value from a row. Defaults to `key`. */
+    field?: string;
+    /** Header label (was ag-grid `headerName`). */
+    label: string;
+    /** Component class rendered in each cell, hosted via NgComponentOutlet. */
+    cell?: Type<any>;
+    /** Maps a row to the `@Input()`s of the `cell` component. */
+    cellInputs?: (ctx: ListCellContext<T>) => Record<string, unknown>;
+    /** Returns sanitized HTML for the cell (legacy string renderers). */
+    cellHtml?: (shim: ListLegacyCellShim) => string;
+    /** Returns plain text for the cell. */
+    valueFormatter?: (shim: ListLegacyCellShim) => string;
+    /** Initial width in px. Omit to let the column flex to fill available space. */
+    width?: number;
+    minWidth?: number;
+    /** Defaults to true. */
+    resizable?: boolean;
+    /** Extra class(es) applied to every cell in the column. */
+    cellClass?: string;
+    sortable?: boolean;
+    /** Convenience flag mirrored from legacy `headerComponentParams.enableSorting`. */
+    enableSorting?: boolean;
+    sortDir?: ListSortDir;
+    /** Called on header sort click with the resolved direction (was `sortColumn`). */
+    onSort?: (colId: string, dir: ListSortDir) => void;
+    /** Called on cell click (was ag-grid `onCellClicked`). */
+    onCellClick?: (ctx: ListCellContext<T>) => void;
+    filterType?: 'TEXTINPUT' | 'SELECT' | 'COMBO' | 'DATETIME' | 'ATTRIBUTE' | 'MULTISELECT' | 'CUSTOM' | string;
+    /** API field the filter queries. Defaults to `field` then `key`. Use when the
+     *  display field differs from the filterable field (e.g. key `os` → `envInfo.os`,
+     *  key `type` (display `type.name`) → `typeId`). */
+    filterField?: string;
+    /** Placeholder shown in the filter-row control when nothing is selected. */
+    filterPlaceholder?: string;
+    filterOptions?: any[];
+    getFilterOptions?: () => any[];
+    /** Extra params for the filter controls (attribute getters, combo options, etc.). */
+    headerParams?: Record<string, any>;
+    /** Component class rendered as a hover tooltip. */
+    tooltip?: Type<any>;
+    tooltipInputs?: (ctx: ListCellContext<T>) => Record<string, unknown>;
+    /** Defaults to true. When false the column cannot be hidden. */
+    hideable?: boolean;
+    /** Leave the column out of the Columns menu (it still renders in the table). */
+    excludeFromChooser?: boolean;
+    /** In tree mode, the column that holds the expand/collapse control and per-level
+     *  indentation. When no column sets this, the first visible column is used. */
+    treeColumn?: boolean;
+    /** Defaults to true. When false the column cannot be drag-reordered. */
+    reorderable?: boolean;
+    /** Initial visibility (was ag-grid `hide`). */
+    hidden?: boolean;
+}
+/**
+ * Optional base interface for component cells hosted by {@link ListTableComponent}.
+ * The table sets whatever `@Input()`s a column's `cellInputs` returns; implementing this
+ * is not required but documents the common ones.
+ */
+interface ListCell<T = any> {
+    row?: T;
+    value?: any;
+}
+/** Nested-row layout: 'card' floats each level as a bordered card, 'flat' renders inline. */
+type TreeVariant = 'card' | 'flat';
+/** Per-control toolbar config. A control shows and is interactive by default; set
+ *  `show: false` to remove it, or `disabled: true` to keep it visible but greyed out. */
+interface ToolbarControlOptions {
+    show?: boolean;
+    disabled?: boolean;
+}
+/** Show/hide and enable/disable each control around the table: the bar above it
+ *  (search, filters, refresh, auto-refresh, columns) and the footer below it
+ *  (rows-per-page, pagination). */
+interface ListTableToolbarOptions {
+    search?: ToolbarControlOptions;
+    filters?: ToolbarControlOptions;
+    refresh?: ToolbarControlOptions;
+    autoRefresh?: ToolbarControlOptions;
+    columns?: ToolbarControlOptions;
+    pageSize?: ToolbarControlOptions;
+    pagination?: ToolbarControlOptions;
+}
+/** Structural options for {@link ListTableComponent}. */
+interface ListTableOptions {
+    noSelect?: boolean;
+    noMenu?: boolean;
+    pager?: 'pages' | 'cursor';
+    tree?: boolean;
+    /** Tree mode: render checkboxes on nested rows and include them in the selection. */
+    selectChildren?: boolean;
+    fitColumns?: boolean;
+    toolbar?: ListTableToolbarOptions;
+}
+
+/**
+ * Per-instance state + localStorage persistence for {@link ListTableComponent}.
+ * Uses its own `lt_<tableId>_*` keys (separate from the legacy ag-grid table) so a
+ * first visit starts from the column defs' default widths, not a carried-over ag layout.
+ */
+declare class ListTableService {
+    tableId: string;
+    /** Coordinates the toolbar dropdowns so only one (filter pill or column chooser)
+     *  is open at a time. Openers emit themselves; others close when they see an
+     *  owner that isn't them. */
+    private readonly menuOpenedSubject;
+    readonly menuOpened$: rxjs.Observable<unknown>;
+    notifyMenuOpened(owner: unknown): void;
+    private stateKey;
+    private widthsKey;
+    private pageSizeKey;
+    private treeVariantKey;
+    /** Returns the saved tree layout ('card' | 'flat'), or `fallback` if none. */
+    restoreTreeVariant(fallback: TreeVariant): TreeVariant;
+    saveTreeVariant(variant: TreeVariant): void;
+    private static pageSizeKeyFor;
+    restorePageSize(fallback: number): number;
+    savePageSize(size: number): void;
+    /** Reads a table's remembered rows-per-page without an instance (for host pre-seeding). */
+    static readPersistedPageSize(tableId: string, fallback: number): number;
+    /**
+     * Returns a shallow-cloned copy of `columns` with any persisted width, visibility,
+     * and order applied. Columns not present in the saved state keep their declared
+     * position (appended after the saved ones).
+     */
+    /** Parses a stored JSON value, or null when missing/unavailable/malformed. */
+    private readJson;
+    /** Applies a widths map then a persisted order/visibility list onto a fresh copy of
+     *  `columns`. Shared by the top-level and per-depth restore paths. */
+    private mergePersistedColumns;
+    /** Order + visibility + width entries for one set of columns. */
+    private columnStateEntries;
+    applyPersistedState(columns: ListColumn[]): ListColumn[];
+    /** Persists the current order + visibility (and widths embedded in each entry). */
+    saveState(columns: ListColumn[]): void;
+    private childStateKey;
+    private childWidthsKey;
+    /** Applies persisted order/visibility/width for one nested depth to its columns. */
+    applyPersistedChildState(level: number, columns: ListColumn[]): ListColumn[];
+    saveChildState(level: number, columns: ListColumn[]): void;
+    saveChildWidth(level: number, colId: string, width: number, columns: ListColumn[]): void;
+    /** Persists a single column's width, then rewrites the ordered state. */
+    saveWidth(colId: string, width: number, columns: ListColumn[]): void;
+    /** Clears all persisted layout for this table ("Restore Default Table"). */
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListTableService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ListTableService>;
+}
+
+/**
+ * Emits `clickOutside` when a click lands outside the host element. A local,
+ * dependency-free standalone replacement for `ng-click-outside`, so the table and
+ * its cells can be consumed from the package without pulling an undeclared dependency.
+ *
+ * The document listener runs outside Angular to avoid a change-detection pass on every
+ * click anywhere on the page; the emit re-enters the zone so bound handlers run normally.
+ */
+declare class ClickOutsideDirective implements OnInit, OnDestroy {
+    private el;
+    private ngZone;
+    private platformId;
+    clickOutside: EventEmitter<Event>;
+    constructor(el: ElementRef, ngZone: NgZone, platformId: Object);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private onDocumentClick;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickOutsideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickOutsideDirective, "[clickOutside]", never, {}, { "clickOutside": "clickOutside"; }, never, never, true, never>;
+}
+
+/**
+ * A single row in a {@link ListMenuComponent}.
+ *
+ * `action` is the identifier the host dispatches on; `data` carries the original
+ * domain object (menu item / header action / filter option) so the host can act
+ * on it without the menu needing to know its shape.
+ */
+interface ListMenuItem {
+    /** Visible text. */
+    label: string;
+    /** Identifier emitted back to the host on click. */
+    action: string;
+    /** Optional icon class(es) rendered before the label. */
+    icon?: string;
+    /** Optional sanitized SVG rendered before the label (takes precedence over `icon`). */
+    iconSvg?: SafeHtml;
+    /** When true the row is present but visually removed (keeps list order stable). */
+    hidden?: boolean;
+    /** When true the row is shown but not clickable. */
+    disabled?: boolean;
+    /** Optional element id (preserves existing automation hooks). */
+    id?: string;
+    /** Original domain object this row was built from. */
+    data?: any;
+}
+/**
+ * Generic, theme-driven action menu popover. Presentational only: the host owns
+ * open state and position and handles `(itemClick)` / `(closed)`.
+ */
+declare class ListMenuComponent {
+    /** Whether the menu is rendered. */
+    open: boolean;
+    /** Rows to render. */
+    items: ListMenuItem[];
+    /** Fixed-position left offset (px). */
+    left: number;
+    /** Fixed-position top offset (px). */
+    top: number;
+    /** Optional id for the menu container (automation hook). */
+    menuId?: string;
+    /** Emitted when a clickable row is selected. */
+    itemClick: EventEmitter<{
+        item: ListMenuItem;
+        event: MouseEvent;
+    }>;
+    /** Emitted when the user clicks outside the open menu. */
+    closed: EventEmitter<Event>;
+    onItem(item: ListMenuItem, event: MouseEvent): void;
+    onClickOutside(event: Event): void;
+    trackItem: (_: number, item: ListMenuItem) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListMenuComponent, "lib-list-menu", never, { "open": { "alias": "open"; "required": false; }; "items": { "alias": "items"; "required": false; }; "left": { "alias": "left"; "required": false; }; "top": { "alias": "top"; "required": false; }; "menuId": { "alias": "menuId"; "required": false; }; }, { "itemClick": "itemClick"; "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * Custom, token-skinnable list table. Columns are declared with {@link ListColumn};
+ * sort, filter, and pagination flow through {@link DataTableFilterService}.
+ */
+declare class ListTableComponent implements OnInit, AfterViewInit, AfterViewChecked, OnDestroy {
+    svc: ListTableService;
+    private tableFilterService;
+    private el;
+    private ngZone;
+    private sanitizer;
+    set tableId(id: string);
+    get tableId(): string;
+    private _tableId;
+    set columns(value: ListColumn[]);
+    set rowData(value: any[]);
+    get rowData(): any[];
+    private _rowData;
+    set isLoading(value: boolean);
+    get isLoading(): boolean;
+    private _isLoading;
+    /** Placeholder rows drawn during the first load, before any data has arrived. */
+    skeletonRowCount: number;
+    /** True once the table has shown real rows at least once, so a later load shows the
+     *  refresh bar over the existing rows instead of the full-page skeleton again. */
+    hasLoadedOnce: boolean;
+    /** The logical "first load with nothing on screen yet" state. The skeleton renders
+     *  off showSkeleton (below), which debounces this so a very fast first load goes
+     *  straight to rows without a skeleton flash. */
+    get isInitialLoad(): boolean;
+    /** Whether the skeleton placeholder is visible. Debounced from isInitialLoad with the
+     *  same show-delay as the refresh bar: a first load shorter than REFRESH_SHOW_DELAY
+     *  never shows it. Unlike the bar there is no minimum-visible hold, so real rows
+     *  replace the skeleton the moment they arrive. */
+    showSkeleton: boolean;
+    private skeletonShowTimer;
+    private updateSkeleton;
+    /** Whether the thin top refresh bar is visible. Debounced from isLoading via
+     *  updateRefreshBar rather than read straight off it. */
+    showRefreshBar: boolean;
+    private readonly REFRESH_SHOW_DELAY;
+    private readonly REFRESH_MIN_VISIBLE;
+    private refreshShowTimer;
+    private refreshHideTimer;
+    private refreshShownAt;
+    private updateRefreshBar;
+    /** Row indexes for the skeleton loop (at least one). */
+    get skeletonRows(): number[];
+    private readonly SK_WIDTHS;
+    /** Skeleton bar width (as a %) for a given column/row, varied but stable. */
+    skeletonBarWidth(colIndex: number, rowIndex: number): number;
+    set options(value: ListTableOptions);
+    get options(): ListTableOptions;
+    private _options;
+    /** Resolved show/disabled state for each toolbar control, read by the template.
+     *  Every control shows and is enabled unless the host's `options.toolbar` says otherwise. */
+    toolbarControls: {
+        search: {
+            show: boolean;
+            disabled: boolean;
+        };
+        filters: {
+            show: boolean;
+            disabled: boolean;
+        };
+        refresh: {
+            show: boolean;
+            disabled: boolean;
+        };
+        autoRefresh: {
+            show: boolean;
+            disabled: boolean;
+        };
+        columns: {
+            show: boolean;
+            disabled: boolean;
+        };
+        pageSize: {
+            show: boolean;
+            disabled: boolean;
+        };
+        pagination: {
+            show: boolean;
+            disabled: boolean;
+        };
+    };
+    private normalizeToolbar;
+    /** Tree mode: fetch a row's children the first time it is expanded. Return the
+     *  child rows (any shape the columns render). A row with `leaf: true`, or one that
+     *  resolves to an empty array, shows no expand control.
+     *  Note: tree runtime state (`children`, `leaf`, `__tree*`) is written onto the row
+     *  objects, so a host that reuses a row in a save call should strip it first. */
+    loadChildren?: (row: any) => Promise<any[]> | any[];
+    /** Tree mode: columns per depth level (index = level; level 0 uses `columns`).
+     *  Nested rows render in their own grid with a per-level sub-header, so children
+     *  need not match the parent. Unset renders children with the parent's columns.
+     *  The bound value is the default; users can show/hide/reorder/resize child columns
+     *  per depth from the Columns menu, persisted per table. */
+    set childColumnsByLevel(v: ListColumn[][] | undefined);
+    get childColumnsByLevel(): ListColumn[][] | undefined;
+    private _declaredChildColumnsByLevel?;
+    private _childColumnsByLevel?;
+    private _childLevelCache;
+    private _childColsVersion;
+    private _childLevelCacheVersion;
+    private _treeKeyCache;
+    private _leadOffsetCache;
+    private _treeMemoVersion;
+    private invalidateColumnCache;
+    private syncTreeMemo;
+    /** Rebuilds the effective per-level child columns from the declared defaults with
+     *  any persisted order/visibility/width applied. */
+    private buildChildColumns;
+    nodeToggled: EventEmitter<{
+        row: any;
+        expanded: boolean;
+    }>;
+    hasNext: boolean;
+    hasPrev: boolean;
+    startCount: any;
+    endCount: any;
+    totalCount: any;
+    filterApplied: boolean;
+    menuItems: any[];
+    headerActions: any[];
+    /** @deprecated kept for the old lib-no-items bindings; the new empty state uses line glyphs, not images. */
+    noItemsImage: string;
+    showNoItemsAdd: boolean;
+    noItemsReadonly: boolean;
+    /** Primary create label shown on the first-use empty state (else the per-entity default). */
+    createLabel: string;
+    /** What these rows belong to, used in the empty headline ("This network has no services").
+     *  Defaults to 'network' since the Ziti pages are network-scoped; set '' for a list that is not. */
+    emptyScope: string;
+    accessDenied: boolean;
+    entityTypeName: string;
+    filterName: string;
+    filterColumn: string;
+    actionRequested: EventEmitter<{
+        action: string;
+        item?: any;
+    }>;
+    tableReady: EventEmitter<any>;
+    /** Full set of selected rows (all depths) whenever the selection changes. */
+    selectionChanged: EventEmitter<any[]>;
+    /** The row the pointer is over, or null when it leaves. Emitted once per row (at the
+     *  row level, not per cell) so consumers can react to the whole hovered row, for
+     *  example to highlight that row's path in a connected diagram. */
+    rowHover: EventEmitter<any>;
+    contextMenu?: ElementRef;
+    filterZone?: ElementRef<HTMLElement>;
+    filtersRow?: ElementRef<HTMLElement>;
+    /** Full column list (includes hidden), after persisted state. */
+    allColumns: ListColumn[];
+    /** Currently rendered columns (visible + ordered). */
+    visibleColumns: ListColumn[];
+    /** Hidden columns, shaped for the shared hidden-columns bar (`headerName`). */
+    hiddenColumns: any[];
+    entityTypeLabel: string;
+    openMenu: boolean;
+    openHeaderMenu: boolean;
+    menuLeft: number;
+    menuTop: number;
+    selectedItem: any;
+    allToggled: boolean;
+    /** Rows actually rendered: in tree mode this is the roots plus the expanded
+     *  descendants in order; otherwise it is `rowData` unchanged. */
+    flatRows: any[];
+    /** Tree look: 'card' floats each nested level as a bordered card; 'flat' renders
+     *  nested rows inline with the table, sub-headers as plain strips, no card chrome.
+     *  The bound value is the default; the user can switch it from the Columns menu and
+     *  the choice is remembered per table. */
+    set treeVariant(v: TreeVariant);
+    get treeVariant(): TreeVariant;
+    private _treeVariant;
+    private _declaredTreeVariant;
+    /** Show the flat/nested row-layout switch in the Columns menu. Hidden for now;
+     *  the variant still comes from the `treeVariant` input. */
+    showTreeVariantToggle: boolean;
+    /** Flat variant only: draw a running guide rail down the left of each nested level. */
+    treeRail: boolean;
+    get isFlatTree(): boolean;
+    /** Show the flat/nested switch only when the table actually renders nested rows. */
+    get canSwitchTreeVariant(): boolean;
+    setTreeVariant(variant: TreeVariant): void;
+    readonly treeIndentRem = 1.25;
+    readonly treeDeepAlignRem = 0.625;
+    readonly treeFlatBaseRem = 3.75;
+    readonly treeFlatStepRem = 2.125;
+    readonly treeCardBaseRem = 4;
+    readonly treeSelectColRem = 2.25;
+    showColumnChooser: boolean;
+    searchString: string;
+    activeFilters: FilterObj[];
+    filtering: boolean;
+    private inputChangedDebounced;
+    visibleFilterColumns: ListColumn[];
+    overflowFilterColumns: ListColumn[];
+    showFilterOverflow: boolean;
+    private filterWidths;
+    private filtersDirty;
+    private filterRO?;
+    private observedToolbar?;
+    private overflowRaf;
+    private readonly FILTER_GAP;
+    private readonly MORE_BTN_W;
+    private resizing?;
+    private readonly onPointerMove;
+    private readonly onPointerUp;
+    private _rawColumns;
+    private _initialColumns;
+    private _initialized;
+    private subscription;
+    private _expandedKeys;
+    private _childrenCache;
+    private _destroyed;
+    constructor(svc: ListTableService, tableFilterService: DataTableFilterService, el: ElementRef, ngZone: NgZone, sanitizer: DomSanitizer);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    get showTable(): boolean;
+    /** Columns surfaced as inline filter controls in the toolbar. Text filters are
+     *  excluded because the free-text search box already covers the primary text field. */
+    get filterableColumns(): ListColumn[];
+    /** A filter column is "active" when it has an applied filter. */
+    isFilterActive(col: ListColumn): boolean;
+    /** Applied filters that are currently hidden in the overflow dropdown. */
+    get hiddenActiveCount(): number;
+    toggleFilterOverflow(event: MouseEvent): void;
+    closeFilterOverflow(event?: Event): void;
+    private ensureFilterResizeObserver;
+    private scheduleFilterOverflow;
+    private recomputeFilterOverflow;
+    /** Split filter controls into inline vs. overflow, pinning active filters and
+     *  dropping inactive (then, only if forced, active) from the right until they fit. */
+    private applyFilterSplit;
+    private buildColumns;
+    private updateVisible;
+    trackRow: (index: number, row: any) => any;
+    trackCol: (index: number, col: ListColumn) => string;
+    colWidth(col: ListColumn): string | null;
+    private rawValue;
+    private cellContext;
+    private legacyShim;
+    renderMode(col: ListColumn): 'component' | 'html' | 'text';
+    cellInputs(col: ListColumn, row: any, i: number): Record<string, unknown>;
+    cellHtml(col: ListColumn, row: any, i: number): string;
+    cellText(col: ListColumn, row: any, i: number): any;
+    cellClass(col: ListColumn): string;
+    onCellClick(col: ListColumn, row: any, i: number): void;
+    tooltipInputs(col: ListColumn, row: any, i: number): Record<string, unknown>;
+    hoverTooltip: {
+        component: Type<any>;
+        inputs: Record<string, unknown>;
+        left: number;
+        top: number;
+    } | null;
+    onCellHover(col: ListColumn, row: any, i: number, event: MouseEvent): void;
+    onCellLeave(): void;
+    /** The row currently under the pointer, so we only emit when it actually changes. */
+    private hoveredRow;
+    onRowHover(row: any): void;
+    onRowLeave(row: any): void;
+    /** True when nested rows get checkboxes and join the selection (opt-in). */
+    get childSelectEnabled(): boolean;
+    /** Rows the checkboxes and select-all act on: top-level only, unless selectChildren
+     *  is set. Keeps select-all from marking nested rows a host that reads rowData never sees. */
+    private get selectableRows();
+    toggleItem: (item: any) => void;
+    /** Some rows selected but the header select-all isn't fully on (indeterminate). */
+    get someSelected(): boolean;
+    toggleAll(): void;
+    private syncSelectAll;
+    /** Emit every selected row across all depths. Walks the full data, not just the rendered
+     *  rows, so a collapsed parent's selected children are still reported. */
+    private emitSelection;
+    get isTreeMode(): boolean;
+    /** True when per-level child columns are configured (children render in their own
+     *  grid with a sub-header rather than the parent's columns). */
+    get hasChildColumns(): boolean;
+    /** Columns used at a given depth: level 0 is the main (visible) columns; deeper
+     *  levels use `childColumnsByLevel`, falling back to the deepest set defined. */
+    columnsForLevel(level: number): ListColumn[];
+    /** Child columns the chooser lists at a depth: all declared ones (including hidden),
+     *  minus structural columns like the select checkbox or row-actions gutter. */
+    allColumnsForLevel(level: number): ListColumn[];
+    /** Depths that offer configurable columns (skips the level-0 placeholder and any
+     *  level that only holds structural columns), one chooser group per level. */
+    get childLevels(): number[];
+    /** Chooser hint for a nested level: its first few column labels, then "+N". */
+    childLevelLabel(level: number): string;
+    /** Key of the column that carries the expand control + indentation for a column set:
+     *  the flagged one, else the first real data column (skipping a leading structural
+     *  column such as a select checkbox the host put at the start). */
+    private treeColumnKeyFor;
+    treeColumnKeyForLevel(level: number): string | undefined;
+    /** Width of the columns before the tree column, used to pull the flat first-column
+     *  indent back by whatever structural columns (like a select checkbox) sit ahead of
+     *  it, so its content still lands under the parent row's name. */
+    treeLeadOffset(level: number): string;
+    isTreeColumn(col: ListColumn, level: number): boolean;
+    isTreeCell(col: ListColumn): boolean;
+    /** Columns a full-width nested row spans: the data columns plus the select and
+     *  menu gutters, matching the header's cell count. */
+    get treeSpanCount(): number;
+    /** Per-level indent (rem); the card variant nudges levels past the first so the edge meets the parent chevron. */
+    treeIndentFor(level: number): number;
+    /** Flat variant: left pad (rem) of a nested row's first column (sub-header + data),
+     *  one chevron-width per level so it lines up under the parent row's name. */
+    treeFlatFirstIndentRem(level: number): number;
+    /** Flat variant: drop the chevron slot for a leaf-only level so values sit under their header. */
+    showTreeLead(row: any): boolean;
+    /** Left inset (rem) of a nested card at a given depth, matching the td padding. */
+    private treeCardLeftRem;
+    private _railCache;
+    /** Vertical guide lines redrawing each ancestor card's left edge at this row's
+     *  position, so a card's left border stays continuous where a nested card is
+     *  inserted between its rows. Returns a stack of 1px background gradients, or null
+     *  when there is no ancestor to redraw (roots and the first nested level). */
+    treeAncestorRails(level: number): string | null;
+    private computeAncestorRails;
+    gridTemplate(level: number): string;
+    private hasChildren;
+    /** A row can be expanded unless it is a leaf, has no loaded children, and has no
+     *  loader left to try. */
+    canExpand(row: any): boolean;
+    toggleNode(row: any): void;
+    private onChildrenLoaded;
+    /** Flatten the tree into the ordered render list, tagging each row with its depth.
+     *  Outside tree mode the render list is `rowData` as-is. */
+    private rebuildFlatRows;
+    onHeaderSort(event: {
+        colId: string;
+        dir: ListSortDir;
+    }): void;
+    showColumn(event: {
+        column: any;
+        visible: boolean;
+    }): void;
+    onReorder(event: CdkDragDrop<ListColumn[]>): void;
+    resetTableColumns(): void;
+    /** Count of columns the user has hidden beyond the defaults (drives the badge).
+     *  Columns hidden by default don't count, so a fresh/default load shows no badge. */
+    get hiddenColumnCount(): number;
+    /** True when visibility, order, and width all match the originally declared
+     *  columns. Width is included so resizing a column alone still enables the
+     *  reset button; a column with no declared width uses null on both sides so
+     *  it only counts as changed once the user drags it to a concrete width. */
+    get columnsAtDefault(): boolean;
+    /** True when every nested level's columns match their declared order/visibility/width. */
+    private get childColumnsAtDefault();
+    /** True when the column is hidden in the originally declared defaults. */
+    isDefaultHidden(col: ListColumn): boolean;
+    toggleColumnChooser(event: MouseEvent): void;
+    closeColumnChooser(): void;
+    private _chooserDragged;
+    onChooserDragStarted(): void;
+    onChooserDragEnded(): void;
+    /** Toggle a column's visibility. `level` undefined targets the top-level columns;
+     *  a number targets that nested depth's columns. */
+    toggleColumnVisible(col: ListColumn, level?: number): void;
+    /** True when this is the only visible column at its level, so its toggle is disabled
+     *  to keep at least one column on screen. */
+    isLastVisibleColumn(col: ListColumn, level?: number): boolean;
+    /** Columns shown in the top-level Columns menu. */
+    get chooserColumns(): ListColumn[];
+    /** Reorder columns from a chooser drag. `level` undefined targets the top-level
+     *  columns; a number targets that nested depth's columns. */
+    chooserReorder(event: CdkDragDrop<ListColumn[]>, level?: number): void;
+    /** Refresh and persist after a column visibility/order change, routing to the
+     *  top-level or nested-level persistence as appropriate. */
+    private afterColumnChange;
+    private nestedChooserOpen;
+    isNestedGroupOpen(id: string): boolean;
+    toggleNestedGroup(id: string): void;
+    startResize(col: ListColumn, event: PointerEvent): void;
+    /** Resize a nested row's column. Measures the sub-header cell's current rendered
+     *  width so a flexible (1fr) column converts to a concrete width before dragging;
+     *  the grid reflows live because its template reads each column's width. */
+    startChildResize(col: ListColumn, level: number, event: PointerEvent): void;
+    private handleResizeMove;
+    /** fitColumns: pick the sink column and the range the drag may travel, so the column and the sink
+     *  trade width while every other column stays fixed. No-op (plain resize) when fitColumns is off. */
+    private setupFitCompensation;
+    /** The column that absorbs a resize: a flexible column first (it is meant to take up slack), else
+     *  the nearest resizable column that is not the tree column, so indentation never shifts. */
+    private pickSink;
+    private measuredHeaderWidth;
+    private measuredCellWidth;
+    private handleResizeEnd;
+    private detachResizeListeners;
+    openActionMenu: (event: MouseEvent, item: any) => void;
+    closeActionMenu: () => void;
+    openHeaderActionMenu(event: MouseEvent): void;
+    hideMenuItem(menuItem: any, selectedItem: any): boolean;
+    closeHeaderActionMenu: () => void;
+    /** Restore-default (rotate) icon for the built-in header action. */
+    private readonly RESET_TABLE_ICON;
+    /** Header action menu rows: the reset action followed by host-provided header actions.
+     *  A host action's `icon` (SVG markup) is rendered before its label, like the row menu. */
+    get headerMenuItems(): ListMenuItem[];
+    onHeaderMenuClick(evt: {
+        item: ListMenuItem;
+        event: MouseEvent;
+    }): void;
+    /** Row action menu rows, built from `menuItems` against the currently selected row.
+     *  A menu item's `icon` (SVG markup) is rendered before its label in the menu. */
+    get rowMenuItems(): ListMenuItem[];
+    onRowMenuClick(evt: {
+        item: ListMenuItem;
+        event: MouseEvent;
+    }): void;
+    openCreate(): void;
+    /** Clear the search box and every active filter, which drives the host to refetch
+     *  unfiltered (used by the "no results" empty state's Clear filters action). */
+    clearTableFilters(): void;
+    onSearchInput(): void;
+    private applySearch;
+    nextPage(): void;
+    prevPage(): void;
+    get cursorPager(): boolean;
+    get nextDisabled(): boolean;
+    get prevDisabled(): boolean;
+    pageSizeOptions: number[];
+    /** Default rows-per-page when nothing is remembered (the persisted choice wins). */
+    initialPageSize: number;
+    /** Auto-refresh interval in seconds a page starts the table at (0 = off). This is the
+     *  hook for a page to default the control on; left at 0, the table behaves as before
+     *  (off until the user picks an interval). The user's in-session choice is not persisted. */
+    autoRefreshSeconds: number;
+    get pageSize(): number;
+    get currentPageNum(): number;
+    get totalPages(): number;
+    /** Page numbers to render, with `0` marking a gap ("..."). Shows the first and
+     *  last page plus a window around the current page so long lists stay compact. */
+    get pageWindow(): number[];
+    goToPage(page: number): void;
+    onPageSizeChange(size: number): void;
+    /** Re-fetch the current page (re-emits the page so the host reloads its data). */
+    refresh(): void;
+    private iconCache;
+    private safeIcon;
+    private updateEntityTypeLabel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListTableComponent, "lib-list-table", never, { "tableId": { "alias": "tableId"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "rowData": { "alias": "rowData"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "skeletonRowCount": { "alias": "skeletonRowCount"; "required": false; }; "options": { "alias": "options"; "required": false; }; "loadChildren": { "alias": "loadChildren"; "required": false; }; "childColumnsByLevel": { "alias": "childColumnsByLevel"; "required": false; }; "hasNext": { "alias": "hasNext"; "required": false; }; "hasPrev": { "alias": "hasPrev"; "required": false; }; "startCount": { "alias": "startCount"; "required": false; }; "endCount": { "alias": "endCount"; "required": false; }; "totalCount": { "alias": "totalCount"; "required": false; }; "filterApplied": { "alias": "filterApplied"; "required": false; }; "menuItems": { "alias": "menuItems"; "required": false; }; "headerActions": { "alias": "headerActions"; "required": false; }; "noItemsImage": { "alias": "noItemsImage"; "required": false; }; "showNoItemsAdd": { "alias": "showNoItemsAdd"; "required": false; }; "noItemsReadonly": { "alias": "noItemsReadonly"; "required": false; }; "createLabel": { "alias": "createLabel"; "required": false; }; "emptyScope": { "alias": "emptyScope"; "required": false; }; "accessDenied": { "alias": "accessDenied"; "required": false; }; "entityTypeName": { "alias": "entityTypeName"; "required": false; }; "filterName": { "alias": "filterName"; "required": false; }; "filterColumn": { "alias": "filterColumn"; "required": false; }; "treeVariant": { "alias": "treeVariant"; "required": false; }; "showTreeVariantToggle": { "alias": "showTreeVariantToggle"; "required": false; }; "treeRail": { "alias": "treeRail"; "required": false; }; "initialPageSize": { "alias": "initialPageSize"; "required": false; }; "autoRefreshSeconds": { "alias": "autoRefreshSeconds"; "required": false; }; }, { "nodeToggled": "nodeToggled"; "actionRequested": "actionRequested"; "tableReady": "tableReady"; "selectionChanged": "selectionChanged"; "rowHover": "rowHover"; }, never, ["[toolbar-filters]", "[empty-state]"], true, never>;
+}
+
+/**
+ * Row selection toggle for {@link ListTableComponent}. Router / exclusive /
+ * reserved / system rows cannot be toggled.
+ */
+declare class SelectCellComponent {
+    item: any;
+    disableToggle: boolean;
+    set row(v: any);
+    /** Host callback invoked with the row when a selectable row is toggled. */
+    toggleItem: ((item: any) => void) | undefined;
+    toggle(item: any): void;
+    get tooltip(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectCellComponent, "lib-select-cell", never, { "row": { "alias": "row"; "required": false; }; "toggleItem": { "alias": "toggleItem"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Header cell for {@link ListTableComponent}: label and 3-state sort (asc/desc). */
+declare class ListHeaderCellComponent {
+    column: ListColumn;
+    sortDir: ListSortDir;
+    sortChanged: EventEmitter<{
+        colId: string;
+        dir: ListSortDir;
+    }>;
+    get enableSorting(): boolean;
+    sort(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListHeaderCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListHeaderCellComponent, "lib-list-header-cell", never, { "column": { "alias": "column"; "required": false; }; "sortDir": { "alias": "sortDir"; "required": false; }; }, { "sortChanged": "sortChanged"; }, never, never, true, never>;
+}
+
+type FilterMode = 'text' | 'single' | 'multi' | 'daterange';
+interface FilterOption {
+    label: string;
+    value: any;
+    /** Optional class(es) to render the option as a colored chip/badge (e.g. Type). */
+    chipClass?: string;
+}
+/**
+ * A single control in the table's filter row. Renders the right widget for the
+ * column's `filterType` (text input / single-select / multi-select / date-range)
+ * and pushes changes through {@link DataTableFilterService}, whose value contract the
+ * controller query-builder already understands (icontains / = / anyOf() / datetime range).
+ */
+declare class ListFilterCellComponent implements OnInit, OnDestroy {
+    private filterService;
+    private listSvc;
+    column: ListColumn;
+    mode: FilterMode;
+    options: FilterOption[];
+    textValue: string;
+    selectedValue: any;
+    selectedValues: string[];
+    /** In-dropdown search text for the multi-select attribute combo. */
+    attrSearch: string;
+    /** Match any selected attribute (or) vs every one (and); attribute filters only. */
+    attrSemantic: 'AnyOf' | 'AllOf';
+    open: boolean;
+    menuLeft: number;
+    menuTop: number;
+    menuWidth: number;
+    trigger?: ElementRef<HTMLElement>;
+    rangePicker?: MatDateRangePicker<Date>;
+    dateRangeStart: Date | null;
+    dateRangeEnd: Date | null;
+    private sub;
+    private textDebounced;
+    constructor(filterService: DataTableFilterService, listSvc: ListTableService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get field(): string;
+    get placeholder(): string;
+    /** True only for the Ziti role-attribute flavor of multi-select (adds #/@ prefixing). */
+    get isAttributeMode(): boolean;
+    private resolveMode;
+    private resolveOptions;
+    private labelForValue;
+    /** Short display of the current selection, shown after the field label when set. */
+    get valueLabel(): string;
+    get hasValue(): boolean;
+    isOptionSelected(opt: FilterOption): boolean;
+    /** Attribute options filtered by the in-dropdown search box (multi mode). */
+    get filteredOptions(): FilterOption[];
+    /** A named attribute (rendered with @ + secondary color) vs a role attribute (# + primary). */
+    isNamedOption(opt: FilterOption): boolean;
+    /** Option label. The attribute flavor prefixes # (role) / keeps @ (named); others render plain. */
+    optionLabel(opt: FilterOption): string;
+    toggleMenu(event: MouseEvent): void;
+    closeMenu(): void;
+    onTextInput(): void;
+    private emitText;
+    selectOption(opt: FilterOption): void;
+    toggleOption(opt: FilterOption): void;
+    private emitMulti;
+    setSemantic(semantic: 'AnyOf' | 'AllOf'): void;
+    selectDatePreset(opt: FilterOption): void;
+    openCustomRange(event: MouseEvent): void;
+    onRangeStartChanged(date: Date | null): void;
+    onRangeEndChanged(date: Date | null): void;
+    private emitCustomRange;
+    clear(event: MouseEvent): void;
+    private removeThis;
+    private syncFromFilters;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListFilterCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListFilterCellComponent, "lib-list-filter-cell", never, { "column": { "alias": "column"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface RefreshInterval {
+    label: string;
+    seconds: number;
+}
+/** Auto-refresh control: a pill + interval menu. Owns the timer and emits `refresh` each tick. */
+declare class ListTableAutoRefreshComponent implements OnDestroy {
+    /** Current interval in seconds; 0 means off. */
+    set seconds(value: number);
+    get seconds(): number;
+    private _seconds;
+    /** Skip a tick while a refresh is already in flight. */
+    loading: boolean;
+    intervals: RefreshInterval[];
+    refresh: EventEmitter<void>;
+    secondsChange: EventEmitter<number>;
+    open: boolean;
+    /** Menu geometry, all measured when the menu opens: left offset so labels line up
+     *  under the button's value, width so the right edge lands on the button's right
+     *  edge, and right padding so the check centers under the chevron. */
+    menuLeft: number;
+    menuWidth: number;
+    menuPadRight: number;
+    private timer?;
+    arEl?: ElementRef<HTMLElement>;
+    valueEl?: ElementRef<HTMLElement>;
+    chevronEl?: ElementRef<HTMLElement>;
+    get enabled(): boolean;
+    get valueLabel(): string;
+    toggleMenu(event: MouseEvent): void;
+    /** Position + size the menu so its labels sit directly under the button's value,
+     *  its right edge lands on the button's right edge (one shared border), and the
+     *  right-aligned check centers under the chevron. */
+    private alignMenuToValue;
+    closeMenu(): void;
+    isSelected(seconds: number): boolean;
+    select(seconds: number): void;
+    private restartTimer;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListTableAutoRefreshComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListTableAutoRefreshComponent, "lib-list-table-auto-refresh", never, { "seconds": { "alias": "seconds"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "intervals": { "alias": "intervals"; "required": false; }; }, { "refresh": "refresh"; "secondsChange": "secondsChange"; }, never, never, true, never>;
+}
+
+/** Which situation the table is in when it has nothing to show. */
+type EmptyVariant = 'empty' | 'no-results' | 'access-denied' | 'error';
+/** Line glyph drawn in the empty-state figure. */
+type EmptyGlyph = 'generic' | 'service' | 'identity' | 'router' | 'policy' | 'search' | 'lock' | 'alert';
+/**
+ * Modern, themeable placeholder shown inside {@link ListTableComponent} when a list has
+ * no rows. Four variants (first-use empty, no search results, access denied, load error),
+ * per-entity default copy keyed by tableId, and a `[empty-state]` projection slot for a
+ * fully custom placeholder. All copy/glyph/actions can be overridden per table.
+ */
+declare class ListEmptyComponent {
+    variant: EmptyVariant;
+    /** tableId used to look up the default copy (e.g. 'services', 'identities'). */
+    entityKey: string;
+    /** Human label used to derive a noun when the key has no tailored copy. */
+    entityLabel: string;
+    /** What this list belongs to, e.g. 'network'. Set: "This network has no services";
+     *  blank: "There are no services", for lists not tied to a network. */
+    scope: string;
+    /** Overrides for the generated content; unset falls back to the per-entity defaults. */
+    title?: string;
+    message?: string;
+    icon?: EmptyGlyph;
+    /** Label for the primary create action (first-use empty only). */
+    createLabel: string;
+    /** Whether the create action is offered (false hides it, e.g. read-only tables). */
+    hasAdd: boolean;
+    readonly: boolean;
+    /** Draw the soft card. On for the full-page state; off inside the table, so a card isn't nested in the grid. */
+    framed: boolean;
+    create: EventEmitter<void>;
+    clearFilters: EventEmitter<void>;
+    retry: EventEmitter<void>;
+    private static readonly COPY;
+    private get copy();
+    get glyph(): EmptyGlyph;
+    /** Tone drives the glyph colour away from the create-accent for non-create variants. */
+    get tone(): '' | 'warn' | 'danger';
+    private get noun();
+    get resolvedTitle(): string;
+    get resolvedMessage(): string;
+    /** The primary create action shows only on the first-use empty state when allowed. */
+    get showCreate(): boolean;
+    get primaryLabel(): string;
+    onCreate(): void;
+    onClear(): void;
+    onRetry(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListEmptyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListEmptyComponent, "lib-list-empty", never, { "variant": { "alias": "variant"; "required": false; }; "entityKey": { "alias": "entityKey"; "required": false; }; "entityLabel": { "alias": "entityLabel"; "required": false; }; "scope": { "alias": "scope"; "required": false; }; "title": { "alias": "title"; "required": false; }; "message": { "alias": "message"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "createLabel": { "alias": "createLabel"; "required": false; }; "hasAdd": { "alias": "hasAdd"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "framed": { "alias": "framed"; "required": false; }; }, { "create": "create"; "clearFilters": "clearFilters"; "retry": "retry"; }, never, ["[empty-state]"], true, never>;
+}
+
+declare class NoItemsComponent implements OnChanges {
+    image: string;
+    typeName: string;
+    isEmpty: boolean;
+    hasAdd: boolean;
+    hiddenResults: boolean;
+    isLoading: boolean;
+    readonly: boolean;
+    accessDenied: boolean;
+    background: any;
+    clickEmit: EventEmitter<any>;
+    refresh: EventEmitter<any>;
+    constructor();
+    ngOnChanges(): void;
+    iconClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoItemsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NoItemsComponent, "lib-no-items", never, { "image": { "alias": "image"; "required": false; }; "typeName": { "alias": "typeName"; "required": false; }; "isEmpty": { "alias": "isEmpty"; "required": false; }; "hasAdd": { "alias": "hasAdd"; "required": false; }; "hiddenResults": { "alias": "hiddenResults"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "accessDenied": { "alias": "accessDenied"; "required": false; }; }, { "clickEmit": "clickEmit"; "refresh": "refresh"; }, never, never, true, never>;
+}
+
+export { ClickOutsideDirective, DataTableFilterService, ListEmptyComponent, ListFilterCellComponent, ListHeaderCellComponent, ListMenuComponent, ListTableAutoRefreshComponent, ListTableComponent, ListTableService, NoItemsComponent, SelectCellComponent };
+export type { EmptyGlyph, EmptyVariant, FilterObj, ListCell, ListCellContext, ListColumn, ListLegacyCellShim, ListMenuItem, ListSortDir, ListTableOptions, ListTableToolbarOptions, RefreshInterval, ToolbarControlOptions, TreeVariant };
+//# sourceMappingURL=index.d.ts.map