ngx-strata 0.1.0

package/types/ngx-strata.d.ts

@@ -0,0 +1,639 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy, AfterContentInit, ElementRef, Renderer2, EnvironmentProviders, InjectionToken, Provider, AfterViewInit, TemplateRef, OnChanges, SimpleChanges, PipeTransform, Type, ComponentRef, ViewContainerRef } from '@angular/core';
+import { Placement } from '@floating-ui/dom';
+import { SafeHtml, DomSanitizer } from '@angular/platform-browser';
+import { Observable } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import * as ngx_strata from 'ngx-strata';
+
+declare class TooltipDirective implements OnInit, OnDestroy, AfterContentInit {
+    private document;
+    private element;
+    private renderer;
+    stSimpleTooltip: _angular_core.InputSignal<string>;
+    tooltipEnabled: boolean;
+    tooltipPlacement: TooltipPlacement;
+    tooltipAlwaysShow: boolean;
+    private tooltipContentElement;
+    private arrowElement;
+    private eventListeners;
+    private autoUpdateCleanupFunction?;
+    private config;
+    constructor(document: Document, element: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    doPosition(): void;
+    ngOnDestroy(): void;
+    private shouldRender;
+    showTimeoutCancel: any;
+    private show;
+    private hide;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipDirective, "[stSimpleTooltip]", never, { "stSimpleTooltip": { "alias": "stSimpleTooltip"; "required": true; "isSignal": true; }; "tooltipEnabled": { "alias": "tooltipEnabled"; "required": false; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; }; "tooltipAlwaysShow": { "alias": "tooltipAlwaysShow"; "required": false; }; }, {}, never, never, true, never>;
+}
+type TooltipPlacement = Exclude<Placement, 'left-start' | 'left-end' | 'right-start' | 'right-end'>;
+
+type DarkmodeSetting = 'DARK' | 'LIGHT' | 'SYSTEM';
+type CurrentDarkmode = 'LIGHT' | 'DARK';
+type Size = 'xs' | 'sm' | 'md' | 'lg';
+type Theme = 'brand' | 'default' | 'danger' | 'warning' | 'success' | 'info';
+
+declare class DarkmodeService {
+    private readonly STORAGE_KEY;
+    private document;
+    private osPrefersDark;
+    private setting;
+    private darkmode;
+    currentMode: _angular_core.Signal<CurrentDarkmode>;
+    currentSetting: _angular_core.Signal<DarkmodeSetting>;
+    constructor();
+    setDarkmodeSetting(newSetting: DarkmodeSetting): CurrentDarkmode;
+    private getSystemDarkmodePreference;
+    private calculateDarkmode;
+    private updateDarkmodeTagOnDOM;
+    private saveSettingToStorage;
+    private getSettingFromStorage;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DarkmodeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DarkmodeService>;
+}
+
+interface IconConfig {
+    name: string;
+    url: string;
+}
+type IconSize = 'xs' | 'sm' | 'md' | 'lg';
+
+declare const provideBaseIcons: () => EnvironmentProviders;
+declare const provideIcons: (iconConfigs: IconConfig[]) => EnvironmentProviders;
+
+declare function provideStrata(config?: Partial<StrataConfig>): (Provider | EnvironmentProviders)[];
+type StrataConfig = {
+    includeBaseIcons: boolean;
+    tooltipDelayMs: number;
+};
+declare const STRATA_CONFIG: InjectionToken<StrataConfig>;
+
+declare class ActionMenuItemComponent {
+    private checkbox;
+    private toggle;
+    closeMenuOnClick: _angular_core.InputSignal<boolean>;
+    onMenuItemClicked: _angular_core.OutputEmitterRef<boolean>;
+    elementRef: ElementRef<HTMLElement>;
+    onHostClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionMenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ActionMenuItemComponent, "st-action-menu-item", never, { "closeMenuOnClick": { "alias": "closeMenuOnClick"; "required": false; "isSignal": true; }; }, { "onMenuItemClicked": "onMenuItemClicked"; }, ["checkbox", "toggle"], ["[area='start']", "*", "[area='end']"], true, never>;
+}
+
+declare class ActionMenuComponent implements AfterViewInit {
+    projectedButton: _angular_core.Signal<ElementRef<any> | undefined>;
+    defaultButton: _angular_core.Signal<ElementRef<any> | undefined>;
+    actionMenuItems: _angular_core.Signal<readonly ActionMenuItemComponent[]>;
+    placement: _angular_core.InputSignal<Placement>;
+    renderer: Renderer2;
+    menuOpen: _angular_core.WritableSignal<boolean>;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ActionMenuComponent, "st-action-menu", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, {}, ["projectedButton", "actionMenuItems"], ["button[stButton]", "st-action-menu-item"], true, never>;
+}
+
+declare class AccordionItemComponent {
+    title: _angular_core.InputSignal<string>;
+    open: _angular_core.ModelSignal<boolean>;
+    toggled: _angular_core.OutputEmitterRef<boolean>;
+    constructor();
+    get isOpen(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionItemComponent, "st-accordion-item", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "toggled": "toggled"; }, never, ["*"], true, never>;
+}
+
+declare class AccordionGroupComponent implements AfterContentInit {
+    items: _angular_core.Signal<readonly AccordionItemComponent[]>;
+    allowMultipleOpen: _angular_core.InputSignal<boolean>;
+    ngAfterContentInit(): void;
+    closeOtherItems(currentItem: AccordionItemComponent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionGroupComponent, "st-accordion-group", never, { "allowMultipleOpen": { "alias": "allowMultipleOpen"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
+}
+
+declare class AvatarStackComponent implements AfterViewInit {
+    avatarRefs: _angular_core.Signal<readonly ElementRef<any>[]>;
+    size: _angular_core.InputSignal<Size>;
+    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<AvatarStackComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarStackComponent, "st-avatar-stack", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "spacing": { "alias": "spacing"; "required": false; "isSignal": true; }; "firstOnFront": { "alias": "firstOnFront"; "required": false; "isSignal": true; }; }, {}, ["avatarRefs"], ["*"], true, never>;
+}
+
+declare abstract class IconRegistry {
+    abstract getIcon(name: string): Observable<SafeHtml>;
+}
+
+declare class IconComponent implements OnDestroy {
+    defaultIcon: string;
+    name: _angular_core.InputSignal<string>;
+    size: _angular_core.ModelSignal<IconSize>;
+    get sizeClass(): boolean;
+    get sizeSmClass(): boolean;
+    get sizeMdClass(): boolean;
+    get sizeLgClass(): boolean;
+    svgMarkdown: any;
+    private iconSubscription;
+    iconRegistry: IconRegistry;
+    ngOnDestroy(): void;
+    ngOnChanges(): void;
+    private setIcon;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconComponent, "st-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "size": "sizeChange"; }, never, never, true, never>;
+}
+
+declare class AvatarComponent implements AfterViewInit {
+    iconComponents: _angular_core.Signal<readonly IconComponent[]>;
+    text: _angular_core.InputSignal<string | null>;
+    size: _angular_core.ModelSignal<Size>;
+    get elementClasses(): Size[];
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarComponent, "st-avatar", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "size": "sizeChange"; }, ["iconComponents"], ["*"], true, never>;
+}
+
+declare class ButtonGroupComponent {
+    renderer: Renderer2;
+    justification: _angular_core.InputSignal<ButtonGroupJustification>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonGroupComponent, "st-button-group", never, { "justification": { "alias": "justification"; "required": false; "isSignal": true; }; }, {}, never, ["[stButton], st-divider"], true, never>;
+}
+type ButtonGroupJustification = 'start' | 'center' | 'end' | 'expand' | 'stack';
+
+declare class ButtonDirective implements AfterContentInit {
+    host: ElementRef<any>;
+    variant: _angular_core.InputSignal<ButtonVariant>;
+    size: _angular_core.InputSignal<ButtonSize>;
+    fullWidth: _angular_core.InputSignal<boolean>;
+    private iconAtStart;
+    private iconAtEnd;
+    private iconOnly;
+    constructor();
+    get classes(): string[];
+    ngAfterContentInit(): void;
+    nodeIsStIcon(node: any): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonDirective, "[stButton]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+type ButtonVariant = 'primary' | 'secondary' | 'outline' | 'ghost';
+type ButtonSize = 'sm' | 'md' | 'lg';
+
+declare class CardComponent {
+    elevated: _angular_core.InputSignal<boolean>;
+    selectable: _angular_core.InputSignal<boolean>;
+    padding: _angular_core.InputSignal<boolean>;
+    variant: _angular_core.InputSignal<CardVariant>;
+    get withPadding(): boolean;
+    get isSelectable(): boolean;
+    get tabIndex(): number | null;
+    get isElevated(): boolean;
+    get isFlat(): boolean;
+    get isOutline(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardComponent, "st-card", never, { "elevated": { "alias": "elevated"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["[area='cover']", "*"], true, never>;
+}
+type CardVariant = 'elevated' | 'flat' | 'outline';
+
+declare class CheckboxComponent {
+    value: _angular_core.ModelSignal<boolean | undefined>;
+    label: _angular_core.InputSignal<string | undefined>;
+    name: _angular_core.InputSignal<string | undefined>;
+    onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "st-checkbox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+declare class DropdownComponent {
+    open: _angular_core.WritableSignal<boolean>;
+    placeholder: _angular_core.InputSignal<string>;
+    placement: _angular_core.InputSignal<Placement>;
+    fullWidth: _angular_core.InputSignal<boolean>;
+    label: _angular_core.InputSignal<string | undefined>;
+    name: _angular_core.InputSignal<string | undefined>;
+    selected: _angular_core.ModelSignal<SelectItem | undefined>;
+    size: _angular_core.InputSignal<DropdownSize>;
+    searchable: _angular_core.InputSignal<boolean>;
+    searchQuery: _angular_core.ModelSignal<string | undefined>;
+    searchPlaceholder: _angular_core.InputSignal<string>;
+    dropdownItems: _angular_core.InputSignal<SelectItem[]>;
+    shownItems: _angular_core.Signal<SelectItem[]>;
+    onSelect: _angular_core.OutputEmitterRef<SelectItem>;
+    private inputField;
+    get classList(): DropdownSize[];
+    toggleDropdown(event?: MouseEvent): void;
+    onItemClick(item: SelectItem, mouseEvent: MouseEvent): void;
+    onItemHover(mouseEvent: MouseEvent): void;
+    private show;
+    private hide;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownComponent, "st-dropdown", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchQuery": { "alias": "searchQuery"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "dropdownItems": { "alias": "dropdownItems"; "required": true; "isSignal": true; }; }, { "selected": "selectedChange"; "searchQuery": "searchQueryChange"; "onSelect": "onSelect"; }, never, never, true, never>;
+}
+interface SelectItem {
+    text: string;
+    id: string;
+}
+type DropdownSize = 'sm' | 'md' | 'lg';
+
+declare class DividerComponent {
+    label: _angular_core.InputSignal<string | undefined>;
+    margin: _angular_core.InputSignal<boolean>;
+    vertical: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DividerComponent, "st-divider", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "margin": { "alias": "margin"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TagComponent {
+    size: _angular_core.InputSignal<TagSize>;
+    get class(): TagSize;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TagComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TagComponent, "st-tag", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+type TagSize = 'sm' | 'md' | 'lg';
+
+declare abstract class IconLoader {
+    abstract loadSvg(url: string): Observable<SafeHtml>;
+}
+
+declare class HttpIconLoader implements IconLoader {
+    httpClient: HttpClient;
+    sanitizer: DomSanitizer;
+    loadSvg(url: string): Observable<SafeHtml>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpIconLoader, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<HttpIconLoader>;
+}
+
+declare class IconRegistryService {
+    private iconLoader;
+    icons: Record<string, string>;
+    svgs: Record<string, SafeHtml>;
+    constructor(iconLoader: IconLoader);
+    registerIcons(iconConfigs: IconConfig[]): void;
+    registerIcon(iconConfig: IconConfig): void;
+    getIconUrl(name: string): string | null;
+    getIcon(name: string): Observable<SafeHtml>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconRegistryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IconRegistryService>;
+}
+
+declare class ItemListComponent<T> {
+    items: _angular_core.InputSignal<T[]>;
+    dividers: _angular_core.InputSignal<boolean>;
+    template: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    get hostClasses(): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemListComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemListComponent<any>, "st-item-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "dividers": { "alias": "dividers"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ItemComponent {
+    interactable: _angular_core.InputSignal<boolean>;
+    get isInteractable(): boolean;
+    get tabIndex(): number | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemComponent, "st-item", never, { "interactable": { "alias": "interactable"; "required": false; "isSignal": true; }; }, {}, never, ["[area='start']", "*", "[area='end']"], true, never>;
+}
+
+declare class NativeInputRefDirective {
+    el: ElementRef<any>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NativeInputRefDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NativeInputRefDirective, "input[stInput], textarea[stInput]", never, {}, {}, never, never, true, never>;
+}
+
+declare class InputFieldComponent implements AfterViewInit {
+    iconComponents: _angular_core.Signal<readonly IconComponent[]>;
+    inputField: _angular_core.Signal<NativeInputRefDirective | undefined>;
+    private pendingFocus;
+    constructor();
+    ngAfterViewInit(): void;
+    focus(): void;
+    blur(): void;
+    get nativeInput(): HTMLInputElement | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputFieldComponent, "st-input-field", never, {}, {}, ["iconComponents", "inputField"], ["label", "[prefix]", "input,textarea", "[suffix]"], true, never>;
+}
+
+declare class AutoResizeDirective implements AfterViewInit, OnChanges {
+    minimumRows: _angular_core.InputSignal<number>;
+    maximumRows: _angular_core.InputSignal<number | undefined>;
+    private lineHeight;
+    private element;
+    onInput(): void;
+    onWindowResize(): void;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private calculateLineHeight;
+    private resize;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutoResizeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AutoResizeDirective, "[stAutoResize]", never, { "minimumRows": { "alias": "minimumRows"; "required": false; "isSignal": true; }; "maximumRows": { "alias": "maximumRows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class OverlayDirective implements OnChanges, OnDestroy {
+    stOverlay: _angular_core.InputSignal<TemplateRef<any>>;
+    overlayOpen: _angular_core.ModelSignal<boolean>;
+    overlayPlacement: _angular_core.InputSignal<Placement>;
+    overlayOffset: _angular_core.InputSignal<number>;
+    private readonly element;
+    private readonly viewContainerRef;
+    private overlayEl?;
+    private cleanup?;
+    constructor();
+    ngOnChanges(): void;
+    private create;
+    private updatePosition;
+    private destroy;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OverlayDirective, "[stOverlay]", never, { "stOverlay": { "alias": "stOverlay"; "required": true; "isSignal": true; }; "overlayOpen": { "alias": "overlayOpen"; "required": false; "isSignal": true; }; "overlayPlacement": { "alias": "overlayPlacement"; "required": false; "isSignal": true; }; "overlayOffset": { "alias": "overlayOffset"; "required": false; "isSignal": true; }; }, { "overlayOpen": "overlayOpenChange"; }, never, never, true, never>;
+}
+
+declare class PaginationComponent {
+    currentPage: _angular_core.ModelSignal<number>;
+    totalPages: _angular_core.InputSignal<number>;
+    onPageSelect: _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<PaginationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaginationComponent, "st-pagination", never, { "currentPage": { "alias": "currentPage"; "required": false; "isSignal": true; }; "totalPages": { "alias": "totalPages"; "required": true; "isSignal": true; }; "hideNextPreviousAtStartEnd": { "alias": "hideNextPreviousAtStartEnd"; "required": false; "isSignal": true; }; }, { "currentPage": "currentPageChange"; "onPageSelect": "onPageSelect"; }, never, never, true, never>;
+}
+type PaginationItem = {
+    page: number | undefined;
+    text: string;
+    clickable: boolean;
+};
+
+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 ProgressComponent {
+    min: _angular_core.InputSignal<number>;
+    max: _angular_core.InputSignal<number>;
+    value: _angular_core.InputSignal<number>;
+    type: _angular_core.InputSignal<ProgressType>;
+    showLabel: _angular_core.InputSignal<boolean>;
+    labelFormat: _angular_core.InputSignal<ProgressLabelFormat>;
+    growDirection: _angular_core.InputSignal<ProgressGrowDirection>;
+    size: _angular_core.InputSignal<number>;
+    strokeWidth: _angular_core.InputSignal<number>;
+    percentage: _angular_core.Signal<number>;
+    radius: _angular_core.Signal<number>;
+    circumference: _angular_core.Signal<number>;
+    dashOffset: _angular_core.Signal<number>;
+    get cssClasses(): string[];
+    get percentageProperty(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressComponent, "st-progress", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "labelFormat": { "alias": "labelFormat"; "required": false; "isSignal": true; }; "growDirection": { "alias": "growDirection"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+type ProgressType = 'linear' | 'radial';
+type ProgressLabelFormat = 'percentage' | 'value';
+type ProgressGrowDirection = 'left' | 'right';
+
+declare class SegmentedControlItemComponent {
+    text: _angular_core.InputSignal<string>;
+    selected: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    onSelection: _angular_core.OutputEmitterRef<void>;
+    get tabIndex(): number | null;
+    get disabledAttribute(): boolean | null;
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedControlItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedControlItemComponent, "st-segmented-control-item", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; "onSelection": "onSelection"; }, never, never, true, never>;
+}
+
+declare class SegmentedControlComponent implements AfterViewInit {
+    segmentItems: _angular_core.Signal<readonly SegmentedControlItemComponent[]>;
+    segmentItemsRefs: _angular_core.Signal<readonly ElementRef<any>[]>;
+    selectedItem: _angular_core.WritableSignal<SegmentedControlItemComponent | null>;
+    selectedIndex: _angular_core.WritableSignal<number>;
+    offset: _angular_core.Signal<number>;
+    private widths;
+    ngAfterViewInit(): void;
+    selectItem(selectedItem: SegmentedControlItemComponent): void;
+    calculateOffset(currentIndex: number): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedControlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedControlComponent, "st-segmented-control", never, {}, {}, ["segmentItems", "segmentItemsRefs"], ["st-segmented-control-item"], true, never>;
+}
+
+declare class SliderComponent implements AfterViewInit, OnDestroy {
+    wrapper: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    private resizeObserver;
+    value: _angular_core.ModelSignal<number | undefined>;
+    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>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private updateTickMath;
+    private getThumbSize;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SliderComponent, "st-slider", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "minimum": { "alias": "minimum"; "required": true; "isSignal": true; }; "maximum": { "alias": "maximum"; "required": true; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+declare class SpinnerComponent {
+    size: _angular_core.InputSignal<SpinnerSize>;
+    get cssClasses(): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpinnerComponent, "st-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+type SpinnerSize = 'xs' | 'sm' | 'md' | 'lg';
+
+declare class TextStackComponent {
+    overflow: _angular_core.InputSignal<TextStackOverflow>;
+    get cssClasses(): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextStackComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextStackComponent, "st-text-stack", never, { "overflow": { "alias": "overflow"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+type TextStackOverflow = 'truncate' | 'wrap';
+
+declare class ToggleComponent {
+    checked: _angular_core.ModelSignal<boolean>;
+    get isChecked(): boolean;
+    size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    get sizeClass(): "sm" | "md" | "lg";
+    onCheckChanged(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleComponent, "st-toggle", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, never, true, never>;
+}
+
+interface ModalConfiguration {
+    title?: string;
+    component: Type<unknown>;
+    onModalClosed?: (value?: any) => 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;
+}
+interface WithID {
+    id: string;
+}
+type ModalSize = 'xs' | 'sm' | 'md' | 'lg';
+
+declare class ModalService {
+    private stack;
+    private currentModals;
+    showModal(config: ModalConfiguration): void;
+    showAlert(config: AlertConfiguration, callback: (value: boolean) => void): void;
+    closeCurrentModal(value?: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ModalService>;
+}
+
+declare class AlertContentComponent {
+    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>;
+    constructor(modalService: ModalService);
+    onAffirmation(): void;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertContentComponent, "st-alert-content", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "affirmativeButton": { "alias": "affirmativeButton"; "required": true; "isSignal": true; }; "cancelButton": { "alias": "cancelButton"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class Stack<T> {
+    items: T[];
+    push(item: T): void;
+    pop(): T;
+    peek(): T;
+    empty(): boolean;
+    size(): number;
+}
+
+declare class ModalContainerComponent implements OnDestroy {
+    private modalService;
+    injectedComponent: ComponentRef<any>;
+    currentModal: ModalConfiguration | null;
+    stack: Stack<ModalConfiguration & WithID>;
+    private subscription;
+    constructor(modalService: ModalService);
+    ngOnDestroy(): void;
+    onBackdropClick(event: MouseEvent): void;
+    stackTrack(index: number, item: ModalConfiguration & WithID): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalContainerComponent, "st-modal-container", never, {}, {}, never, never, true, never>;
+}
+
+declare class ModalHeaderComponent {
+    modalService: ModalService;
+    title: _angular_core.InputSignal<string | null | undefined>;
+    showCloseButton: _angular_core.InputSignal<boolean>;
+    onCloseButtonClicked(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalHeaderComponent, "st-modal-header", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ModalComponent implements AfterViewInit {
+    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<ModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalComponent, "st-modal", never, { "configuration": { "alias": "configuration"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "size": "sizeChange"; }, never, never, true, never>;
+}
+
+interface NotificationConfiguration {
+    icon?: string;
+    message: string;
+    theme?: Theme;
+    duration?: number;
+}
+type NotificationsWithIds = NotificationConfiguration & {
+    id: string;
+};
+declare const DEFAULT_THEME: Theme;
+declare const DEFAULT_DURATION: number;
+
+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 NotificationContainerComponent {
+    notificationService: NotificationService;
+    notifications: _angular_core.WritableSignal<ngx_strata.NotificationsWithIds[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NotificationContainerComponent, "st-notification-container", never, {}, {}, never, never, true, never>;
+}
+
+declare class NotificationComponent {
+    icon?: string;
+    message: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NotificationComponent, "st-notification", never, { "icon": { "alias": "icon"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NumberDisplayComponent {
+    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<NumberDisplayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberDisplayComponent, "st-number-display", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "changedValue": { "alias": "changedValue"; "required": false; "isSignal": true; }; "showPlus": { "alias": "showPlus"; "required": false; "isSignal": true; }; "deemphasizeDecimals": { "alias": "deemphasizeDecimals"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ThemeDirective {
+    element: ElementRef<any>;
+    stTheme: _angular_core.InputSignal<Theme>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThemeDirective, "[stTheme]", never, { "stTheme": { "alias": "stTheme"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { AccordionGroupComponent, AccordionItemComponent, ActionMenuComponent, ActionMenuItemComponent, AlertContentComponent, AutoResizeDirective, AvatarComponent, AvatarStackComponent, ButtonDirective, ButtonGroupComponent, CapitalizePipe, CardComponent, CheckboxComponent, DEFAULT_DURATION, DEFAULT_THEME, DarkmodeService, DividerComponent, DropdownComponent, HttpIconLoader, IconComponent, IconLoader, IconRegistry, IconRegistryService, InputFieldComponent, ItemComponent, ItemListComponent, ModalComponent, ModalContainerComponent, ModalHeaderComponent, ModalService, NativeInputRefDirective, NotificationComponent, NotificationContainerComponent, NotificationService, NumberDisplayComponent, OverlayDirective, PaginationComponent, ProgressComponent, STRATA_CONFIG, SegmentedControlComponent, SegmentedControlItemComponent, SliderComponent, SpinnerComponent, TagComponent, TextStackComponent, ThemeDirective, ToggleComponent, TooltipDirective, provideBaseIcons, provideIcons, provideStrata };
+export type { AlertConfiguration, ButtonGroupJustification, ButtonSize, ButtonVariant, CardVariant, CurrentDarkmode, DarkmodeSetting, DropdownSize, IconConfig, IconSize, ModalConfiguration, ModalSize, NotificationConfiguration, NotificationsWithIds, PaginationItem, ProgressGrowDirection, ProgressLabelFormat, ProgressType, SelectItem, Size, SpinnerSize, StrataConfig, TagSize, TextStackOverflow, Theme, TooltipPlacement, WithID };