@ngstarter-ui/components 1.0.21

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

@@ -0,0 +1,65 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, OnChanges, AfterContentInit, Signal, ElementRef, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1 from '@ngstarter-ui/components/core';
+
+declare class Segmented implements OnInit, OnChanges, AfterContentInit, ControlValueAccessor {
+    private _elementRef;
+    private _renderer;
+    private _cdr;
+    private _destroyRef;
+    private _isDestroyed;
+    protected _disabled: boolean;
+    readonly _buttons: Signal<readonly any[]>;
+    readonly _buttonElements: Signal<readonly ElementRef<any>[]>;
+    _thumbWidth: number;
+    _thumbLeft: number;
+    _thumbOpacity: number;
+    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;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    _onResize(): void;
+    private _updateThumb;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: BooleanInput): void;
+    private _select;
+    isSelected(value: any): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Segmented, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Segmented, "ngs-segmented", ["ngsSegmented"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, ["_buttons", "_buttonElements"], ["ngs-segmented-button,[ngs-segmented-button]"], true, never>;
+}
+
+declare class SegmentedButton {
+    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<SegmentedButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedButton, "ngs-segmented-button,[ngs-segmented-button]", ["ngsSegmentedButton"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; }, {}, never, ["[ngsSegmentedIcon]", "*"], true, [{ directive: typeof i1.Ripple; inputs: {}; outputs: {}; }]>;
+}
+
+declare class SegmentedIconDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SegmentedIconDirective, "[ngsSegmentedIcon]", ["ngsSegmentedIcon"], {}, {}, never, never, true, never>;
+}
+
+export { Segmented, SegmentedButton, SegmentedIconDirective };

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

