@ngstarter-ui/components 1.0.21

package/types/ngstarter-ui-components-logo.d.ts

@@ -0,0 +1,26 @@
+import * as i0 from '@angular/core';
+
+declare class Logo {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Logo, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Logo, "ngs-logo,[ngs-logo]", ["ngsLogo"], {}, {}, never, ["ngs-logo-shape", "ngs-logo-text", "ngs-logo-description", "*"], true, never>;
+}
+
+declare class LogoShape {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LogoShape, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LogoShape, "ngs-logo-shape", never, {}, {}, never, ["img"], true, never>;
+}
+
+type LogoTextSize = 'small' | 'default' | 'large';
+
+declare class LogoText {
+    readonly size: i0.InputSignal<LogoTextSize>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LogoText, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LogoText, "ngs-logo-text", ["ngsLogoText"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class LogoDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LogoDescription, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LogoDescription, "ngs-logo-description", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { Logo, LogoDescription, LogoShape, LogoText };

package/types/ngstarter-ui-components-marquee.d.ts

@@ -0,0 +1,27 @@
+import * as i0 from '@angular/core';
+import { AfterContentInit, OnChanges, OnDestroy, TemplateRef, SimpleChanges } from '@angular/core';
+
+declare class Marquee implements AfterContentInit, OnChanges, OnDestroy {
+    private _elementRef;
+    private _platformId;
+    private _intersectionObserver?;
+    reverse: i0.InputSignalWithTransform<boolean, unknown>;
+    pauseOnHover: i0.InputSignalWithTransform<boolean, unknown>;
+    protected isInView: boolean;
+    readonly template: i0.Signal<TemplateRef<any>>;
+    protected get nativeElement(): HTMLElement;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Marquee, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Marquee, "ngs-marquee", ["ngsMarquee"], { "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, "[ngsMarqueeItem]", never, {}, {}, never, never, true, never>;
+}
+
+export { Marquee, MarqueeItemDirective };

package/types/ngstarter-ui-components-menu.d.ts

@@ -0,0 +1,199 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, OnInit, TemplateRef, Signal, AfterContentInit } from '@angular/core';
+import { Subject, Observable } from 'rxjs';
+import { ControlValueAccessor } from '@angular/forms';
+import { SelectionModel } from '@angular/cdk/collections';
+import { Option } from '@ngstarter-ui/components/select';
+
+/** Reason why the menu was closed. */
+type MenuCloseReason = 'click' | 'keydown' | 'tab' | 'backdrop' | 'mouse';
+
+declare class MenuTrigger implements OnDestroy {
+    private _overlay;
+    private _elementRef;
+    private _viewContainerRef;
+    private destroyRef;
+    private _injector;
+    private _parentMenu;
+    private _menu;
+    readonly menu: _angular_core.InputSignal<Menu | null>;
+    readonly menuData: _angular_core.InputSignal<any>;
+    readonly menuDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly xPosition: _angular_core.InputSignal<"before" | "after">;
+    readonly yPosition: _angular_core.InputSignal<"above" | "below">;
+    readonly menuOpened: _angular_core.OutputEmitterRef<void>;
+    readonly menuClosed: _angular_core.OutputEmitterRef<MenuCloseReason>;
+    readonly restoreFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private _overlayRef;
+    private _portal;
+    private _closingSubscription;
+    private _hoverSubscription;
+    private _childMenuClosedSubscription;
+    private _closeTimeoutId;
+    private _previouslyFocusedElement;
+    readonly menuOpen: _angular_core.WritableSignal<boolean>;
+    ngOnDestroy(): void;
+    _handleMouseLeave(): void;
+    _clearCloseTimeout(): void;
+    _handleClick(event: MouseEvent): void;
+    toggleMenu(): void;
+    openMenu(): void;
+    closeMenu(reason: MenuCloseReason, force?: boolean): void;
+    private _setIsMenuOpen;
+    private _getPanelClasses;
+    private _createOverlay;
+    private _getOverlayConfig;
+    private _getPositions;
+    private _menuClosingActions;
+    _handleMouseEnter(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuTrigger, "[ngsMenuTriggerFor]", ["ngsMenuTrigger"], { "menu": { "alias": "ngsMenuTriggerFor"; "required": false; "isSignal": true; }; "menuData": { "alias": "ngsMenuTriggerData"; "required": false; "isSignal": true; }; "menuDisabled": { "alias": "ngsMenuDisabled"; "required": false; "isSignal": true; }; "xPosition": { "alias": "xPosition"; "required": false; "isSignal": true; }; "yPosition": { "alias": "yPosition"; "required": false; "isSignal": true; }; "restoreFocus": { "alias": "ngsMenuTriggerRestoreFocus"; "required": false; "isSignal": true; }; }, { "menuOpened": "menuOpened"; "menuClosed": "menuClosed"; }, never, never, true, never>;
+}
+
+declare class MenuItem implements OnInit {
+    private _injector;
+    protected _menuTrigger: MenuTrigger | null;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly role: _angular_core.InputSignal<"menuitem" | "menuitem-radio" | "menuitem-checkbox">;
+    selected: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly _triggered: _angular_core.OutputEmitterRef<void>;
+    private _elementRef;
+    private _menu;
+    get label(): string;
+    focus(): void;
+    ngOnInit(): void;
+    _handleClick(event: MouseEvent): void;
+    _handleMouseEnter(): void;
+    protected readonly _isHighlighted: _angular_core.WritableSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItem, "ngs-menu-item, [ngs-menu-item]", ["ngsMenuItem"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "_triggered": "_triggered"; }, never, ["ngs-icon", "*"], true, never>;
+}
+
+declare class MenuContent {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuContent, "[ngsMenuContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class Menu implements OnDestroy {
+    readonly role: _angular_core.InputSignal<"menu" | "menubar">;
+    readonly classList: _angular_core.InputSignal<string>;
+    readonly xPosition: _angular_core.InputSignal<"before" | "after">;
+    readonly yPosition: _angular_core.InputSignal<"above" | "below">;
+    protected readonly _panelClasses: _angular_core.WritableSignal<string[]>;
+    readonly closed: _angular_core.OutputEmitterRef<MenuCloseReason>;
+    readonly _childMenuClosed: Subject<void>;
+    readonly templateRef: _angular_core.Signal<TemplateRef<any>>;
+    readonly content: _angular_core.Signal<MenuContent | undefined>;
+    readonly items: _angular_core.Signal<readonly MenuItem[]>;
+    protected readonly _isNested: _angular_core.WritableSignal<boolean>;
+    protected readonly _context: _angular_core.WritableSignal<any>;
+    private _parentMenu;
+    private _parentMenuTrigger;
+    private _itemSubscription;
+    private _openedTrigger;
+    constructor();
+    ngOnDestroy(): void;
+    close(reason: MenuCloseReason): void;
+    _setPanelClasses(classes: string[]): void;
+    _setContext(context: any): void;
+    _triggerOpened(trigger: any): void;
+    _triggerClosed(trigger: any): void;
+    hasOpenChild(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Menu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Menu, "ngs-menu", ["ngsMenu"], { "role": { "alias": "role"; "required": false; "isSignal": true; }; "classList": { "alias": "classList"; "required": false; "isSignal": true; }; "xPosition": { "alias": "xPosition"; "required": false; "isSignal": true; }; "yPosition": { "alias": "yPosition"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, ["content", "items"], ["[ngs-menu-header]", "*", "[ngs-menu-footer]"], true, never>;
+}
+
+declare class MenuDivider {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuDivider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuDivider, "ngs-menu-divider", never, {}, {}, never, never, true, never>;
+}
+
+declare class MenuHeading {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuHeading, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuHeading, "ngs-menu-heading", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ContextMenuTrigger implements OnDestroy {
+    private _overlay;
+    private _elementRef;
+    private _viewContainerRef;
+    private _ngZone;
+    readonly menu: _angular_core.InputSignal<Menu | null>;
+    readonly menuData: _angular_core.InputSignal<any>;
+    readonly menuOpened: _angular_core.OutputEmitterRef<void>;
+    readonly menuClosed: _angular_core.OutputEmitterRef<MenuCloseReason>;
+    private _overlayRef;
+    private _portal;
+    private _closingSubscription;
+    readonly menuOpen: _angular_core.WritableSignal<boolean>;
+    ngOnDestroy(): void;
+    openMenu(x: number, y: number): void;
+    closeMenu(reason: MenuCloseReason): void;
+    private _setIsMenuOpen;
+    private _getPanelClasses;
+    private _createOverlay;
+    private _getOverlayConfig;
+    private _getPositionStrategy;
+    private _menuClosingActions;
+    _handleContextMenu(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContextMenuTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ContextMenuTrigger, "[ngsContextMenuTriggerFor]", ["ngsContextMenuTrigger"], { "menu": { "alias": "ngsContextMenuTriggerFor"; "required": false; "isSignal": true; }; "menuData": { "alias": "ngsContextMenuTriggerData"; "required": false; "isSignal": true; }; }, { "menuOpened": "menuOpened"; "menuClosed": "menuClosed"; }, never, never, true, never>;
+}
+
+declare class MenuHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuHeader, "ngs-menu-header", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class MenuFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuFooter, "ngs-menu-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Describes a parent component that manages a list of options.
+ * Contains properties that the options can inherit.
+ * @docs-private
+ */
+interface OptionParentComponent {
+    disableRipple?: boolean | Signal<boolean>;
+    multiple?: boolean | Signal<boolean>;
+    inertGroups?: boolean;
+    hideSingleSelectionIndicator?: boolean;
+}
+
+declare class MenuOptionGroupDirective implements OptionParentComponent, OnInit, ControlValueAccessor, AfterContentInit {
+    private _changeDetectorRef;
+    private _destroyRef;
+    private _menu;
+    disableRipple: boolean;
+    inertGroups: boolean;
+    hideSingleSelectionIndicator: boolean;
+    multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly multipleSignal: Signal<boolean>;
+    readonly hideCheckIcon: _angular_core.WritableSignal<boolean>;
+    readonly _optionsContentChanges: _angular_core.WritableSignal<number>;
+    _selectionModel: SelectionModel<any>;
+    private _value;
+    readonly options: Signal<readonly Option[]>;
+    readonly ngsOptions: Signal<readonly any[]>;
+    private _options$;
+    private _ngsOptions$;
+    private _initialized;
+    readonly valueChange: _angular_core.OutputEmitterRef<any>;
+    readonly optionSelectionChanges: Observable<any>;
+    onChange: any;
+    onTouched: any;
+    ngOnInit(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    ngAfterContentInit(): void;
+    private _selectOptionByValue;
+    writeValue(newValue: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuOptionGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuOptionGroupDirective, "[ngsMenuOptionGroup]", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, ["options", "ngsOptions"], never, true, never>;
+}
+
+export { ContextMenuTrigger, Menu, MenuContent, MenuDivider, MenuFooter, MenuHeader, MenuHeading, MenuItem, MenuOptionGroupDirective, MenuTrigger };
+export type { MenuCloseReason };

package/types/ngstarter-ui-components-micro-chart.d.ts

@@ -0,0 +1,195 @@
+import * as _angular_core from '@angular/core';
+import { Renderer2, ViewContainerRef, Injector, TemplateRef, OnDestroy, AfterViewChecked, OnChanges, SimpleChanges } from '@angular/core';
+import { OverlayPosition } from '@ngstarter-ui/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 MchartLine 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>;
+    private _currentTooltipPosition;
+    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<MchartLine, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MchartLine, "ngs-mchart-line", ["ngsMchartLine"], { "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 MchartBar 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>;
+    private _currentTooltipPosition;
+    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<MchartBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MchartBar, "ngs-mchart-bar", ["ngsMchartBar"], { "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 MchartPie 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<MchartPie, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MchartPie, "ngs-mchart-pie", ["ngsMchartPie"], { "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 MchartTooltip {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MchartTooltip, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MchartTooltip, "ngs-mchart-tooltip", ["ngsMchartTooltip"], {}, {}, never, ["ngs-mchart-tooltip-title", "ngs-mchart-tooltip-body", "*"], true, never>;
+}
+
+declare class MchartTooltipTitle {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MchartTooltipTitle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MchartTooltipTitle, "ngs-mchart-tooltip-title", ["ngsMchartTooltipTitle"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class MchartTooltipBody {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MchartTooltipBody, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MchartTooltipBody, "ngs-mchart-tooltip-body", ["ngsMchartTooltipBody"], {}, {}, never, ["*"], true, never>;
+}
+
+export { MchartBar, MchartLine, MchartPie, MchartTooltip, MchartTooltipBody, MchartTooltipTitle };

package/types/ngstarter-ui-components-navigation.d.ts

@@ -0,0 +1,136 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, ElementRef, AfterContentInit, OnChanges, SimpleChanges, InjectionToken } from '@angular/core';
+import * as i1 from '@ngstarter-ui/components/core';
+
+declare class NavigationItemIconDirective {
+    readonly templateRef: TemplateRef<any> | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationItemIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationItemIconDirective, "[ngsNavigationItemIcon]", ["ngsNavigationItemIcon"], {}, {}, never, never, true, never>;
+}
+
+declare class NavigationItem {
+    private store;
+    private _navigation;
+    private _elementRef;
+    private parentGroup;
+    protected readonly iconRef: _angular_core.Signal<NavigationItemIconDirective | undefined>;
+    readonly active: _angular_core.Signal<boolean>;
+    get api(): {
+        isActive: () => boolean;
+    };
+    readonly key: _angular_core.InputSignal<any>;
+    readonly forceActive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly badgeTextOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected click(event: MouseEvent): void;
+    get _hostElement(): ElementRef;
+    protected get iconRefTemplate(): TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationItem, "ngs-navigation-item,[ngs-navigation-item]", ["ngsNavigationItem"], { "key": { "alias": "key"; "required": false; "isSignal": true; }; "forceActive": { "alias": "forceActive"; "required": false; "isSignal": true; }; "badgeTextOnly": { "alias": "badgeTextOnly"; "required": false; "isSignal": true; }; }, {}, ["iconRef"], ["[ngsNavigationItemIcon]", "*", "[ngsNavigationItemBadge]"], true, never>;
+}
+
+declare class NavigationItemDefDirective {
+    template: TemplateRef<any>;
+    when: _angular_core.InputSignal<string | ((item: any) => boolean) | undefined>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationItemDefDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationItemDefDirective, "[ngsNavigationItemDef]", never, { "when": { "alias": "ngsNavigationItemDef"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class Navigation implements AfterContentInit, OnChanges {
+    private store;
+    private _elementRef;
+    private _renderer;
+    private location;
+    private router;
+    private destroyRef;
+    readonly _items: _angular_core.Signal<readonly NavigationItem[]>;
+    readonly _defs: _angular_core.Signal<readonly NavigationItemDefDirective[]>;
+    activeKey: _angular_core.InputSignal<any>;
+    dataSource: _angular_core.InputSignal<any[] | undefined>;
+    itemTypeProperty: _angular_core.InputSignal<string>;
+    appearance: _angular_core.InputSignal<unknown>;
+    activateByRoute: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    autoScrollToActiveItem: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly itemClicked: _angular_core.OutputEmitterRef<NavigationItem>;
+    constructor();
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _hasScroll;
+    private _isScrolledIntoView;
+    private findActiveItemByRoute;
+    getTemplate(item: any): TemplateRef<any> | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Navigation, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Navigation, "ngs-navigation", ["ngsNavigation"], { "activeKey": { "alias": "activeKey"; "required": false; "isSignal": true; }; "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "itemTypeProperty": { "alias": "itemTypeProperty"; "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", "_defs"], ["*"], true, never>;
+}
+
+declare class NavigationHeading {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationHeading, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationHeading, "ngs-navigation-heading", ["ngsNavigationHeading"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class NavigationDivider {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationDivider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationDivider, "ngs-navigation-divider", ["ngsNavigationDivider"], {}, {}, never, never, true, never>;
+}
+
+declare class NavigationGroup {
+    readonly key: _angular_core.WritableSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationGroup, "ngs-navigation-group", ["ngsNavigationGroup"], {}, {}, never, ["ngs-navigation-group-toggle", "ngs-navigation-group-menu"], true, never>;
+}
+
+declare class NavigationGroupMenu implements AfterContentInit {
+    private store;
+    private _group;
+    readonly active: _angular_core.Signal<boolean>;
+    readonly _items: _angular_core.Signal<readonly NavigationItem[]>;
+    readonly _defs: _angular_core.Signal<readonly NavigationItemDefDirective[]>;
+    dataSource: _angular_core.InputSignal<any[] | undefined>;
+    itemTypeProperty: _angular_core.InputSignal<string>;
+    readonly hasActiveItemInGroup: _angular_core.Signal<boolean>;
+    ngAfterContentInit(): void;
+    getTemplate(item: any): TemplateRef<any> | null;
+    private _detectGroupIsActive;
+    private _isActive;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationGroupMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationGroupMenu, "ngs-navigation-group-menu", ["ngsNavigationGroupMenu"], { "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "itemTypeProperty": { "alias": "itemTypeProperty"; "required": false; "isSignal": true; }; }, {}, ["_items", "_defs"], ["*"], true, never>;
+}
+
+declare class NavigationGroupToggleIconDirective {
+    readonly templateRef: TemplateRef<any> | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationGroupToggleIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationGroupToggleIconDirective, "[ngsNavigationGroupToggleIcon]", ["ngsNavigationGroupToggleIcon"], {}, {}, never, never, true, never>;
+}
+
+declare class NavigationGroupToggle {
+    private store;
+    private _group;
+    readonly iconRef: _angular_core.Signal<NavigationGroupToggleIconDirective | undefined>;
+    readonly active: _angular_core.Signal<boolean>;
+    readonly badgeTextOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected toggle(event: MouseEvent): void;
+    protected get iconRefTemplate(): TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationGroupToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationGroupToggle, "ngs-navigation-group-toggle", ["ngsNavigationGroupToggle"], { "badgeTextOnly": { "alias": "badgeTextOnly"; "required": false; "isSignal": true; }; }, {}, ["iconRef"], ["[ngsNavigationItemIcon]", "*", "[ngsNavigationItemBadge]", "[ngsNavigationGroupToggleIcon]"], true, [{ directive: typeof i1.Ripple; inputs: {}; outputs: {}; }]>;
+}
+
+declare class NavigationItemBadgeDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationItemBadgeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationItemBadgeDirective, "[ngsNavigationItemBadge]", ["ngsNavigationItemBadge"], {}, {}, never, never, true, never>;
+}
+
+interface NavigationItemData {
+    key: any;
+    type: 'heading' | 'group' | 'link' | 'item' | 'divider' | string;
+    name?: string;
+    icon?: string;
+    children?: NavigationItemData[];
+    link?: string;
+    [prop: string]: any;
+    badge?: string | number;
+}
+declare const NAVIGATION: InjectionToken<unknown>;
+declare const NAVIGATION_GROUP: InjectionToken<unknown>;
+
+export { NAVIGATION, NAVIGATION_GROUP, Navigation, NavigationDivider, NavigationGroup, NavigationGroupMenu, NavigationGroupToggle, NavigationGroupToggleIconDirective, NavigationHeading, NavigationItem, NavigationItemBadgeDirective, NavigationItemDefDirective, NavigationItemIconDirective };
+export type { NavigationItemData };