@akcelik/strct 1.6.0 → 1.11.0

package/types/akcelik-strct.d.ts

@@ -1,6 +1,6 @@
 import * as _angular_core from '@angular/core';
-import { OnDestroy, TemplateRef } from '@angular/core';
-import { SafeHtml } from '@angular/platform-browser';
+import { OnDestroy, TemplateRef, PipeTransform } from '@angular/core';
+import { SafeHtml, SafeStyle } from '@angular/platform-browser';
 import { ControlValueAccessor } from '@angular/forms';
 import * as _akcelik_strct from '@akcelik/strct';
 
@@ -198,6 +198,7 @@ declare const STRCT_ICON_DEFS: {
     megaphone: string;
     flag: string;
     shieldAlert: string;
+    rocket: string;
     shieldCheck: string;
     running: string;
     stopped: string;
@@ -1212,6 +1213,7 @@ declare class StrctDropdown {
     /** Accessible name of the popover dialog (localizable). */
     readonly popoverLabel: _angular_core.InputSignal<string>;
     readonly open: _angular_core.WritableSignal<boolean>;
+    constructor();
     toggle(): void;
     close(): void;
     /** Menu items close on activation; popover form controls never do. */
@@ -1221,6 +1223,16 @@ declare class StrctDropdown {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDropdown, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDropdown, "strct-dropdown", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; "popover": { "alias": "popover"; "required": false; "isSignal": true; }; "popoverLabel": { "alias": "popoverLabel"; "required": false; "isSignal": true; }; }, {}, never, ["[strctDropdownTrigger]", "*"], true, never>;
 }
+/**
+ * Marks (and upgrades) the dropdown's trigger element. The attribute alone is
+ * enough for content projection; importing the directive additionally wires
+ * `aria-haspopup` / `aria-expanded` onto the real button.
+ */
+declare class StrctDropdownTrigger {
+    protected readonly dd: StrctDropdown | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDropdownTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrctDropdownTrigger, "[strctDropdownTrigger]", never, {}, {}, never, never, true, never>;
+}
 /** A selectable row inside a `<strct-dropdown>`. */
 declare class StrctDropdownItem {
     /** Danger. */
@@ -2472,6 +2484,12 @@ interface StrctDatagridLabels {
     chooseColumns: string;
     refresh: string;
     actions: string;
+    filterColumn: string;
+    filterPlaceholder: string;
+    clearFilter: string;
+    editCell: string;
+    toggleChildren: string;
+    quickFilter: string;
 }
 /** Resolves a stable identity for a row: a property key, or a function. */
 type StrctRowId = string | ((row: StrctRow) => unknown);
@@ -2491,7 +2509,19 @@ interface StrctDatagridColumn {
      * except the last an explicit px `width` so offsets stay exact.
      */
     sticky?: boolean;
+    /** Header filter popover: contains-text by default; see `filterOptions`. */
+    filterable?: boolean;
+    /** Distinct values for a checkbox set-filter (implies `filterable`). */
+    filterOptions?: unknown[];
+    /**
+     * Inline cell editing: double-click opens an input; Enter / blur commit via
+     * `(cellEdit)`, Escape cancels. The grid never mutates rows — apply the
+     * change in your handler and pass the updated array back in.
+     */
+    editable?: boolean;
 }
+/** Per-column filter state: contains-text, or the checked value set. */
+type StrctDatagridFilters = Record<string, string | unknown[]>;
 type SortDir = 'asc' | 'desc';
 /** What the grid wants loaded in server-side (`lazy`) mode. */
 interface StrctDatagridLazyState {
@@ -2500,6 +2530,10 @@ interface StrctDatagridLazyState {
     pageSize: number;
     sortKey: string | null;
     sortDir: SortDir;
+    /** Active per-column filters (empty object when none). */
+    filters: StrctDatagridFilters;
+    /** The global quick-filter term ('' when none). */
+    quickFilter: string;
 }
 /** Persistable user column preferences (widths from resize, hidden from the
  *  chooser, order from drag-reorder). */
@@ -2608,6 +2642,12 @@ declare class StrctDatagrid {
         chooseColumns: string;
         refresh: string;
         actions: string;
+        filterColumn: string;
+        filterPlaceholder: string;
+        clearFilter: string;
+        editCell: string;
+        toggleChildren: string;
+        quickFilter: string;
     }>;
     /**
      * Virtual scrolling for large data sets: only the rows inside the viewport
@@ -2645,6 +2685,30 @@ declare class StrctDatagrid {
      * groups. Paging is bypassed while grouped; not combinable with `virtual`.
      */
     readonly groupBy: _angular_core.InputSignal<string | null>;
+    /**
+     * Two-way per-column filter state: `key → contains-text` (text filter) or
+     * `key → unknown[]` (checked value set). Applied client-side; in `lazy`
+     * mode it is passed through on `lazyLoad` instead.
+     */
+    readonly filters: _angular_core.ModelSignal<StrctDatagridFilters>;
+    /**
+     * Global quick filter (two-way): one term substring-matched (OR) across
+     * `quickFilterFields` — the console-standard "filter this list fast" box.
+     * Complementary to the per-column `filters` (which AND). Applied before
+     * paging client-side; passed through on `lazyLoad` in server mode.
+     */
+    readonly quickFilter: _angular_core.ModelSignal<string>;
+    /** Columns the quick term scans. Defaults to every column's `key`. */
+    readonly quickFilterFields: _angular_core.InputSignal<string[] | null>;
+    /** Render the built-in quick-filter searchbox in the toolbar. */
+    readonly quickFilterable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Tree-grid: the row property holding a row's children array. Rows render
+     * hierarchically with indent + carets; sorting applies per sibling level;
+     * an active filter shows matches with their ancestors, force-expanded.
+     * Not combinable with `groupBy` or `lazy`.
+     */
+    readonly childrenKey: _angular_core.InputSignal<string | null>;
     /** Emitted when the selection changes. */
     readonly selectionChange: _angular_core.OutputEmitterRef<StrctRow[]>;
     /** Emitted when the refresh button is clicked. */
@@ -2656,6 +2720,14 @@ declare class StrctDatagrid {
     }>;
     /** Server-side data request (lazy mode): load this page / sort and set `rows`. */
     readonly lazyLoad: _angular_core.OutputEmitterRef<StrctDatagridLazyState>;
+    /** An editable cell was committed (Enter / blur). The grid does not mutate
+     *  rows — apply `value` to your data and pass the updated array back in. */
+    readonly cellEdit: _angular_core.OutputEmitterRef<{
+        row: StrctRow;
+        column: StrctDatagridColumn;
+        value: string;
+        previous: unknown;
+    }>;
     private readonly menu;
     protected readonly detailDef: _angular_core.Signal<StrctRowDetailDef | undefined>;
     protected readonly actionBarDef: _angular_core.Signal<StrctDatagridActionBar | undefined>;
@@ -2702,6 +2774,42 @@ declare class StrctDatagrid {
     /** What tbody renders: plain (virtual/paged) rows, or groups + their rows. */
     protected readonly displayItems: _angular_core.Signal<DgItem[]>;
     protected itemKey(it: DgItem): unknown;
+    protected readonly filterOpenKey: _angular_core.WritableSignal<string | null>;
+    protected toggleFilterPanel(key: string, event: Event): void;
+    protected hasFilter(key: string): boolean;
+    protected textFilter(key: string): string;
+    protected setTextFilter(key: string, value: string): void;
+    protected optionChecked(key: string, opt: unknown): boolean;
+    protected toggleFilterOption(key: string, opt: unknown): void;
+    protected clearFilter(key: string): void;
+    protected onDocClickFilter(event: MouseEvent): void;
+    protected onEscapeFilter(): void;
+    private readonly expandedTree;
+    protected treeDepth(row: StrctRow): number;
+    protected treeHasChildren(row: StrctRow): boolean;
+    protected treeExpanded(row: StrctRow): boolean;
+    /** Expand / collapse one tree row. */
+    toggleTreeRow(row: StrctRow): void;
+    private readonly hostRef;
+    protected readonly editing: _angular_core.WritableSignal<{
+        rowKey: unknown;
+        colKey: string;
+    } | null>;
+    protected isEditingCell(row: StrctRow, col: StrctDatagridColumn): boolean;
+    protected startEdit(row: StrctRow, col: StrctDatagridColumn): void;
+    protected commitEdit(row: StrctRow, col: StrctDatagridColumn, event: Event): void;
+    protected cancelEdit(event?: Event): void;
+    /** Active (non-empty) filter entries. */
+    private readonly activeFilters;
+    private readonly quickTerm;
+    private matchesQuick;
+    private matchesFilters;
+    /** Rows surviving the quick + per-column filters (client-side modes only). */
+    private readonly filteredRows;
+    /** "12 / 480" — shown while any client-side filtering narrows the set. */
+    protected readonly filterNote: _angular_core.Signal<string | null>;
+    /** Tree mode: flattened visible rows + per-row depth/children/expanded meta. */
+    private readonly treeFlat;
     protected readonly sorted: _angular_core.Signal<StrctRow[]>;
     protected readonly paged: _angular_core.Signal<StrctRow[]>;
     /** Full count for the pager / footer (server total in lazy mode). */
@@ -2778,7 +2886,7 @@ declare class StrctDatagrid {
     private commitSelection;
     private compare;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDatagrid, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDatagrid, "strct-datagrid", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rows": { "alias": "rows"; "required": true; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "detailPane": { "alias": "detailPane"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "singleLine": { "alias": "singleLine"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "columnChooser": { "alias": "columnChooser"; "required": false; "isSignal": true; }; "sync": { "alias": "sync"; "required": false; "isSignal": true; }; "footerActionsDisabled": { "alias": "footerActionsDisabled"; "required": false; "isSignal": true; }; "rowId": { "alias": "rowId"; "required": false; "isSignal": true; }; "rowActions": { "alias": "rowActions"; "required": false; "isSignal": true; }; "initialSelection": { "alias": "initialSelection"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "virtual": { "alias": "virtual"; "required": false; "isSignal": true; }; "viewportHeight": { "alias": "viewportHeight"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "lazy": { "alias": "lazy"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "stateKey": { "alias": "stateKey"; "required": false; "isSignal": true; }; "columnState": { "alias": "columnState"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "groupBy": { "alias": "groupBy"; "required": false; "isSignal": true; }; }, { "columnState": "columnStateChange"; "selectionChange": "selectionChange"; "syncChange": "syncChange"; "rowAction": "rowAction"; "lazyLoad": "lazyLoad"; }, ["detailDef", "actionBarDef", "cellDefs"], ["[strctDatagridActionBar]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDatagrid, "strct-datagrid", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rows": { "alias": "rows"; "required": true; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "detailPane": { "alias": "detailPane"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "singleLine": { "alias": "singleLine"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "columnChooser": { "alias": "columnChooser"; "required": false; "isSignal": true; }; "sync": { "alias": "sync"; "required": false; "isSignal": true; }; "footerActionsDisabled": { "alias": "footerActionsDisabled"; "required": false; "isSignal": true; }; "rowId": { "alias": "rowId"; "required": false; "isSignal": true; }; "rowActions": { "alias": "rowActions"; "required": false; "isSignal": true; }; "initialSelection": { "alias": "initialSelection"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "virtual": { "alias": "virtual"; "required": false; "isSignal": true; }; "viewportHeight": { "alias": "viewportHeight"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "lazy": { "alias": "lazy"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "stateKey": { "alias": "stateKey"; "required": false; "isSignal": true; }; "columnState": { "alias": "columnState"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "groupBy": { "alias": "groupBy"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "quickFilter": { "alias": "quickFilter"; "required": false; "isSignal": true; }; "quickFilterFields": { "alias": "quickFilterFields"; "required": false; "isSignal": true; }; "quickFilterable": { "alias": "quickFilterable"; "required": false; "isSignal": true; }; "childrenKey": { "alias": "childrenKey"; "required": false; "isSignal": true; }; }, { "columnState": "columnStateChange"; "filters": "filtersChange"; "quickFilter": "quickFilterChange"; "selectionChange": "selectionChange"; "syncChange": "syncChange"; "rowAction": "rowAction"; "lazyLoad": "lazyLoad"; "cellEdit": "cellEdit"; }, ["detailDef", "actionBarDef", "cellDefs"], ["[strctDatagridActionBar]"], true, never>;
 }
 
 /** Timeline node state colors. */
@@ -3565,5 +3673,628 @@ declare class StrctEmptyState {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctEmptyState, "strct-empty-state", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": true; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
-export { STRCT_ICONS, STRCT_ICON_GROUPS, STRCT_ICON_NAMES, STRCT_MASKS, STRCT_PALETTES, STRCT_RAW_ICONS, StrctAccordion, StrctAccordionPanel, StrctAlert, StrctAvatar, StrctBadge, StrctBreadcrumb, StrctBreadcrumbItem, StrctButton, StrctButtonGroup, StrctCard, StrctCardBlock, StrctCardFooter, StrctCardHeader, StrctCascadeHost, StrctCascadeNode, StrctCascadeSelect, StrctCellDef, StrctCellStatus, StrctChart, StrctCheckbox, StrctChips, StrctCode, StrctColorPicker, StrctCombobox, StrctCommandPalette, StrctContextMenu, StrctContextMenuTrigger, StrctCopy, StrctDatagrid, StrctDatagridActionBar, StrctDatepicker, StrctDesc, StrctDescriptionList, StrctDivider, StrctDonut, StrctDrawer, StrctDrawerFooter, StrctDropdown, StrctDropdownDivider, StrctDropdownItem, StrctEmptyState, StrctField, StrctFile, StrctFilterBar, StrctFlow, StrctFooter, StrctGauge, StrctHeader, StrctHero, StrctIcon, StrctInput, StrctInputMask, StrctInputOtp, StrctKbd, StrctKnob, StrctLogin, StrctMenuPanel, StrctMenuService, StrctMetricTile, StrctModal, StrctNav, StrctNavItem, StrctOverlay, StrctPageHeader, StrctPageHeaderActions, StrctPageHeaderCrumbs, StrctPagination, StrctPassword, StrctProgress, StrctRadio, StrctRadioGroup, StrctRail, StrctRange, StrctRating, StrctRowDetailDef, StrctSearchbox, StrctSectionMenu, StrctSegmented, StrctShell, StrctShellService, StrctSignpost, StrctSkeleton, StrctSparkline, StrctSpeedDial, StrctSpinner, StrctStack, StrctStackItem, StrctStep, StrctSubmenu, StrctTab, StrctTable, StrctTabs, StrctTag, StrctThemeService, StrctThemeSwitcher, StrctTimeline, StrctTimelineItem, StrctToastOutlet, StrctToastService, StrctToggle, StrctTooltip, StrctTree, StrctTreeNode, StrctVerticalNav, StrctWizard, registerStrctIcon, strctValidationIcon, strctValidationTone };
-export type { StrctAlertType, StrctAvatarSize, StrctAvatarStatus, StrctBadgeStatus, StrctButtonSize, StrctButtonVariant, StrctCascadeOption, StrctCellContext, StrctChartAnnotation, StrctChartColor, StrctChartCurve, StrctChartSeries, StrctChartSlot, StrctChartStatus, StrctChartThreshold, StrctChartType, StrctColumn, StrctCommandItem, StrctDatagridColumn, StrctDatagridColumnState, StrctDatagridLabels, StrctDatagridLazyState, StrctDescAlign, StrctDescItem, StrctDonutSegment, StrctDrawerSide, StrctDrawerSize, StrctEmptyVariant, StrctFilterChip, StrctFlowDirection, StrctFlowNode, StrctFlowOrientation, StrctIconBadge, StrctIconName, StrctKnobStatus, StrctMenuItem, StrctMenuLink, StrctMenuOpenOptions, StrctMenuSection, StrctMetricStatus, StrctModalSize, StrctMode, StrctOption, StrctOverlayPlacement, StrctPalette, StrctPaletteInfo, StrctProgressStatus, StrctRailItem, StrctRailStatus, StrctRow, StrctRowId, StrctSegmentedOption, StrctSegmentedSize, StrctSignpostPosition, StrctSpeedDialDirection, StrctSpinnerSize, StrctStatus, StrctTagStatus, StrctThresholds, StrctTimelineState, StrctToast, StrctToastOptions, StrctToastType, StrctTooltipPosition, StrctTreeMenuEvent, StrctTreeNodeData, StrctTreeNodeMenuFn, StrctValidationState, StrctValidationStatus };
+/**
+ * Format a byte count. Binary (KiB, 1024) by default — the storage/memory
+ * convention consoles actually mean; pass `binary: false` for decimal (kB).
+ */
+declare function strctFormatBytes(bytes: number, options?: {
+    binary?: boolean;
+    digits?: number;
+}): string;
+/**
+ * Format a data rate from bits per second (network convention). Pass bytes/s
+ * through `strctFormatBytes(...) + '/s'` instead if you mean throughput.
+ */
+declare function strctFormatRate(bitsPerSecond: number, options?: {
+    digits?: number;
+}): string;
+/**
+ * Format a duration in ms as the two most significant units: "2h 14m",
+ * "3d 6h", "45s", "820ms". Sub-second stays in ms; `maxUnits` widens it.
+ */
+declare function strctFormatDuration(ms: number, options?: {
+    maxUnits?: number;
+}): string;
+/** Format a count with SI magnitude suffixes: 12400 → "12.4k". */
+declare function strctFormatSi(value: number, options?: {
+    digits?: number;
+    unit?: string;
+}): string;
+/** `{{ bytes | strctBytes }}` / `{{ bytes | strctBytes : false }}` (decimal). */
+declare class StrctBytesPipe implements PipeTransform {
+    transform(value: number, binary?: boolean, digits?: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctBytesPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<StrctBytesPipe, "strctBytes", true>;
+}
+/** `{{ bps | strctRate }}` — bits per second with kbit/Mbit/Gbit steps. */
+declare class StrctRatePipe implements PipeTransform {
+    transform(value: number, digits?: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctRatePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<StrctRatePipe, "strctRate", true>;
+}
+/** `{{ ms | strctDuration }}` — "2h 14m"; optional max unit count. */
+declare class StrctDurationPipe implements PipeTransform {
+    transform(value: number, maxUnits?: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDurationPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<StrctDurationPipe, "strctDuration", true>;
+}
+/** `{{ n | strctSi : 'IOPS' }}` — SI magnitude with an optional unit label. */
+declare class StrctSiPipe implements PipeTransform {
+    transform(value: number, unit?: string, digits?: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSiPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<StrctSiPipe, "strctSi", true>;
+}
+
+/** A resolved time window. `presetId` is set when it came from a quick range. */
+interface StrctTimeRange {
+    from: Date;
+    to: Date;
+    presetId?: string;
+}
+/** A "last X" quick range. `ms` is the window length ending at now. */
+interface StrctTimeRangePreset {
+    id: string;
+    label: string;
+    ms: number;
+}
+/** The Grafana-conventional quick ranges consoles expect. */
+declare const STRCT_TIME_RANGE_PRESETS: StrctTimeRangePreset[];
+/**
+ * Monitoring time-range picker — the "Last 1 hour ▾" control charts hang off:
+ * quick relative ranges plus an absolute from/to editor, in one popover.
+ *
+ *   <strct-time-range [(range)]="range" />
+ *
+ * Picking a preset resolves it against "now" immediately and stamps
+ * `presetId`, so a consumer can re-resolve the same preset on its own refresh
+ * tick. The popover reuses `strct-dropdown`'s dialog semantics: inner clicks
+ * keep it open, outside click / Escape dismiss.
+ */
+declare class StrctTimeRangePicker {
+    /** The selected window, two-way. Null until the user (or you) picks one. */
+    readonly range: _angular_core.ModelSignal<StrctTimeRange | null>;
+    /** Quick ranges shown in the left column. */
+    readonly presets: _angular_core.InputSignal<StrctTimeRangePreset[]>;
+    /** Popover alignment, as in strct-dropdown. */
+    readonly align: _angular_core.InputSignal<"end" | "start">;
+    /** Trigger size — match it to the toolbar's buttons (sm strips). */
+    readonly size: _angular_core.InputSignal<"md" | "sm">;
+    /** Localizable strings. */
+    readonly dialogLabel: _angular_core.InputSignal<string>;
+    readonly quickLabel: _angular_core.InputSignal<string>;
+    readonly absoluteLabel: _angular_core.InputSignal<string>;
+    readonly fromLabel: _angular_core.InputSignal<string>;
+    readonly toLabel: _angular_core.InputSignal<string>;
+    readonly applyLabel: _angular_core.InputSignal<string>;
+    readonly invalidLabel: _angular_core.InputSignal<string>;
+    readonly placeholderLabel: _angular_core.InputSignal<string>;
+    /** Fires on every commit (preset pick or absolute apply). */
+    readonly applied: _angular_core.OutputEmitterRef<StrctTimeRange>;
+    protected readonly dd: _angular_core.Signal<StrctDropdown>;
+    protected readonly draftFrom: _angular_core.WritableSignal<string>;
+    protected readonly draftTo: _angular_core.WritableSignal<string>;
+    protected readonly draftError: _angular_core.Signal<boolean>;
+    protected readonly triggerLabel: _angular_core.Signal<string>;
+    protected pickPreset(p: StrctTimeRangePreset): void;
+    protected applyAbsolute(): boolean;
+    /** Re-resolve a preset range against "now" — call from your refresh tick. */
+    refresh(): void;
+    private seedDraft;
+    private toLocal;
+    private formatStamp;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTimeRangePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTimeRangePicker, "strct-time-range", never, { "range": { "alias": "range"; "required": false; "isSignal": true; }; "presets": { "alias": "presets"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "dialogLabel": { "alias": "dialogLabel"; "required": false; "isSignal": true; }; "quickLabel": { "alias": "quickLabel"; "required": false; "isSignal": true; }; "absoluteLabel": { "alias": "absoluteLabel"; "required": false; "isSignal": true; }; "fromLabel": { "alias": "fromLabel"; "required": false; "isSignal": true; }; "toLabel": { "alias": "toLabel"; "required": false; "isSignal": true; }; "applyLabel": { "alias": "applyLabel"; "required": false; "isSignal": true; }; "invalidLabel": { "alias": "invalidLabel"; "required": false; "isSignal": true; }; "placeholderLabel": { "alias": "placeholderLabel"; "required": false; "isSignal": true; }; }, { "range": "rangeChange"; "applied": "applied"; }, never, never, true, never>;
+}
+
+/** A log line: plain text plus an optional severity for tinting. */
+interface StrctLogLine {
+    text: string;
+    level?: 'error' | 'warn' | 'info' | 'debug';
+}
+/** One render segment of a line after ANSI parsing. */
+interface LogSegment {
+    text: string;
+    cls: string;
+}
+interface RenderLine {
+    index: number;
+    level: string;
+    segments: LogSegment[];
+}
+/**
+ * Virtualized log tail — the `kubectl logs -f` surface as a component:
+ *
+ *   <strct-log-viewer [lines]="lines()" [(follow)]="follow" [height]="360" />
+ *
+ * - **Virtualized**: only the visible window plus overscan is in the DOM, so
+ *   100k lines scroll flat.
+ * - **Follow mode** (two-way): sticks to the tail as lines stream in;
+ *   scrolling up pauses it, the button (or scrolling back to the bottom)
+ *   resumes it — the Grafana/Loki convention.
+ * - **ANSI SGR colors** (16-color + bold) parsed into safe spans — no
+ *   innerHTML — and severity tinting from `StrctLogLine.level` or, for plain
+ *   strings, auto-detected ERROR/WARN/INFO/DEBUG tokens.
+ */
+declare class StrctLogViewer {
+    /** Log lines — plain strings or `{ text, level }` objects. */
+    readonly lines: _angular_core.InputSignal<(string | StrctLogLine)[]>;
+    /** Viewport height in px. */
+    readonly height: _angular_core.InputSignal<number>;
+    /** Follow the tail as new lines arrive (two-way; pauses on scroll-up). */
+    readonly follow: _angular_core.ModelSignal<boolean>;
+    /** Soft-wrap long lines instead of horizontal scrolling (two-way). */
+    readonly wrapMode: _angular_core.ModelSignal<boolean>;
+    /** Auto-detect ERROR/WARN/INFO/DEBUG tokens on plain-string lines. */
+    readonly autoLevel: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Localizable strings. */
+    readonly title: _angular_core.InputSignal<string>;
+    readonly followLabel: _angular_core.InputSignal<string>;
+    readonly wrapLabel: _angular_core.InputSignal<string>;
+    readonly linesLabel: _angular_core.InputSignal<string>;
+    readonly emptyLabel: _angular_core.InputSignal<string>;
+    private readonly scroller;
+    private readonly scrollTop;
+    private suppressScrollEvent;
+    private static readonly LINE_H;
+    private static readonly OVERSCAN;
+    protected readonly normalized: _angular_core.Signal<StrctLogLine[]>;
+    protected readonly totalHeight: _angular_core.Signal<number>;
+    private readonly windowStart;
+    protected readonly offsetY: _angular_core.Signal<number>;
+    protected readonly window: _angular_core.Signal<RenderLine[]>;
+    constructor();
+    protected onScroll(): void;
+    protected toggleFollow(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctLogViewer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctLogViewer, "strct-log-viewer", never, { "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "follow": { "alias": "follow"; "required": false; "isSignal": true; }; "wrapMode": { "alias": "wrapMode"; "required": false; "isSignal": true; }; "autoLevel": { "alias": "autoLevel"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "followLabel": { "alias": "followLabel"; "required": false; "isSignal": true; }; "wrapLabel": { "alias": "wrapLabel"; "required": false; "isSignal": true; }; "linesLabel": { "alias": "linesLabel"; "required": false; "isSignal": true; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; "isSignal": true; }; }, { "follow": "followChange"; "wrapMode": "wrapModeChange"; }, never, never, true, never>;
+}
+/** Parse ANSI SGR sequences into class-tagged segments (16-color + bold). */
+declare function parseAnsi(text: string): LogSegment[];
+
+/** One row of a computed line diff. */
+interface StrctDiffRow {
+    type: 'ctx' | 'add' | 'del';
+    oldNo: number | null;
+    newNo: number | null;
+    text: string;
+}
+interface DisplayRow extends StrctDiffRow {
+    kind: 'row';
+}
+interface SkipRow {
+    kind: 'skip';
+    count: number;
+    startIndex: number;
+}
+type AnyRow = DisplayRow | SkipRow;
+/** Split-view pairing: a left (old) and right (new) cell per visual row. */
+interface SplitCell {
+    type: 'ctx' | 'add' | 'del' | 'empty';
+    no: number | null;
+    text: string;
+}
+interface SplitPair {
+    kind: 'row';
+    left: SplitCell;
+    right: SplitCell;
+}
+type AnySplitRow = SplitPair | SkipRow;
+/**
+ * Compute a line diff (LCS-based). Exported for programmatic use — change
+ * counts, gating "anything changed?" logic, custom renderings.
+ */
+declare function strctComputeDiff(before: string, after: string): StrctDiffRow[];
+/**
+ * Config / YAML diff viewer — change-approval screens without a hand-rolled
+ * diff. Unified by default, `split` for side-by-side; long unchanged runs
+ * collapse to an expandable "· N unchanged lines ·" row.
+ *
+ *   <strct-diff [before]="saved" [after]="draft" beforeLabel="Running" afterLabel="Draft" />
+ *
+ * Rows are marked by symbol (+/−) as well as tint, so the diff reads without
+ * color — the same CVD rule the icon badges follow.
+ */
+declare class StrctDiff {
+    /** The two texts to compare. */
+    readonly before: _angular_core.InputSignal<string>;
+    readonly after: _angular_core.InputSignal<string>;
+    /** Unified (default) or side-by-side split view. */
+    readonly mode: _angular_core.InputSignal<"unified" | "split">;
+    /** Context lines kept around changes before collapsing (0 disables collapsing). */
+    readonly context: _angular_core.InputSignal<number>;
+    /** Header bits. */
+    readonly title: _angular_core.InputSignal<string>;
+    readonly language: _angular_core.InputSignal<string>;
+    readonly beforeLabel: _angular_core.InputSignal<string>;
+    readonly afterLabel: _angular_core.InputSignal<string>;
+    readonly copyable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly copyAfterLabel: _angular_core.InputSignal<string>;
+    readonly unchangedLabel: _angular_core.InputSignal<string>;
+    /** Scroll the body past this height (px); null grows freely. */
+    readonly maxHeight: _angular_core.InputSignal<number | null>;
+    private readonly expanded;
+    protected readonly rows: _angular_core.Signal<StrctDiffRow[]>;
+    protected readonly addCount: _angular_core.Signal<number>;
+    protected readonly delCount: _angular_core.Signal<number>;
+    protected readonly unifiedRows: _angular_core.Signal<AnyRow[]>;
+    protected readonly splitRows: _angular_core.Signal<AnySplitRow[]>;
+    /** Group rows into visible chunks and collapsible unchanged runs. */
+    private readonly chunks;
+    protected expand(startIndex: number): void;
+    protected sign(type: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDiff, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDiff, "strct-diff", never, { "before": { "alias": "before"; "required": true; "isSignal": true; }; "after": { "alias": "after"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "language": { "alias": "language"; "required": false; "isSignal": true; }; "beforeLabel": { "alias": "beforeLabel"; "required": false; "isSignal": true; }; "afterLabel": { "alias": "afterLabel"; "required": false; "isSignal": true; }; "copyable": { "alias": "copyable"; "required": false; "isSignal": true; }; "copyAfterLabel": { "alias": "copyAfterLabel"; "required": false; "isSignal": true; }; "unchangedLabel": { "alias": "unchangedLabel"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Two resizable panes with a draggable gutter — master/detail layouts where
+ * the split is the user's to own:
+ *
+ *   <strct-splitter [(split)]="pct" [min]="20" [max]="80">
+ *     <div strctPaneStart>…list…</div>
+ *     <div strctPaneEnd>…detail…</div>
+ *   </strct-splitter>
+ *
+ * `split` is the start pane's share in percent (two-way, persistable).
+ * The gutter is a keyboard separator: arrows nudge, Home/End jump to min/max.
+ */
+declare class StrctSplitter {
+    private readonly host;
+    /** Start pane share in percent (two-way). */
+    readonly split: _angular_core.ModelSignal<number>;
+    /** Clamp bounds for the split (percent). */
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    /** Stack panes vertically (gutter drags up/down). */
+    readonly vertical: _angular_core.InputSignal<boolean>;
+    /** Accessible name of the separator (localizable). */
+    readonly gutterLabel: _angular_core.InputSignal<string>;
+    /** Keyboard nudge step in percent. */
+    readonly step: _angular_core.InputSignal<number>;
+    protected readonly clamped: _angular_core.Signal<number>;
+    protected dragging: boolean;
+    private moveHandler;
+    private upHandler;
+    protected onDragStart(event: MouseEvent): void;
+    private onDragMove;
+    private onDragEnd;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSplitter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSplitter, "strct-splitter", never, { "split": { "alias": "split"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "gutterLabel": { "alias": "gutterLabel"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; }, { "split": "splitChange"; }, never, ["[strctPaneStart]", "[strctPaneEnd]"], true, never>;
+}
+
+/** One transferable item. */
+interface StrctTransferItem {
+    id: string;
+    label: string;
+    icon?: string;
+    disabled?: boolean;
+    data?: unknown;
+}
+/**
+ * Dual-list transfer (picklist) — "assign hosts to the cluster": all items on
+ * the left, the chosen set on the right, checkbox multi-select and move
+ * buttons in between, with a searchbox per side.
+ *
+ *   <strct-transfer [items]="hosts" [(assigned)]="clusterHosts" />
+ *
+ * `assigned` is the two-way id set (string[]); `items` stays the single
+ * source-of-truth list.
+ */
+declare class StrctTransfer {
+    /** The full item universe. */
+    readonly items: _angular_core.InputSignal<StrctTransferItem[]>;
+    /** Assigned item ids (two-way). */
+    readonly assigned: _angular_core.ModelSignal<string[]>;
+    /** Localizable strings. */
+    readonly sourceLabel: _angular_core.InputSignal<string>;
+    readonly targetLabel: _angular_core.InputSignal<string>;
+    readonly searchPlaceholder: _angular_core.InputSignal<string>;
+    readonly emptyLabel: _angular_core.InputSignal<string>;
+    readonly assignLabel: _angular_core.InputSignal<string>;
+    readonly unassignLabel: _angular_core.InputSignal<string>;
+    /** A move happened (either direction) with the moved ids. */
+    readonly moved: _angular_core.OutputEmitterRef<{
+        direction: "assign" | "unassign";
+        ids: string[];
+    }>;
+    protected readonly sourceQuery: _angular_core.WritableSignal<string>;
+    protected readonly targetQuery: _angular_core.WritableSignal<string>;
+    protected readonly sourceChecked: _angular_core.WritableSignal<Set<string>>;
+    protected readonly targetChecked: _angular_core.WritableSignal<Set<string>>;
+    private readonly assignedSet;
+    protected readonly sourceItems: _angular_core.Signal<StrctTransferItem[]>;
+    protected readonly targetItems: _angular_core.Signal<StrctTransferItem[]>;
+    private matches;
+    protected toggle(which: typeof this.sourceChecked | typeof this.targetChecked, id: string): void;
+    protected assign(): void;
+    protected unassign(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTransfer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTransfer, "strct-transfer", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "assigned": { "alias": "assigned"; "required": false; "isSignal": true; }; "sourceLabel": { "alias": "sourceLabel"; "required": false; "isSignal": true; }; "targetLabel": { "alias": "targetLabel"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; "isSignal": true; }; "assignLabel": { "alias": "assignLabel"; "required": false; "isSignal": true; }; "unassignLabel": { "alias": "unassignLabel"; "required": false; "isSignal": true; }; }, { "assigned": "assignedChange"; "moved": "moved"; }, never, never, true, never>;
+}
+
+/**
+ * Split button — a primary action plus a chevron opening its variants
+ * (Fluent's pattern): "Deploy ▾ → Deploy with snapshot / Deploy paused".
+ *
+ *   <strct-split-button label="Deploy" [items]="variants"
+ *                       (action)="deploy()" (picked)="run($event)" />
+ *
+ * The main segment fires `(action)`; menu entries fire `(picked)`.
+ */
+declare class StrctSplitButton {
+    /** Main action label. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Menu entries (StrctMenuItem: id, label, icon?, critical?, disabled?). */
+    readonly items: _angular_core.InputSignal<StrctMenuItem[]>;
+    /** Optional leading icon of the main segment. */
+    readonly icon: _angular_core.InputSignal<string>;
+    /** Filled (solid accent) look. */
+    readonly solid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable both segments. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Accessible name of the chevron (localizable). */
+    readonly menuLabel: _angular_core.InputSignal<string>;
+    /** The main segment was clicked. */
+    readonly action: _angular_core.OutputEmitterRef<void>;
+    /** A menu entry was chosen. */
+    readonly picked: _angular_core.OutputEmitterRef<StrctMenuItem>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSplitButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSplitButton, "strct-split-button", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "solid": { "alias": "solid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "menuLabel": { "alias": "menuLabel"; "required": false; "isSignal": true; }; }, { "action": "action"; "picked": "picked"; }, never, never, true, never>;
+}
+
+/**
+ * Repeating diagonal text watermark over its content — compliance overlays
+ * for classified/internal consoles ("CONFIDENTIAL", "user@corp · 2026-07-21"):
+ *
+ *   <strct-watermark text="CONFIDENTIAL">…page…</strct-watermark>
+ *
+ * Rendered as a pointer-transparent tiled SVG layer, so the content below
+ * stays fully interactive and selectable. Purely visual — `aria-hidden`.
+ */
+declare class StrctWatermark {
+    private readonly sanitizer;
+    /** The repeated watermark text. */
+    readonly text: _angular_core.InputSignal<string>;
+    /** Layer opacity (0–1). */
+    readonly opacity: _angular_core.InputSignal<number>;
+    /** Rotation in degrees (negative = up-slope). */
+    readonly angle: _angular_core.InputSignal<number>;
+    /** Tile size in px — larger spreads the marks out. */
+    readonly gap: _angular_core.InputSignal<number>;
+    /** Font size in px. */
+    readonly fontSize: _angular_core.InputSignal<number>;
+    protected readonly tile: _angular_core.Signal<SafeStyle>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctWatermark, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctWatermark, "strct-watermark", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "angle": { "alias": "angle"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "fontSize": { "alias": "fontSize"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** One coach-mark step. `target` is a CSS selector; null centers the card. */
+interface StrctTourStep {
+    target: string | null;
+    title: string;
+    body: string;
+}
+/**
+ * Feature tour (coach marks) — "what's new" onboarding over live UI:
+ *
+ *   <strct-tour [(open)]="tourOpen" [steps]="steps" (finished)="done()" />
+ *
+ * Each step spotlights its `target` selector with a ring cut out of a dimmed
+ * backdrop and anchors a card next to it. Arrows / buttons step, Escape
+ * closes, and the card is a labeled dialog. Purely DOM-driven: targets are
+ * looked up when the step shows, so it works over any page.
+ */
+declare class StrctTour {
+    /** Whether the tour is showing (two-way). */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** The steps, in order. */
+    readonly steps: _angular_core.InputSignal<StrctTourStep[]>;
+    /** Localizable strings. */
+    readonly nextLabel: _angular_core.InputSignal<string>;
+    readonly backLabel: _angular_core.InputSignal<string>;
+    readonly skipLabel: _angular_core.InputSignal<string>;
+    readonly doneLabel: _angular_core.InputSignal<string>;
+    /** The last step's Done was clicked (Escape / Skip emit `dismissed`). */
+    readonly finished: _angular_core.OutputEmitterRef<void>;
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    protected readonly index: _angular_core.WritableSignal<number>;
+    /** Bumped on open/step/resize to re-measure the target. */
+    private readonly measureTick;
+    protected readonly current: _angular_core.Signal<StrctTourStep>;
+    protected readonly spot: _angular_core.Signal<{
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    } | null>;
+    protected readonly cardPos: _angular_core.Signal<{
+        top: number;
+        left: number;
+    }>;
+    constructor();
+    protected next(): void;
+    protected prev(): void;
+    protected close(): void;
+    private scrollToTarget;
+    protected onEscape(): void;
+    protected onReflow(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTour, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTour, "strct-tour", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "steps": { "alias": "steps"; "required": true; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; "backLabel": { "alias": "backLabel"; "required": false; "isSignal": true; }; "skipLabel": { "alias": "skipLabel"; "required": false; "isSignal": true; }; "doneLabel": { "alias": "doneLabel"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "finished": "finished"; "dismissed": "dismissed"; }, never, never, true, never>;
+}
+
+/** One top-level menubar entry with its menu. */
+interface StrctMenubarItem {
+    id: string;
+    label: string;
+    items: StrctMenuItem[];
+}
+/**
+ * Horizontal menubar — the application-menu strip ("File · Edit · View") for
+ * dense tool-style consoles:
+ *
+ *   <strct-menubar [menus]="menus" (picked)="run($event)" />
+ *
+ * Click (or Enter/Down) opens a menu; Left/Right move across the bar and,
+ * while open, switch the open menu (the APG menubar convention). Escape and
+ * outside click close. `(picked)` carries `{ menu, item }`.
+ */
+declare class StrctMenubar {
+    private readonly host;
+    /** Top-level menus. */
+    readonly menus: _angular_core.InputSignal<StrctMenubarItem[]>;
+    /** Accessible name of the bar (localizable). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** A menu entry was chosen. */
+    readonly picked: _angular_core.OutputEmitterRef<{
+        menu: StrctMenubarItem;
+        item: StrctMenuItem;
+    }>;
+    protected readonly openId: _angular_core.WritableSignal<string | null>;
+    protected readonly focusIdx: _angular_core.WritableSignal<number>;
+    protected toggleMenu(id: string, i: number): void;
+    protected pick(menu: StrctMenubarItem, item: StrctMenuItem): void;
+    protected onTopKey(event: KeyboardEvent, i: number): void;
+    protected onDocClick(event: MouseEvent): void;
+    protected onEscape(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctMenubar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctMenubar, "strct-menubar", never, { "menus": { "alias": "menus"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "picked": "picked"; }, never, never, true, never>;
+}
+
+/**
+ * Screen-reader announcements for state changes that have no visible text —
+ * "12 rows loaded", "Snapshot created" (Material's LiveAnnouncer, strct-sized):
+ *
+ *   private announcer = inject(StrctAnnouncer);
+ *   this.announcer.announce('12 rows loaded');
+ *
+ * Maintains one visually-hidden live region per politeness level; repeated
+ * identical messages are re-announced (the region is cleared first).
+ */
+declare class StrctAnnouncer implements OnDestroy {
+    private regions;
+    private clearTimer;
+    announce(message: string, politeness?: 'polite' | 'assertive'): void;
+    private regionFor;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctAnnouncer, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StrctAnnouncer>;
+}
+
+/** A registered application hotkey. */
+interface StrctHotkey {
+    /** Combo like `'ctrl+k'`, `'meta+shift+p'`, `'?'` — `mod` = Ctrl/⌘. */
+    combo: string;
+    /** Human description shown in the help overlay. */
+    description: string;
+    /** Help-overlay group heading. */
+    group?: string;
+    handler: (event: KeyboardEvent) => void;
+}
+/**
+ * Application hotkeys, centrally registered so they are discoverable — the
+ * Blueprint pattern:
+ *
+ *   private hotkeys = inject(StrctHotkeysService);
+ *   ngOnInit() { this.dispose = this.hotkeys.register(
+ *     { combo: 'mod+k', description: 'Open command palette', group: 'Global',
+ *       handler: () => this.palette.open() }); }
+ *
+ * Combos: `'a'`, `'?'`, `'ctrl+k'`, `'meta+shift+p'`, `'mod+k'` (mod = Ctrl/⌘).
+ * Plain-key combos are suppressed while typing in inputs / textareas /
+ * contenteditable; modifier combos always fire. Pair with
+ * `<strct-hotkeys-help/>` for the ⌘/ ("?") cheatsheet overlay.
+ */
+declare class StrctHotkeysService implements OnDestroy {
+    private readonly registry;
+    /** All registered hotkeys (for the help overlay). */
+    readonly hotkeys: _angular_core.Signal<StrctHotkey[]>;
+    private readonly listener;
+    constructor();
+    /** Register a hotkey; the returned function unregisters it. */
+    register(hotkey: StrctHotkey): () => void;
+    private onKeydown;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctHotkeysService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StrctHotkeysService>;
+}
+/**
+ * The hotkey cheatsheet overlay. Mount once near the app root; it registers
+ * `?` itself and lists everything in the service, grouped:
+ *
+ *   <strct-hotkeys-help />
+ */
+declare class StrctHotkeysHelp {
+    private readonly service;
+    /** Overlay visibility (two-way; `?` toggles it too). */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** Localizable strings. */
+    readonly title: _angular_core.InputSignal<string>;
+    readonly emptyText: _angular_core.InputSignal<string>;
+    protected readonly grouped: _angular_core.Signal<{
+        name: string;
+        keys: StrctHotkey[];
+    }[]>;
+    constructor();
+    protected onEscape(): void;
+    protected parts(combo: string): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctHotkeysHelp, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctHotkeysHelp, "strct-hotkeys-help", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, never, true, never>;
+}
+
+/** A completed reorder: move the item at `from` to `to` in your array. */
+interface StrctReorderEvent {
+    from: number;
+    to: number;
+}
+/**
+ * List drag-reorder primitive — the consumer owns the array:
+ *
+ *   <ul strctReorder (reordered)="move($event)">
+ *     @for (s of steps(); track s.id) {
+ *       <li strctReorderItem>{{ s.label }}</li>
+ *     }
+ *   </ul>
+ *
+ *   move({ from, to }: StrctReorderEvent) {
+ *     this.steps.update((s) => { const c = [...s]; c.splice(to, 0, ...c.splice(from, 1)); return c; });
+ *   }
+ *
+ * Items are HTML5-draggable; keyboard reorder is Alt+ArrowUp / Alt+ArrowDown
+ * on the focused item (items get `tabindex="0"` unless they already manage
+ * focus). Indexes are positions among the `strctReorderItem` siblings.
+ */
+declare class StrctReorder {
+    private readonly host;
+    /** Emits when a drag or keyboard move completes. */
+    readonly reordered: _angular_core.OutputEmitterRef<StrctReorderEvent>;
+    /** Disable all reordering (display-only mode). */
+    readonly reorderDisabled: _angular_core.InputSignal<boolean>;
+    readonly dragIndex: _angular_core.WritableSignal<number | null>;
+    readonly overIndex: _angular_core.WritableSignal<number | null>;
+    items(): HTMLElement[];
+    indexOf(el: HTMLElement): number;
+    commit(from: number, to: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctReorder, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrctReorder, "[strctReorder]", never, { "reorderDisabled": { "alias": "reorderDisabled"; "required": false; "isSignal": true; }; }, { "reordered": "reordered"; }, never, never, true, never>;
+}
+/** One draggable row inside a `[strctReorder]` container. */
+declare class StrctReorderItem {
+    protected readonly list: StrctReorder;
+    private readonly el;
+    private readonly hadOwnTabindex;
+    protected hostTabindex(): number | null;
+    protected isDragging(): boolean;
+    protected isOver(): boolean;
+    private index;
+    protected onDragStart(event: DragEvent): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDrop(event: DragEvent): void;
+    protected onDragEnd(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctReorderItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrctReorderItem, "[strctReorderItem]", never, {}, {}, never, never, true, never>;
+}
+
+export { STRCT_ICONS, STRCT_ICON_GROUPS, STRCT_ICON_NAMES, STRCT_MASKS, STRCT_PALETTES, STRCT_RAW_ICONS, STRCT_TIME_RANGE_PRESETS, StrctAccordion, StrctAccordionPanel, StrctAlert, StrctAnnouncer, StrctAvatar, StrctBadge, StrctBreadcrumb, StrctBreadcrumbItem, StrctButton, StrctButtonGroup, StrctBytesPipe, StrctCard, StrctCardBlock, StrctCardFooter, StrctCardHeader, StrctCascadeHost, StrctCascadeNode, StrctCascadeSelect, StrctCellDef, StrctCellStatus, StrctChart, StrctCheckbox, StrctChips, StrctCode, StrctColorPicker, StrctCombobox, StrctCommandPalette, StrctContextMenu, StrctContextMenuTrigger, StrctCopy, StrctDatagrid, StrctDatagridActionBar, StrctDatepicker, StrctDesc, StrctDescriptionList, StrctDiff, StrctDivider, StrctDonut, StrctDrawer, StrctDrawerFooter, StrctDropdown, StrctDropdownDivider, StrctDropdownItem, StrctDropdownTrigger, StrctDurationPipe, StrctEmptyState, StrctField, StrctFile, StrctFilterBar, StrctFlow, StrctFooter, StrctGauge, StrctHeader, StrctHero, StrctHotkeysHelp, StrctHotkeysService, StrctIcon, StrctInput, StrctInputMask, StrctInputOtp, StrctKbd, StrctKnob, StrctLogViewer, StrctLogin, StrctMenuPanel, StrctMenuService, StrctMenubar, StrctMetricTile, StrctModal, StrctNav, StrctNavItem, StrctOverlay, StrctPageHeader, StrctPageHeaderActions, StrctPageHeaderCrumbs, StrctPagination, StrctPassword, StrctProgress, StrctRadio, StrctRadioGroup, StrctRail, StrctRange, StrctRatePipe, StrctRating, StrctReorder, StrctReorderItem, StrctRowDetailDef, StrctSearchbox, StrctSectionMenu, StrctSegmented, StrctShell, StrctShellService, StrctSiPipe, StrctSignpost, StrctSkeleton, StrctSparkline, StrctSpeedDial, StrctSpinner, StrctSplitButton, StrctSplitter, StrctStack, StrctStackItem, StrctStep, StrctSubmenu, StrctTab, StrctTable, StrctTabs, StrctTag, StrctThemeService, StrctThemeSwitcher, StrctTimeRangePicker, StrctTimeline, StrctTimelineItem, StrctToastOutlet, StrctToastService, StrctToggle, StrctTooltip, StrctTour, StrctTransfer, StrctTree, StrctTreeNode, StrctVerticalNav, StrctWatermark, StrctWizard, parseAnsi, registerStrctIcon, strctComputeDiff, strctFormatBytes, strctFormatDuration, strctFormatRate, strctFormatSi, strctValidationIcon, strctValidationTone };
+export type { StrctAlertType, StrctAvatarSize, StrctAvatarStatus, StrctBadgeStatus, StrctButtonSize, StrctButtonVariant, StrctCascadeOption, StrctCellContext, StrctChartAnnotation, StrctChartColor, StrctChartCurve, StrctChartSeries, StrctChartSlot, StrctChartStatus, StrctChartThreshold, StrctChartType, StrctColumn, StrctCommandItem, StrctDatagridColumn, StrctDatagridColumnState, StrctDatagridFilters, StrctDatagridLabels, StrctDatagridLazyState, StrctDescAlign, StrctDescItem, StrctDiffRow, StrctDonutSegment, StrctDrawerSide, StrctDrawerSize, StrctEmptyVariant, StrctFilterChip, StrctFlowDirection, StrctFlowNode, StrctFlowOrientation, StrctHotkey, StrctIconBadge, StrctIconName, StrctKnobStatus, StrctLogLine, StrctMenuItem, StrctMenuLink, StrctMenuOpenOptions, StrctMenuSection, StrctMenubarItem, StrctMetricStatus, StrctModalSize, StrctMode, StrctOption, StrctOverlayPlacement, StrctPalette, StrctPaletteInfo, StrctProgressStatus, StrctRailItem, StrctRailStatus, StrctReorderEvent, StrctRow, StrctRowId, StrctSegmentedOption, StrctSegmentedSize, StrctSignpostPosition, StrctSpeedDialDirection, StrctSpinnerSize, StrctStatus, StrctTagStatus, StrctThresholds, StrctTimeRange, StrctTimeRangePreset, StrctTimelineState, StrctToast, StrctToastOptions, StrctToastType, StrctTooltipPosition, StrctTourStep, StrctTransferItem, StrctTreeMenuEvent, StrctTreeNodeData, StrctTreeNodeMenuFn, StrctValidationState, StrctValidationStatus };