@elementar-rt/components 0.6.55

package/pin-input/index.d.ts

@@ -0,0 +1,48 @@
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+import { ControlValueAccessor, FormGroup } from '@angular/forms';
+
+declare class PinInputDirective implements OnInit {
+    private _elementRef;
+    private _renderer;
+    private _placeholder;
+    index: _angular_core.InputSignal<number | undefined>;
+    acceptOnly: _angular_core.InputSignal<RegExp | undefined>;
+    readonly valuePaste: _angular_core.OutputEmitterRef<string>;
+    get api(): {
+        focus: () => void;
+        nativeElement: any;
+    };
+    ngOnInit(): void;
+    protected _handleFocus(): void;
+    protected _handleBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PinInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PinInputDirective, "[emrPinInput]", ["emrPinInput"], { "index": { "alias": "index"; "required": false; "isSignal": true; }; "acceptOnly": { "alias": "acceptOnly"; "required": false; "isSignal": true; }; }, { "valuePaste": "valuePaste"; }, never, never, true, never>;
+}
+
+declare class PinInputComponent implements ControlValueAccessor, OnInit {
+    private _fb;
+    readonly inputs: _angular_core.Signal<readonly PinInputDirective[]>;
+    length: _angular_core.InputSignalWithTransform<number, unknown>;
+    placeholder: _angular_core.InputSignal<string>;
+    acceptOnly: _angular_core.InputSignal<RegExp>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected form: FormGroup;
+    private _disabled;
+    protected isDisabled: _angular_core.Signal<boolean>;
+    onChange: any;
+    onTouched: any;
+    get controls(): any[];
+    ngOnInit(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+    protected _valuePaste(event: ClipboardEvent): void;
+    protected _handleKeyDown(event: KeyboardEvent): void;
+    protected _handleKeyUp(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PinInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PinInputComponent, "emr-pin-input", ["emrPinInput"], { "length": { "alias": "length"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "acceptOnly": { "alias": "acceptOnly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { PinInputComponent };

package/popover/index.d.ts

@@ -0,0 +1,75 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit, OnDestroy, TemplateRef } from '@angular/core';
+import * as _elementar_rt_components_overlay from '@elementar-rt/components/overlay';
+import { OverlayPosition } from '@elementar-rt/components/overlay';
+import { FlexibleConnectedPositionStrategyOrigin } from '@angular/cdk/overlay';
+
+declare class PopoverComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PopoverComponent, "emr-popover", ["emrPopover"], {}, {}, never, ["*"], true, never>;
+}
+
+type PopoverTrigger = 'click' | 'hover';
+type PopoverPosition = OverlayPosition;
+declare const POPOVER_TRIGGER: InjectionToken<PopoverTrigger>;
+
+declare class PopoverTriggerForDirective implements OnInit, OnDestroy {
+    private _overlay;
+    private _elementRef;
+    private _directionality;
+    private _viewContainerRef;
+    private _injector;
+    private _popoverPortal;
+    private _overlayRef;
+    private _destroyRef;
+    private _openTimeout;
+    private _closeTimeout;
+    private _closeDelay;
+    popoverTemplateRef: _angular_core.InputSignal<TemplateRef<unknown>>;
+    trigger: _angular_core.InputSignal<PopoverTrigger>;
+    position: _angular_core.InputSignal<_elementar_rt_components_overlay.OverlayPosition>;
+    delay: _angular_core.InputSignalWithTransform<number, unknown>;
+    origin: _angular_core.InputSignal<FlexibleConnectedPositionStrategyOrigin | undefined>;
+    closeOnOriginClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    closeOnOriginMouseLeave: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    hasBackdrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private _closed;
+    constructor();
+    protected _handleClick(): void;
+    protected _handleMouseover(): void;
+    protected _handleMouseout(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get api(): {
+        isOpen: () => boolean;
+        open: () => void;
+        close: () => void;
+    };
+    private _isOpen;
+    private _open;
+    private _close;
+    private _destroyOverlay;
+    private _subscribeToOutsideClicks;
+    private _getPopoverContentPortal;
+    private _getOverlayConfig;
+    private _getOverlayPositionStrategy;
+    private _getOverlayPositions;
+    private _setType;
+    private _subscribeToHostMouseleave;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverTriggerForDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverTriggerForDirective, "[emrPopoverTriggerFor]", ["emrPopoverTriggerFor"], { "popoverTemplateRef": { "alias": "emrPopoverTriggerFor"; "required": true; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "origin": { "alias": "origin"; "required": false; "isSignal": true; }; "closeOnOriginClick": { "alias": "closeOnOriginClick"; "required": false; "isSignal": true; }; "closeOnOriginMouseLeave": { "alias": "closeOnOriginMouseLeave"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class PopoverOriginDirective {
+    private _elementRef;
+    get api(): {
+        nativeElement: () => any;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverOriginDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverOriginDirective, "[emrPopoverOrigin]", ["emrPopoverOrigin"], {}, {}, never, never, true, never>;
+}
+
+export { POPOVER_TRIGGER, PopoverComponent, PopoverOriginDirective, PopoverTriggerForDirective };
+export type { PopoverPosition, PopoverTrigger };

package/radio-card/index.d.ts

@@ -0,0 +1,37 @@
+import * as i0 from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare class RadioCardGroupComponent implements ControlValueAccessor {
+    readonly value: i0.WritableSignal<any>;
+    readonly disabled: i0.WritableSignal<boolean>;
+    private onChange;
+    private onTouched;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    selectValue(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioCardGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioCardGroupComponent, "emr-radio-card-group", ["emrRadioCardGroup"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class RadioCardComponent {
+    value: i0.InputSignal<any>;
+    protected parentGroup: RadioCardGroupComponent;
+    readonly isSelected: i0.Signal<boolean>;
+    selectCard(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioCardComponent, "emr-radio-card", ["emrRadioCard"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, ["emr-radio-card-title", "*"], true, never>;
+}
+
+declare class RadioCardTitleComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioCardTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioCardTitleComponent, "emr-radio-card-title", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class RadioCardContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioCardContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioCardContentComponent, "emr-radio-card-content", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { RadioCardComponent, RadioCardContentComponent, RadioCardGroupComponent, RadioCardTitleComponent };

package/rail-nav/index.d.ts

@@ -0,0 +1,36 @@
+import * as i0 from '@angular/core';
+import { OnInit } from '@angular/core';
+
+interface RailNavAPI {
+    getActiveKey: () => any;
+    activateItem: (key: any) => void;
+    isActive: (key: any) => boolean;
+}
+interface RailNavComponent$1 {
+    api: RailNavAPI;
+}
+
+declare class RailNavComponent implements OnInit {
+    activeKey: i0.InputSignal<unknown>;
+    private _activeKey;
+    readonly api: RailNavAPI;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RailNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RailNavComponent, "emr-rail-nav", ["emrRailNav"], { "activeKey": { "alias": "activeKey"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class RailNavItemComponent {
+    protected _railNav: RailNavComponent$1;
+    key: i0.InputSignal<string>;
+    get isActive(): boolean;
+    click(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RailNavItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RailNavItemComponent, "emr-rail-nav-item,[emr-rail-nav-item]", ["emrRailNavItem"], { "key": { "alias": "key"; "required": false; "isSignal": true; }; }, {}, never, ["[emrRailNavItemIcon]", "*"], true, never>;
+}
+
+declare class RailNavItemIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RailNavItemIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RailNavItemIconDirective, "[emrRailNavItemIcon]", never, {}, {}, never, never, true, never>;
+}
+
+export { RailNavComponent, RailNavItemComponent, RailNavItemIconDirective };

package/resizable-container/index.d.ts

@@ -0,0 +1,21 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, ElementRef } from '@angular/core';
+
+declare class ResizableContainerComponent implements OnInit {
+    private _renderer;
+    private _elementRef;
+    private _cdr;
+    private _ngZone;
+    private _destroyRef;
+    private _document;
+    private _resizing;
+    private _maxWidth;
+    private _clientX;
+    readonly handlerRef: _angular_core.Signal<ElementRef<any>>;
+    minWidth: _angular_core.InputSignalWithTransform<number, unknown>;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResizableContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResizableContainerComponent, "emr-resizable-container", ["emrResizableContainer"], { "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { ResizableContainerComponent };

package/screen-loader/index.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from '@angular/core';
+
+declare class ScreenLoaderComponent {
+    opened: i0.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScreenLoaderComponent, "emr-screen-loader", ["emrScreenLoader"], { "opened": { "alias": "opened"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { ScreenLoaderComponent };

package/scroll-spy/index.d.ts

@@ -0,0 +1,48 @@
+import * as i0 from '@angular/core';
+import { OnInit, AfterContentInit, InjectionToken } from '@angular/core';
+
+declare class ScrollSpyOnComponent implements OnInit {
+    private _parent;
+    private _elementRef;
+    private _renderer;
+    private _document;
+    targetId: i0.InputSignal<string>;
+    ngOnInit(): void;
+    protected get isActive(): boolean;
+    protected _handleClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollSpyOnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollSpyOnComponent, "emr-scroll-spy-on,[emr-scroll-spy-on]", ["emrScrollSpyOn"], { "targetId": { "alias": "targetId"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScrollSpyNavComponent implements AfterContentInit {
+    private _document;
+    private _cdr;
+    private _platformId;
+    private _zone;
+    private _threshold;
+    private _destroyRef;
+    readonly _items: i0.Signal<readonly ScrollSpyOnComponent[]>;
+    protected _activeId: string;
+    private _elementToScroll;
+    ngAfterContentInit(): void;
+    get activeId(): string;
+    scrollTo(targetId: string): void;
+    private _findActiveItem;
+    private _elementIsVisibleInViewport;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollSpyNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollSpyNavComponent, "emr-scroll-spy-nav,[emr-scroll-spy-nav]", ["emrScrollSpyNav"], {}, {}, ["_items"], ["*"], true, never>;
+}
+
+declare class ScrollSpyTitleComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollSpyTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollSpyTitleComponent, "emr-scroll-spy-title", ["emrScrollSpyTitle"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class ScrollSpyContainerDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollSpyContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollSpyContainerDirective, "[emrScrollSpyContainer]", ["emrScrollSpyContainer"], {}, {}, never, never, true, never>;
+}
+
+declare const SCROLL_SPY_NAV: InjectionToken<unknown>;
+
+export { SCROLL_SPY_NAV, ScrollSpyContainerDirective, ScrollSpyNavComponent, ScrollSpyOnComponent, ScrollSpyTitleComponent };

package/segmented/index.d.ts

@@ -0,0 +1,54 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, OnChanges, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1 from '@angular/material/core';
+
+declare class SegmentedComponent implements OnInit, OnChanges, ControlValueAccessor {
+    private _elementRef;
+    private _renderer;
+    private _cdr;
+    protected _disabled: boolean;
+    value: _angular_core.InputSignal<unknown>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    size: _angular_core.InputSignal<string>;
+    readonly valueChange: _angular_core.OutputEmitterRef<any>;
+    private _selectedValue;
+    _onChange: any;
+    _onTouched: any;
+    get api(): {
+        isSelected: (value: any) => boolean;
+        select: (value: any) => void;
+    };
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: BooleanInput): void;
+    private _select;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedComponent, "emr-segmented", ["emrSegmented"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, ["emr-segmented-button,[emr-segmented-button]"], true, never>;
+}
+
+declare class SegmentedButtonComponent {
+    private _segmented;
+    value: _angular_core.InputSignal<any>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    iconOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    get _isSelected(): boolean;
+    get api(): {
+        isSelected: () => boolean;
+    };
+    protected _handleClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedButtonComponent, "emr-segmented-button,[emr-segmented-button]", ["emrSegmentedButton"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; }, {}, never, ["[emrSegmentedIcon]", "*"], true, [{ directive: typeof i1.MatRipple; inputs: {}; outputs: {}; }]>;
+}
+
+declare class SegmentedIconDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SegmentedIconDirective, "[emrSegmentedIcon]", ["emrSegmentedIcon"], {}, {}, never, never, true, never>;
+}
+
+export { SegmentedButtonComponent, SegmentedComponent, SegmentedIconDirective };

package/side-panel/index.d.ts

@@ -0,0 +1,42 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { TooltipPosition } from '@angular/material/tooltip';
+
+type PanelPosition = 'left' | 'right';
+interface SidePanelTabConfig {
+    tabId: string;
+    label: string;
+    icon?: string | TemplateRef<any>;
+    content: TemplateRef<any>;
+}
+
+declare class SidePanelComponent {
+    position: _angular_core.InputSignal<PanelPosition>;
+    isPositionRight: _angular_core.Signal<boolean>;
+    tooltipPosition: _angular_core.Signal<TooltipPosition>;
+    private projectedTabsQuery;
+    protected internalTabs: _angular_core.WritableSignal<SidePanelTabConfig[]>;
+    activeTabId: _angular_core.WritableSignal<string | null>;
+    isOpen: _angular_core.WritableSignal<boolean>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    selectedTabContent: _angular_core.Signal<TemplateRef<any> | null>;
+    constructor();
+    toggleTab(tabId: string): void;
+    close(): void;
+    protected isTemplateRef(value: any): value is TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidePanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidePanelComponent, "emr-side-panel", ["emrSidePanel"], { "position": { "alias": "position"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, ["projectedTabsQuery"], never, true, never>;
+}
+
+declare class SidePanelTabComponent {
+    tabId: _angular_core.InputSignal<string>;
+    label: _angular_core.InputSignal<string>;
+    icon: _angular_core.InputSignal<string | TemplateRef<any> | undefined>;
+    content: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidePanelTabComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidePanelTabComponent, "emr-side-panel-tab", ["emrSidePanelTab"], { "tabId": { "alias": "tabId"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { SidePanelComponent, SidePanelTabComponent };
+export type { PanelPosition, SidePanelTabConfig };

package/sidebar/index.d.ts

@@ -0,0 +1,143 @@
+import * as i0 from '@angular/core';
+import { ElementRef, AfterContentInit, SimpleChanges, OnInit, InjectionToken } from '@angular/core';
+import * as i1 from '@angular/material/core';
+
+declare class SidebarComponent {
+    compact: i0.InputSignalWithTransform<boolean, unknown>;
+    protected _compactHover: boolean;
+    get api(): {
+        isCompact: () => boolean;
+    };
+    protected mouseenter(): void;
+    protected mouseleave(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarComponent, "emr-sidebar", ["emrSidebar"], { "compact": { "alias": "compact"; "required": false; "isSignal": true; }; }, {}, never, ["emr-sidebar-header", "emr-sidebar-body", "emr-sidebar-footer"], true, never>;
+}
+
+declare class SidebarHeaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarHeaderComponent, "emr-sidebar-header", ["emrSidebarHeader"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class SidebarBodyComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarBodyComponent, "emr-sidebar-body", ["emrSidebarBody"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class SidebarNavItem {
+    active: boolean;
+}
+declare class SidebarNavItemComponent implements SidebarNavItem {
+    private _navigation;
+    private _elementRef;
+    private _navStore;
+    get api(): {
+        isActive: () => boolean;
+    };
+    key: i0.InputSignal<any>;
+    forceActive: i0.InputSignalWithTransform<boolean, unknown>;
+    click(event: MouseEvent): void;
+    get active(): boolean;
+    get _hostElement(): ElementRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarNavItemComponent, "emr-sidebar-nav-item,[emr-sidebar-nav-item]", ["emr-sidebar-nav-item"], { "key": { "alias": "key"; "required": false; "isSignal": true; }; "forceActive": { "alias": "forceActive"; "required": false; "isSignal": true; }; }, {}, never, ["[emrSidebarNavItemIcon]", "*", "[emrSidebarNavItemBadge]"], true, never>;
+}
+
+declare class SidebarNavGroupComponent implements AfterContentInit {
+    private _toggle;
+    private _menu;
+    readonly _groupId: string;
+    ngAfterContentInit(): void;
+    hasActiveItem(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarNavGroupComponent, "emr-sidebar-nav-group", never, {}, {}, ["_toggle", "_menu"], ["*"], true, never>;
+}
+
+declare class SidebarNavComponent implements AfterContentInit {
+    private _elementRef;
+    private _navStore;
+    readonly _items: i0.Signal<readonly SidebarNavItemComponent[]>;
+    readonly _groups: i0.Signal<readonly SidebarNavGroupComponent[]>;
+    activeKey: i0.InputSignal<unknown>;
+    autoScrollToActiveItem: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly itemClicked: i0.OutputEmitterRef<any>;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    private _hasScroll;
+    private _isScrolledIntoView;
+    private _scrollToActiveItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarNavComponent, "emr-sidebar-nav", ["emrSidebarNav"], { "activeKey": { "alias": "activeKey"; "required": false; "isSignal": true; }; "autoScrollToActiveItem": { "alias": "autoScrollToActiveItem"; "required": false; "isSignal": true; }; }, { "itemClicked": "itemClicked"; }, ["_items", "_groups"], ["*"], true, never>;
+}
+
+declare class SidebarFooterComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarFooterComponent, "emr-sidebar-footer", ["emrSidebarFooter"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class SidebarNavHeadingComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavHeadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarNavHeadingComponent, "emr-sidebar-nav-heading", ["emrSidebarNavHeading"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class SidebarNavGroupToggleComponent {
+    private _navStore;
+    readonly for: i0.WritableSignal<any>;
+    get active(): boolean;
+    toggle(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavGroupToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarNavGroupToggleComponent, "emr-sidebar-nav-group-toggle", ["emrSidebarNavGroupToggle"], {}, {}, never, ["[emrSidebarNavItemIcon]", "*", "[emrSidebarNavItemBadge]", "[emrSidebarNavGroupToggleIcon]"], true, [{ directive: typeof i1.MatRipple; inputs: {}; outputs: {}; }]>;
+}
+
+declare class SidebarNavGroupMenuComponent implements AfterContentInit, OnInit {
+    readonly navigation: SidebarNavComponent;
+    private _group;
+    private _navStore;
+    readonly _items: i0.Signal<readonly SidebarNavItemComponent[]>;
+    key: i0.WritableSignal<any>;
+    get active(): boolean;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    hasActiveItem(): boolean;
+    private _checkIfActive;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavGroupMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarNavGroupMenuComponent, "emr-sidebar-nav-group-menu", ["emrSidebarNavGroupMenu"], {}, {}, ["_items"], ["*"], true, never>;
+}
+
+declare class SidebarNavDividerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavDividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarNavDividerComponent, "emr-sidebar-nav-divider", ["emrSidebarNavDivider"], {}, {}, never, never, true, never>;
+}
+
+declare class SidebarCompactViewModeDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarCompactViewModeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SidebarCompactViewModeDirective, "[emrSidebarCompactViewMode]", ["emrSidebarCompactViewMode"], {}, {}, never, never, true, never>;
+}
+
+declare class SidebarFullViewModeDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarFullViewModeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SidebarFullViewModeDirective, "[emrSidebarFullViewMode]", ["emrSidebarFullViewMode"], {}, {}, never, never, true, never>;
+}
+
+declare class SidebarNavItemIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavItemIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SidebarNavItemIconDirective, "[emrSidebarNavItemIcon]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SidebarNavItemBadgeDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavItemBadgeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SidebarNavItemBadgeDirective, "[emrSidebarNavItemBadge]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SidebarNavGroupToggleIconDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavGroupToggleIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SidebarNavGroupToggleIconDirective, "[emrSidebarNavGroupToggleIcon]", never, {}, {}, never, never, true, never>;
+}
+
+declare const SIDEBAR_NAVIGATION: InjectionToken<unknown>;
+declare const SIDEBAR_NAVIGATION_GROUP: InjectionToken<unknown>;
+
+export { SIDEBAR_NAVIGATION, SIDEBAR_NAVIGATION_GROUP, SidebarBodyComponent, SidebarCompactViewModeDirective, SidebarComponent, SidebarFooterComponent, SidebarFullViewModeDirective, SidebarHeaderComponent, SidebarNavComponent, SidebarNavDividerComponent, SidebarNavGroupComponent, SidebarNavGroupMenuComponent, SidebarNavGroupToggleComponent, SidebarNavGroupToggleIconDirective, SidebarNavHeadingComponent, SidebarNavItem, SidebarNavItemBadgeDirective, SidebarNavItemComponent, SidebarNavItemIconDirective };

package/signature-pad/index.d.ts

@@ -0,0 +1,49 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, ElementRef } from '@angular/core';
+
+declare class SignaturePadComponent implements OnDestroy {
+    penColor: _angular_core.ModelSignal<string>;
+    lineWidth: _angular_core.InputSignal<number>;
+    backgroundColor: _angular_core.InputSignal<string>;
+    lazyRadius: _angular_core.InputSignal<number>;
+    lazyFriction: _angular_core.InputSignal<number>;
+    lazyEnabled: _angular_core.InputSignal<boolean>;
+    colors: _angular_core.InputSignal<string[]>;
+    signatureSaved: _angular_core.OutputEmitterRef<string>;
+    signatureCleared: _angular_core.OutputEmitterRef<void>;
+    mainCanvasRef: _angular_core.Signal<ElementRef<HTMLCanvasElement>>;
+    private canvasWidth;
+    private canvasHeight;
+    private mainContext;
+    private memoryCanvasElement;
+    private memoryContext;
+    private lazyBrushInstance;
+    private isDrawing;
+    private currentStrokePoints;
+    private resizeObserver;
+    private platformId;
+    private document;
+    private subscriptions;
+    private pointerDown$;
+    constructor();
+    ngOnDestroy(): void;
+    private setupPointerEvents;
+    private setupResizeObserver;
+    private initializeLazyBrush;
+    private initializeCanvasesAndContexts;
+    private configureContextStyling;
+    private handlePointerDownLogic;
+    private handlePointerMoveLogic;
+    private handlePointerUpLogic;
+    private drawSmoothStroke;
+    private getCoordinates;
+    clear(): void;
+    save(): void;
+    onColorChange(color: string): void;
+    private isCanvasEffectivelyBlank;
+    handleEscapeKey(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SignaturePadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SignaturePadComponent, "emr-signature-pad", ["emrSignaturePad"], { "penColor": { "alias": "penColor"; "required": false; "isSignal": true; }; "lineWidth": { "alias": "lineWidth"; "required": false; "isSignal": true; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; "isSignal": true; }; "lazyRadius": { "alias": "lazyRadius"; "required": false; "isSignal": true; }; "lazyFriction": { "alias": "lazyFriction"; "required": false; "isSignal": true; }; "lazyEnabled": { "alias": "lazyEnabled"; "required": false; "isSignal": true; }; "colors": { "alias": "colors"; "required": false; "isSignal": true; }; }, { "penColor": "penColorChange"; "signatureSaved": "signatureSaved"; "signatureCleared": "signatureCleared"; }, never, never, true, never>;
+}
+
+export { SignaturePadComponent };

package/skeleton/index.d.ts

@@ -0,0 +1,24 @@
+import * as i0 from '@angular/core';
+
+declare class SkeletonComponent {
+    direction: i0.InputSignal<"row" | "col">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonComponent, "emr-skeleton", ["emrSkeleton"], { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class SkeletonCircleComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonCircleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonCircleComponent, "emr-skeleton-circle", ["emrSkeletonCircle"], {}, {}, never, never, true, never>;
+}
+
+declare class SkeletonLineComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonLineComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonLineComponent, "emr-skeleton-line", ["emrSkeletonLine"], {}, {}, never, never, true, never>;
+}
+
+declare class SkeletonBlockComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonBlockComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonBlockComponent, "emr-skeleton-block", ["emrSkeletonBlock"], {}, {}, never, never, true, never>;
+}
+
+export { SkeletonBlockComponent, SkeletonCircleComponent, SkeletonComponent, SkeletonLineComponent };

package/splash-screen/index.d.ts

@@ -0,0 +1,31 @@
+import * as _angular_core from '@angular/core';
+import * as _ngrx_signals from '@ngrx/signals';
+
+declare class SplashScreenComponent {
+    private _store;
+    private _renderer;
+    private _elementRef;
+    private _router;
+    animationDuration: _angular_core.InputSignalWithTransform<number, unknown>;
+    hideDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    constructor();
+    ngOnInit(): void;
+    private _show;
+    private _hide;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplashScreenComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SplashScreenComponent, "emr-splash-screen", ["emrSplashScreen"], { "animationDuration": { "alias": "animationDuration"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "hideDelay"; "required": false; "isSignal": true; }; }, {}, never, ["emr-text-logo,emr-image-logo"], true, never>;
+}
+
+interface SplashScreenState {
+    visible: boolean;
+}
+declare const SplashScreenStore: _angular_core.Type<{
+    visible: _angular_core.Signal<boolean>;
+    show: () => void;
+    hide: () => void;
+} & _ngrx_signals.StateSource<{
+    visible: boolean;
+}>>;
+
+export { SplashScreenComponent, SplashScreenStore };
+export type { SplashScreenState };