@akcelik/strct 0.1.0

package/types/akcelik-strct.d.ts

@@ -0,0 +1,1375 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, TemplateRef } from '@angular/core';
+import { SafeHtml } from '@angular/platform-browser';
+import { ControlValueAccessor } from '@angular/forms';
+
+type StrctPalette = 'arctic' | 'ember' | 'sage';
+type StrctMode = 'dark' | 'light';
+interface StrctPaletteInfo {
+    id: StrctPalette;
+    /** Human label, shown in switchers. */
+    label: string;
+    /** Swatch color used by the palette dot. */
+    swatch: string;
+}
+/** All palettes the token system ships with, in display order. */
+declare const STRCT_PALETTES: readonly StrctPaletteInfo[];
+/**
+ * Owns the active palette + light/dark mode. Writes `data-palette` and
+ * `data-theme` onto the document root (which the token layer keys off) and
+ * persists the choice to localStorage. Inject it anywhere and read the signals
+ * or call the setters.
+ */
+declare class StrctThemeService {
+    private readonly doc;
+    private readonly _palette;
+    private readonly _mode;
+    readonly palette: _angular_core.Signal<StrctPalette>;
+    readonly mode: _angular_core.Signal<StrctMode>;
+    readonly palettes: readonly StrctPaletteInfo[];
+    readonly isDark: _angular_core.Signal<boolean>;
+    constructor();
+    setPalette(palette: StrctPalette): void;
+    setMode(mode: StrctMode): void;
+    toggleMode(): void;
+    private read;
+    private write;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctThemeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StrctThemeService>;
+}
+
+/** Palette dots + light/dark pill, wired to {@link StrctThemeService}. */
+declare class StrctThemeSwitcher {
+    protected readonly theme: StrctThemeService;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctThemeSwitcher, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctThemeSwitcher, "strct-theme-switcher", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Inner markup (path/shape contents) for each icon, drawn on a 0 0 16 16
+ * viewBox with `currentColor` stroke. Keep strokes at 1.3–1.5 for crispness.
+ *
+ * The set is intentionally datacenter-flavoured (hosts, clusters, switches,
+ * storage, VMs …). Object state — running / stopped / maintenance — is layered
+ * on with the `badge` input rather than a separate icon per state.
+ */
+declare const STRCT_ICONS: Record<string, string>;
+/** Icon names grouped for galleries / documentation. */
+declare const STRCT_ICON_GROUPS: {
+    label: string;
+    names: string[];
+}[];
+/**
+ * Full-SVG icons that keep their own viewBox and colors (no stroke wrapper).
+ * Use this for brand / vendor logos you have the rights to ship — register the
+ * official asset's markup yourself; the library does not bundle any logos.
+ */
+declare const STRCT_RAW_ICONS: Record<string, string>;
+/**
+ * Register an icon at runtime.
+ *   registerStrctIcon('mything', '<path d="…"/>');                 // stroke glyph
+ *   registerStrctIcon('vendorDell', '<svg viewBox="…">…</svg>', { raw: true });
+ */
+declare function registerStrctIcon(name: string, content: string, options?: {
+    raw?: boolean;
+}): void;
+type StrctIconBadge = 'none' | 'ok' | 'warn' | 'crit' | 'off' | 'info';
+/**
+ * Inline stroke icon. `<strct-icon name="host" badge="ok" />` renders the host
+ * glyph with a green status dot (a "running host"). Unknown names render
+ * nothing rather than throwing.
+ */
+declare class StrctIcon {
+    private readonly sanitizer;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<number>;
+    readonly strokeWidth: _angular_core.InputSignal<number>;
+    /** Optional status dot overlaid on the glyph (object state). */
+    readonly badge: _angular_core.InputSignal<StrctIconBadge>;
+    /** True when the named icon is a full-SVG (raw) icon registered by the app. */
+    protected readonly isRaw: _angular_core.Signal<boolean>;
+    protected readonly svg: _angular_core.Signal<SafeHtml>;
+    protected readonly rawSvg: _angular_core.Signal<SafeHtml>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctIcon, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctIcon, "strct-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type StrctOverlayPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end' | 'right' | 'left';
+/**
+ * Positions an overlay panel with `position: fixed` relative to an anchor
+ * element, so it escapes ancestor `overflow: hidden/scroll` clipping.
+ * Repositions on scroll/resize and flips vertically near the viewport edge.
+ *
+ *   <button #trigger>…</button>
+ *   <div class="menu" [strctOverlay]="trigger" strctOverlayPlacement="bottom-end">…</div>
+ *
+ * Note: like any fixed-positioned element, the panel is positioned relative to
+ * a transformed/filtered ancestor if one exists (a CSS containing-block rule).
+ * Avoid wrapping a trigger in `transform`/`filter` if you need viewport-anchored
+ * overlays. (The tooltip sidesteps this by rendering into `<body>`.)
+ */
+declare class StrctOverlay implements OnDestroy {
+    private readonly el;
+    private readonly zone;
+    readonly anchor: _angular_core.InputSignal<HTMLElement>;
+    readonly placement: _angular_core.InputSignal<StrctOverlayPlacement>;
+    /** Match the panel width to the anchor (combobox / date / cascade fields). */
+    readonly matchWidth: _angular_core.InputSignal<boolean>;
+    readonly gap: _angular_core.InputSignal<number>;
+    private readonly onScrollResize;
+    private bound;
+    constructor();
+    /** Recompute and apply the fixed coordinates. */
+    position(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctOverlay, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrctOverlay, "[strctOverlay]", never, { "anchor": { "alias": "strctOverlay"; "required": true; "isSignal": true; }; "placement": { "alias": "strctOverlayPlacement"; "required": false; "isSignal": true; }; "matchWidth": { "alias": "strctOverlayMatchWidth"; "required": false; "isSignal": true; }; "gap": { "alias": "strctOverlayGap"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Application frame: a full-viewport grid of header / body / footer rows.
+ *   <strct-shell>
+ *     <strct-header>…</strct-header>
+ *     <div strctShellMain>… sidebar + content …</div>
+ *     <strct-footer>…</strct-footer>
+ *   </strct-shell>
+ */
+declare class StrctShell {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctShell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctShell, "strct-shell", never, {}, {}, never, ["strct-header", "*", "strct-footer"], true, never>;
+}
+/** Top application bar. Holds brand on the left and actions on the right. */
+declare class StrctHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctHeader, "strct-header", never, {}, {}, never, ["*"], true, never>;
+}
+/** Bottom status bar. */
+declare class StrctFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctFooter, "strct-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+/** Scrollable left sidebar surface. Holds the icon nav and/or a tree. */
+declare class StrctVerticalNav {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctVerticalNav, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctVerticalNav, "strct-vertical-nav", never, {}, {}, never, ["*"], true, never>;
+}
+/** Horizontal strip of icon tabs (e.g. section switcher at the top of a sidebar). */
+declare class StrctNav {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctNav, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctNav, "strct-nav", never, {}, {}, never, ["*"], true, never>;
+}
+/** A single icon tab inside `<strct-nav>`. */
+declare class StrctNavItem {
+    readonly active: _angular_core.InputSignal<boolean>;
+    readonly label: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctNavItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctNavItem, "strct-nav-item", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Authentication layout. Two modes:
+ *  - default: a single centered column (drop a card + form inside).
+ *  - `split`: a two-panel card — a decorative accent aside (`[strctLoginAside]`)
+ *    on the left and the form (default content) on the right.
+ *
+ *   <strct-login split>
+ *     <div strctLoginAside>… brand + welcome …</div>
+ *     <form strctLoginMain>… inputs + button …</form>
+ *   </strct-login>
+ */
+declare class StrctLogin {
+    readonly maxWidth: _angular_core.InputSignal<number>;
+    readonly split: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctLogin, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctLogin, "strct-login", never, { "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "split": { "alias": "split"; "required": false; "isSignal": true; }; }, {}, never, ["[strctLoginAside]", "[strctLoginMain]", "*"], true, never>;
+}
+
+type StrctButtonVariant = 'primary' | 'danger' | 'outline' | 'flat' | 'neutral';
+type StrctButtonSize = 'md' | 'sm' | 'mini';
+/**
+ * Styles a native `<button>` / `<a>` so it stays fully accessible and form-aware.
+ *
+ * Buttons are restrained by default: outlined / ghost surfaces with color used
+ * only as a subtle border + text accent. Add `solid` for a rare filled call to
+ * action.
+ *   <button strct-button variant="primary">Save</button>
+ *   <button strct-button variant="primary" solid>Deploy</button>
+ *   <a strct-button variant="flat" size="sm" href="...">Cancel</a>
+ */
+declare class StrctButton {
+    readonly variant: _angular_core.InputSignal<StrctButtonVariant>;
+    readonly size: _angular_core.InputSignal<StrctButtonSize>;
+    /** Opt in to a filled surface (use sparingly, for the primary action). */
+    readonly solid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly block: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Square padding for a single-icon button. */
+    readonly iconOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctButton, "button[strct-button], a[strct-button]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "solid": { "alias": "solid"; "required": false; "isSignal": true; }; "block": { "alias": "block"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/** Segments adjacent buttons into a single joined control. */
+declare class StrctButtonGroup {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctButtonGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctButtonGroup, "strct-button-group", never, {}, {}, never, ["*"], true, never>;
+}
+
+type StrctBadgeStatus = 'neutral' | 'accent' | 'success' | 'warning' | 'danger';
+/** Small inline status pill: `<strct-badge status="success">Active</strct-badge>`. */
+declare class StrctBadge {
+    readonly status: _angular_core.InputSignal<StrctBadgeStatus>;
+    /** Opt-in filled style instead of the default outlined style. */
+    readonly solid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctBadge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctBadge, "strct-badge", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; "solid": { "alias": "solid"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type StrctTagStatus = 'neutral' | 'accent' | 'success' | 'warning' | 'danger';
+/**
+ * Compact, optionally removable chip.
+ *   <strct-tag status="accent" removable (removed)="drop()">Frontend</strct-tag>
+ */
+declare class StrctTag {
+    readonly status: _angular_core.InputSignal<StrctTagStatus>;
+    readonly removable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly removed: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTag, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTag, "strct-tag", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["*"], true, never>;
+}
+
+type StrctAvatarSize = 'sm' | 'md' | 'lg';
+type StrctAvatarStatus = 'none' | 'online' | 'busy' | 'offline';
+/**
+ * Circular avatar: an image when `src` is set, otherwise initials from `name`.
+ *   <strct-avatar name="Ada Lovelace" status="online" />
+ */
+declare class StrctAvatar {
+    readonly src: _angular_core.InputSignal<string>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<StrctAvatarSize>;
+    readonly status: _angular_core.InputSignal<StrctAvatarStatus>;
+    protected readonly initials: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctAvatar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctAvatar, "strct-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type StrctProgressStatus = 'accent' | 'success' | 'warning' | 'danger';
+/** Horizontal value/usage bar. `<strct-progress [value]="72" status="warning" />`. */
+declare class StrctProgress {
+    readonly value: _angular_core.InputSignal<number>;
+    readonly status: _angular_core.InputSignal<StrctProgressStatus>;
+    protected readonly clamped: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctProgress, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctProgress, "strct-progress", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type StrctSpinnerSize = 'sm' | 'md' | 'lg';
+/** Indeterminate loading ring. `<strct-spinner size="sm" />`. */
+declare class StrctSpinner {
+    readonly size: _angular_core.InputSignal<StrctSpinnerSize>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSpinner, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSpinner, "strct-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Shimmering loading placeholder.
+ *   <strct-skeleton width="60%" height="14px" />
+ *   <strct-skeleton circle width="40px" height="40px" />
+ */
+declare class StrctSkeleton {
+    readonly width: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly circle: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSkeleton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSkeleton, "strct-skeleton", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "circle": { "alias": "circle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type StrctSpeedDialDirection = 'up' | 'down' | 'left' | 'right';
+/**
+ * Floating action button that fans out to reveal actions. Project icon buttons
+ * (optionally with `strctTooltip`) as the actions.
+ *   <strct-speed-dial icon="ellipsis" direction="up">
+ *     <button strct-button iconOnly strctTooltip="Snapshot"><strct-icon name="snapshot" /></button>
+ *     <button strct-button iconOnly strctTooltip="Restart"><strct-icon name="sync" /></button>
+ *   </strct-speed-dial>
+ */
+declare class StrctSpeedDial {
+    private readonly host;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly direction: _angular_core.InputSignal<StrctSpeedDialDirection>;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    toggle(): void;
+    protected onDocClick(event: MouseEvent): void;
+    protected onEscape(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSpeedDial, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSpeedDial, "strct-speed-dial", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Surface container. Compose with the header / block / footer pieces:
+ *   <strct-card>
+ *     <strct-card-header>Title</strct-card-header>
+ *     <strct-card-block>...</strct-card-block>
+ *     <strct-card-footer><button strct-button>OK</button></strct-card-footer>
+ *   </strct-card>
+ */
+declare class StrctCard {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCard, "strct-card", never, {}, {}, never, ["*"], true, never>;
+}
+declare class StrctCardHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCardHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCardHeader, "strct-card-header", never, {}, {}, never, ["*"], true, never>;
+}
+declare class StrctCardBlock {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCardBlock, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCardBlock, "strct-card-block", never, {}, {}, never, ["*"], true, never>;
+}
+declare class StrctCardFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCardFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCardFooter, "strct-card-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+/** Vertical container for `<strct-accordion-panel>` items. */
+declare class StrctAccordion {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctAccordion, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctAccordion, "strct-accordion", never, {}, {}, never, ["*"], true, never>;
+}
+/** Collapsible panel with a header. `expanded` is two-way bindable. */
+declare class StrctAccordionPanel {
+    readonly heading: _angular_core.InputSignal<string>;
+    readonly expanded: _angular_core.ModelSignal<boolean>;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctAccordionPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctAccordionPanel, "strct-accordion-panel", never, { "heading": { "alias": "heading"; "required": true; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, never, ["*"], true, never>;
+}
+
+/** A single tab. Place inside `<strct-tabs>`; `label` names its button. */
+declare class StrctTab {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly _active;
+    readonly active: _angular_core.Signal<boolean>;
+    /** @internal called by the parent tab group */
+    setActive(value: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTab, "strct-tab", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/** Tab group. Wraps `<strct-tab>` children and renders the tab bar. */
+declare class StrctTabs {
+    readonly tabs: _angular_core.Signal<readonly StrctTab[]>;
+    readonly selectedIndex: _angular_core.WritableSignal<number>;
+    constructor();
+    select(index: number): void;
+    onKeydown(event: KeyboardEvent, bar: HTMLElement): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTabs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTabs, "strct-tabs", never, {}, {}, ["tabs"], ["*"], true, never>;
+}
+
+/** Root container for a tree of `<strct-tree-node>` items. */
+declare class StrctTree {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTree, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTree, "strct-tree", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Tree node. Nest `<strct-tree-node>` children to build hierarchy:
+ *   <strct-tree-node label="Group" [(expanded)]="open">
+ *     <strct-tree-node label="Leaf" icon="grid" [active]="true" />
+ *   </strct-tree-node>
+ */
+declare class StrctTreeNode {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly active: _angular_core.InputSignal<boolean>;
+    readonly expanded: _angular_core.ModelSignal<boolean>;
+    readonly activated: _angular_core.OutputEmitterRef<void>;
+    private readonly childNodes;
+    protected readonly hasChildren: _angular_core.Signal<boolean>;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTreeNode, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTreeNode, "strct-tree-node", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; "activated": "activated"; }, ["childNodes"], ["[strctTreeTrailing]", "*"], true, never>;
+}
+
+type StrctModalSize = 'sm' | 'md' | 'lg';
+/**
+ * Overlay dialog with two-way `open`:
+ *   <strct-modal [(open)]="show" title="Confirm">
+ *     Body…
+ *     <ng-container strctModalFooter>
+ *       <button strct-button (click)="show = false">Cancel</button>
+ *     </ng-container>
+ *   </strct-modal>
+ */
+declare class StrctModal {
+    private readonly elementRef;
+    private readonly doc;
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<StrctModalSize>;
+    readonly hideFooter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Allow closing via backdrop click / Escape. */
+    readonly dismissable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    protected readonly titleId: string;
+    /** Element that had focus before the dialog opened, restored on close. */
+    private previousActive;
+    constructor();
+    close(): void;
+    protected onBackdrop(): void;
+    protected onEscape(): void;
+    /** Wrap Tab focus within the dialog. */
+    protected onTab(event: Event): void;
+    private dialog;
+    private focusable;
+    private focusInitial;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctModal, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctModal, "strct-modal", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "hideFooter": { "alias": "hideFooter"; "required": false; "isSignal": true; }; "dismissable": { "alias": "dismissable"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "closed": "closed"; }, never, ["*", "[strctModalFooter]"], true, never>;
+}
+
+/**
+ * Click-to-open menu:
+ *   <strct-dropdown align="end">
+ *     <button strct-button strctDropdownTrigger>Actions</button>
+ *     <strct-dropdown-item>Rename</strct-dropdown-item>
+ *     <strct-dropdown-item danger>Delete</strct-dropdown-item>
+ *   </strct-dropdown>
+ */
+declare class StrctDropdown {
+    private readonly host;
+    readonly align: _angular_core.InputSignal<"end" | "start">;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    toggle(): void;
+    close(): void;
+    protected onDocClick(event: MouseEvent): void;
+    protected onEscape(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDropdown, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDropdown, "strct-dropdown", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, ["[strctDropdownTrigger]", "*"], true, never>;
+}
+/** A selectable row inside a `<strct-dropdown>`. */
+declare class StrctDropdownItem {
+    readonly danger: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDropdownItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDropdownItem, "strct-dropdown-item", never, { "danger": { "alias": "danger"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/** Thin separator between groups of menu items. */
+declare class StrctDropdownDivider {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDropdownDivider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDropdownDivider, "strct-dropdown-divider", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Right-click (context) menu. Wraps a trigger area and shows a menu at the
+ * cursor. Reuse `strct-dropdown-item` for the entries:
+ *   <strct-context-menu>
+ *     <div>Right-click here</div>
+ *     <ng-container strctContextMenuItems>
+ *       <strct-dropdown-item>Open</strct-dropdown-item>
+ *       <strct-dropdown-item danger>Delete</strct-dropdown-item>
+ *     </ng-container>
+ *   </strct-context-menu>
+ */
+declare class StrctContextMenu {
+    readonly open: _angular_core.WritableSignal<boolean>;
+    readonly x: _angular_core.WritableSignal<number>;
+    readonly y: _angular_core.WritableSignal<number>;
+    /** Approximate menu box used to keep it inside the viewport. */
+    private static readonly MENU_W;
+    private static readonly MENU_H;
+    onContextMenu(event: MouseEvent): void;
+    close(): void;
+    protected onDocClick(): void;
+    protected onEscape(): void;
+    protected onResize(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctContextMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctContextMenu, "strct-context-menu", never, {}, {}, never, ["*", "[strctContextMenuItems]"], true, never>;
+}
+
+/**
+ * A nested fly-out inside a `strct-context-menu` or `strct-dropdown`. Reuse
+ * `strct-dropdown-item` for the nested entries.
+ *   <strct-submenu label="Power">
+ *     <strct-dropdown-item>Power on</strct-dropdown-item>
+ *     <strct-dropdown-item>Power off</strct-dropdown-item>
+ *   </strct-submenu>
+ */
+declare class StrctSubmenu {
+    readonly label: _angular_core.InputSignal<string>;
+    /** Optional leading icon; when omitted the icon column is still reserved so
+     *  the label stays aligned with sibling items that do have icons. */
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSubmenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSubmenu, "strct-submenu", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["[strctSubmenuLabel]", "*"], true, never>;
+}
+
+/** A single wizard step. `label` names it in the step header. */
+declare class StrctStep {
+    readonly label: _angular_core.InputSignal<string>;
+    private readonly _active;
+    readonly active: _angular_core.Signal<boolean>;
+    /** @internal */
+    setActive(value: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctStep, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctStep, "strct-step", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/** Multi-step flow with a numbered header and Back / Next / Finish controls. */
+declare class StrctWizard {
+    readonly steps: _angular_core.Signal<readonly StrctStep[]>;
+    readonly current: _angular_core.WritableSignal<number>;
+    readonly finished: _angular_core.OutputEmitterRef<void>;
+    protected readonly isLast: _angular_core.Signal<boolean>;
+    constructor();
+    next(): void;
+    back(): void;
+    finish(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctWizard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctWizard, "strct-wizard", never, {}, { "finished": "finished"; }, ["steps"], ["*"], true, never>;
+}
+
+/**
+ * Separator rule. Horizontal by default; pass `vertical` for an inline rule.
+ * Projected content becomes a centered label on a horizontal divider.
+ *   <strct-divider>OR</strct-divider>
+ *   <strct-divider vertical />
+ */
+declare class StrctDivider {
+    readonly vertical: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDivider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDivider, "strct-divider", never, { "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Breadcrumb trail container. Wraps `<strct-breadcrumb-item>` children. */
+declare class StrctBreadcrumb {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctBreadcrumb, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctBreadcrumb, "strct-breadcrumb", never, {}, {}, never, ["*"], true, never>;
+}
+/** One crumb. Mark the final one `current`. */
+declare class StrctBreadcrumbItem {
+    readonly current: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctBreadcrumbItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctBreadcrumbItem, "strct-breadcrumb-item", never, { "current": { "alias": "current"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type PageToken = number | 'dots';
+/**
+ * Page navigator with first/last + a windowed range and ellipsis gaps.
+ *   <strct-pagination [total]="240" [pageSize]="20" [(page)]="page" />
+ */
+declare class StrctPagination {
+    readonly total: _angular_core.InputSignal<number>;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly page: _angular_core.ModelSignal<number>;
+    readonly pageCount: _angular_core.Signal<number>;
+    protected readonly pages: _angular_core.Signal<PageToken[]>;
+    go(target: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctPagination, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctPagination, "strct-pagination", never, { "total": { "alias": "total"; "required": true; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "page": { "alias": "page"; "required": false; "isSignal": true; }; }, { "page": "pageChange"; }, never, never, true, never>;
+}
+
+/**
+ * Applies the shared `.strct-control` look to a native input / textarea / select.
+ *   <input strctInput placeholder="Name" />
+ *   <select strctInput>…</select>
+ * The visual definition lives in `strct/styles/_forms.scss` (shipped via the
+ * theme entry point), so this directive only attaches the class.
+ */
+declare class StrctInput {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrctInput, "input[strctInput], textarea[strctInput], select[strctInput]", never, {}, {}, never, never, true, never>;
+}
+
+/** Checkbox with custom box. Works with `[(ngModel)]` / reactive forms. */
+declare class StrctCheckbox implements ControlValueAccessor {
+    readonly checked: _angular_core.WritableSignal<boolean>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    /** Static disable; forms' setDisabledState also drives the disabled state. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private onChange;
+    protected onTouched: () => void;
+    constructor();
+    onToggle(event: Event): void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCheckbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCheckbox, "strct-checkbox", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** On/off switch. Works with `[(ngModel)]` / reactive forms. */
+declare class StrctToggle implements ControlValueAccessor {
+    readonly checked: _angular_core.WritableSignal<boolean>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    /** Static disable; forms' setDisabledState also drives the disabled state. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private onChange;
+    protected onTouched: () => void;
+    constructor();
+    onToggle(event: Event): void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctToggle, "strct-toggle", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Radio group (the form control). Wrap `<strct-radio>` items:
+ *   <strct-radio-group [(ngModel)]="size">
+ *     <strct-radio [value]="'sm'">Small</strct-radio>
+ *     <strct-radio [value]="'lg'">Large</strct-radio>
+ *   </strct-radio-group>
+ */
+declare class StrctRadioGroup implements ControlValueAccessor {
+    readonly name: string;
+    readonly value: _angular_core.WritableSignal<unknown>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    private onChange;
+    private onTouched;
+    select(value: unknown): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctRadioGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctRadioGroup, "strct-radio-group", never, {}, {}, never, ["*"], true, never>;
+}
+/** One option inside a `<strct-radio-group>`. */
+declare class StrctRadio {
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly group: StrctRadioGroup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctRadio, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctRadio, "strct-radio", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Slider built on a native range input — fully accessible, CVA-compatible.
+ *   <strct-range [min]="0" [max]="100" [(ngModel)]="volume" showValue />
+ */
+declare class StrctRange implements ControlValueAccessor {
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly showValue: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly value: _angular_core.WritableSignal<number>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly fillPercent: _angular_core.Signal<number>;
+    private onChange;
+    protected onTouched: () => void;
+    constructor();
+    onInput(event: Event): void;
+    writeValue(value: number): void;
+    registerOnChange(fn: (value: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctRange, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctRange, "strct-range", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Password input with a reveal toggle and an optional strength meter. CVA-compatible.
+ *   <strct-password [(ngModel)]="pw" meter />
+ */
+declare class StrctPassword implements ControlValueAccessor {
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly meter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly value: _angular_core.WritableSignal<string>;
+    readonly revealed: _angular_core.WritableSignal<boolean>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly score: _angular_core.Signal<number>;
+    protected readonly level: _angular_core.Signal<{
+        label: string;
+        color: string;
+    }>;
+    private onChange;
+    protected onTouched: () => void;
+    onInput(event: Event): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctPassword, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctPassword, "strct-password", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "meter": { "alias": "meter"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Drag-and-drop file picker. CVA value is a `File[]`.
+ *   <strct-file [(ngModel)]="files" multiple accept="image/*" />
+ */
+declare class StrctFile implements ControlValueAccessor {
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly accept: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly files: _angular_core.WritableSignal<File[]>;
+    readonly dragging: _angular_core.WritableSignal<boolean>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    private onChange;
+    protected onTouched: () => void;
+    onSelect(event: Event): void;
+    onDragOver(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    remove(file: File): void;
+    protected humanSize(bytes: number): string;
+    private setFiles;
+    writeValue(value: File[]): void;
+    registerOnChange(fn: (value: File[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctFile, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctFile, "strct-file", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Star rating input. CVA value is the selected count (0–max). */
+declare class StrctRating implements ControlValueAccessor {
+    readonly max: _angular_core.InputSignal<number>;
+    readonly size: _angular_core.InputSignal<number>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly value: _angular_core.WritableSignal<number>;
+    readonly hover: _angular_core.WritableSignal<number>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    protected stars(): number[];
+    private onChange;
+    private onTouched;
+    pick(star: number): void;
+    writeValue(value: number): void;
+    registerOnChange(fn: (value: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctRating, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctRating, "strct-rating", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Tag input — type a word and press Enter to add a chip; Backspace on an empty
+ * field removes the last. CVA value is `string[]`.
+ *   <strct-chips [(ngModel)]="labels" placeholder="Add a tag…" />
+ */
+declare class StrctChips implements ControlValueAccessor {
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly allowDuplicates: _angular_core.InputSignal<boolean>;
+    readonly value: _angular_core.WritableSignal<string[]>;
+    readonly draft: _angular_core.WritableSignal<string>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    private onChange;
+    protected onTouched: () => void;
+    onKeydown(event: KeyboardEvent): void;
+    protected commitDraft(): void;
+    remove(chip: string): void;
+    private emit;
+    writeValue(value: string[]): void;
+    registerOnChange(fn: (value: string[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctChips, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctChips, "strct-chips", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "allowDuplicates": { "alias": "allowDuplicates"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * One-time-password input — a row of single-character boxes with auto-advance,
+ * backspace and paste. CVA value is the concatenated string.
+ *   <strct-input-otp [length]="6" [(ngModel)]="code" />
+ */
+declare class StrctInputOtp implements ControlValueAccessor {
+    private readonly host;
+    readonly length: _angular_core.InputSignal<number>;
+    readonly masked: _angular_core.InputSignal<boolean>;
+    readonly slots: _angular_core.WritableSignal<string[]>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly indices: _angular_core.Signal<number[]>;
+    private onChange;
+    private onTouched;
+    onInput(i: number, event: Event): void;
+    onKeydown(i: number, event: KeyboardEvent): void;
+    onPaste(event: ClipboardEvent): void;
+    private setSlot;
+    private focusBox;
+    private emit;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctInputOtp, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctInputOtp, "strct-input-otp", never, { "length": { "alias": "length"; "required": false; "isSignal": true; }; "masked": { "alias": "masked"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type StrctKnobStatus = 'accent' | 'success' | 'warning' | 'danger';
+/**
+ * Rotary dial input. Drag (up/down), arrow keys, Home/End or the wheel change
+ * the value. CVA-compatible.
+ *   <strct-knob [min]="0" [max]="100" [(ngModel)]="fanSpeed" label="Fan" />
+ */
+declare class StrctKnob implements ControlValueAccessor {
+    private readonly elementRef;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly size: _angular_core.InputSignal<number>;
+    readonly thickness: _angular_core.InputSignal<number>;
+    readonly status: _angular_core.InputSignal<StrctKnobStatus>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.WritableSignal<number>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly half: _angular_core.Signal<number>;
+    protected readonly radius: _angular_core.Signal<number>;
+    protected readonly color: _angular_core.Signal<string>;
+    private readonly fraction;
+    private readonly circumference;
+    protected readonly trackDash: _angular_core.Signal<string>;
+    protected readonly valueDash: _angular_core.Signal<string>;
+    /** Pointer rotation: -135° (start, lower-left) to +135° (end, lower-right). */
+    protected readonly pointerAngle: _angular_core.Signal<number>;
+    private onChange;
+    private onTouched;
+    private dragStartY;
+    private dragStartValue;
+    private readonly onMove;
+    private readonly onUp;
+    protected onPointerDown(event: PointerEvent): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onWheel(event: WheelEvent): void;
+    private setValue;
+    writeValue(value: number): void;
+    registerOnChange(fn: (value: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctKnob, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctKnob, "strct-knob", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Ready-made masks for common datacenter / form fields. */
+declare const STRCT_MASKS: {
+    readonly phoneTr: "(999) 999 99 99";
+    readonly nationalIdTr: "99999999999";
+    readonly creditCard: "9999 9999 9999 9999";
+    /** MAC address — 6 hex octets, e.g. 00:1B:44:11:3A:B7 */
+    readonly mac: "HH:HH:HH:HH:HH:HH";
+    /** Fibre-channel WWPN — 8 hex octets, e.g. 20:00:00:25:B5:1A:00:0F */
+    readonly wwpn: "HH:HH:HH:HH:HH:HH:HH:HH";
+};
+/**
+ * Masked text input. Mask tokens: `9` = digit, `A` = letter, `H` = hex digit,
+ * `*` = alphanumeric; every other character is a literal. CVA value is the
+ * formatted string.
+ *   <strct-input-mask mask="(999) 999 99 99" [(ngModel)]="phone" />
+ *   <strct-input-mask mask="HH:HH:HH:HH:HH:HH" uppercase [(ngModel)]="mac" />
+ */
+declare class StrctInputMask implements ControlValueAccessor {
+    readonly mask: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Upper-case entered letters (handy for hex MAC / WWPN). */
+    readonly uppercase: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly display: _angular_core.WritableSignal<string>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    private onChange;
+    protected onTouched: () => void;
+    onInput(event: Event): void;
+    private isToken;
+    private matches;
+    private format;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctInputMask, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctInputMask, "strct-input-mask", never, { "mask": { "alias": "mask"; "required": true; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "uppercase": { "alias": "uppercase"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface StrctOption {
+    value: unknown;
+    label: string;
+}
+/**
+ * Filterable single-select (autocomplete). CVA-compatible, fully keyboard
+ * driven (↑/↓ to move, Enter to pick, Esc to close).
+ *   <strct-combobox [options]="opts" [(ngModel)]="selected" placeholder="Pick…" />
+ */
+declare class StrctCombobox implements ControlValueAccessor {
+    private readonly host;
+    protected readonly listId: string;
+    readonly options: _angular_core.InputSignal<StrctOption[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly query: _angular_core.WritableSignal<string>;
+    readonly value: _angular_core.WritableSignal<unknown>;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    readonly activeIndex: _angular_core.WritableSignal<number>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    /** True while the user is typing a filter that hasn't been committed yet. */
+    private readonly dirty;
+    protected readonly filtered: _angular_core.Signal<StrctOption[]>;
+    private onChange;
+    protected onTouched: () => void;
+    openList(): void;
+    onType(event: Event): void;
+    onKeydown(event: KeyboardEvent): void;
+    private move;
+    select(opt: StrctOption, event: Event): void;
+    private commit;
+    protected onDocClick(event: MouseEvent): void;
+    private close;
+    private indexOfValue;
+    private syncQueryToValue;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCombobox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCombobox, "strct-combobox", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface DayCell {
+    day: number;
+    iso: string;
+    inMonth: boolean;
+}
+/**
+ * Calendar date picker. Value is an ISO `yyyy-mm-dd` string. CVA-compatible.
+ *   <strct-datepicker [(ngModel)]="date" />
+ */
+declare class StrctDatepicker implements ControlValueAccessor {
+    private readonly host;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    protected readonly dow: string[];
+    readonly value: _angular_core.WritableSignal<string>;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    /** Keyboard cursor within the open calendar. */
+    readonly focusedIso: _angular_core.WritableSignal<string>;
+    private readonly view;
+    protected get today(): string;
+    protected readonly monthLabel: _angular_core.Signal<string>;
+    protected readonly displayLabel: _angular_core.Signal<string>;
+    protected readonly cells: _angular_core.Signal<DayCell[]>;
+    private onChange;
+    private onTouched;
+    toggle(): void;
+    shiftMonth(delta: number): void;
+    pick(iso: string): void;
+    onKeydown(event: KeyboardEvent): void;
+    private syncFocus;
+    private shiftFocus;
+    protected onDocClick(event: MouseEvent): void;
+    protected onEscape(): void;
+    private startOfMonth;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDatepicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDatepicker, "strct-datepicker", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Swatch-based color picker with a hex field. CVA value is a `#rrggbb` string.
+ *   <strct-color-picker [(ngModel)]="color" />
+ */
+declare class StrctColorPicker implements ControlValueAccessor {
+    private readonly host;
+    readonly swatches: _angular_core.InputSignal<string[]>;
+    readonly value: _angular_core.WritableSignal<string>;
+    readonly draft: _angular_core.WritableSignal<string>;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    private onChange;
+    private onTouched;
+    toggle(): void;
+    protected eq(color: string): boolean;
+    pick(color: string): void;
+    onHex(event: Event): void;
+    private commit;
+    protected onDocClick(event: MouseEvent): void;
+    protected onEscape(): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctColorPicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctColorPicker, "strct-color-picker", never, { "swatches": { "alias": "swatches"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface StrctCascadeOption {
+    label: string;
+    value?: unknown;
+    children?: StrctCascadeOption[];
+}
+/** DI token the nodes use to talk back to the host control (avoids a circular type). */
+declare abstract class StrctCascadeHost {
+    abstract pick(value: unknown): void;
+    abstract isSelected(value: unknown): boolean;
+}
+/**
+ * One row in the cascade. Leaf rows select on click; group rows reveal a
+ * fly-out of their children on hover. Recurses to any depth.
+ */
+declare class StrctCascadeNode {
+    private readonly host;
+    readonly option: _angular_core.InputSignal<StrctCascadeOption>;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly hasChildren: _angular_core.Signal<boolean>;
+    protected readonly isLeafSelected: _angular_core.Signal<boolean>;
+    protected onClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCascadeNode, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCascadeNode, "strct-cascade-node", never, { "option": { "alias": "option"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Hierarchical single-select — pick a leaf from nested groups (e.g. a port
+ * group under a virtual switch). CVA-compatible.
+ *   <strct-cascade-select [options]="switches" [(ngModel)]="portGroup" />
+ */
+declare class StrctCascadeSelect extends StrctCascadeHost implements ControlValueAccessor {
+    private readonly elementRef;
+    readonly options: _angular_core.InputSignal<StrctCascadeOption[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.WritableSignal<unknown>;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly selectedLabel: _angular_core.Signal<string>;
+    private onChange;
+    private onTouched;
+    toggle(): void;
+    pick(value: unknown): void;
+    isSelected(value: unknown): boolean;
+    private findLabel;
+    protected onDocClick(event: MouseEvent): void;
+    protected onEscape(): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCascadeSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCascadeSelect, "strct-cascade-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface StrctColumn {
+    key: string;
+    label: string;
+    align?: 'start' | 'center' | 'end';
+    width?: string;
+}
+type StrctRow = Record<string, unknown>;
+/**
+ * Declarative data table.
+ *   <strct-table [columns]="cols" [rows]="data" hover />
+ */
+declare class StrctTable {
+    readonly columns: _angular_core.InputSignal<StrctColumn[]>;
+    readonly rows: _angular_core.InputSignal<StrctRow[]>;
+    readonly striped: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly emptyText: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTable, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTable, "strct-table", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rows": { "alias": "rows"; "required": true; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "hover": { "alias": "hover"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface StrctDatagridColumn {
+    key: string;
+    label: string;
+    sortable?: boolean;
+    align?: 'start' | 'center' | 'end';
+    width?: string;
+}
+/**
+ * Marks the expandable-row detail template. The row is the template's implicit
+ * context: `<ng-template strctRowDetail let-row> … {{ row['name'] }} … </ng-template>`.
+ */
+declare class StrctRowDetailDef {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctRowDetailDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrctRowDetailDef, "[strctRowDetail]", never, {}, {}, never, never, true, never>;
+}
+/** Marks the persistent action-bar (toolbar) content shown above the grid. */
+declare class StrctDatagridActionBar {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDatagridActionBar, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrctDatagridActionBar, "[strctDatagridActionBar]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Interactive data table: sortable columns, row selection, expandable detail
+ * rows, a batch action bar and built-in paging.
+ *   <strct-datagrid [columns]="cols" [rows]="data" selectable expandable [pageSize]="10">
+ *     <button strct-button strctDatagridActions size="sm">Migrate</button>
+ *     <ng-template strctRowDetail let-row> … </ng-template>
+ *   </strct-datagrid>
+ */
+declare class StrctDatagrid {
+    readonly columns: _angular_core.InputSignal<StrctDatagridColumn[]>;
+    readonly rows: _angular_core.InputSignal<StrctRow[]>;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Expand a row in place to reveal its detail template below it. */
+    readonly expandable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Collapse the grid to a single column and open a side detail pane for the
+     *  clicked row (distinct from {@link expandable}). */
+    readonly detailPane: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly compact: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly emptyText: _angular_core.InputSignal<string>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<StrctRow[]>;
+    protected readonly detailDef: _angular_core.Signal<StrctRowDetailDef | undefined>;
+    protected readonly actionBarDef: _angular_core.Signal<StrctDatagridActionBar | undefined>;
+    readonly page: _angular_core.WritableSignal<number>;
+    private readonly sort;
+    private readonly selected;
+    private readonly expandedRows;
+    protected readonly activeRow: _angular_core.WritableSignal<StrctRow | null>;
+    protected readonly canExpand: _angular_core.Signal<boolean>;
+    protected readonly canDetail: _angular_core.Signal<boolean>;
+    protected readonly paneOpen: _angular_core.Signal<boolean>;
+    /** Only the first column is shown while the detail pane is open. */
+    protected readonly visibleColumns: _angular_core.Signal<StrctDatagridColumn[]>;
+    protected readonly sorted: _angular_core.Signal<StrctRow[]>;
+    protected readonly paged: _angular_core.Signal<StrctRow[]>;
+    protected readonly selectedCount: _angular_core.Signal<number>;
+    protected readonly allPageSelected: _angular_core.Signal<boolean>;
+    protected readonly somePageSelected: _angular_core.Signal<boolean>;
+    constructor();
+    protected colspan(): number;
+    /** Toggle the detail pane for a row (triggered by its »  button, not the row,
+     *  so row cells remain selectable for copy). */
+    openDetail(row: StrctRow): void;
+    closePane(): void;
+    sortBy(key: string): void;
+    protected sortIcon(key: string): string;
+    protected ariaSort(key: string): 'ascending' | 'descending' | 'none';
+    protected onHeaderSpace(event: Event, key: string): void;
+    protected isSelected(row: StrctRow): boolean;
+    protected isExpanded(row: StrctRow): boolean;
+    toggleExpand(row: StrctRow): void;
+    toggleRow(row: StrctRow): void;
+    toggleAll(): void;
+    clearSelection(): void;
+    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; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, ["detailDef", "actionBarDef"], ["[strctDatagridActionBar]", "[strctDatagridActions]"], true, never>;
+}
+
+type StrctTimelineState = 'default' | 'current' | 'success' | 'warning' | 'danger';
+/** Vertical timeline container. Wraps `<strct-timeline-item>` children. */
+declare class StrctTimeline {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTimeline, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTimeline, "strct-timeline", never, {}, {}, never, ["*"], true, never>;
+}
+/** A timeline entry: a node on the rail plus a title and projected body. */
+declare class StrctTimelineItem {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly state: _angular_core.InputSignal<StrctTimelineState>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTimelineItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTimelineItem, "strct-timeline-item", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Key/value definition list. Wraps `<strct-stack-item>` rows. */
+declare class StrctStack {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctStack, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctStack, "strct-stack", never, {}, {}, never, ["*"], true, never>;
+}
+/** A label + value row. The value is projected content. */
+declare class StrctStackItem {
+    readonly label: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctStackItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctStackItem, "strct-stack-item", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type StrctChartStatus = 'accent' | 'success' | 'warning' | 'danger';
+/**
+ * Tiny inline trend line. `<strct-sparkline [data]="[3,5,4,8,6,9]" area />`.
+ */
+declare class StrctSparkline {
+    readonly data: _angular_core.InputSignal<number[]>;
+    readonly status: _angular_core.InputSignal<StrctChartStatus>;
+    readonly area: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly width: _angular_core.InputSignal<number>;
+    readonly height: _angular_core.InputSignal<number>;
+    protected readonly color: _angular_core.Signal<string>;
+    private readonly points;
+    protected readonly linePoints: _angular_core.Signal<string>;
+    protected readonly areaPoints: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSparkline, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSparkline, "strct-sparkline", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "area": { "alias": "area"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type StrctChartType = 'line' | 'area' | 'bar';
+/**
+ * Single-series chart (line / area / bar). Dependency-free SVG, token-coloured.
+ *   <strct-chart [data]="cpu" type="area" [labels]="hours" status="warning" />
+ */
+declare class StrctChart {
+    readonly data: _angular_core.InputSignal<number[]>;
+    readonly type: _angular_core.InputSignal<StrctChartType>;
+    readonly labels: _angular_core.InputSignal<string[]>;
+    readonly status: _angular_core.InputSignal<StrctChartStatus>;
+    readonly height: _angular_core.InputSignal<number>;
+    /** Override the top of the value axis (defaults to the data max + headroom). */
+    readonly max: _angular_core.InputSignal<number | null>;
+    protected readonly vbW = 320;
+    protected readonly pad: {
+        l: number;
+        r: number;
+        t: number;
+        b: number;
+    };
+    protected readonly color: _angular_core.Signal<string>;
+    private readonly maxValue;
+    private chartH;
+    protected readonly points: _angular_core.Signal<{
+        x: number;
+        y: number;
+    }[]>;
+    protected readonly linePoints: _angular_core.Signal<string>;
+    protected readonly areaPoints: _angular_core.Signal<string>;
+    protected readonly bars: _angular_core.Signal<{
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }[]>;
+    protected readonly gridY: _angular_core.Signal<number[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctChart, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctChart, "strct-chart", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface StrctDonutSegment {
+    value: number;
+    label?: string;
+    color?: string;
+}
+/**
+ * Donut / ring chart from weighted segments.
+ *   <strct-donut [segments]="[{value:6,label:'Running'},{value:2,label:'Off'}]"
+ *                centerValue="8" centerLabel="VMs" />
+ */
+declare class StrctDonut {
+    readonly segments: _angular_core.InputSignal<StrctDonutSegment[]>;
+    readonly size: _angular_core.InputSignal<number>;
+    readonly thickness: _angular_core.InputSignal<number>;
+    readonly centerValue: _angular_core.InputSignal<string | number>;
+    readonly centerLabel: _angular_core.InputSignal<string>;
+    protected readonly half: _angular_core.Signal<number>;
+    protected readonly radius: _angular_core.Signal<number>;
+    protected readonly circumference: _angular_core.Signal<number>;
+    protected readonly arcs: _angular_core.Signal<{
+        color: string;
+        len: number;
+        offset: number;
+    }[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDonut, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDonut, "strct-donut", never, { "segments": { "alias": "segments"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; "centerValue": { "alias": "centerValue"; "required": false; "isSignal": true; }; "centerLabel": { "alias": "centerLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * 270° radial gauge for a 0–100 value (CPU, memory, capacity …).
+ *   <strct-gauge [value]="72" status="warning" label="CPU" />
+ */
+declare class StrctGauge {
+    readonly value: _angular_core.InputSignal<number>;
+    readonly status: _angular_core.InputSignal<StrctChartStatus>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<number>;
+    readonly thickness: _angular_core.InputSignal<number>;
+    protected readonly clamped: _angular_core.Signal<number>;
+    protected readonly half: _angular_core.Signal<number>;
+    protected readonly radius: _angular_core.Signal<number>;
+    protected readonly color: _angular_core.Signal<string>;
+    private readonly circumference;
+    protected readonly trackDash: _angular_core.Signal<string>;
+    protected readonly valueDash: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctGauge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctGauge, "strct-gauge", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type StrctAlertType = 'info' | 'success' | 'warning' | 'danger';
+/** Inline contextual banner. `<strct-alert type="warning">…</strct-alert>`. */
+declare class StrctAlert {
+    readonly type: _angular_core.InputSignal<StrctAlertType>;
+    readonly closable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    protected readonly icon: _angular_core.Signal<"info" | "success" | "warning" | "danger">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctAlert, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctAlert, "strct-alert", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+type StrctTooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Lightweight hover/focus tooltip. Renders a fixed-positioned bubble so it is
+ * never clipped by an ancestor's `overflow`.
+ *   <button strct-button strctTooltip="More info">?</button>
+ */
+declare class StrctTooltip {
+    private readonly host;
+    private readonly renderer;
+    private readonly doc;
+    private bubble;
+    readonly strctTooltip: _angular_core.InputSignal<string>;
+    readonly tooltipPosition: _angular_core.InputSignal<StrctTooltipPosition>;
+    protected show(): void;
+    protected hide(): void;
+    private place;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrctTooltip, "[strctTooltip]", never, { "strctTooltip": { "alias": "strctTooltip"; "required": true; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type StrctSignpostPosition = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * A click-triggered popover with an arrow, for contextual help / detail.
+ *   <strct-signpost position="right">
+ *     <button strct-button size="sm" strctSignpostTrigger>?</button>
+ *     <h4>Title</h4>
+ *     <p>Any projected content…</p>
+ *   </strct-signpost>
+ */
+declare class StrctSignpost {
+    private readonly host;
+    readonly position: _angular_core.InputSignal<StrctSignpostPosition>;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    toggle(): void;
+    close(): void;
+    protected overlayPlacement(): StrctOverlayPlacement;
+    protected onDocClick(event: MouseEvent): void;
+    protected onEscape(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSignpost, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSignpost, "strct-signpost", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, ["[strctSignpostTrigger]", "*"], true, never>;
+}
+
+type StrctToastType = 'info' | 'success' | 'warning' | 'danger';
+interface StrctToast {
+    id: number;
+    type: StrctToastType;
+    message: string;
+    /** Auto-dismiss after this many ms; 0 keeps it until dismissed. */
+    duration: number;
+}
+interface StrctToastOptions {
+    type?: StrctToastType;
+    duration?: number;
+}
+/**
+ * Queues transient notifications. Render `<strct-toast-outlet />` once near the
+ * app root, then call from anywhere:
+ *   inject(StrctToastService).success('Saved');
+ */
+declare class StrctToastService {
+    private counter;
+    private readonly _toasts;
+    readonly toasts: _angular_core.Signal<StrctToast[]>;
+    show(message: string, options?: StrctToastOptions): number;
+    info(message: string, duration?: number): number;
+    success(message: string, duration?: number): number;
+    warning(message: string, duration?: number): number;
+    danger(message: string, duration?: number): number;
+    dismiss(id: number): void;
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StrctToastService>;
+}
+/** Renders the toast stack. Place once, typically just inside the app shell. */
+declare class StrctToastOutlet {
+    protected readonly service: StrctToastService;
+    protected icon(type: StrctToastType): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctToastOutlet, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctToastOutlet, "strct-toast-outlet", never, {}, {}, never, never, true, never>;
+}
+
+export { STRCT_ICONS, STRCT_ICON_GROUPS, STRCT_MASKS, STRCT_PALETTES, STRCT_RAW_ICONS, StrctAccordion, StrctAccordionPanel, StrctAlert, StrctAvatar, StrctBadge, StrctBreadcrumb, StrctBreadcrumbItem, StrctButton, StrctButtonGroup, StrctCard, StrctCardBlock, StrctCardFooter, StrctCardHeader, StrctCascadeHost, StrctCascadeNode, StrctCascadeSelect, StrctChart, StrctCheckbox, StrctChips, StrctColorPicker, StrctCombobox, StrctContextMenu, StrctDatagrid, StrctDatagridActionBar, StrctDatepicker, StrctDivider, StrctDonut, StrctDropdown, StrctDropdownDivider, StrctDropdownItem, StrctFile, StrctFooter, StrctGauge, StrctHeader, StrctIcon, StrctInput, StrctInputMask, StrctInputOtp, StrctKnob, StrctLogin, StrctModal, StrctNav, StrctNavItem, StrctOverlay, StrctPagination, StrctPassword, StrctProgress, StrctRadio, StrctRadioGroup, StrctRange, StrctRating, StrctRowDetailDef, StrctShell, 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 };
+export type { StrctAlertType, StrctAvatarSize, StrctAvatarStatus, StrctBadgeStatus, StrctButtonSize, StrctButtonVariant, StrctCascadeOption, StrctChartStatus, StrctChartType, StrctColumn, StrctDatagridColumn, StrctDonutSegment, StrctIconBadge, StrctKnobStatus, StrctModalSize, StrctMode, StrctOption, StrctOverlayPlacement, StrctPalette, StrctPaletteInfo, StrctProgressStatus, StrctRow, StrctSignpostPosition, StrctSpeedDialDirection, StrctSpinnerSize, StrctTagStatus, StrctTimelineState, StrctToast, StrctToastOptions, StrctToastType, StrctTooltipPosition };