@elementar-rt/components 0.6.55

package/marquee/index.d.ts

@@ -0,0 +1,26 @@
+import * as i0 from '@angular/core';
+import { AfterContentInit, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+
+declare class MarqueeComponent implements AfterContentInit, OnChanges, OnDestroy {
+    private _elementRef;
+    private _platformId;
+    private _intersectionObserver?;
+    reverse: i0.InputSignalWithTransform<boolean, unknown>;
+    pauseOnHover: i0.InputSignalWithTransform<boolean, unknown>;
+    protected isInView: boolean;
+    protected get nativeElement(): HTMLElement;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarqueeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MarqueeComponent, "emr-marquee", ["emrMarquee"], { "reverse": { "alias": "reverse"; "required": false; "isSignal": true; }; "pauseOnHover": { "alias": "pauseOnHover"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class MarqueeItemDirective {
+    private _elementRef;
+    get nativeElement(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarqueeItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MarqueeItemDirective, "[emrMarqueeItem]", never, {}, {}, never, never, true, never>;
+}
+
+export { MarqueeComponent, MarqueeItemDirective };

package/micro-chart/index.d.ts

@@ -0,0 +1,193 @@
+import * as _angular_core from '@angular/core';
+import { Renderer2, ViewContainerRef, Injector, TemplateRef, OnDestroy, AfterViewChecked, OnChanges, SimpleChanges } from '@angular/core';
+import { OverlayPosition } from '@elementar-rt/components/overlay';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { OverlayRef, Overlay, OverlayConfig, FlexibleConnectedPositionStrategy, ConnectedPosition } from '@angular/cdk/overlay';
+
+type MchartLineCurveType = 'linear' | 'catmullRom' | 'curveBumpX' | 'curveStep';
+
+declare abstract class BaseChartTooltip {
+    protected _tooltipOrigin: HTMLElement;
+    protected _tooltipPortal: TemplatePortal;
+    protected _overlayRef: OverlayRef;
+    protected _renderer: Renderer2;
+    protected _overlay: Overlay;
+    protected _viewContainerRef: ViewContainerRef;
+    protected _injector: Injector;
+    protected _document: Document;
+    abstract getTooltipTemplateRef(): TemplateRef<any> | undefined;
+    abstract getTooltipPosition(): OverlayPosition;
+    protected _createTooltipOrigin(): void;
+    protected _showTooltip(data: object): void;
+    protected _hideTooltip(): void;
+    protected _setTooltipPositionByEvent(e: MouseEvent): void;
+    protected _setTooltipVisible(): void;
+    protected _setTooltipInVisible(): void;
+    protected _getContentPortal(data: object): TemplatePortal<any>;
+    protected _getOverlayConfig(): OverlayConfig;
+    protected _getOverlayPositionStrategy(): FlexibleConnectedPositionStrategy;
+    protected _getOverlayPositions(): ConnectedPosition[];
+}
+
+declare class MchartLineComponent extends BaseChartTooltip implements OnDestroy, AfterViewChecked {
+    private _initialized;
+    private _host;
+    private _svg;
+    private _dimensions;
+    private _hostWidth;
+    private _hostHeight;
+    private _innerWidth;
+    private _innerHeight;
+    private _yScale;
+    private _xScale;
+    private _curveMap;
+    private _resizeObserver;
+    private _tooltipDot;
+    private _area;
+    private _line;
+    private _platformId;
+    private _destroyRef;
+    private _elementRef;
+    data: _angular_core.InputSignal<number[]>;
+    labels: _angular_core.InputSignal<any[]>;
+    strokeWidth: _angular_core.InputSignalWithTransform<number, unknown>;
+    showArea: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    showMarkers: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    responsive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    fillAreaGradient: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    curve: _angular_core.InputSignal<MchartLineCurveType>;
+    xAccessor: _angular_core.InputSignal<(d: any, i: number) => number>;
+    yAccessor: _angular_core.InputSignal<(d: any) => any>;
+    compact: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    markerDotSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    tooltip: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    tooltipPosition: _angular_core.InputSignal<OverlayPosition>;
+    get gradientId(): string;
+    private _gradientId;
+    constructor();
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    getTooltipPosition(): OverlayPosition;
+    getTooltipTemplateRef(): TemplateRef<any> | undefined;
+    private _render;
+    private _setupContainers;
+    private _setupData;
+    private _setupResizeObserver;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MchartLineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MchartLineComponent, "emr-mchart-line", ["emrMchartLine"], { "data": { "alias": "data"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "showArea": { "alias": "showArea"; "required": false; "isSignal": true; }; "showMarkers": { "alias": "showMarkers"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "fillAreaGradient": { "alias": "fillAreaGradient"; "required": false; "isSignal": true; }; "curve": { "alias": "curve"; "required": false; "isSignal": true; }; "xAccessor": { "alias": "xAccessor"; "required": false; "isSignal": true; }; "yAccessor": { "alias": "yAccessor"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "markerDotSize": { "alias": "markerDotSize"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MchartBarComponent extends BaseChartTooltip implements OnDestroy, AfterViewChecked {
+    private _initialized;
+    private _host;
+    private _svg;
+    private _hlContainer;
+    private _dataContainer;
+    private _dimensions;
+    private _innerWidth;
+    private _innerHeight;
+    private _hostWidth;
+    private _hostHeight;
+    private _xScale;
+    private _yScale;
+    private _resizeObserver;
+    private _platformId;
+    private _elementRef;
+    private _destroyRef;
+    data: _angular_core.InputSignal<number[]>;
+    labels: _angular_core.InputSignal<string[]>;
+    gap: _angular_core.InputSignalWithTransform<number, unknown>;
+    radius: _angular_core.InputSignalWithTransform<number, unknown>;
+    highlight: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    responsive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    fillGradient: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    xAccessor: _angular_core.InputSignal<(d: any, i: number) => number>;
+    yAccessor: _angular_core.InputSignal<(d: any) => any>;
+    tooltip: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    tooltipPosition: _angular_core.InputSignal<OverlayPosition>;
+    get gradientId(): string;
+    private _gradientId;
+    constructor();
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    getTooltipPosition(): OverlayPosition;
+    getTooltipTemplateRef(): TemplateRef<any> | undefined;
+    private _render;
+    private _init;
+    private _setupAxisScale;
+    private _setupData;
+    private _setupResizeObserver;
+    private _initTooltip;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MchartBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MchartBarComponent, "emr-mchart-bar", ["emrMchartBar"], { "data": { "alias": "data"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "highlight": { "alias": "highlight"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "fillGradient": { "alias": "fillGradient"; "required": false; "isSignal": true; }; "xAccessor": { "alias": "xAccessor"; "required": false; "isSignal": true; }; "yAccessor": { "alias": "yAccessor"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MchartPieComponent extends BaseChartTooltip implements AfterViewChecked, OnChanges, OnDestroy {
+    private _initialized;
+    private _host;
+    private _svg;
+    private _dataContainer;
+    private _legendContainer;
+    private _dimensions;
+    private _innerWidth;
+    private _innerHeight;
+    private _hostWidth;
+    private _hostHeight;
+    private _resizeObserver;
+    private _platformId;
+    private _elementRef;
+    private _radius;
+    private _arcGenerator;
+    private _pieGenerator;
+    private _colorsGenerator;
+    private _arcTweenGenerator;
+    private _pieData;
+    data: _angular_core.InputSignal<number[]>;
+    labels: _angular_core.InputSignal<string[] | number[]>;
+    valueAccessor: _angular_core.InputSignal<(d: any) => any>;
+    dataItemStrokeWidth: _angular_core.InputSignalWithTransform<number, unknown>;
+    legendContainerWidth: _angular_core.InputSignalWithTransform<number, unknown>;
+    showDataAnimation: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    showValueOnSlices: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    showLegend: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    legendOffset: _angular_core.InputSignalWithTransform<number, unknown>;
+    legendItemHeight: _angular_core.InputSignalWithTransform<number, unknown>;
+    legendItemSymbolSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    legendItemFontSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    legendItemSymbolBorderRadius: _angular_core.InputSignalWithTransform<number, unknown>;
+    valueFontSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    tooltip: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    tooltipPosition: _angular_core.InputSignal<OverlayPosition>;
+    getTooltipPosition(): OverlayPosition;
+    getTooltipTemplateRef(): TemplateRef<any> | undefined;
+    ngAfterViewChecked(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private _render;
+    private _initDimensions;
+    private _initContainers;
+    private _setGenerators;
+    private _setLegend;
+    private _draw;
+    private _setupResizeObserver;
+    private _initTooltip;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MchartPieComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MchartPieComponent, "emr-mchart-pie", ["emrMchartPie"], { "data": { "alias": "data"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "valueAccessor": { "alias": "valueAccessor"; "required": false; "isSignal": true; }; "dataItemStrokeWidth": { "alias": "dataItemStrokeWidth"; "required": false; "isSignal": true; }; "legendContainerWidth": { "alias": "legendContainerWidth"; "required": false; "isSignal": true; }; "showDataAnimation": { "alias": "showDataAnimation"; "required": false; "isSignal": true; }; "showValueOnSlices": { "alias": "showValueOnSlices"; "required": false; "isSignal": true; }; "showLegend": { "alias": "showLegend"; "required": false; "isSignal": true; }; "legendOffset": { "alias": "legendOffset"; "required": false; "isSignal": true; }; "legendItemHeight": { "alias": "legendItemHeight"; "required": false; "isSignal": true; }; "legendItemSymbolSize": { "alias": "legendItemSymbolSize"; "required": false; "isSignal": true; }; "legendItemFontSize": { "alias": "legendItemFontSize"; "required": false; "isSignal": true; }; "legendItemSymbolBorderRadius": { "alias": "legendItemSymbolBorderRadius"; "required": false; "isSignal": true; }; "valueFontSize": { "alias": "valueFontSize"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MchartTooltipComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MchartTooltipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MchartTooltipComponent, "emr-mchart-tooltip", ["emrMchartTooltip"], {}, {}, never, ["emr-mchart-tooltip-title", "emr-mchart-tooltip-body", "*"], true, never>;
+}
+
+declare class MchartTooltipTitleComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MchartTooltipTitleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MchartTooltipTitleComponent, "emr-mchart-tooltip-title", ["emrMchartTooltipTitle"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class MchartTooltipBodyComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MchartTooltipBodyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MchartTooltipBodyComponent, "emr-mchart-tooltip-body", ["emrMchartTooltipBody"], {}, {}, never, ["*"], true, never>;
+}
+
+export { MchartBarComponent, MchartLineComponent, MchartPieComponent, MchartTooltipBodyComponent, MchartTooltipComponent, MchartTooltipTitleComponent };

package/navigation/index.d.ts

@@ -0,0 +1,119 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, ElementRef, InjectionToken, AfterContentInit, OnChanges, SimpleChanges } from '@angular/core';
+import * as i1 from '@angular/material/core';
+
+declare class NavigationItemIconDirective {
+    readonly templateRef: TemplateRef<any> | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationItemIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NavigationItemIconDirective, "[emrNavigationItemIcon]", ["emrNavigationItemIcon"], {}, {}, never, never, true, never>;
+}
+
+declare class NavigationItemComponent {
+    private store;
+    private _navigation;
+    private _elementRef;
+    private parentGroup;
+    protected readonly iconRef: i0.Signal<NavigationItemIconDirective | undefined>;
+    readonly active: i0.Signal<boolean>;
+    get api(): {
+        isActive: () => boolean;
+    };
+    readonly key: i0.InputSignal<any>;
+    readonly forceActive: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly badgeTextOnly: i0.InputSignalWithTransform<boolean, unknown>;
+    protected click(event: MouseEvent): void;
+    get _hostElement(): ElementRef;
+    protected get iconRefTemplate(): TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationItemComponent, "emr-navigation-item,[emr-navigation-item]", ["emrNavigationItem"], { "key": { "alias": "key"; "required": false; "isSignal": true; }; "forceActive": { "alias": "forceActive"; "required": false; "isSignal": true; }; "badgeTextOnly": { "alias": "badgeTextOnly"; "required": false; "isSignal": true; }; }, {}, ["iconRef"], ["[emrNavigationItemIcon]", "*", "[emrNavigationItemBadge]"], true, never>;
+}
+
+interface NavigationItem {
+    key: any;
+    type: 'heading' | 'group' | 'link' | 'item' | 'divider' | string;
+    name?: string;
+    icon?: string;
+    children?: NavigationItem[];
+    link?: string;
+    [prop: string]: any;
+    badge?: string | number;
+}
+declare const NAVIGATION: InjectionToken<unknown>;
+declare const NAVIGATION_GROUP: InjectionToken<unknown>;
+
+declare class NavigationComponent implements AfterContentInit, OnChanges {
+    private store;
+    private _elementRef;
+    private _renderer;
+    private location;
+    private router;
+    private destroyRef;
+    readonly _items: i0.Signal<readonly NavigationItemComponent[]>;
+    activeKey: i0.InputSignal<any>;
+    appearance: i0.InputSignal<unknown>;
+    activateByRoute: i0.InputSignalWithTransform<boolean, unknown>;
+    autoScrollToActiveItem: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly itemClicked: i0.OutputEmitterRef<NavigationItem>;
+    constructor();
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _hasScroll;
+    private _isScrolledIntoView;
+    private findActiveItemByRoute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationComponent, "emr-navigation", ["emrNavigation"], { "activeKey": { "alias": "activeKey"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "activateByRoute": { "alias": "activateByRoute"; "required": false; "isSignal": true; }; "autoScrollToActiveItem": { "alias": "autoScrollToActiveItem"; "required": false; "isSignal": true; }; }, { "itemClicked": "itemClicked"; }, ["_items"], ["*"], true, never>;
+}
+
+declare class NavigationHeadingComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationHeadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationHeadingComponent, "emr-navigation-heading", ["emrNavigationHeading"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class NavigationDividerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationDividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationDividerComponent, "emr-navigation-divider", ["emrNavigationDivider"], {}, {}, never, never, true, never>;
+}
+
+declare class NavigationGroupComponent {
+    readonly key: i0.WritableSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationGroupComponent, "emr-navigation-group", ["emrNavigationGroup"], {}, {}, never, ["emr-navigation-group-toggle", "emr-navigation-group-menu"], true, never>;
+}
+
+declare class NavigationGroupMenuComponent implements AfterContentInit {
+    private store;
+    private _group;
+    readonly active: i0.Signal<boolean>;
+    readonly _items: i0.Signal<readonly NavigationItemComponent[]>;
+    readonly hasActiveItemInGroup: i0.Signal<boolean>;
+    ngAfterContentInit(): void;
+    private _detectGroupIsActive;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationGroupMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationGroupMenuComponent, "emr-navigation-group-menu", ["emrNavigationGroupMenu"], {}, {}, ["_items"], ["*"], true, never>;
+}
+
+declare class NavigationGroupToggleIconDirective {
+    readonly templateRef: TemplateRef<any> | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationGroupToggleIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NavigationGroupToggleIconDirective, "[emrNavigationGroupToggleIcon]", ["emrNavigationGroupToggleIcon"], {}, {}, never, never, true, never>;
+}
+
+declare class NavigationGroupToggleComponent {
+    private store;
+    private _group;
+    readonly iconRef: i0.Signal<NavigationGroupToggleIconDirective | undefined>;
+    readonly active: i0.Signal<boolean>;
+    readonly badgeTextOnly: i0.InputSignalWithTransform<boolean, unknown>;
+    protected toggle(event: MouseEvent): void;
+    protected get iconRefTemplate(): TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationGroupToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationGroupToggleComponent, "emr-navigation-group-toggle", ["emrNavigationGroupToggle"], { "badgeTextOnly": { "alias": "badgeTextOnly"; "required": false; "isSignal": true; }; }, {}, ["iconRef"], ["[emrNavigationItemIcon]", "*", "[emrNavigationItemBadge]", "[emrNavigationGroupToggleIcon]"], true, [{ directive: typeof i1.MatRipple; inputs: {}; outputs: {}; }]>;
+}
+
+declare class NavigationItemBadgeDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationItemBadgeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NavigationItemBadgeDirective, "[emrNavigationItemBadge]", ["emrNavigationItemBadge"], {}, {}, never, never, true, never>;
+}
+
+export { NAVIGATION, NAVIGATION_GROUP, NavigationComponent, NavigationDividerComponent, NavigationGroupComponent, NavigationGroupMenuComponent, NavigationGroupToggleComponent, NavigationGroupToggleIconDirective, NavigationHeadingComponent, NavigationItemBadgeDirective, NavigationItemComponent, NavigationItemIconDirective };
+export type { NavigationItem };

package/notifications/index.d.ts

@@ -0,0 +1,84 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, AfterContentInit } from '@angular/core';
+
+declare class NotificationDefDirective {
+    readonly templateRef: TemplateRef<any>;
+    emrNotificationDef: i0.InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationDefDirective, "[emrNotificationDef]", never, { "emrNotificationDef": { "alias": "emrNotificationDef"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NotificationControlsDefDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationControlsDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationControlsDefDirective, "[emrNotificationControlsDef]", never, {}, {}, never, never, true, never>;
+}
+
+interface Notification {
+    actor: any;
+    type: string;
+    createdAt: string;
+    isUnread?: boolean;
+    [propName: string]: any;
+}
+
+declare class NotificationListComponent<T extends Notification> implements AfterContentInit {
+    readonly defs: i0.Signal<readonly NotificationDefDirective[]>;
+    readonly controlsDef: i0.Signal<NotificationControlsDefDirective | undefined>;
+    notifications: i0.InputSignal<T[]>;
+    static: i0.InputSignalWithTransform<boolean, unknown>;
+    protected _initialized: boolean;
+    protected _defsMap: Map<string, TemplateRef<any>>;
+    get controlsTpl(): TemplateRef<any>;
+    ngAfterContentInit(): void;
+    getNotificationTemplate(type: string): TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationListComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationListComponent<any>, "emr-notification-list", ["emrNotificationList"], { "notifications": { "alias": "notifications"; "required": false; "isSignal": true; }; "static": { "alias": "static"; "required": false; "isSignal": true; }; }, {}, ["defs", "controlsDef"], never, true, never>;
+}
+
+declare class NotificationSkeletonComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationSkeletonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationSkeletonComponent, "emr-notification-skeleton", ["emrNotificationSkeleton"], {}, {}, never, never, true, never>;
+}
+
+declare class NotificationTimeComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationTimeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationTimeComponent, "emr-notification-time,[emr-notification-time]", ["emrNotificationTime"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class NotificationActorComponent {
+    private elementRef;
+    protected get asLink(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationActorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationActorComponent, "emr-notification-actor,[emr-notification-actor]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class NotificationMessageComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationMessageComponent, "emr-notification-message", ["emrNotificationMessage"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class NotificationComponent {
+    isUnread: i0.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationComponent, "emr-notification,[emr-notification]", ["emrNotification"], { "isUnread": { "alias": "isUnread"; "required": false; "isSignal": true; }; }, {}, never, ["[emrNotificationAvatar]", "emr-notification-message,[emr-notification-message]", "emr-notification-content,[emr-notification-content]", "emr-notification-time,[emr-notification-time]"], true, never>;
+}
+
+declare class NotificationContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationContentComponent, "emr-notification-content,[emr-notification-content]", ["emrNotificationContent"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class NotificationPropsDirective {
+    isUnread: i0.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationPropsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationPropsDirective, "[emrNotificationProps]", ["emrNotificationProps"], { "isUnread": { "alias": "isUnread"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NotificationAvatarDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationAvatarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NotificationAvatarDirective, "[emrNotificationAvatar]", ["emrNotificationAvatar"], {}, {}, never, never, true, never>;
+}
+
+export { NotificationActorComponent, NotificationAvatarDirective, NotificationComponent, NotificationContentComponent, NotificationControlsDefDirective, NotificationDefDirective, NotificationListComponent, NotificationMessageComponent, NotificationPropsDirective, NotificationSkeletonComponent, NotificationTimeComponent };
+export type { Notification };

package/number-input/index.d.ts

@@ -0,0 +1,93 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, OnDestroy, DoCheck } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Subject } from 'rxjs';
+
+declare class DecreaseControlDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DecreaseControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DecreaseControlDirective, "[emrDecreaseControl]", ["emrDecreaseControl"], {}, {}, never, never, true, never>;
+}
+
+declare class IncreaseControlDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncreaseControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IncreaseControlDirective, "[emrIncreaseControl]", ["emrIncreaseControl"], {}, {}, never, never, true, never>;
+}
+
+declare class NumberInputComponent implements MatFormFieldControl<any>, ControlValueAccessor, OnDestroy, DoCheck {
+    ngControl: NgControl;
+    private _parentForm;
+    private _parentFormGroup;
+    private _elementRef;
+    readonly disableAutomaticLabeling: boolean;
+    readonly placeholder: string;
+    private _input;
+    readonly _decreaseControlRef: i0.Signal<DecreaseControlDirective | undefined>;
+    readonly _increaseControlRef: i0.Signal<IncreaseControlDirective | undefined>;
+    min: i0.InputSignalWithTransform<number | undefined, unknown>;
+    max: i0.InputSignalWithTransform<number | undefined, unknown>;
+    step: i0.InputSignalWithTransform<number, unknown>;
+    readonly: i0.InputSignalWithTransform<boolean, unknown>;
+    set disabled(disabled: any);
+    get disabled(): any;
+    private _disabled;
+    get required(): boolean;
+    set required(req: BooleanInput);
+    private _required;
+    readonly valueChange: i0.OutputEmitterRef<number | undefined>;
+    static nextId: number;
+    private _value;
+    controlType?: string | undefined;
+    autofilled?: boolean | undefined;
+    userAriaDescribedBy?: string | undefined;
+    stateChanges: Subject<void>;
+    focused: boolean;
+    touched: boolean;
+    errorState: boolean;
+    get id(): string;
+    get shouldLabelFloat(): boolean;
+    get empty(): boolean;
+    constructor(ngControl: NgControl);
+    setDescribedByIds(ids: string[]): void;
+    onFocusIn(event: FocusEvent): void;
+    onFocusOut(event: FocusEvent): void;
+    set value(value: number | undefined);
+    get value(): number | undefined;
+    ngOnDestroy(): void;
+    protected get _decreaseControlTemplateRef(): TemplateRef<any>;
+    protected get _increaseControlTemplateRef(): TemplateRef<any>;
+    onChange: any;
+    onTouched: any;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+    decrease(event: MouseEvent, input: HTMLInputElement): void;
+    increase(event: MouseEvent, input: HTMLInputElement): void;
+    isDecreaseDisabled(): any;
+    isIncreaseDisabled(): any;
+    inputChange(event: any): void;
+    private _emitEvent;
+    ngDoCheck(): void;
+    onContainerClick(event: MouseEvent): void;
+    private updateErrorState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberInputComponent, [{ optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NumberInputComponent, "emr-number-input", ["emrNumberInput"], { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "valueChange": "valueChange"; }, ["_decreaseControlRef", "_increaseControlRef"], never, true, never>;
+}
+
+declare class NumberInputPrefixDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberInputPrefixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NumberInputPrefixDirective, "[emrNumberInputPrefix]", ["emrNumberInputPrefix"], {}, {}, never, never, true, never>;
+}
+
+declare class NumberInputSuffixDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberInputSuffixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NumberInputSuffixDirective, "[emrNumberInputSuffix]", ["emrNumberInputSuffix"], {}, {}, never, never, true, never>;
+}
+
+export { DecreaseControlDirective, IncreaseControlDirective, NumberInputComponent, NumberInputPrefixDirective, NumberInputSuffixDirective };

package/overlay/index.d.ts

@@ -0,0 +1,12 @@
+import { ConnectedPosition } from '@angular/cdk/overlay';
+
+type OverlayPosition = 'below-start' | 'below-center' | 'below-end' | 'above-start' | 'above-center' | 'above-end' | 'before-start' | 'before-center' | 'before-end' | 'after-start' | 'after-center' | 'after-end';
+
+declare class PositionManager {
+    private _positions;
+    private _positionPairs;
+    build(position: OverlayPosition): ConnectedPosition[];
+}
+
+export { PositionManager };
+export type { OverlayPosition };

package/overlay-scrollbar/index.d.ts

@@ -0,0 +1,66 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+
+declare class OverlayScrollbarComponent {
+    private readonly platformId;
+    private readonly elRef;
+    private readonly zone;
+    private readonly renderer;
+    private readonly destroyRef;
+    private readonly router;
+    readonly scrollableContentRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly scrollTrackRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly scrollThumbRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly scrollTrackXRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly scrollThumbXRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly scrollbarWidth: _angular_core.InputSignal<string>;
+    readonly autoHide: _angular_core.InputSignal<boolean>;
+    readonly absolute: _angular_core.InputSignal<boolean>;
+    readonly isDragging: _angular_core.WritableSignal<boolean>;
+    readonly isHovering: _angular_core.WritableSignal<boolean>;
+    private readonly scrollTop;
+    private readonly scrollLeft;
+    private readonly contentScrollHeight;
+    private readonly contentScrollWidth;
+    private readonly contentClientHeight;
+    private readonly contentClientWidth;
+    private readonly trackClientHeight;
+    private readonly trackClientWidth;
+    private readonly showDueToActivity;
+    readonly hasScrollY: _angular_core.Signal<boolean>;
+    readonly scrollRatioY: _angular_core.Signal<number>;
+    readonly minThumbHeight = 20;
+    readonly thumbHeight: _angular_core.Signal<number>;
+    readonly maxScrollTop: _angular_core.Signal<number>;
+    readonly maxThumbTop: _angular_core.Signal<number>;
+    readonly thumbTop: _angular_core.Signal<number>;
+    readonly hasScrollX: _angular_core.Signal<boolean>;
+    readonly scrollRatioX: _angular_core.Signal<number>;
+    readonly minThumbWidth = 20;
+    readonly thumbWidth: _angular_core.Signal<number>;
+    readonly maxScrollLeft: _angular_core.Signal<number>;
+    readonly maxThumbLeft: _angular_core.Signal<number>;
+    readonly thumbLeft: _angular_core.Signal<number>;
+    readonly hasAnyScroll: _angular_core.Signal<boolean>;
+    readonly isVisible: _angular_core.Signal<boolean>;
+    readonly isInteractive: _angular_core.Signal<boolean>;
+    private isInitialized;
+    private eventsSubscription;
+    private observersSubscription;
+    private hideTimeout;
+    constructor();
+    private initializeComponentLogic;
+    private raf;
+    private setupStyleEffects;
+    private setupObservers;
+    private setupEventStreams;
+    private scheduleHide;
+    private clearHideTimeout;
+    private updateDimensions;
+    private cleanup;
+    private setupRouteChanges;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayScrollbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayScrollbarComponent, "emr-overlay-scrollbar", ["emrOverlayScrollbar"], { "scrollbarWidth": { "alias": "scrollbarWidth"; "required": false; "isSignal": true; }; "autoHide": { "alias": "autoHide"; "required": false; "isSignal": true; }; "absolute": { "alias": "absolute"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { OverlayScrollbarComponent };