ngx-strata 0.1.0 → 0.2.1

package/types/ngx-strata.d.ts

@@ -1,12 +1,25 @@
 import * as _angular_core from '@angular/core';
-import { OnInit, OnDestroy, AfterContentInit, ElementRef, Renderer2, EnvironmentProviders, InjectionToken, Provider, AfterViewInit, TemplateRef, OnChanges, SimpleChanges, PipeTransform, Type, ComponentRef, ViewContainerRef } from '@angular/core';
+import { OnInit, OnDestroy, AfterContentInit, ElementRef, Renderer2, EnvironmentProviders, InjectionToken, Provider, AfterViewInit, TemplateRef, OnChanges, SimpleChanges, PipeTransform, QueryList, Type, ViewContainerRef } from '@angular/core';
 import { Placement } from '@floating-ui/dom';
+import * as _angular_platform_browser from '@angular/platform-browser';
 import { SafeHtml, DomSanitizer } from '@angular/platform-browser';
 import { Observable } from 'rxjs';
 import { HttpClient } from '@angular/common/http';
+import { RouterLinkActive } from '@angular/router';
 import * as ngx_strata from 'ngx-strata';
 
-declare class TooltipDirective implements OnInit, OnDestroy, AfterContentInit {
+declare class StrataActivatableDirective {
+    private _elementRef;
+    disabled: _angular_core.InputSignal<boolean>;
+    interactable: _angular_core.ModelSignal<boolean>;
+    activated: _angular_core.OutputEmitterRef<Event>;
+    isFocusable: _angular_core.Signal<boolean>;
+    onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataActivatableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrataActivatableDirective, "[stActivatable]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "interactable": { "alias": "interactable"; "required": false; "isSignal": true; }; }, { "interactable": "interactableChange"; "activated": "activated"; }, never, never, true, never>;
+}
+
+declare class StrataTooltipDirective implements OnInit, OnDestroy, AfterContentInit {
     private document;
     private element;
     private renderer;
@@ -25,19 +38,14 @@ declare class TooltipDirective implements OnInit, OnDestroy, AfterContentInit {
     doPosition(): void;
     ngOnDestroy(): void;
     private shouldRender;
-    showTimeoutCancel: any;
+    showTimeoutCancel?: ReturnType<typeof setTimeout>;
     private show;
     private hide;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipDirective, "[stSimpleTooltip]", never, { "stSimpleTooltip": { "alias": "stSimpleTooltip"; "required": true; "isSignal": true; }; "tooltipEnabled": { "alias": "tooltipEnabled"; "required": false; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; }; "tooltipAlwaysShow": { "alias": "tooltipAlwaysShow"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrataTooltipDirective, "[stSimpleTooltip]", never, { "stSimpleTooltip": { "alias": "stSimpleTooltip"; "required": true; "isSignal": true; }; "tooltipEnabled": { "alias": "tooltipEnabled"; "required": false; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; }; "tooltipAlwaysShow": { "alias": "tooltipAlwaysShow"; "required": false; }; }, {}, never, never, true, never>;
 }
 type TooltipPlacement = Exclude<Placement, 'left-start' | 'left-end' | 'right-start' | 'right-end'>;
 
-type DarkmodeSetting = 'DARK' | 'LIGHT' | 'SYSTEM';
-type CurrentDarkmode = 'LIGHT' | 'DARK';
-type Size = 'xs' | 'sm' | 'md' | 'lg';
-type Theme = 'brand' | 'default' | 'danger' | 'warning' | 'success' | 'info';
-
 declare class DarkmodeService {
     private readonly STORAGE_KEY;
     private document;
@@ -56,6 +64,42 @@ declare class DarkmodeService {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DarkmodeService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<DarkmodeService>;
 }
+type DarkmodeSetting = 'DARK' | 'LIGHT' | 'SYSTEM';
+type CurrentDarkmode = 'LIGHT' | 'DARK';
+
+interface HotkeyOptions {
+    /** If true, the hotkey fires even when focus is inside an input, textarea, or contenteditable. Defaults to false. */
+    allowInInput?: boolean;
+}
+declare class HotkeyService {
+    private readonly config;
+    private readonly destroyRef;
+    private readonly registrations;
+    constructor();
+    /**
+     * Register a keyboard shortcut.
+     *
+     * @param combo - A combo string like `'meta+k'`, `'ctrl+shift+p'`, `'shift+?'`.
+     *   Use `'meta'` for ⌘ on Mac / Win key on Windows. When `crossPlatformHotkeys` is
+     *   enabled in StrataConfig (default), registering `meta+k` also fires on `ctrl+k`
+     *   and vice-versa.
+     * @param handler - Callback invoked when the combo is matched.
+     * @param options - Optional configuration per registration.
+     * @returns A teardown function — call it to unregister the hotkey.
+     */
+    register(combo: string, handler: () => void, options?: HotkeyOptions): () => void;
+    private handleKeydown;
+    private matchesCombo;
+    private parseCombo;
+    /**
+     * When crossPlatformHotkeys is enabled, mirror meta ↔ ctrl so that
+     * a single `register('meta+k', ...)` call fires on both ⌘K (Mac) and Ctrl+K (Win/Linux).
+     */
+    private expandCrossPlatform;
+    private isInputFocused;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HotkeyService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<HotkeyService>;
+}
 
 interface IconConfig {
     name: string;
@@ -67,57 +111,117 @@ declare const provideBaseIcons: () => EnvironmentProviders;
 declare const provideIcons: (iconConfigs: IconConfig[]) => EnvironmentProviders;
 
 declare function provideStrata(config?: Partial<StrataConfig>): (Provider | EnvironmentProviders)[];
-type StrataConfig = {
+interface StrataConfig {
     includeBaseIcons: boolean;
     tooltipDelayMs: number;
-};
+    /** When true (default), registering a 'meta+x' hotkey also fires on 'ctrl+x' and vice-versa. */
+    crossPlatformHotkeys: boolean;
+    /** Visual labels for hotkey modifiers */
+    shortcutLabels?: {
+        meta?: string;
+        ctrl?: string;
+        shift?: string;
+        alt?: string;
+    };
+}
 declare const STRATA_CONFIG: InjectionToken<StrataConfig>;
 
-declare class ActionMenuItemComponent {
+declare class StrataActionMenuItemComponent {
     private checkbox;
     private toggle;
     closeMenuOnClick: _angular_core.InputSignal<boolean>;
-    onMenuItemClicked: _angular_core.OutputEmitterRef<boolean>;
+    active: _angular_core.InputSignal<boolean>;
+    get isActive(): boolean;
+    menuItemClicked: _angular_core.OutputEmitterRef<boolean>;
     elementRef: ElementRef<HTMLElement>;
     onHostClick(event: MouseEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionMenuItemComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ActionMenuItemComponent, "st-action-menu-item", never, { "closeMenuOnClick": { "alias": "closeMenuOnClick"; "required": false; "isSignal": true; }; }, { "onMenuItemClicked": "onMenuItemClicked"; }, ["checkbox", "toggle"], ["[area='start']", "*", "[area='end']"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataActionMenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataActionMenuItemComponent, "st-action-menu-item", never, { "closeMenuOnClick": { "alias": "closeMenuOnClick"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; }, { "menuItemClicked": "menuItemClicked"; }, ["checkbox", "toggle"], ["[area='start']", "*", "[area='end']"], true, never>;
 }
 
-declare class ActionMenuComponent implements AfterViewInit {
+declare class StrataActionMenuComponent {
     projectedButton: _angular_core.Signal<ElementRef<any> | undefined>;
     defaultButton: _angular_core.Signal<ElementRef<any> | undefined>;
-    actionMenuItems: _angular_core.Signal<readonly ActionMenuItemComponent[]>;
+    actionMenuItems: _angular_core.Signal<readonly StrataActionMenuItemComponent[]>;
     placement: _angular_core.InputSignal<Placement>;
     renderer: Renderer2;
     menuOpen: _angular_core.WritableSignal<boolean>;
-    ngAfterViewInit(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionMenuComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ActionMenuComponent, "st-action-menu", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, {}, ["projectedButton", "actionMenuItems"], ["button[stButton]", "st-action-menu-item"], true, never>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataActionMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataActionMenuComponent, "st-action-menu", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, {}, ["projectedButton", "actionMenuItems"], ["button[stButton]", "st-action-menu-item"], true, never>;
+}
+
+declare class StrataAlertComponent {
+    header: _angular_core.InputSignal<string | undefined>;
+    message: _angular_core.InputSignal<string>;
+    iconName: _angular_core.InputSignal<string | undefined>;
+    dismissible: _angular_core.InputSignal<boolean>;
+    dismiss: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataAlertComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataAlertComponent, "st-alert", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": true; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; }, { "dismiss": "dismiss"; }, never, ["[actions]"], true, never>;
 }
 
-declare class AccordionItemComponent {
+declare class StrataBreadcrumbItemComponent {
+    text: _angular_core.InputSignal<string>;
+    icon: _angular_core.InputSignal<string | undefined>;
+    interactable: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    activated: _angular_core.OutputEmitterRef<Event>;
+    separatorIcon: _angular_core.WritableSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataBreadcrumbItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataBreadcrumbItemComponent, "st-breadcrumb-item", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "interactable": { "alias": "interactable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "activated": "activated"; }, never, never, true, never>;
+}
+
+declare class StrataBreadcrumbComponent {
+    separatorIcon: _angular_core.InputSignal<string>;
+    items: _angular_core.Signal<readonly StrataBreadcrumbItemComponent[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataBreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataBreadcrumbComponent, "st-breadcrumb", never, { "separatorIcon": { "alias": "separatorIcon"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
+}
+
+declare class StrataAccordionItemComponent {
     title: _angular_core.InputSignal<string>;
     open: _angular_core.ModelSignal<boolean>;
     toggled: _angular_core.OutputEmitterRef<boolean>;
     constructor();
     get isOpen(): boolean;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionItemComponent, "st-accordion-item", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "toggled": "toggled"; }, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataAccordionItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataAccordionItemComponent, "st-accordion-item", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "toggled": "toggled"; }, never, ["*"], true, never>;
 }
 
-declare class AccordionGroupComponent implements AfterContentInit {
-    items: _angular_core.Signal<readonly AccordionItemComponent[]>;
+declare class StrataAccordionGroupComponent {
+    items: _angular_core.Signal<readonly StrataAccordionItemComponent[]>;
     allowMultipleOpen: _angular_core.InputSignal<boolean>;
-    ngAfterContentInit(): void;
-    closeOtherItems(currentItem: AccordionItemComponent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionGroupComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionGroupComponent, "st-accordion-group", never, { "allowMultipleOpen": { "alias": "allowMultipleOpen"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
+    constructor();
+    closeOtherItems(currentItem: StrataAccordionItemComponent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataAccordionGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataAccordionGroupComponent, "st-accordion-group", never, { "allowMultipleOpen": { "alias": "allowMultipleOpen"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
+}
+
+declare class StrataIconComponent {
+    private iconRegistry;
+    name: _angular_core.InputSignal<string>;
+    size: _angular_core.ModelSignal<IconSize>;
+    svgMarkdown: _angular_core.Signal<_angular_platform_browser.SafeHtml | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataIconComponent, "st-icon", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "size": "sizeChange"; }, never, never, true, never>;
+}
+
+declare class StrataAvatarComponent implements AfterViewInit {
+    iconComponents: _angular_core.Signal<readonly StrataIconComponent[]>;
+    text: _angular_core.InputSignal<string | null>;
+    size: _angular_core.ModelSignal<AvatarSize>;
+    get elementClasses(): AvatarSize[];
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataAvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataAvatarComponent, "st-avatar", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "size": "sizeChange"; }, ["iconComponents"], ["*"], true, never>;
 }
+type AvatarSize = 'xs' | 'sm' | 'md' | 'lg';
 
-declare class AvatarStackComponent implements AfterViewInit {
+declare class StrataAvatarStackComponent implements AfterViewInit {
     avatarRefs: _angular_core.Signal<readonly ElementRef<any>[]>;
-    size: _angular_core.InputSignal<Size>;
+    size: _angular_core.InputSignal<AvatarSize>;
     spacing: _angular_core.InputSignal<"loose" | "mid" | "tight">;
     firstOnFront: _angular_core.InputSignal<boolean>;
     get xsClass(): boolean;
@@ -129,51 +233,19 @@ declare class AvatarStackComponent implements AfterViewInit {
     get midClass(): boolean;
     get tightClass(): boolean;
     ngAfterViewInit(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarStackComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarStackComponent, "st-avatar-stack", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "spacing": { "alias": "spacing"; "required": false; "isSignal": true; }; "firstOnFront": { "alias": "firstOnFront"; "required": false; "isSignal": true; }; }, {}, ["avatarRefs"], ["*"], true, never>;
-}
-
-declare abstract class IconRegistry {
-    abstract getIcon(name: string): Observable<SafeHtml>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataAvatarStackComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataAvatarStackComponent, "st-avatar-stack", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "spacing": { "alias": "spacing"; "required": false; "isSignal": true; }; "firstOnFront": { "alias": "firstOnFront"; "required": false; "isSignal": true; }; }, {}, ["avatarRefs"], ["*"], true, never>;
 }
 
-declare class IconComponent implements OnDestroy {
-    defaultIcon: string;
-    name: _angular_core.InputSignal<string>;
-    size: _angular_core.ModelSignal<IconSize>;
-    get sizeClass(): boolean;
-    get sizeSmClass(): boolean;
-    get sizeMdClass(): boolean;
-    get sizeLgClass(): boolean;
-    svgMarkdown: any;
-    private iconSubscription;
-    iconRegistry: IconRegistry;
-    ngOnDestroy(): void;
-    ngOnChanges(): void;
-    private setIcon;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconComponent, "st-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "size": "sizeChange"; }, never, never, true, never>;
-}
-
-declare class AvatarComponent implements AfterViewInit {
-    iconComponents: _angular_core.Signal<readonly IconComponent[]>;
-    text: _angular_core.InputSignal<string | null>;
-    size: _angular_core.ModelSignal<Size>;
-    get elementClasses(): Size[];
-    ngAfterViewInit(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarComponent, "st-avatar", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "size": "sizeChange"; }, ["iconComponents"], ["*"], true, never>;
-}
-
-declare class ButtonGroupComponent {
+declare class StrataButtonGroupComponent {
     renderer: Renderer2;
     justification: _angular_core.InputSignal<ButtonGroupJustification>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonGroupComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonGroupComponent, "st-button-group", never, { "justification": { "alias": "justification"; "required": false; "isSignal": true; }; }, {}, never, ["[stButton], st-divider"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataButtonGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataButtonGroupComponent, "st-button-group", never, { "justification": { "alias": "justification"; "required": false; "isSignal": true; }; }, {}, never, ["[stButton], st-divider"], true, never>;
 }
 type ButtonGroupJustification = 'start' | 'center' | 'end' | 'expand' | 'stack';
 
-declare class ButtonDirective implements AfterContentInit {
+declare class StrataButtonDirective implements AfterContentInit {
     host: ElementRef<any>;
     variant: _angular_core.InputSignal<ButtonVariant>;
     size: _angular_core.InputSignal<ButtonSize>;
@@ -181,17 +253,17 @@ declare class ButtonDirective implements AfterContentInit {
     private iconAtStart;
     private iconAtEnd;
     private iconOnly;
-    constructor();
     get classes(): string[];
     ngAfterContentInit(): void;
-    nodeIsStIcon(node: any): boolean;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonDirective, "[stButton]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    nodeIsStIcon(node: Node): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrataButtonDirective, "[stButton]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 type ButtonVariant = 'primary' | 'secondary' | 'outline' | 'ghost';
 type ButtonSize = 'sm' | 'md' | 'lg';
 
-declare class CardComponent {
+declare class StrataCardComponent {
+    private elementRef;
     elevated: _angular_core.InputSignal<boolean>;
     selectable: _angular_core.InputSignal<boolean>;
     padding: _angular_core.InputSignal<boolean>;
@@ -202,71 +274,102 @@ declare class CardComponent {
     get isElevated(): boolean;
     get isFlat(): boolean;
     get isOutline(): boolean;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardComponent, "st-card", never, { "elevated": { "alias": "elevated"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["[area='cover']", "*"], true, never>;
+    handleKeyboardEvent(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataCardComponent, "st-card", never, { "elevated": { "alias": "elevated"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["[area='cover']", "*"], true, never>;
 }
 type CardVariant = 'elevated' | 'flat' | 'outline';
 
-declare class CheckboxComponent {
+declare class StrataCheckboxComponent {
     value: _angular_core.ModelSignal<boolean | undefined>;
     label: _angular_core.InputSignal<string | undefined>;
     name: _angular_core.InputSignal<string | undefined>;
     onClick(event: MouseEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "st-checkbox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataCheckboxComponent, "st-checkbox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
 }
 
-declare class DropdownComponent {
+declare class StrataSelectItemComponent {
+    value: _angular_core.InputSignal<unknown>;
+    text: _angular_core.InputSignal<string>;
+    itemClicked: _angular_core.OutputEmitterRef<StrataSelectItemComponent>;
+    hidden: _angular_core.WritableSignal<boolean>;
+    elementRef: ElementRef<HTMLElement>;
+    get display(): string;
+    onClick(event: MouseEvent): void;
+    onMouseOver(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataSelectItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataSelectItemComponent, "st-select-item", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "text": { "alias": "text"; "required": true; "isSignal": true; }; }, { "itemClicked": "itemClicked"; }, never, ["*"], true, never>;
+}
+
+declare class StrataSingleSelectComponent {
     open: _angular_core.WritableSignal<boolean>;
     placeholder: _angular_core.InputSignal<string>;
     placement: _angular_core.InputSignal<Placement>;
     fullWidth: _angular_core.InputSignal<boolean>;
     label: _angular_core.InputSignal<string | undefined>;
     name: _angular_core.InputSignal<string | undefined>;
-    selected: _angular_core.ModelSignal<SelectItem | undefined>;
-    size: _angular_core.InputSignal<DropdownSize>;
+    selected: _angular_core.ModelSignal<unknown>;
+    selectedItem: _angular_core.Signal<StrataSelectItemComponent | undefined>;
     searchable: _angular_core.InputSignal<boolean>;
     searchQuery: _angular_core.ModelSignal<string | undefined>;
     searchPlaceholder: _angular_core.InputSignal<string>;
-    dropdownItems: _angular_core.InputSignal<SelectItem[]>;
-    shownItems: _angular_core.Signal<SelectItem[]>;
-    onSelect: _angular_core.OutputEmitterRef<SelectItem>;
+    itemSelected: _angular_core.OutputEmitterRef<unknown>;
+    selectItems: _angular_core.Signal<readonly StrataSelectItemComponent[]>;
+    triggerTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
     private inputField;
-    get classList(): DropdownSize[];
-    toggleDropdown(event?: MouseEvent): void;
-    onItemClick(item: SelectItem, mouseEvent: MouseEvent): void;
-    onItemHover(mouseEvent: MouseEvent): void;
+    private destroyRef;
+    constructor();
+    onSearchChange(query: string | undefined): void;
+    toggle(event?: MouseEvent): void;
+    onItemClick(item: StrataSelectItemComponent): void;
     private show;
     private hide;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownComponent, "st-dropdown", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchQuery": { "alias": "searchQuery"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "dropdownItems": { "alias": "dropdownItems"; "required": true; "isSignal": true; }; }, { "selected": "selectedChange"; "searchQuery": "searchQueryChange"; "onSelect": "onSelect"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataSingleSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataSingleSelectComponent, "st-single-select", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchQuery": { "alias": "searchQuery"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; "searchQuery": "searchQueryChange"; "itemSelected": "itemSelected"; }, ["selectItems", "triggerTemplate"], ["st-select-item"], true, never>;
 }
-interface SelectItem {
-    text: string;
-    id: string;
+
+declare class StrataSelectTriggerDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataSelectTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrataSelectTriggerDirective, "[stSelectTrigger]", never, {}, {}, never, never, true, never>;
 }
-type DropdownSize = 'sm' | 'md' | 'lg';
 
-declare class DividerComponent {
+declare class StrataDividerComponent {
     label: _angular_core.InputSignal<string | undefined>;
     margin: _angular_core.InputSignal<boolean>;
     vertical: _angular_core.InputSignal<boolean>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DividerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DividerComponent, "st-divider", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "margin": { "alias": "margin"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataDividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataDividerComponent, "st-divider", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "margin": { "alias": "margin"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class TagComponent {
+declare class StrataTagComponent {
     size: _angular_core.InputSignal<TagSize>;
     get class(): TagSize;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TagComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TagComponent, "st-tag", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataTagComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataTagComponent, "st-tag", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 type TagSize = 'sm' | 'md' | 'lg';
 
+declare class StrataKbdComponent {
+    private readonly config;
+    /**
+     * The sequence of keys to display.
+     * Can be an array like `['⌘', 'K']` or a string combo like `'meta+k'`.
+     */
+    keys: _angular_core.InputSignal<string | string[]>;
+    resolvedKeys: _angular_core.Signal<string[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataKbdComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataKbdComponent, "st-kbd", never, { "keys": { "alias": "keys"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 declare abstract class IconLoader {
     abstract loadSvg(url: string): Observable<SafeHtml>;
 }
 
+declare abstract class IconRegistry {
+    abstract getIcon(name: string): Observable<SafeHtml>;
+}
+
 declare class HttpIconLoader implements IconLoader {
     httpClient: HttpClient;
     sanitizer: DomSanitizer;
@@ -288,61 +391,68 @@ declare class IconRegistryService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<IconRegistryService>;
 }
 
-declare class ItemListComponent<T> {
+declare class StrataItemListComponent<T> {
     items: _angular_core.InputSignal<T[]>;
     dividers: _angular_core.InputSignal<boolean>;
-    template: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    template: _angular_core.InputSignal<TemplateRef<T> | undefined>;
     get hostClasses(): string[];
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemListComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemListComponent<any>, "st-item-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "dividers": { "alias": "dividers"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataItemListComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataItemListComponent<any>, "st-item-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "dividers": { "alias": "dividers"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class ItemComponent {
-    interactable: _angular_core.InputSignal<boolean>;
+declare class StrataItemComponent {
+    private element;
+    private _activatable;
+    private checkbox;
+    private toggle;
+    private radio;
+    interactable: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    constructor();
     get isInteractable(): boolean;
-    get tabIndex(): number | null;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemComponent, "st-item", never, { "interactable": { "alias": "interactable"; "required": false; "isSignal": true; }; }, {}, never, ["[area='start']", "*", "[area='end']"], true, never>;
+    get isDisabledClass(): boolean;
+    onHostClick(event: MouseEvent): void;
+    onActivated(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataItemComponent, "st-item", never, {}, {}, ["checkbox", "toggle", "radio"], ["[area='start']", "*", "[area='end']"], true, [{ directive: typeof StrataActivatableDirective; inputs: { "disabled": "disabled"; "interactable": "interactable"; }; outputs: { "activated": "activated"; }; }]>;
 }
 
-declare class NativeInputRefDirective {
+declare class StrataNativeInputRefDirective {
     el: ElementRef<any>;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NativeInputRefDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NativeInputRefDirective, "input[stInput], textarea[stInput]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataNativeInputRefDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrataNativeInputRefDirective, "input[stInput], textarea[stInput]", never, {}, {}, never, never, true, never>;
 }
 
-declare class InputFieldComponent implements AfterViewInit {
-    iconComponents: _angular_core.Signal<readonly IconComponent[]>;
-    inputField: _angular_core.Signal<NativeInputRefDirective | undefined>;
+declare class StrataInputFieldComponent implements AfterViewInit {
+    iconComponents: _angular_core.Signal<readonly StrataIconComponent[]>;
+    inputField: _angular_core.Signal<StrataNativeInputRefDirective | undefined>;
     private pendingFocus;
     constructor();
     ngAfterViewInit(): void;
     focus(): void;
     blur(): void;
     get nativeInput(): HTMLInputElement | undefined;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputFieldComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputFieldComponent, "st-input-field", never, {}, {}, ["iconComponents", "inputField"], ["label", "[prefix]", "input,textarea", "[suffix]"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataInputFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataInputFieldComponent, "st-input-field", never, {}, {}, ["iconComponents", "inputField"], ["label", "[prefix]", "input,textarea", "[suffix]"], true, never>;
 }
 
-declare class AutoResizeDirective implements AfterViewInit, OnChanges {
+declare class StrataAutoResizeDirective implements AfterViewInit, OnChanges {
     minimumRows: _angular_core.InputSignal<number>;
     maximumRows: _angular_core.InputSignal<number | undefined>;
     private lineHeight;
     private element;
     onInput(): void;
     onWindowResize(): void;
-    constructor();
     ngAfterViewInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
     private calculateLineHeight;
     private resize;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutoResizeDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AutoResizeDirective, "[stAutoResize]", never, { "minimumRows": { "alias": "minimumRows"; "required": false; "isSignal": true; }; "maximumRows": { "alias": "maximumRows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataAutoResizeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrataAutoResizeDirective, "[stAutoResize]", never, { "minimumRows": { "alias": "minimumRows"; "required": false; "isSignal": true; }; "maximumRows": { "alias": "maximumRows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class OverlayDirective implements OnChanges, OnDestroy {
-    stOverlay: _angular_core.InputSignal<TemplateRef<any>>;
+declare class StrataOverlayDirective implements OnChanges, OnDestroy {
+    stOverlay: _angular_core.InputSignal<TemplateRef<unknown>>;
     overlayOpen: _angular_core.ModelSignal<boolean>;
     overlayPlacement: _angular_core.InputSignal<Placement>;
     overlayOffset: _angular_core.InputSignal<number>;
@@ -350,20 +460,20 @@ declare class OverlayDirective implements OnChanges, OnDestroy {
     private readonly viewContainerRef;
     private overlayEl?;
     private cleanup?;
-    constructor();
+    private viewRef?;
     ngOnChanges(): void;
     private create;
     private updatePosition;
     private destroy;
     ngOnDestroy(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayDirective, "[stOverlay]", never, { "stOverlay": { "alias": "stOverlay"; "required": true; "isSignal": true; }; "overlayOpen": { "alias": "overlayOpen"; "required": false; "isSignal": true; }; "overlayPlacement": { "alias": "overlayPlacement"; "required": false; "isSignal": true; }; "overlayOffset": { "alias": "overlayOffset"; "required": false; "isSignal": true; }; }, { "overlayOpen": "overlayOpenChange"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataOverlayDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrataOverlayDirective, "[stOverlay]", never, { "stOverlay": { "alias": "stOverlay"; "required": true; "isSignal": true; }; "overlayOpen": { "alias": "overlayOpen"; "required": false; "isSignal": true; }; "overlayPlacement": { "alias": "overlayPlacement"; "required": false; "isSignal": true; }; "overlayOffset": { "alias": "overlayOffset"; "required": false; "isSignal": true; }; }, { "overlayOpen": "overlayOpenChange"; }, never, never, true, never>;
 }
 
-declare class PaginationComponent {
+declare class StrataPaginationComponent {
     currentPage: _angular_core.ModelSignal<number>;
     totalPages: _angular_core.InputSignal<number>;
-    onPageSelect: _angular_core.OutputEmitterRef<number>;
+    pageSelected: _angular_core.OutputEmitterRef<number>;
     pageButtons: _angular_core.Signal<PaginationItem[]>;
     hideNextPreviousAtStartEnd: _angular_core.InputSignal<boolean>;
     changePage(newPage: number): void;
@@ -373,72 +483,149 @@ declare class PaginationComponent {
     private showAllPages;
     private spaceItem;
     private pageItem;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginationComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaginationComponent, "st-pagination", never, { "currentPage": { "alias": "currentPage"; "required": false; "isSignal": true; }; "totalPages": { "alias": "totalPages"; "required": true; "isSignal": true; }; "hideNextPreviousAtStartEnd": { "alias": "hideNextPreviousAtStartEnd"; "required": false; "isSignal": true; }; }, { "currentPage": "currentPageChange"; "onPageSelect": "onPageSelect"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataPaginationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataPaginationComponent, "st-pagination", never, { "currentPage": { "alias": "currentPage"; "required": false; "isSignal": true; }; "totalPages": { "alias": "totalPages"; "required": true; "isSignal": true; }; "hideNextPreviousAtStartEnd": { "alias": "hideNextPreviousAtStartEnd"; "required": false; "isSignal": true; }; }, { "currentPage": "currentPageChange"; "pageSelected": "pageSelected"; }, never, never, true, never>;
 }
-type PaginationItem = {
+interface PaginationItem {
     page: number | undefined;
     text: string;
     clickable: boolean;
-};
+}
 
 declare class CapitalizePipe implements PipeTransform {
     static capitalize(value: string): string;
-    transform(value: string, ...args: unknown[]): unknown;
+    transform(value: string, ..._args: unknown[]): unknown;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CapitalizePipe, never>;
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<CapitalizePipe, "capitalize", true>;
 }
 
-declare class ProgressComponent {
+declare class StrataProgressLinearComponent {
     min: _angular_core.InputSignal<number>;
     max: _angular_core.InputSignal<number>;
     value: _angular_core.InputSignal<number>;
-    type: _angular_core.InputSignal<ProgressType>;
     showLabel: _angular_core.InputSignal<boolean>;
-    labelFormat: _angular_core.InputSignal<ProgressLabelFormat>;
-    growDirection: _angular_core.InputSignal<ProgressGrowDirection>;
+    labelFormat: _angular_core.InputSignal<ProgressLinearLabelFormat>;
+    growDirection: _angular_core.InputSignal<ProgressLinearGrowDirection>;
+    percentage: _angular_core.Signal<number>;
+    get cssClasses(): string[];
+    get percentageProperty(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataProgressLinearComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataProgressLinearComponent, "st-progress-linear", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "labelFormat": { "alias": "labelFormat"; "required": false; "isSignal": true; }; "growDirection": { "alias": "growDirection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+type ProgressLinearLabelFormat = 'percentage' | 'value';
+type ProgressLinearGrowDirection = 'left' | 'right';
+
+declare class StrataProgressRadialComponent {
+    min: _angular_core.InputSignal<number>;
+    max: _angular_core.InputSignal<number>;
+    value: _angular_core.InputSignal<number>;
+    showLabel: _angular_core.InputSignal<boolean>;
+    labelFormat: _angular_core.InputSignal<ProgressRadialLabelFormat>;
     size: _angular_core.InputSignal<number>;
     strokeWidth: _angular_core.InputSignal<number>;
     percentage: _angular_core.Signal<number>;
     radius: _angular_core.Signal<number>;
     circumference: _angular_core.Signal<number>;
     dashOffset: _angular_core.Signal<number>;
-    get cssClasses(): string[];
     get percentageProperty(): number;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressComponent, "st-progress", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "labelFormat": { "alias": "labelFormat"; "required": false; "isSignal": true; }; "growDirection": { "alias": "growDirection"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataProgressRadialComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataProgressRadialComponent, "st-progress-radial", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "labelFormat": { "alias": "labelFormat"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
-type ProgressType = 'linear' | 'radial';
-type ProgressLabelFormat = 'percentage' | 'value';
-type ProgressGrowDirection = 'left' | 'right';
+type ProgressRadialLabelFormat = 'percentage' | 'value';
 
-declare class SegmentedControlItemComponent {
+declare class StrataRadioComponent {
+    value: _angular_core.InputSignal<string>;
+    label: _angular_core.InputSignal<string | undefined>;
+    checked: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    select: _angular_core.OutputEmitterRef<void>;
+    get isChecked(): boolean;
+    get isDisabled(): boolean;
+    onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataRadioComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataRadioComponent, "st-radio", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "select": "select"; }, never, never, true, never>;
+}
+
+declare class StrataRadioGroupComponent {
+    value: _angular_core.ModelSignal<string>;
+    radios: _angular_core.Signal<readonly StrataRadioComponent[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataRadioGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataRadioGroupComponent, "st-radio-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["radios"], ["*"], true, never>;
+}
+
+declare class StrataSegmentedControlItemComponent {
     text: _angular_core.InputSignal<string>;
     selected: _angular_core.ModelSignal<boolean>;
     disabled: _angular_core.InputSignal<boolean>;
-    onSelection: _angular_core.OutputEmitterRef<void>;
+    selectionChanged: _angular_core.OutputEmitterRef<void>;
     get tabIndex(): number | null;
     get disabledAttribute(): boolean | null;
     onClick(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedControlItemComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedControlItemComponent, "st-segmented-control-item", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; "onSelection": "onSelection"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataSegmentedControlItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataSegmentedControlItemComponent, "st-segmented-control-item", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; "selectionChanged": "selectionChanged"; }, never, never, true, never>;
 }
 
-declare class SegmentedControlComponent implements AfterViewInit {
-    segmentItems: _angular_core.Signal<readonly SegmentedControlItemComponent[]>;
+declare class StrataSegmentedControlComponent implements AfterViewInit {
+    private elementRef;
+    private destroyRef;
+    fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    segmentItems: _angular_core.Signal<readonly StrataSegmentedControlItemComponent[]>;
     segmentItemsRefs: _angular_core.Signal<readonly ElementRef<any>[]>;
-    selectedItem: _angular_core.WritableSignal<SegmentedControlItemComponent | null>;
+    selectedItem: _angular_core.WritableSignal<StrataSegmentedControlItemComponent | null>;
     selectedIndex: _angular_core.WritableSignal<number>;
+    offsets: _angular_core.WritableSignal<number[]>;
+    itemWidths: _angular_core.WritableSignal<number[]>;
+    tops: _angular_core.WritableSignal<number[]>;
+    heights: _angular_core.WritableSignal<number[]>;
     offset: _angular_core.Signal<number>;
-    private widths;
+    indicatorWidth: _angular_core.Signal<number>;
+    indicatorTop: _angular_core.Signal<number>;
+    indicatorHeight: _angular_core.Signal<number>;
     ngAfterViewInit(): void;
-    selectItem(selectedItem: SegmentedControlItemComponent): void;
-    calculateOffset(currentIndex: number): number;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedControlComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedControlComponent, "st-segmented-control", never, {}, {}, ["segmentItems", "segmentItemsRefs"], ["st-segmented-control-item"], true, never>;
+    constructor();
+    selectItem(selectedItem: StrataSegmentedControlItemComponent): void;
+    private updateDimensions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataSegmentedControlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataSegmentedControlComponent, "st-segmented-control", never, { "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; }, {}, ["segmentItems", "segmentItemsRefs"], ["st-segmented-control-item"], true, never>;
+}
+
+declare class StrataSidemenuComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataSidemenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataSidemenuComponent, "st-sidemenu", never, {}, {}, never, ["[st-sidemenu-header]", "*", "[st-sidemenu-footer]"], true, never>;
+}
+
+declare class StrataSidemenuSectionComponent {
+    label: _angular_core.InputSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataSidemenuSectionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataSidemenuSectionComponent, "st-sidemenu-section", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class StrataSidemenuItemGroupComponent implements AfterContentInit {
+    label: _angular_core.InputSignal<string>;
+    expanded: _angular_core.WritableSignal<boolean>;
+    hasActiveChild: _angular_core.WritableSignal<boolean>;
+    private router;
+    private destroyRef;
+    routerLinks: QueryList<RouterLinkActive>;
+    ngAfterContentInit(): void;
+    toggle(): void;
+    private checkActiveState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataSidemenuItemGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataSidemenuItemGroupComponent, "st-sidemenu-item-group", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, ["routerLinks"], ["*"], true, never>;
+}
+
+declare class StrataSidemenuItemDirective {
+    active: _angular_core.InputSignal<boolean>;
+    private readonly elementRef;
+    constructor();
+    readonly isSidemenuItem = true;
+    get isSelected(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataSidemenuItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrataSidemenuItemDirective, "[stSidemenuItem]", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class SliderComponent implements AfterViewInit, OnDestroy {
+declare class StrataSliderComponent implements AfterViewInit, OnDestroy {
     wrapper: _angular_core.Signal<ElementRef<HTMLDivElement>>;
     private resizeObserver;
     value: _angular_core.ModelSignal<number | undefined>;
@@ -452,40 +639,93 @@ declare class SliderComponent implements AfterViewInit, OnDestroy {
     ngOnDestroy(): void;
     private updateTickMath;
     private getThumbSize;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SliderComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SliderComponent, "st-slider", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "minimum": { "alias": "minimum"; "required": true; "isSignal": true; }; "maximum": { "alias": "maximum"; "required": true; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataSliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataSliderComponent, "st-slider", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "minimum": { "alias": "minimum"; "required": true; "isSignal": true; }; "maximum": { "alias": "maximum"; "required": true; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
 }
 
-declare class SpinnerComponent {
+declare class StrataSpinnerComponent {
     size: _angular_core.InputSignal<SpinnerSize>;
     get cssClasses(): string[];
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpinnerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpinnerComponent, "st-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataSpinnerComponent, "st-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 type SpinnerSize = 'xs' | 'sm' | 'md' | 'lg';
 
-declare class TextStackComponent {
+declare class StrataTabItemComponent {
+    /**
+     * The text label for the tab.
+     * Can also be provided via content projection.
+     */
+    text: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the tab is currently selected.
+     */
+    selected: _angular_core.ModelSignal<boolean>;
+    /**
+     * Whether the tab is disabled.
+     */
+    disabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Emitted when the tab is clicked.
+     */
+    selectionChanged: _angular_core.OutputEmitterRef<void>;
+    get isSelected(): boolean;
+    get isDisabled(): boolean;
+    get tabIndex(): number | null;
+    get activeClass(): boolean;
+    get disabledClass(): boolean;
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataTabItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataTabItemComponent, "st-tab-item", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; "selectionChanged": "selectionChanged"; }, never, ["*"], true, never>;
+}
+
+declare class StrataTabsComponent implements AfterViewInit {
+    tabItems: _angular_core.Signal<readonly StrataTabItemComponent[]>;
+    tabItemsRefs: _angular_core.Signal<readonly ElementRef<any>[]>;
+    indicator: _angular_core.Signal<ElementRef<any> | undefined>;
+    selectedTab: _angular_core.WritableSignal<StrataTabItemComponent | null>;
+    selectedIndex: _angular_core.WritableSignal<number>;
+    private resizeObserver?;
+    constructor();
+    ngAfterViewInit(): void;
+    private updateIndicator;
+    private selectTab;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataTabsComponent, "st-tabs", never, {}, {}, ["tabItems", "tabItemsRefs"], ["*"], true, never>;
+}
+
+declare class StrataTextStackComponent {
     overflow: _angular_core.InputSignal<TextStackOverflow>;
     get cssClasses(): string[];
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextStackComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextStackComponent, "st-text-stack", never, { "overflow": { "alias": "overflow"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataTextStackComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataTextStackComponent, "st-text-stack", never, { "overflow": { "alias": "overflow"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 type TextStackOverflow = 'truncate' | 'wrap';
 
-declare class ToggleComponent {
+declare class StrataToggleComponent {
+    private _activatable;
     checked: _angular_core.ModelSignal<boolean>;
-    get isChecked(): boolean;
-    size: _angular_core.InputSignal<"sm" | "md" | "lg">;
-    get sizeClass(): "sm" | "md" | "lg";
-    onCheckChanged(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleComponent, "st-toggle", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, never, true, never>;
+    label: _angular_core.InputSignal<string | undefined>;
+    labelPosition: _angular_core.InputSignal<"before" | "after">;
+    disabled: _angular_core.InputSignal<boolean>;
+    onCheckChanged(event?: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataToggleComponent, "st-toggle", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, ["*"], true, [{ directive: typeof StrataActivatableDirective; inputs: { "disabled": "disabled"; }; outputs: { "activated": "activated"; }; }]>;
 }
 
+declare class StrataThemeDirective {
+    element: ElementRef<any>;
+    stTheme: _angular_core.InputSignal<Theme>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataThemeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrataThemeDirective, "[stTheme]", never, { "stTheme": { "alias": "stTheme"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+type Theme = 'brand' | 'default' | 'danger' | 'warning' | 'success' | 'info';
+
 interface ModalConfiguration {
     title?: string;
     component: Type<unknown>;
-    onModalClosed?: (value?: any) => void;
+    onModalClosed?: (value?: unknown) => void;
     hideCloseButton?: boolean;
     disableBackdropClosure?: boolean;
     size?: ModalSize;
@@ -499,22 +739,23 @@ interface AlertConfiguration {
     affirmativeButton: string;
     cancelButton?: string;
 }
-interface WithID {
-    id: string;
-}
 type ModalSize = 'xs' | 'sm' | 'md' | 'lg';
+declare abstract class StrataModalRef {
+    abstract close(value?: unknown): void;
+}
 
 declare class ModalService {
-    private stack;
-    private currentModals;
+    private _modals;
+    modals: _angular_core.Signal<ModalConfiguration[]>;
     showModal(config: ModalConfiguration): void;
     showAlert(config: AlertConfiguration, callback: (value: boolean) => void): void;
-    closeCurrentModal(value?: any): void;
+    closeCurrentModal(value?: unknown): void;
+    close(config: ModalConfiguration, value?: unknown): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<ModalService>;
 }
 
-declare class AlertContentComponent {
+declare class StrataAlertContentComponent {
     private modalService;
     title: _angular_core.InputSignal<string>;
     message: _angular_core.InputSignal<string | undefined>;
@@ -526,43 +767,30 @@ declare class AlertContentComponent {
     constructor(modalService: ModalService);
     onAffirmation(): void;
     onCancel(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertContentComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertContentComponent, "st-alert-content", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "affirmativeButton": { "alias": "affirmativeButton"; "required": true; "isSignal": true; }; "cancelButton": { "alias": "cancelButton"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-declare class Stack<T> {
-    items: T[];
-    push(item: T): void;
-    pop(): T;
-    peek(): T;
-    empty(): boolean;
-    size(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataAlertContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataAlertContentComponent, "st-alert-content", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "affirmativeButton": { "alias": "affirmativeButton"; "required": true; "isSignal": true; }; "cancelButton": { "alias": "cancelButton"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class ModalContainerComponent implements OnDestroy {
-    private modalService;
-    injectedComponent: ComponentRef<any>;
-    currentModal: ModalConfiguration | null;
-    stack: Stack<ModalConfiguration & WithID>;
-    private subscription;
+declare class StrataModalContainerComponent {
+    modalService: ModalService;
     constructor(modalService: ModalService);
-    ngOnDestroy(): void;
     onBackdropClick(event: MouseEvent): void;
-    stackTrack(index: number, item: ModalConfiguration & WithID): string;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalContainerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalContainerComponent, "st-modal-container", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataModalContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataModalContainerComponent, "st-modal-container", never, {}, {}, never, never, true, never>;
 }
 
-declare class ModalHeaderComponent {
+declare class StrataModalHeaderComponent {
     modalService: ModalService;
     title: _angular_core.InputSignal<string | null | undefined>;
     showCloseButton: _angular_core.InputSignal<boolean>;
     onCloseButtonClicked(event: MouseEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalHeaderComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalHeaderComponent, "st-modal-header", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataModalHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataModalHeaderComponent, "st-modal-header", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class ModalComponent implements AfterViewInit {
+declare class StrataModalComponent implements AfterViewInit {
+    private modalService;
+    private injector;
     modalContents: _angular_core.Signal<ViewContainerRef>;
     configuration: _angular_core.InputSignal<ModalConfiguration>;
     size: _angular_core.ModelSignal<ModalSize | undefined>;
@@ -570,8 +798,8 @@ declare class ModalComponent implements AfterViewInit {
     ngAfterViewInit(): void;
     private setInputsOnInjectedComponent;
     onCardClick(event: MouseEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalComponent, "st-modal", never, { "configuration": { "alias": "configuration"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "size": "sizeChange"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataModalComponent, "st-modal", never, { "configuration": { "alias": "configuration"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "size": "sizeChange"; }, never, never, true, never>;
 }
 
 interface NotificationConfiguration {
@@ -584,7 +812,7 @@ type NotificationsWithIds = NotificationConfiguration & {
     id: string;
 };
 declare const DEFAULT_THEME: Theme;
-declare const DEFAULT_DURATION: number;
+declare const DEFAULT_DURATION = 3000;
 
 declare class NotificationService {
     notificationStack: _angular_core.WritableSignal<NotificationsWithIds[]>;
@@ -594,22 +822,21 @@ declare class NotificationService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<NotificationService>;
 }
 
-declare class NotificationContainerComponent {
+declare class StrataNotificationContainerComponent {
     notificationService: NotificationService;
     notifications: _angular_core.WritableSignal<ngx_strata.NotificationsWithIds[]>;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationContainerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NotificationContainerComponent, "st-notification-container", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataNotificationContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataNotificationContainerComponent, "st-notification-container", never, {}, {}, never, never, true, never>;
 }
 
-declare class NotificationComponent {
+declare class StrataNotificationComponent {
     icon?: string;
     message: string;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NotificationComponent, "st-notification", never, { "icon": { "alias": "icon"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataNotificationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataNotificationComponent, "st-notification", never, { "icon": { "alias": "icon"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, {}, never, never, true, never>;
 }
 
-declare class NumberDisplayComponent {
+declare class StrataNumberDisplayComponent {
     private readonly locale;
     value: _angular_core.InputSignal<number>;
     decimals: _angular_core.InputSignal<number>;
@@ -623,17 +850,26 @@ declare class NumberDisplayComponent {
     showPlus: _angular_core.InputSignal<boolean>;
     deemphasizeDecimals: _angular_core.InputSignal<boolean>;
     readonly decimalPoint: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberDisplayComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberDisplayComponent, "st-number-display", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "changedValue": { "alias": "changedValue"; "required": false; "isSignal": true; }; "showPlus": { "alias": "showPlus"; "required": false; "isSignal": true; }; "deemphasizeDecimals": { "alias": "deemphasizeDecimals"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataNumberDisplayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataNumberDisplayComponent, "st-number-display", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "changedValue": { "alias": "changedValue"; "required": false; "isSignal": true; }; "showPlus": { "alias": "showPlus"; "required": false; "isSignal": true; }; "deemphasizeDecimals": { "alias": "deemphasizeDecimals"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class ThemeDirective {
-    element: ElementRef<any>;
-    stTheme: _angular_core.InputSignal<Theme>;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThemeDirective, "[stTheme]", never, { "stTheme": { "alias": "stTheme"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+declare class StrataShellComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataShellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataShellComponent, "st-shell", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class StrataMessageStateComponent {
+    header: _angular_core.InputSignal<string>;
+    subtitle: _angular_core.InputSignal<string | undefined>;
+    primaryActionText: _angular_core.InputSignal<string | undefined>;
+    primaryActionTheme: _angular_core.InputSignal<Theme | undefined>;
+    secondaryActionText: _angular_core.InputSignal<string | undefined>;
+    primaryAction: _angular_core.OutputEmitterRef<void>;
+    secondaryAction: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataMessageStateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataMessageStateComponent, "st-message-state", never, { "header": { "alias": "header"; "required": true; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "primaryActionText": { "alias": "primaryActionText"; "required": false; "isSignal": true; }; "primaryActionTheme": { "alias": "primaryActionTheme"; "required": false; "isSignal": true; }; "secondaryActionText": { "alias": "secondaryActionText"; "required": false; "isSignal": true; }; }, { "primaryAction": "primaryAction"; "secondaryAction": "secondaryAction"; }, never, ["*"], true, never>;
 }
 
-export { AccordionGroupComponent, AccordionItemComponent, ActionMenuComponent, ActionMenuItemComponent, AlertContentComponent, AutoResizeDirective, AvatarComponent, AvatarStackComponent, ButtonDirective, ButtonGroupComponent, CapitalizePipe, CardComponent, CheckboxComponent, DEFAULT_DURATION, DEFAULT_THEME, DarkmodeService, DividerComponent, DropdownComponent, HttpIconLoader, IconComponent, IconLoader, IconRegistry, IconRegistryService, InputFieldComponent, ItemComponent, ItemListComponent, ModalComponent, ModalContainerComponent, ModalHeaderComponent, ModalService, NativeInputRefDirective, NotificationComponent, NotificationContainerComponent, NotificationService, NumberDisplayComponent, OverlayDirective, PaginationComponent, ProgressComponent, STRATA_CONFIG, SegmentedControlComponent, SegmentedControlItemComponent, SliderComponent, SpinnerComponent, TagComponent, TextStackComponent, ThemeDirective, ToggleComponent, TooltipDirective, provideBaseIcons, provideIcons, provideStrata };
-export type { AlertConfiguration, ButtonGroupJustification, ButtonSize, ButtonVariant, CardVariant, CurrentDarkmode, DarkmodeSetting, DropdownSize, IconConfig, IconSize, ModalConfiguration, ModalSize, NotificationConfiguration, NotificationsWithIds, PaginationItem, ProgressGrowDirection, ProgressLabelFormat, ProgressType, SelectItem, Size, SpinnerSize, StrataConfig, TagSize, TextStackOverflow, Theme, TooltipPlacement, WithID };
+export { CapitalizePipe, DEFAULT_DURATION, DEFAULT_THEME, DarkmodeService, HotkeyService, HttpIconLoader, IconLoader, IconRegistry, IconRegistryService, ModalService, NotificationService, STRATA_CONFIG, StrataAccordionGroupComponent, StrataAccordionItemComponent, StrataActionMenuComponent, StrataActionMenuItemComponent, StrataActivatableDirective, StrataAlertComponent, StrataAlertContentComponent, StrataAutoResizeDirective, StrataAvatarComponent, StrataAvatarStackComponent, StrataBreadcrumbComponent, StrataBreadcrumbItemComponent, StrataButtonDirective, StrataButtonGroupComponent, StrataCardComponent, StrataCheckboxComponent, StrataDividerComponent, StrataIconComponent, StrataInputFieldComponent, StrataItemComponent, StrataItemListComponent, StrataKbdComponent, StrataMessageStateComponent, StrataModalComponent, StrataModalContainerComponent, StrataModalHeaderComponent, StrataModalRef, StrataNativeInputRefDirective, StrataNotificationComponent, StrataNotificationContainerComponent, StrataNumberDisplayComponent, StrataOverlayDirective, StrataPaginationComponent, StrataProgressLinearComponent, StrataProgressRadialComponent, StrataRadioComponent, StrataRadioGroupComponent, StrataSegmentedControlComponent, StrataSegmentedControlItemComponent, StrataSelectItemComponent, StrataSelectTriggerDirective, StrataShellComponent, StrataSidemenuComponent, StrataSidemenuItemDirective, StrataSidemenuItemGroupComponent, StrataSidemenuSectionComponent, StrataSingleSelectComponent, StrataSliderComponent, StrataSpinnerComponent, StrataTabItemComponent, StrataTabsComponent, StrataTagComponent, StrataTextStackComponent, StrataThemeDirective, StrataToggleComponent, StrataTooltipDirective, provideBaseIcons, provideIcons, provideStrata };
+export type { AlertConfiguration, AvatarSize, ButtonGroupJustification, ButtonSize, ButtonVariant, CardVariant, CurrentDarkmode, DarkmodeSetting, HotkeyOptions, IconConfig, IconSize, ModalConfiguration, ModalSize, NotificationConfiguration, NotificationsWithIds, PaginationItem, ProgressLinearGrowDirection, ProgressLinearLabelFormat, ProgressRadialLabelFormat, SpinnerSize, StrataConfig, TagSize, TextStackOverflow, Theme, TooltipPlacement };