ngx-strata 0.2.5 → 0.4.0

package/types/ngx-strata.d.ts

@@ -1,15 +1,17 @@
 import * as _angular_core from '@angular/core';
-import { OnInit, OnDestroy, AfterContentInit, EnvironmentProviders, InjectionToken, Provider, ElementRef, Renderer2, AfterViewInit, TemplateRef, OnChanges, SimpleChanges, PipeTransform, QueryList, Type, ViewContainerRef } from '@angular/core';
+import { OnInit, OnDestroy, AfterContentInit, EnvironmentProviders, InjectionToken, Provider, PipeTransform, ElementRef, OnChanges, TemplateRef, Renderer2, AfterViewInit, SimpleChanges, Type, ViewContainerRef, QueryList, OutputEmitterRef } 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 { ControlValueAccessor } from '@angular/forms';
 import { Observable } from 'rxjs';
 import { HttpClient } from '@angular/common/http';
-import { RouterLinkActive } from '@angular/router';
 import * as ngx_strata from 'ngx-strata';
+import { RouterLinkActive } from '@angular/router';
 
 declare class StrataActivatableDirective {
     private _elementRef;
+    private _config;
     disabled: _angular_core.InputSignal<boolean>;
     interactable: _angular_core.ModelSignal<boolean>;
     activated: _angular_core.OutputEmitterRef<Event>;
@@ -24,9 +26,9 @@ declare class StrataTooltipDirective implements OnInit, OnDestroy, AfterContentI
     private element;
     private renderer;
     stSimpleTooltip: _angular_core.InputSignal<string>;
-    tooltipEnabled: boolean;
-    tooltipPlacement: TooltipPlacement;
-    tooltipAlwaysShow: boolean;
+    tooltipEnabled: _angular_core.InputSignal<boolean>;
+    tooltipPlacement: _angular_core.InputSignal<TooltipPlacement>;
+    tooltipAlwaysShow: _angular_core.InputSignal<boolean>;
     private tooltipContentElement;
     private arrowElement;
     private eventListeners;
@@ -41,7 +43,7 @@ declare class StrataTooltipDirective implements OnInit, OnDestroy, AfterContentI
     private show;
     private hide;
     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>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrataTooltipDirective, "[stSimpleTooltip]", never, { "stSimpleTooltip": { "alias": "stSimpleTooltip"; "required": true; "isSignal": true; }; "tooltipEnabled": { "alias": "tooltipEnabled"; "required": false; "isSignal": true; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; "isSignal": true; }; "tooltipAlwaysShow": { "alias": "tooltipAlwaysShow"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 type TooltipPlacement = Exclude<Placement, 'left-start' | 'left-end' | 'right-start' | 'right-end'>;
 
@@ -109,13 +111,21 @@ type IconSize = 'xs' | 'sm' | 'md' | 'lg';
 declare const provideBaseIcons: () => EnvironmentProviders;
 declare const provideIcons: (iconConfigs: IconConfig[]) => EnvironmentProviders;
 
+type StrataPlatform = 'auto' | 'mac' | 'windows' | 'linux';
+declare function isApplePlatform(): boolean;
+declare function resolveIsApple(platform?: StrataPlatform): boolean;
+
+declare function getDefaultShortcutLabels(platform?: StrataPlatform, crossPlatformHotkeys?: boolean): {
+    meta: string;
+    ctrl: string;
+    shift: string;
+    alt: string;
+};
 declare function provideStrata(config?: Partial<StrataConfig>): (Provider | EnvironmentProviders)[];
 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;
@@ -123,9 +133,41 @@ interface StrataConfig {
         alt?: string;
     };
     overlayViewportBuffer?: number;
+    activationKeys?: string[];
+    platform?: StrataPlatform;
 }
 declare const STRATA_CONFIG: InjectionToken<StrataConfig>;
 
+declare class CapitalizePipe implements PipeTransform {
+    static capitalize(value: string): string;
+    transform(value: string, ..._args: unknown[]): unknown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CapitalizePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CapitalizePipe, "capitalize", true>;
+}
+
+declare class StrataAccordionItemComponent {
+    private static nextId;
+    readonly contentId: string;
+    readonly headerId: string;
+    title: _angular_core.InputSignal<string>;
+    open: _angular_core.ModelSignal<boolean>;
+    toggled: _angular_core.OutputEmitterRef<boolean>;
+    constructor();
+    toggle(): void;
+    get isOpen(): boolean;
+    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 StrataAccordionGroupComponent {
+    items: _angular_core.Signal<readonly StrataAccordionItemComponent[]>;
+    allowMultipleOpen: _angular_core.InputSignal<boolean>;
+    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 StrataActionMenuItemComponent {
     private checkbox;
     private toggle;
@@ -139,16 +181,41 @@ declare class StrataActionMenuItemComponent {
     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 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>;
+    overlayFitViewport: _angular_core.InputSignal<boolean>;
+    private readonly element;
+    private readonly viewContainerRef;
+    private readonly config;
+    private overlayEl?;
+    private cleanup?;
+    private viewRef?;
+    ngOnChanges(): void;
+    private create;
+    private updatePosition;
+    private destroy;
+    getOverlayElement(): HTMLElement | undefined;
+    ngOnDestroy(): void;
+    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; }; "overlayFitViewport": { "alias": "overlayFitViewport"; "required": false; "isSignal": true; }; }, { "overlayOpen": "overlayOpenChange"; }, never, never, true, never>;
+}
+
 declare class StrataActionMenuComponent {
     projectedButton: _angular_core.Signal<ElementRef<any> | undefined>;
     defaultButton: _angular_core.Signal<ElementRef<any> | undefined>;
+    overlayDirective: _angular_core.Signal<StrataOverlayDirective | undefined>;
     actionMenuItems: _angular_core.Signal<readonly StrataActionMenuItemComponent[]>;
     placement: _angular_core.InputSignal<Placement>;
+    closeOnOutsideClick: _angular_core.InputSignal<boolean>;
+    elementRef: ElementRef<HTMLElement>;
     renderer: Renderer2;
     menuOpen: _angular_core.WritableSignal<boolean>;
     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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataActionMenuComponent, "st-action-menu", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; "isSignal": true; }; }, {}, ["projectedButton", "actionMenuItems"], ["button[stButton]", "st-action-menu-item"], true, never>;
 }
 
 declare class StrataAlertComponent {
@@ -161,91 +228,94 @@ declare class StrataAlertComponent {
     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 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<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 StrataAccordionGroupComponent {
-    items: _angular_core.Signal<readonly StrataAccordionItemComponent[]>;
-    allowMultipleOpen: _angular_core.InputSignal<boolean>;
-    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>;
+    ariaLabel: _angular_core.InputSignal<string | undefined>;
     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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataIconComponent, "st-icon", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "size": "sizeChange"; }, never, never, true, never>;
 }
 
 declare class StrataAvatarComponent implements AfterViewInit {
     iconComponents: _angular_core.Signal<readonly StrataIconComponent[]>;
+    src: _angular_core.InputSignal<string | null>;
+    alt: _angular_core.InputSignal<string>;
     text: _angular_core.InputSignal<string | null>;
     size: _angular_core.ModelSignal<AvatarSize>;
+    imageError: _angular_core.WritableSignal<boolean>;
+    constructor();
     get elementClasses(): AvatarSize[];
+    onImageError(): void;
     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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataAvatarComponent, "st-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "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 StrataAvatarStackComponent implements AfterViewInit {
-    avatarRefs: _angular_core.Signal<readonly ElementRef<any>[]>;
+declare class StrataAvatarStackComponent {
     size: _angular_core.InputSignal<AvatarSize>;
     spacing: _angular_core.InputSignal<"loose" | "mid" | "tight">;
     firstOnFront: _angular_core.InputSignal<boolean>;
-    get xsClass(): boolean;
-    get smClass(): boolean;
-    get mdClass(): boolean;
-    get lgClass(): boolean;
-    get firstOnFrontClass(): boolean;
-    get looseClass(): boolean;
-    get midClass(): boolean;
-    get tightClass(): boolean;
-    ngAfterViewInit(): void;
     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>;
+    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; }; }, {}, never, ["*"], true, never>;
+}
+type AvatarStackSpacing = 'loose' | 'mid' | 'tight';
+
+type BadgeVariant = 'accent' | 'neutral' | 'success' | 'warning' | 'error' | 'info';
+type BadgeSize = 'xs' | 'sm' | 'md';
+type BadgePlacement = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'inline';
+
+declare class StrataBadgeComponent {
+    value: _angular_core.InputSignal<string | number | undefined>;
+    icon: _angular_core.InputSignal<string | undefined>;
+    max: _angular_core.InputSignal<number>;
+    variant: _angular_core.InputSignal<BadgeVariant>;
+    size: _angular_core.InputSignal<BadgeSize>;
+    placement: _angular_core.InputSignal<BadgePlacement>;
+    visible: _angular_core.InputSignal<boolean>;
+    showZero: _angular_core.InputSignal<boolean>;
+    ariaLabel: _angular_core.InputSignal<string | undefined>;
+    isDot: _angular_core.Signal<boolean>;
+    isIconOnly: _angular_core.Signal<boolean>;
+    displayValue: _angular_core.Signal<string>;
+    shouldRender: _angular_core.Signal<boolean>;
+    computedAriaLabel: _angular_core.Signal<string | undefined>;
+    readonly role = "status";
+    get hostAriaLabel(): string | undefined;
+    get hostClasses(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataBadgeComponent, "st-badge", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "showZero": { "alias": "showZero"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+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 StrataButtonGroupComponent {
-    renderer: Renderer2;
     justification: _angular_core.InputSignal<ButtonGroupJustification>;
     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 StrataButtonDirective implements AfterContentInit {
+declare class StrataButtonDirective implements AfterContentInit, OnDestroy {
     host: ElementRef<any>;
     variant: _angular_core.InputSignal<ButtonVariant>;
     size: _angular_core.InputSignal<ButtonSize>;
@@ -253,8 +323,11 @@ declare class StrataButtonDirective implements AfterContentInit {
     private iconAtStart;
     private iconAtEnd;
     private iconOnly;
+    private observer?;
     get classes(): string[];
     ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    private updateIconState;
     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>;
@@ -280,58 +353,27 @@ declare class StrataCardComponent {
 }
 type CardVariant = 'elevated' | 'flat' | 'outline';
 
-declare class StrataCheckboxComponent {
+declare class StrataCheckboxComponent implements ControlValueAccessor {
+    private readonly defaultId;
     value: _angular_core.ModelSignal<boolean | undefined>;
     label: _angular_core.InputSignal<string | undefined>;
     name: _angular_core.InputSignal<string | undefined>;
-    onClick(event: MouseEvent): void;
+    id: _angular_core.InputSignal<string | undefined>;
+    disabled: _angular_core.InputSignal<boolean>;
+    private cvaDisabled;
+    effectiveDisabled: _angular_core.Signal<boolean>;
+    effectiveId: _angular_core.Signal<string>;
+    private onChange;
+    private onTouched;
+    toggle(): void;
+    onHostClick(event: MouseEvent): void;
+    onSpaceKey(event: Event): void;
+    writeValue(val: boolean | null | undefined): void;
+    registerOnChange(fn: (val: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
     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 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<unknown>;
-    selectedItem: _angular_core.Signal<StrataSelectItemComponent | undefined>;
-    searchable: _angular_core.InputSignal<boolean>;
-    searchQuery: _angular_core.ModelSignal<string | undefined>;
-    searchPlaceholder: _angular_core.InputSignal<string>;
-    itemSelected: _angular_core.OutputEmitterRef<unknown>;
-    selectItems: _angular_core.Signal<readonly StrataSelectItemComponent[]>;
-    triggerTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
-    private inputField;
-    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<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>;
-}
-
-declare class StrataSelectTriggerDirective {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataSelectTriggerDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrataSelectTriggerDirective, "[stSelectTrigger]", never, {}, {}, never, never, true, 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; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
 }
 
 declare class StrataDividerComponent {
@@ -342,24 +384,37 @@ declare class StrataDividerComponent {
     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 StrataTagComponent {
-    size: _angular_core.InputSignal<TagSize>;
-    get class(): TagSize;
-    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 class StrataFileUploadComponent {
+    fileInput: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    accept: _angular_core.InputSignal<string>;
+    multiple: _angular_core.InputSignal<boolean>;
+    maxFileSize: _angular_core.InputSignal<number | undefined>;
+    disabled: _angular_core.InputSignal<boolean>;
+    label: _angular_core.InputSignal<string>;
+    hint: _angular_core.InputSignal<string | undefined>;
+    fileSelect: _angular_core.OutputEmitterRef<File>;
+    filesSelect: _angular_core.OutputEmitterRef<File[]>;
+    fileRejected: _angular_core.OutputEmitterRef<{
+        file: File;
+        reason: "type" | "size";
+    }>;
+    isDragOver: _angular_core.WritableSignal<boolean>;
+    get hostDisabled(): boolean;
+    get hostDragOver(): boolean;
+    readonly hostRole = "button";
+    get hostTabIndex(): number;
+    onClick(event: MouseEvent): void;
+    onKeydown(event: Event): void;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    onFileChange(event: Event): void;
+    browse(): void;
+    clear(): void;
+    private processFiles;
+    private matchesAccept;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataFileUploadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataFileUploadComponent, "st-file-upload", never, { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; }, { "fileSelect": "fileSelect"; "filesSelect": "filesSelect"; "fileRejected": "fileRejected"; }, never, ["[uploadIcon]", "*"], true, never>;
 }
 
 declare abstract class IconLoader {
@@ -390,30 +445,86 @@ declare class IconRegistryService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<IconRegistryService>;
 }
 
-declare class StrataItemListComponent<T> {
-    items: _angular_core.InputSignal<T[]>;
-    dividers: _angular_core.InputSignal<boolean>;
-    template: _angular_core.InputSignal<TemplateRef<T> | undefined>;
-    get hostClasses(): string[];
-    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 StrataItemComponent {
-    private element;
-    private _activatable;
-    private checkbox;
-    private toggle;
-    private radio;
-    interactable: _angular_core.ModelSignal<boolean>;
+type CropShape = 'circle' | 'square';
+interface CropResult {
+    blob: Blob;
+    dataUrl: string;
+    file?: File;
+    width: number;
+    height: number;
+}
+interface CropPosition {
+    x: number;
+    y: number;
+}
+
+declare class StrataImageCropperComponent implements OnDestroy {
+    viewportRef: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    imageRef: _angular_core.Signal<ElementRef<HTMLImageElement> | undefined>;
+    image: _angular_core.InputSignal<string | File | Blob | null>;
+    shape: _angular_core.InputSignal<CropShape>;
+    maskSize: _angular_core.InputSignal<number>;
+    outputWidth: _angular_core.InputSignal<number>;
+    outputHeight: _angular_core.InputSignal<number>;
+    outputFormat: _angular_core.InputSignal<"image/png" | "image/jpeg" | "image/webp">;
+    outputQuality: _angular_core.InputSignal<number>;
+    minZoom: _angular_core.InputSignal<number>;
+    maxZoom: _angular_core.InputSignal<number>;
+    showZoom: _angular_core.InputSignal<boolean>;
+    showRotate: _angular_core.InputSignal<boolean>;
+    showClear: _angular_core.InputSignal<boolean>;
+    clearLabel: _angular_core.InputSignal<string>;
+    autoCrop: _angular_core.InputSignal<boolean>;
     disabled: _angular_core.InputSignal<boolean>;
+    zoom: _angular_core.ModelSignal<number>;
+    rotation: _angular_core.ModelSignal<number>;
+    crop: _angular_core.OutputEmitterRef<CropResult>;
+    imageLoaded: _angular_core.OutputEmitterRef<{
+        width: number;
+        height: number;
+        src: string;
+    }>;
+    imageError: _angular_core.OutputEmitterRef<string>;
+    imageCleared: _angular_core.OutputEmitterRef<void>;
+    currentImageSrc: _angular_core.WritableSignal<string | null>;
+    naturalWidth: _angular_core.WritableSignal<number>;
+    naturalHeight: _angular_core.WritableSignal<number>;
+    panX: _angular_core.WritableSignal<number>;
+    panY: _angular_core.WritableSignal<number>;
+    isDragging: _angular_core.WritableSignal<boolean>;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    hasImage: _angular_core.Signal<boolean>;
+    baseScale: _angular_core.Signal<number>;
+    imageTransform: _angular_core.Signal<string>;
+    private startPointerPos;
+    private startPanPos;
+    private activePointerId;
+    private createdBlobUrl;
+    private autoCropTimeout;
     constructor();
-    get isInteractable(): boolean;
-    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"; }; }]>;
+    get hostDisabled(): boolean;
+    get hostHasImage(): boolean;
+    get hostMaskSize(): string;
+    ngOnDestroy(): void;
+    setImage(source: string | File | Blob | null): void;
+    center(): void;
+    reset(): void;
+    clear(): void;
+    rotateRight(): void;
+    rotateLeft(): void;
+    onImageElementLoad(event: Event): void;
+    onImageElementError(): void;
+    onPointerDown(event: PointerEvent): void;
+    onPointerMove(event: PointerEvent): void;
+    onPointerUp(event: PointerEvent): void;
+    onWheel(event: WheelEvent): void;
+    onZoomChange(val: number | string): void;
+    cropImage(): Promise<CropResult>;
+    private scheduleAutoCrop;
+    private loadImageSource;
+    private cleanupBlobUrl;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataImageCropperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataImageCropperComponent, "st-image-cropper", never, { "image": { "alias": "image"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "maskSize": { "alias": "maskSize"; "required": false; "isSignal": true; }; "outputWidth": { "alias": "outputWidth"; "required": false; "isSignal": true; }; "outputHeight": { "alias": "outputHeight"; "required": false; "isSignal": true; }; "outputFormat": { "alias": "outputFormat"; "required": false; "isSignal": true; }; "outputQuality": { "alias": "outputQuality"; "required": false; "isSignal": true; }; "minZoom": { "alias": "minZoom"; "required": false; "isSignal": true; }; "maxZoom": { "alias": "maxZoom"; "required": false; "isSignal": true; }; "showZoom": { "alias": "showZoom"; "required": false; "isSignal": true; }; "showRotate": { "alias": "showRotate"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "autoCrop": { "alias": "autoCrop"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "rotation": { "alias": "rotation"; "required": false; "isSignal": true; }; }, { "zoom": "zoomChange"; "rotation": "rotationChange"; "crop": "crop"; "imageLoaded": "imageLoaded"; "imageError": "imageError"; "imageCleared": "imageCleared"; }, never, ["[emptyState], [placeholder], st-file-upload", "[actions]"], true, never>;
 }
 
 declare class StrataNativeInputRefDirective {
@@ -422,7 +533,9 @@ declare class StrataNativeInputRefDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrataNativeInputRefDirective, "input[stInput], textarea[stInput]", never, {}, {}, never, never, true, never>;
 }
 
+type InputFieldSize = 'sm' | 'md' | 'lg';
 declare class StrataInputFieldComponent implements AfterViewInit {
+    size: _angular_core.InputSignal<InputFieldSize>;
     iconComponents: _angular_core.Signal<readonly StrataIconComponent[]>;
     inputField: _angular_core.Signal<StrataNativeInputRefDirective | undefined>;
     private pendingFocus;
@@ -432,7 +545,7 @@ declare class StrataInputFieldComponent implements AfterViewInit {
     blur(): void;
     get nativeInput(): HTMLInputElement | undefined;
     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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataInputFieldComponent, "st-input-field", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, ["iconComponents", "inputField"], ["label", "[prefix]", "input,textarea", "[suffix]"], true, never>;
 }
 
 declare class StrataAutoResizeDirective implements AfterViewInit, OnChanges {
@@ -450,54 +563,308 @@ declare class StrataAutoResizeDirective implements AfterViewInit, OnChanges {
     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 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>;
-    overlayFitViewport: _angular_core.InputSignal<boolean>;
-    private readonly element;
-    private readonly viewContainerRef;
-    private readonly config;
-    private overlayEl?;
-    private cleanup?;
-    private viewRef?;
-    ngOnChanges(): void;
-    private create;
-    private updatePosition;
-    private destroy;
-    ngOnDestroy(): void;
-    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; }; "overlayFitViewport": { "alias": "overlayFitViewport"; "required": false; "isSignal": true; }; }, { "overlayOpen": "overlayOpenChange"; }, never, never, true, never>;
+declare class StrataItemListComponent<T> {
+    items: _angular_core.InputSignal<T[]>;
+    dividers: _angular_core.InputSignal<boolean>;
+    template: _angular_core.InputSignal<TemplateRef<T> | undefined>;
+    get hostClasses(): string[];
+    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 StrataPaginationComponent {
-    currentPage: _angular_core.ModelSignal<number>;
-    totalPages: _angular_core.InputSignal<number>;
-    pageSelected: _angular_core.OutputEmitterRef<number>;
-    pageButtons: _angular_core.Signal<PaginationItem[]>;
-    hideNextPreviousAtStartEnd: _angular_core.InputSignal<boolean>;
-    changePage(newPage: number): void;
-    private calculatePageButtons;
-    private showStartingPages;
-    private showEndingPages;
-    private showAllPages;
-    private spaceItem;
-    private pageItem;
-    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>;
-}
-interface PaginationItem {
-    page: number | undefined;
-    text: string;
-    clickable: 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 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 CapitalizePipe implements PipeTransform {
-    static capitalize(value: string): string;
-    transform(value: string, ..._args: unknown[]): unknown;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CapitalizePipe, never>;
-    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CapitalizePipe, "capitalize", true>;
+declare class StrataKbdComponent {
+    private readonly config;
+    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 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';
+
+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>;
+}
+
+declare class StrataAlertContentComponent {
+    private modalService;
+    title: _angular_core.InputSignal<string>;
+    message: _angular_core.InputSignal<string | undefined>;
+    icon: _angular_core.InputSignal<string | undefined>;
+    readonly computedIcon: _angular_core.Signal<string>;
+    theme: _angular_core.InputSignal<Theme>;
+    affirmativeButton: _angular_core.InputSignal<string>;
+    cancelButton: _angular_core.InputSignal<string | undefined>;
+    onAffirmation(): void;
+    onCancel(): void;
+    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>;
+}
+
+interface ModalConfiguration {
+    title?: string;
+    component: Type<unknown>;
+    onModalClosed?: (value?: unknown) => void;
+    hideCloseButton?: boolean;
+    disableBackdropClosure?: boolean;
+    size?: ModalSize;
+    variant?: ModalVariant;
+    inputs?: Record<string, unknown>;
+}
+interface AlertConfiguration {
+    message: string;
+    icon?: string;
+    title?: string;
+    theme?: Theme;
+    affirmativeButton: string;
+    cancelButton?: string;
+}
+type ModalSize = 'xs' | 'sm' | 'md' | 'lg';
+type ModalVariant = 'default' | 'raised';
+declare abstract class StrataModalRef {
+    abstract close(value?: unknown): void;
+}
+
+declare class ModalService {
+    private _modals;
+    modals: _angular_core.Signal<ModalConfiguration[]>;
+    private document;
+    constructor();
+    showModal(config: ModalConfiguration): void;
+    showAlert(config: AlertConfiguration, callback: (value: boolean) => void): 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 StrataModalContainerComponent {
+    modalService: ModalService;
+    onEscape(event: Event): void;
+    onBackdropClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataModalContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataModalContainerComponent, "st-modal-container", never, {}, {}, never, never, true, never>;
+}
+
+declare class StrataModalFooterComponent {
+    justification: _angular_core.InputSignal<ModalFooterJustification>;
+    get hostClass(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataModalFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataModalFooterComponent, "st-modal-footer", never, { "justification": { "alias": "justification"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+type ModalFooterJustification = 'start' | 'center' | 'end' | 'space-between';
+
+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<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 StrataModalComponent implements OnInit, AfterViewInit, OnDestroy {
+    private modalService;
+    private injector;
+    private elementRef;
+    private previousActiveElement;
+    modalContents: _angular_core.Signal<ViewContainerRef>;
+    configuration: _angular_core.InputSignal<ModalConfiguration>;
+    size: _angular_core.ModelSignal<ModalSize | undefined>;
+    variant: _angular_core.InputSignal<ModalVariant | undefined>;
+    readonly currentSize: _angular_core.Signal<ModalSize>;
+    readonly currentVariant: _angular_core.Signal<ModalVariant>;
+    readonly role = "dialog";
+    readonly ariaModal = "true";
+    readonly tabIndex = -1;
+    get hostClasses(): string;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    private setInputsOnInjectedComponent;
+    onCardClick(event: MouseEvent): void;
+    onKeydown(event: KeyboardEvent): void;
+    private getFocusableElements;
+    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; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "size": "sizeChange"; }, never, never, true, never>;
+}
+
+interface StrataNotificationRef {
+    readonly id: string;
+    dismiss(): void;
+}
+interface NotificationConfiguration {
+    id?: string;
+    icon?: string;
+    message: string;
+    theme?: Theme;
+    duration?: number;
+    dismissible?: boolean;
+}
+type NotificationsWithIds = NotificationConfiguration & {
+    id: string;
+    dismissible: boolean;
+};
+declare const DEFAULT_THEME: Theme;
+declare const DEFAULT_DURATION = 3000;
+
+declare class NotificationService {
+    notificationStack: _angular_core.WritableSignal<NotificationsWithIds[]>;
+    dismiss(notificationId: string): void;
+    showNotification(config: NotificationConfiguration): StrataNotificationRef;
+    private hideNotification;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NotificationService>;
+}
+
+declare class StrataNotificationContainerComponent {
+    notificationService: NotificationService;
+    notifications: _angular_core.WritableSignal<ngx_strata.NotificationsWithIds[]>;
+    dismiss(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataNotificationContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataNotificationContainerComponent, "st-notification-container", never, {}, {}, never, never, true, never>;
+}
+
+declare class StrataNotificationComponent {
+    icon: _angular_core.InputSignal<string | undefined>;
+    message: _angular_core.InputSignal<string>;
+    dismissible: _angular_core.InputSignal<boolean>;
+    dismiss: _angular_core.OutputEmitterRef<void>;
+    onDismiss(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataNotificationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataNotificationComponent, "st-notification", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": true; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; }, { "dismiss": "dismiss"; }, never, never, true, never>;
+}
+
+declare class StrataNumberDisplayComponent {
+    private readonly locale;
+    value: _angular_core.InputSignal<number>;
+    decimals: _angular_core.InputSignal<number>;
+    private digitsInfo;
+    private formattedNumber;
+    readonly separatedDigits: _angular_core.Signal<{
+        integer: string;
+        decimals?: string;
+    }>;
+    changedValue: _angular_core.InputSignal<boolean>;
+    showPlus: _angular_core.InputSignal<boolean>;
+    deemphasizeDecimals: _angular_core.InputSignal<boolean>;
+    readonly decimalPoint: _angular_core.Signal<string>;
+    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>;
+}
+
+type OtpType = 'number' | 'alphanumeric' | 'password';
+type OtpSize = 'sm' | 'md' | 'lg';
+type OtpState = 'idle' | 'loading' | 'success' | 'error';
+declare class StrataOtpComponent implements ControlValueAccessor, AfterViewInit, OnDestroy {
+    value: _angular_core.ModelSignal<string>;
+    length: _angular_core.InputSignal<number>;
+    type: _angular_core.InputSignal<OtpType>;
+    uppercase: _angular_core.InputSignal<boolean>;
+    mask: _angular_core.InputSignal<boolean>;
+    size: _angular_core.InputSignal<OtpSize>;
+    state: _angular_core.ModelSignal<OtpState>;
+    loading: _angular_core.InputSignal<boolean>;
+    error: _angular_core.InputSignal<string | boolean>;
+    success: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    readonly: _angular_core.InputSignal<boolean>;
+    placeholder: _angular_core.InputSignal<string>;
+    ariaLabel: _angular_core.InputSignal<string>;
+    helperText: _angular_core.InputSignal<string | undefined>;
+    errorMessage: _angular_core.InputSignal<string | undefined>;
+    autofocus: _angular_core.InputSignal<boolean>;
+    clearOnError: _angular_core.InputSignal<boolean>;
+    clearOnErrorDelay: _angular_core.InputSignal<number>;
+    resetErrorOnInput: _angular_core.InputSignal<boolean>;
+    completed: _angular_core.OutputEmitterRef<string>;
+    errorReset: _angular_core.OutputEmitterRef<void>;
+    slotInputs: _angular_core.Signal<readonly ElementRef<HTMLInputElement>[]>;
+    digits: _angular_core.WritableSignal<string[]>;
+    private cvaDisabled;
+    private clearOnErrorTimer;
+    effectiveState: _angular_core.Signal<OtpState>;
+    effectiveDisabled: _angular_core.Signal<boolean>;
+    computedErrorMessage: _angular_core.Signal<string | undefined>;
+    private onChange;
+    private onTouched;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    focus(index?: number): void;
+    clear(): void;
+    onKeyDown(event: KeyboardEvent, index: number): void;
+    onInput(event: Event, index: number): void;
+    onPaste(event: ClipboardEvent, index: number): void;
+    onFocus(index: number): void;
+    onClick(index: number): void;
+    writeValue(val: string | null | undefined): void;
+    registerOnChange(fn: (val: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private handleUserInputStart;
+    private isValidChar;
+    private sanitizeChar;
+    private distributeChars;
+    private updateSlot;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataOtpComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataOtpComponent, "st-otp", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "length": { "alias": "length"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "uppercase": { "alias": "uppercase"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "success": { "alias": "success"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "autofocus": { "alias": "autofocus"; "required": false; "isSignal": true; }; "clearOnError": { "alias": "clearOnError"; "required": false; "isSignal": true; }; "clearOnErrorDelay": { "alias": "clearOnErrorDelay"; "required": false; "isSignal": true; }; "resetErrorOnInput": { "alias": "resetErrorOnInput"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "state": "stateChange"; "completed": "completed"; "errorReset": "errorReset"; }, never, never, true, never>;
+}
+
+declare class StrataPaginationComponent {
+    readonly role = "navigation";
+    readonly ariaLabel = "Pagination";
+    currentPage: _angular_core.ModelSignal<number>;
+    totalPages: _angular_core.InputSignal<number>;
+    pageSelected: _angular_core.OutputEmitterRef<number>;
+    pageButtons: _angular_core.Signal<PaginationItem[]>;
+    hideNextPreviousAtStartEnd: _angular_core.InputSignal<boolean>;
+    changePage(newPage: number): void;
+    private calculatePageButtons;
+    private showStartingPages;
+    private showEndingPages;
+    private showAllPages;
+    private spaceItem;
+    private pageItem;
+    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>;
+}
+interface PaginationItem {
+    page: number | undefined;
+    text: string;
+    clickable: boolean;
 }
 
 declare class StrataProgressLinearComponent {
@@ -539,38 +906,62 @@ declare class StrataRadioComponent {
     label: _angular_core.InputSignal<string | undefined>;
     checked: _angular_core.ModelSignal<boolean>;
     disabled: _angular_core.InputSignal<boolean>;
+    groupDisabled: _angular_core.WritableSignal<boolean>;
+    effectiveDisabled: _angular_core.Signal<boolean>;
     selected: _angular_core.OutputEmitterRef<void>;
-    get isChecked(): boolean;
-    get isDisabled(): boolean;
+    select(): void;
     onClick(event: MouseEvent): void;
+    onSpaceKey(event: Event): 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"; "selected": "selected"; }, never, never, true, never>;
 }
 
-declare class StrataRadioGroupComponent {
+declare class StrataRadioGroupComponent implements ControlValueAccessor {
     value: _angular_core.ModelSignal<string>;
+    disabled: _angular_core.InputSignal<boolean>;
+    private cvaDisabled;
+    effectiveDisabled: _angular_core.Signal<boolean>;
     radios: _angular_core.Signal<readonly StrataRadioComponent[]>;
+    private onChange;
+    private onTouched;
     constructor();
+    writeValue(val: string | null | undefined): void;
+    registerOnChange(fn: (val: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
     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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataRadioGroupComponent, "st-radio-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["radios"], ["*"], true, never>;
 }
 
 declare class StrataSegmentedControlItemComponent {
     text: _angular_core.InputSignal<string>;
+    value: _angular_core.InputSignal<string | undefined>;
+    effectiveValue: _angular_core.Signal<string>;
     selected: _angular_core.ModelSignal<boolean>;
     disabled: _angular_core.InputSignal<boolean>;
+    groupDisabled: _angular_core.WritableSignal<boolean>;
+    effectiveDisabled: _angular_core.Signal<boolean>;
     selectionChanged: _angular_core.OutputEmitterRef<void>;
     get tabIndex(): number | null;
     get disabledAttribute(): boolean | null;
     onClick(): void;
+    onKeydown(event: Event): void;
     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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataSegmentedControlItemComponent, "st-segmented-control-item", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "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 StrataSegmentedControlComponent implements AfterViewInit {
+type SegmentedControlSize = 'sm' | 'md' | 'lg';
+declare class StrataSegmentedControlComponent implements ControlValueAccessor, AfterViewInit {
     private elementRef;
     private destroyRef;
+    value: _angular_core.ModelSignal<string>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    size: _angular_core.InputSignal<SegmentedControlSize>;
     fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private cvaDisabled;
+    effectiveDisabled: _angular_core.Signal<boolean>;
+    private onChange;
+    private onTouched;
     segmentItems: _angular_core.Signal<readonly StrataSegmentedControlItemComponent[]>;
     segmentItemsRefs: _angular_core.Signal<readonly ElementRef<any>[]>;
     selectedItem: _angular_core.WritableSignal<StrataSegmentedControlItemComponent | null>;
@@ -583,12 +974,21 @@ declare class StrataSegmentedControlComponent implements AfterViewInit {
     indicatorWidth: _angular_core.Signal<number>;
     indicatorTop: _angular_core.Signal<number>;
     indicatorHeight: _angular_core.Signal<number>;
-    ngAfterViewInit(): void;
     constructor();
-    selectItem(selectedItem: StrataSegmentedControlItemComponent): void;
+    ngAfterViewInit(): void;
+    selectItem(selectedItem: StrataSegmentedControlItemComponent, emitChange?: boolean): void;
     private updateDimensions;
+    writeValue(val: string | null | undefined): void;
+    registerOnChange(fn: (val: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
     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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataSegmentedControlComponent, "st-segmented-control", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["segmentItems", "segmentItemsRefs"], ["st-segmented-control-item"], 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 StrataSidemenuComponent {
@@ -604,44 +1004,126 @@ declare class StrataSidemenuSectionComponent {
 
 declare class StrataSidemenuItemGroupComponent implements AfterContentInit {
     label: _angular_core.InputSignal<string>;
+    routerLink: _angular_core.InputSignal<string | unknown[] | undefined>;
+    href: _angular_core.InputSignal<string | undefined>;
+    active: _angular_core.InputSignal<boolean | undefined>;
     expanded: _angular_core.WritableSignal<boolean>;
     hasActiveChild: _angular_core.WritableSignal<boolean>;
     private router;
     private destroyRef;
     routerLinks: QueryList<RouterLinkActive>;
+    get isHeaderActive(): boolean;
+    get isNavigable(): boolean;
     ngAfterContentInit(): void;
-    toggle(): void;
+    toggle(event?: MouseEvent): 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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataSidemenuItemGroupComponent, "st-sidemenu-item-group", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "routerLink": { "alias": "routerLink"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; }, {}, ["routerLinks"], ["*"], true, never>;
 }
 
 declare class StrataSidemenuItemDirective {
     active: _angular_core.InputSignal<boolean>;
+    secondaryActionIcon: _angular_core.InputSignal<string | undefined>;
+    secondaryAction: OutputEmitterRef<MouseEvent>;
     private readonly elementRef;
+    private readonly renderer;
+    private readonly vcr;
+    private secondaryButtonEl;
+    private iconComponentRef;
+    private unlistenClick;
     constructor();
+    private updateSecondaryButton;
+    private removeSecondaryButton;
     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>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrataSidemenuItemDirective, "[stSidemenuItem]", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "secondaryActionIcon": { "alias": "secondaryActionIcon"; "required": false; "isSignal": true; }; }, { "secondaryAction": "secondaryAction"; }, never, never, true, never>;
+}
+
+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 StrataSliderComponent implements AfterViewInit, OnDestroy {
+type SingleSelectSize = 'sm' | 'md' | 'lg';
+declare class StrataSingleSelectComponent implements ControlValueAccessor {
+    size: _angular_core.InputSignal<SingleSelectSize>;
+    open: _angular_core.WritableSignal<boolean>;
+    placeholder: _angular_core.InputSignal<string>;
+    placement: _angular_core.InputSignal<Placement>;
+    disabled: _angular_core.InputSignal<boolean>;
+    private cvaDisabled;
+    effectiveDisabled: _angular_core.Signal<boolean>;
+    private onChange;
+    private onTouched;
+    fullWidth: _angular_core.InputSignal<boolean>;
+    label: _angular_core.InputSignal<string | undefined>;
+    name: _angular_core.InputSignal<string | undefined>;
+    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>;
+    itemSelected: _angular_core.OutputEmitterRef<unknown>;
+    selectItems: _angular_core.Signal<readonly StrataSelectItemComponent[]>;
+    triggerTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    private inputField;
+    private destroyRef;
+    constructor();
+    onSearchChange(query: string | undefined): void;
+    toggle(event?: Event): void;
+    onItemClick(item: StrataSelectItemComponent): void;
+    writeValue(val: unknown): void;
+    registerOnChange(fn: (val: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private show;
+    private hide;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataSingleSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataSingleSelectComponent, "st-single-select", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "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>;
+}
+
+declare class StrataSelectTriggerDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataSelectTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrataSelectTriggerDirective, "[stSelectTrigger]", never, {}, {}, never, never, true, never>;
+}
+
+declare class StrataSliderComponent implements ControlValueAccessor, AfterViewInit, OnDestroy {
     wrapper: _angular_core.Signal<ElementRef<HTMLDivElement>>;
     private resizeObserver;
     value: _angular_core.ModelSignal<number | undefined>;
+    disabled: _angular_core.InputSignal<boolean>;
+    private cvaDisabled;
+    effectiveDisabled: _angular_core.Signal<boolean>;
+    private onChange;
+    private onTouched;
     minimum: _angular_core.InputSignal<number>;
     maximum: _angular_core.InputSignal<number>;
     step: _angular_core.InputSignal<number | "none" | undefined>;
     computedStep: _angular_core.Signal<number | "any">;
     steps: _angular_core.Signal<number>;
     isStepped: _angular_core.Signal<boolean>;
+    private viewInitialized;
+    constructor();
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     private updateTickMath;
     private getThumbSize;
+    onModelChange(val: number | string): void;
+    writeValue(val: number | null | undefined): void;
+    registerOnChange(fn: (val: number | undefined) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
     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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataSliderComponent, "st-slider", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "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 StrataSpinnerComponent {
@@ -652,6 +1134,48 @@ declare class StrataSpinnerComponent {
 }
 type SpinnerSize = 'xs' | 'sm' | 'md' | 'lg';
 
+type StepperOrientation = 'horizontal' | 'vertical';
+type StepState = 'completed' | 'current' | 'future' | 'error';
+type StepperSize = 'sm' | 'md';
+type StepperTheme = Theme;
+
+declare class StrataStepComponent {
+    label: _angular_core.InputSignal<string>;
+    description: _angular_core.InputSignal<string | undefined>;
+    icon: _angular_core.InputSignal<string | undefined>;
+    state: _angular_core.InputSignal<StepState | undefined>;
+    keepIconOnCompleted: _angular_core.InputSignal<boolean>;
+    index: _angular_core.WritableSignal<number>;
+    isFirst: _angular_core.WritableSignal<boolean>;
+    isLast: _angular_core.WritableSignal<boolean>;
+    orientation: _angular_core.WritableSignal<StepperOrientation>;
+    size: _angular_core.WritableSignal<StepperSize>;
+    showCheckmarkOnCompleted: _angular_core.WritableSignal<boolean>;
+    computedState: _angular_core.WritableSignal<StepState>;
+    effectiveState: _angular_core.Signal<StepState>;
+    iconSize: _angular_core.Signal<IconSize>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataStepComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataStepComponent, "st-step", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "keepIconOnCompleted": { "alias": "keepIconOnCompleted"; "required": false; "isSignal": true; }; }, {}, never, ["*", "*"], true, never>;
+}
+
+declare class StrataStepperComponent {
+    private themeDirective;
+    currentStep: _angular_core.ModelSignal<number>;
+    orientation: _angular_core.InputSignal<StepperOrientation>;
+    size: _angular_core.InputSignal<StepperSize>;
+    theme: _angular_core.InputSignal<Theme | undefined>;
+    showCheckmarkOnCompleted: _angular_core.InputSignal<boolean>;
+    readonly activeTheme: _angular_core.Signal<Theme>;
+    steps: _angular_core.Signal<readonly StrataStepComponent[]>;
+    constructor();
+    next(): void;
+    previous(): void;
+    reset(): void;
+    goTo(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataStepperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataStepperComponent, "st-stepper", never, { "currentStep": { "alias": "currentStep"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "showCheckmarkOnCompleted": { "alias": "showCheckmarkOnCompleted"; "required": false; "isSignal": true; }; }, { "currentStep": "currentStepChange"; }, ["steps"], ["*"], true, never>;
+}
+
 declare class StrataTabItemComponent {
     /**
      * The text label for the tab.
@@ -695,6 +1219,14 @@ declare class StrataTabsComponent implements AfterViewInit {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataTabsComponent, "st-tabs", never, {}, {}, ["tabItems", "tabItemsRefs"], ["*"], true, never>;
 }
 
+declare class StrataTagComponent {
+    size: _angular_core.InputSignal<TagSize>;
+    get class(): TagSize;
+    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 StrataTextStackComponent {
     overflow: _angular_core.InputSignal<TextStackOverflow>;
     get cssClasses(): string[];
@@ -703,174 +1235,24 @@ declare class StrataTextStackComponent {
 }
 type TextStackOverflow = 'truncate' | 'wrap';
 
-declare class StrataToggleComponent {
+declare class StrataToggleComponent implements ControlValueAccessor {
     private _activatable;
     checked: _angular_core.ModelSignal<boolean>;
     label: _angular_core.InputSignal<string | undefined>;
     labelPosition: _angular_core.InputSignal<"before" | "after">;
     disabled: _angular_core.InputSignal<boolean>;
+    private cvaDisabled;
+    effectiveDisabled: _angular_core.Signal<boolean>;
+    private onChange;
+    private onTouched;
     onCheckChanged(event?: Event): void;
+    writeValue(val: boolean | null | undefined): void;
+    registerOnChange(fn: (val: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): 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';
-
-declare class StrataAlertContentComponent {
-    private modalService;
-    title: _angular_core.InputSignal<string>;
-    message: _angular_core.InputSignal<string | undefined>;
-    icon: _angular_core.InputSignal<string | undefined>;
-    readonly computedIcon: _angular_core.Signal<string>;
-    theme: _angular_core.InputSignal<Theme>;
-    affirmativeButton: _angular_core.InputSignal<string>;
-    cancelButton: _angular_core.InputSignal<string | undefined>;
-    onAffirmation(): void;
-    onCancel(): void;
-    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>;
-}
-
-interface ModalConfiguration {
-    title?: string;
-    component: Type<unknown>;
-    onModalClosed?: (value?: unknown) => void;
-    hideCloseButton?: boolean;
-    disableBackdropClosure?: boolean;
-    size?: ModalSize;
-    inputs?: Record<string, unknown>;
-}
-interface AlertConfiguration {
-    message: string;
-    icon?: string;
-    title?: string;
-    theme?: Theme;
-    affirmativeButton: string;
-    cancelButton?: string;
-}
-type ModalSize = 'xs' | 'sm' | 'md' | 'lg';
-declare abstract class StrataModalRef {
-    abstract close(value?: unknown): void;
-}
-
-declare class ModalService {
-    private _modals;
-    modals: _angular_core.Signal<ModalConfiguration[]>;
-    private document;
-    constructor();
-    showModal(config: ModalConfiguration): void;
-    showAlert(config: AlertConfiguration, callback: (value: boolean) => void): 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 StrataModalContainerComponent {
-    modalService: ModalService;
-    onBackdropClick(event: MouseEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataModalContainerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataModalContainerComponent, "st-modal-container", never, {}, {}, never, never, true, never>;
-}
-
-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<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 StrataModalComponent implements AfterViewInit {
-    private modalService;
-    private injector;
-    modalContents: _angular_core.Signal<ViewContainerRef>;
-    configuration: _angular_core.InputSignal<ModalConfiguration>;
-    size: _angular_core.ModelSignal<ModalSize | undefined>;
-    get sizeClass(): string;
-    ngAfterViewInit(): void;
-    private setInputsOnInjectedComponent;
-    onCardClick(event: MouseEvent): void;
-    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 {
-    icon?: string;
-    message: string;
-    theme?: Theme;
-    duration?: number;
-}
-type NotificationsWithIds = NotificationConfiguration & {
-    id: string;
-};
-declare const DEFAULT_THEME: Theme;
-declare const DEFAULT_DURATION = 3000;
-
-declare class NotificationService {
-    notificationStack: _angular_core.WritableSignal<NotificationsWithIds[]>;
-    showNotification(config: NotificationConfiguration): void;
-    private hideNotification;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NotificationService>;
-}
-
-declare class StrataNotificationContainerComponent {
-    notificationService: NotificationService;
-    notifications: _angular_core.WritableSignal<ngx_strata.NotificationsWithIds[]>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrataNotificationContainerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrataNotificationContainerComponent, "st-notification-container", never, {}, {}, never, never, true, never>;
-}
-
-declare class StrataNotificationComponent {
-    icon?: string;
-    message: string;
-    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 StrataNumberDisplayComponent {
-    private readonly locale;
-    value: _angular_core.InputSignal<number>;
-    decimals: _angular_core.InputSignal<number>;
-    private digitsInfo;
-    private formattedNumber;
-    readonly separatedDigits: _angular_core.Signal<{
-        integer: string;
-        decimals?: string;
-    }>;
-    changedValue: _angular_core.InputSignal<boolean>;
-    showPlus: _angular_core.InputSignal<boolean>;
-    deemphasizeDecimals: _angular_core.InputSignal<boolean>;
-    readonly decimalPoint: _angular_core.Signal<string>;
-    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 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 { 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 };
+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, StrataBadgeComponent, StrataBreadcrumbComponent, StrataBreadcrumbItemComponent, StrataButtonDirective, StrataButtonGroupComponent, StrataCardComponent, StrataCheckboxComponent, StrataDividerComponent, StrataFileUploadComponent, StrataIconComponent, StrataImageCropperComponent, StrataInputFieldComponent, StrataItemComponent, StrataItemListComponent, StrataKbdComponent, StrataMessageStateComponent, StrataModalComponent, StrataModalContainerComponent, StrataModalFooterComponent, StrataModalHeaderComponent, StrataModalRef, StrataNativeInputRefDirective, StrataNotificationComponent, StrataNotificationContainerComponent, StrataNumberDisplayComponent, StrataOtpComponent, StrataOverlayDirective, StrataPaginationComponent, StrataProgressLinearComponent, StrataProgressRadialComponent, StrataRadioComponent, StrataRadioGroupComponent, StrataSegmentedControlComponent, StrataSegmentedControlItemComponent, StrataSelectItemComponent, StrataSelectTriggerDirective, StrataShellComponent, StrataSidemenuComponent, StrataSidemenuItemDirective, StrataSidemenuItemGroupComponent, StrataSidemenuSectionComponent, StrataSingleSelectComponent, StrataSliderComponent, StrataSpinnerComponent, StrataStepComponent, StrataStepperComponent, StrataTabItemComponent, StrataTabsComponent, StrataTagComponent, StrataTextStackComponent, StrataThemeDirective, StrataToggleComponent, StrataTooltipDirective, getDefaultShortcutLabels, isApplePlatform, provideBaseIcons, provideIcons, provideStrata, resolveIsApple };
+export type { AlertConfiguration, AvatarSize, AvatarStackSpacing, BadgePlacement, BadgeSize, BadgeVariant, ButtonGroupJustification, ButtonSize, ButtonVariant, CardVariant, CropPosition, CropResult, CropShape, CurrentDarkmode, DarkmodeSetting, HotkeyOptions, IconConfig, IconSize, InputFieldSize, ModalConfiguration, ModalFooterJustification, ModalSize, ModalVariant, NotificationConfiguration, NotificationsWithIds, OtpSize, OtpState, OtpType, PaginationItem, ProgressLinearGrowDirection, ProgressLinearLabelFormat, ProgressRadialLabelFormat, SegmentedControlSize, SingleSelectSize, SpinnerSize, StepState, StepperOrientation, StepperSize, StepperTheme, StrataConfig, StrataNotificationRef, StrataPlatform, TagSize, TextStackOverflow, Theme, TooltipPlacement };