@@ -0,0 +1,126 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef, InjectionToken, Signal, WritableSignal, OnDestroy, AfterContentInit, DoCheck } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { CdkConnectedOverlay, CdkOverlayOrigin } from '@angular/cdk/overlay';
+import { _OptionParent, _Option, Optgroup } from '@ngstarter-ui/components/option';
+export { Optgroup, Option } from '@ngstarter-ui/components/option';
+import { FormFieldControl } from '@ngstarter-ui/components/form-field';
+
+declare class SelectTrigger {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SelectTrigger, "ngs-select-trigger", never, {}, {}, never, never, true, never>;
+}
+
+declare class SelectBody {
+    _elementRef: ElementRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectBody, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectBody, "ngs-select-body", ["ngsSelectBody"], {}, {}, never, ["*"], true, never>;
+}
+
+declare abstract class _Select {
+    abstract multiple: Signal<boolean>;
+    abstract hideCheckIcon: Signal<boolean>;
+    abstract _optionsContentChanges: WritableSignal<number>;
+    abstract focus(): void;
+}
+declare const SELECT: InjectionToken<_Select>;
+
+declare class SelectChange {
+    source: Select;
+    value: any;
+    constructor(source: Select, value: any);
+}
+declare class Select implements ControlValueAccessor, OnDestroy, AfterContentInit, DoCheck, FormFieldControl<any>, _Select, _OptionParent {
+    private _elementRef;
+    private _cdr;
+    private _destroy;
+    private _formField;
+    readonly ngControl: NgControl | null;
+    readonly stateChanges: _angular_core.WritableSignal<void>;
+    private _focused;
+    protected readonly selectBody: _angular_core.Signal<readonly SelectBody[]>;
+    get focused(): boolean;
+    _id: _angular_core.InputSignal<string>;
+    get id(): string;
+    _placeholder: _angular_core.InputSignal<string | undefined>;
+    get placeholder(): string | undefined;
+    private _disabled;
+    _disabledInput: _angular_core.InputSignalWithTransform<boolean, any>;
+    _required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    get required(): boolean;
+    multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    hideCheckIcon: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    ariaLabel: _angular_core.InputSignal<string | undefined>;
+    tabIndex: _angular_core.InputSignalWithTransform<number, any>;
+    ariaDescribedby: _angular_core.InputSignal<string | null>;
+    isDisabled: _angular_core.Signal<boolean>;
+    get disabled(): boolean;
+    readonly selectionChange: _angular_core.OutputEmitterRef<any>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    options: _angular_core.Signal<readonly _Option[]>;
+    optionGroups: _angular_core.Signal<readonly Optgroup[]>;
+    customTrigger: _angular_core.Signal<readonly SelectTrigger[]>;
+    overlayDir: _angular_core.Signal<CdkConnectedOverlay | undefined>;
+    panel: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    origin: _angular_core.Signal<CdkOverlayOrigin | undefined>;
+    get overlayOrigin(): CdkOverlayOrigin | ElementRef;
+    get overlayWidth(): string | number;
+    panelOpen: _angular_core.WritableSignal<boolean>;
+    _panelPosition: _angular_core.WritableSignal<"top" | "bottom">;
+    private _selectionModel;
+    private _selectionChanges;
+    value: _angular_core.ModelSignal<any>;
+    private _optionsDestroy;
+    private _selectionModelDestroy;
+    _optionsContentChanges: _angular_core.WritableSignal<number>;
+    private _errorState;
+    get errorState(): boolean;
+    private _empty;
+    get empty(): boolean;
+    private _shouldLabelFloat;
+    get shouldLabelFloat(): boolean;
+    _onChange: (value: any) => void;
+    _onTouched: () => void;
+    constructor();
+    get selected(): _Option | _Option[];
+    triggerValue: _angular_core.Signal<string>;
+    ngAfterContentInit(): void;
+    private _resetOptions;
+    ngOnDestroy(): void;
+    ngDoCheck(): void;
+    private updateErrorState;
+    toggle(): void;
+    open(): void;
+    close(): void;
+    _onPositionChange(event: any): void;
+    _onFocus(): void;
+    _onBlur(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    focus(): void;
+    _handleKeydown(event: KeyboardEvent): void;
+    _onOptionClick(option: _Option): void;
+    private _selectOption;
+    private _propagateChanges;
+    private _setSelectionByValue;
+    private _scrollToSelectedOption;
+    private _getOptionIndex;
+    private _selectValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Select, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Select, "ngs-select", ["ngsSelect"], { "_id": { "alias": "id"; "required": false; "isSignal": true; }; "_placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "_disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "_required": { "alias": "required"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "hideCheckIcon": { "alias": "hideCheckIcon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "opened": "opened"; "closed": "closed"; "value": "valueChange"; }, ["selectBody", "options", "optionGroups", "customTrigger"], ["ngs-select-trigger", "ngs-select-header", "ngs-select-body", "ngs-optgroup,ngs-option", "*", "ngs-select-footer"], true, never>;
+}
+
+declare class SelectHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectHeader, "ngs-select-header", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class SelectFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectFooter, "ngs-select-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { SELECT, Select, SelectBody, SelectChange, SelectFooter, SelectHeader, SelectTrigger, _Select };

package/types/ngstarter-ui-components-side-panel.d.ts

@@ -0,0 +1,42 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { TooltipPosition } from '@ngstarter-ui/components/tooltip';
+
+type PanelPosition = 'left' | 'right';
+interface SidePanelTabConfig {
+    tabId: string;
+    label: string;
+    icon?: string | TemplateRef<any>;
+    content: TemplateRef<any>;
+}
+
+declare class SidePanel {
+    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<SidePanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidePanel, "ngs-side-panel", ["ngsSidePanel"], { "position": { "alias": "position"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, ["projectedTabsQuery"], never, true, never>;
+}
+
+declare class SidePanelTab {
+    tabId: _angular_core.InputSignal<string>;
+    label: _angular_core.InputSignal<string>;
+    icon: _angular_core.InputSignal<string | TemplateRef<any> | undefined>;
+    readonly content: _angular_core.Signal<TemplateRef<any>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidePanelTab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidePanelTab, "ngs-side-panel-tab", ["ngsSidePanelTab"], { "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 { SidePanel, SidePanelTab };
+export type { PanelPosition, SidePanelTabConfig };

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

@@ -0,0 +1,143 @@
+import * as i0 from '@angular/core';
+import { ElementRef, AfterContentInit, TemplateRef, SimpleChanges, OnInit, InjectionToken } from '@angular/core';
+import * as i1 from '@ngstarter-ui/components/core';
+
+declare class Sidebar {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Sidebar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Sidebar, "ngs-sidebar", ["ngsSidebar"], {}, {}, never, ["ngs-sidebar-header", "ngs-sidebar-body", "ngs-sidebar-footer"], true, never>;
+}
+
+declare class SidebarHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarHeader, "ngs-sidebar-header", ["ngsSidebarHeader"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class SidebarBody {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarBody, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarBody, "ngs-sidebar-body", ["ngsSidebarBody"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class SidebarNavItemInterface {
+    active: boolean;
+}
+declare class SidebarNavItem implements SidebarNavItemInterface {
+    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<SidebarNavItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarNavItem, "ngs-sidebar-nav-item,[ngs-sidebar-nav-item]", ["ngs-sidebar-nav-item"], { "key": { "alias": "key"; "required": false; "isSignal": true; }; "forceActive": { "alias": "forceActive"; "required": false; "isSignal": true; }; }, {}, never, ["[ngsSidebarNavItemIcon]", "*", "[ngsSidebarNavItemBadge]"], true, never>;
+}
+
+declare class SidebarNavGroup implements AfterContentInit {
+    private _toggle;
+    private _menu;
+    readonly _groupId: string;
+    ngAfterContentInit(): void;
+    hasActiveItem(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarNavGroup, "ngs-sidebar-nav-group", never, {}, {}, ["_toggle", "_menu"], ["*"], true, never>;
+}
+
+declare class SidebarNavItemDefDirective {
+    template: TemplateRef<any>;
+    when: i0.InputSignal<string | ((item: any) => boolean) | undefined>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavItemDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SidebarNavItemDefDirective, "[ngsSidebarNavItemDef]", never, { "when": { "alias": "ngsSidebarNavItemDef"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SidebarNav implements AfterContentInit {
+    private _elementRef;
+    private _navStore;
+    readonly _items: i0.Signal<readonly SidebarNavItem[]>;
+    readonly _groups: i0.Signal<readonly SidebarNavGroup[]>;
+    readonly _defs: i0.Signal<readonly SidebarNavItemDefDirective[]>;
+    activeKey: i0.InputSignal<unknown>;
+    dataSource: i0.InputSignal<any[] | undefined>;
+    itemTypeProperty: i0.InputSignal<string>;
+    autoScrollToActiveItem: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly itemClicked: i0.OutputEmitterRef<any>;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    private _hasScroll;
+    private _isScrolledIntoView;
+    getTemplate(item: any): TemplateRef<any> | null;
+    private _scrollToActiveItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNav, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarNav, "ngs-sidebar-nav", ["ngsSidebarNav"], { "activeKey": { "alias": "activeKey"; "required": false; "isSignal": true; }; "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "itemTypeProperty": { "alias": "itemTypeProperty"; "required": false; "isSignal": true; }; "autoScrollToActiveItem": { "alias": "autoScrollToActiveItem"; "required": false; "isSignal": true; }; }, { "itemClicked": "itemClicked"; }, ["_items", "_groups", "_defs"], ["*"], true, never>;
+}
+
+declare class SidebarFooter {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarFooter, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarFooter, "ngs-sidebar-footer", ["ngsSidebarFooter"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class SidebarNavHeading {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavHeading, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarNavHeading, "ngs-sidebar-nav-heading", ["ngsSidebarNavHeading"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class SidebarNavGroupToggle {
+    private _navStore;
+    readonly for: i0.WritableSignal<any>;
+    get active(): boolean;
+    toggle(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavGroupToggle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarNavGroupToggle, "ngs-sidebar-nav-group-toggle", ["ngsSidebarNavGroupToggle"], {}, {}, never, ["[ngsSidebarNavItemIcon]", "*", "[ngsSidebarNavItemBadge]", "[ngsSidebarNavGroupToggleIcon]"], true, [{ directive: typeof i1.Ripple; inputs: {}; outputs: {}; }]>;
+}
+
+declare class SidebarNavGroupMenu implements AfterContentInit, OnInit {
+    readonly navigation: SidebarNav;
+    private _group;
+    private _navStore;
+    readonly _items: i0.Signal<readonly SidebarNavItem[]>;
+    readonly _defs: i0.Signal<readonly SidebarNavItemDefDirective[]>;
+    key: i0.WritableSignal<any>;
+    dataSource: i0.InputSignal<any[] | undefined>;
+    itemTypeProperty: i0.InputSignal<string>;
+    get active(): boolean;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    hasActiveItem(): boolean;
+    getTemplate(item: any): TemplateRef<any> | null;
+    private _checkIfActive;
+    private _isActive;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavGroupMenu, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarNavGroupMenu, "ngs-sidebar-nav-group-menu", ["ngsSidebarNavGroupMenu"], { "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "itemTypeProperty": { "alias": "itemTypeProperty"; "required": false; "isSignal": true; }; }, {}, ["_items", "_defs"], ["*"], true, never>;
+}
+
+declare class SidebarDivider {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarDivider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarDivider, "ngs-sidebar-divider", never, {}, {}, never, never, true, never>;
+}
+
+declare class SidebarNavItemIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavItemIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SidebarNavItemIconDirective, "[ngsSidebarNavItemIcon]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SidebarNavItemBadgeDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavItemBadgeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SidebarNavItemBadgeDirective, "[ngsSidebarNavItemBadge]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SidebarNavGroupToggleIconDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarNavGroupToggleIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SidebarNavGroupToggleIconDirective, "[ngsSidebarNavGroupToggleIcon]", never, {}, {}, never, never, true, never>;
+}
+
+declare const SIDEBAR_NAVIGATION: InjectionToken<unknown>;
+declare const SIDEBAR_NAVIGATION_GROUP: InjectionToken<unknown>;
+
+export { SIDEBAR_NAVIGATION, SIDEBAR_NAVIGATION_GROUP, Sidebar, SidebarBody, SidebarDivider, SidebarFooter, SidebarHeader, SidebarNav, SidebarNavGroup, SidebarNavGroupMenu, SidebarNavGroupToggle, SidebarNavGroupToggleIconDirective, SidebarNavHeading, SidebarNavItem, SidebarNavItemBadgeDirective, SidebarNavItemDefDirective, SidebarNavItemIconDirective, SidebarNavItemInterface };

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

@@ -0,0 +1,86 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+
+type SidenavMode = 'over' | 'push' | 'side';
+type SidenavPosition = 'start' | 'end';
+declare class Sidenav {
+    private _platformId;
+    private _breakpointObserver;
+    private _destroyRef;
+    private _ngZone;
+    _elementRef: ElementRef<any>;
+    readonly isHovered: _angular_core.WritableSignal<boolean>;
+    protected _isSettled: _angular_core.WritableSignal<boolean>;
+    private _isBreakpointMatched;
+    private _previousOpened;
+    /** Indicates whether the sidenav is in mobile (adaptive) mode. */
+    isMobile: _angular_core.Signal<boolean>;
+    effectiveMode: _angular_core.Signal<SidenavMode>;
+    constructor();
+    adaptive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    adaptiveBreakpoint: _angular_core.InputSignal<string>;
+    opened: _angular_core.ModelSignal<boolean>;
+    fixedWidth: _angular_core.InputSignal<string | number | null>;
+    mode: _angular_core.InputSignal<SidenavMode>;
+    position: _angular_core.InputSignal<SidenavPosition>;
+    collapsed: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    disableClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    toggle(isOpen?: boolean): Promise<void>;
+    _getWidth(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Sidenav, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Sidenav, "ngs-sidenav", ["ngsSidenav"], { "adaptive": { "alias": "adaptive"; "required": false; "isSignal": true; }; "adaptiveBreakpoint": { "alias": "adaptiveBreakpoint"; "required": false; "isSignal": true; }; "opened": { "alias": "opened"; "required": false; "isSignal": true; }; "fixedWidth": { "alias": "fixedWidth"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "disableClose": { "alias": "disableClose"; "required": false; "isSignal": true; }; }, { "opened": "openedChange"; }, never, ["*"], true, never>;
+}
+
+type AutoFocusTarget = 'dialog' | 'first-tabbable' | 'first-heading';
+declare class SidenavContainer {
+    private _ngZone;
+    private _document;
+    private _platformId;
+    protected _isSettled: _angular_core.WritableSignal<boolean>;
+    _sidenavs: _angular_core.Signal<readonly Sidenav[]>;
+    readonly backdropClick: _angular_core.OutputEmitterRef<void>;
+    hasBackdrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    autoFocus: _angular_core.InputSignal<string | boolean>;
+    autosize: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    fixedWidth: _angular_core.InputSignal<string | number | null>;
+    constructor();
+    private _focusSidenav;
+    _isShowingBackdrop(): boolean;
+    _onBackdropClicked(): void;
+    _getContentMarginLeft(): string;
+    _getContentMarginRight(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidenavContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidenavContainer, "ngs-sidenav-container", ["ngsSidenavContainer"], { "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; "autosize": { "alias": "autosize"; "required": false; "isSignal": true; }; "fixedWidth": { "alias": "fixedWidth"; "required": false; "isSignal": true; }; }, { "backdropClick": "backdropClick"; }, ["_sidenavs"], ["ngs-sidenav", "ngs-sidenav-content", "*"], true, never>;
+}
+
+declare class SidenavContent {
+    private _ngZone;
+    protected _container: SidenavContainer;
+    protected _isSettled: _angular_core.WritableSignal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidenavContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidenavContent, "ngs-sidenav-content", ["ngsSidenavContent"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class SidenavCollapsed {
+    private _templateRef;
+    private _viewContainerRef;
+    private _sidenav;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidenavCollapsed, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SidenavCollapsed, "[ngsSidenavCollapsed]", ["ngsSidenavCollapsed"], {}, {}, never, never, true, never>;
+}
+
+declare class SidenavExpanded {
+    private _templateRef;
+    private _viewContainerRef;
+    private _sidenav;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidenavExpanded, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SidenavExpanded, "[ngsSidenavExpanded]", ["ngsSidenavExpanded"], {}, {}, never, never, true, never>;
+}
+
+export { Sidenav, SidenavCollapsed, SidenavContainer, SidenavContent, SidenavExpanded };
+export type { AutoFocusTarget, SidenavMode, SidenavPosition };

package/types/ngstarter-ui-components-signature-pad.d.ts

@@ -0,0 +1,49 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, ElementRef } from '@angular/core';
+
+declare class SignaturePad 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<SignaturePad, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SignaturePad, "ngs-signature-pad", ["ngsSignaturePad"], { "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 { SignaturePad };

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

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

package/types/ngstarter-ui-components-slide-toggle.d.ts

@@ -0,0 +1,41 @@
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare class SlideToggleChange {
+    source: SlideToggle;
+    checked: boolean;
+    constructor(source: SlideToggle, checked: boolean);
+}
+declare class SlideToggle implements ControlValueAccessor {
+    private _uniqueId;
+    id: _angular_core.InputSignal<string>;
+    name: _angular_core.InputSignal<string | null>;
+    labelPosition: _angular_core.InputSignal<"before" | "after">;
+    ariaLabel: _angular_core.InputSignal<string | null>;
+    ariaLabelledby: _angular_core.InputSignal<string | null>;
+    ariaDescribedby: _angular_core.InputSignal<string | null>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    disabled: _angular_core.ModelSignal<boolean>;
+    disableRipple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    tabIndex: _angular_core.InputSignalWithTransform<number, unknown>;
+    hideIcon: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    color: _angular_core.InputSignal<string | undefined>;
+    checked: _angular_core.ModelSignal<boolean>;
+    change: _angular_core.OutputEmitterRef<SlideToggleChange>;
+    toggleChange: _angular_core.OutputEmitterRef<void>;
+    private _onChange;
+    private _onTouched;
+    constructor();
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    toggle(): void;
+    _onInputClick(event: Event): void;
+    private _emitChangeEvent;
+    _onInputBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlideToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlideToggle, "ngs-slide-toggle", ["ngsSlideToggle"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "disableRipple": { "alias": "disableRipple"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "hideIcon": { "alias": "hideIcon"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "checked": "checkedChange"; "change": "change"; "toggleChange": "toggleChange"; }, never, ["*"], true, never>;
+}
+
+export { SlideToggle, SlideToggleChange };