@ng-solid/design-system 22.1.1 → 22.2.1

package/types/ng-solid-design-system.d.ts

@@ -1,292 +1,171 @@
+import { DateValue, DayOfWeek } from '@internationalized/date';
 import * as _angular_core from '@angular/core';
-import { OnChanges, ElementRef, OnInit, QueryList, AfterContentInit, OnDestroy, TemplateRef, AfterViewInit, AfterViewChecked, Type, ViewContainerRef, ComponentRef, SimpleChanges } from '@angular/core';
-import { ControlValueAccessor, FormGroup } from '@angular/forms';
-import { DateValue, DayOfWeek, DateTimeDuration } from '@internationalized/date';
+import { ElementRef, OnInit, Type, AfterViewInit, OnDestroy, Signal, ComponentRef, OnChanges, SimpleChanges, TemplateRef, InjectionToken, EnvironmentProviders } from '@angular/core';
+import { FormGroup, ControlValueAccessor } from '@angular/forms';
 import { NsFile } from '@ng-solid/core';
-import { Subject, Observable } from 'rxjs';
+import { Subject } from 'rxjs';
 import { SafeHtml } from '@angular/platform-browser';
 
-declare class NsAvatarComponent implements OnChanges {
-    readonly src: _angular_core.InputSignal<string>;
-    readonly atl: _angular_core.InputSignal<string>;
-    readonly icon: _angular_core.InputSignal<string>;
-    readonly shape: _angular_core.InputSignal<"circle" | "square">;
-    readonly size: _angular_core.InputSignal<"large" | "medium" | "small">;
-    readonly gap: _angular_core.InputSignalWithTransform<number, unknown>;
-    textRef?: ElementRef<HTMLSpanElement>;
-    hasCover: boolean;
-    hasIcon: boolean;
-    private elementRef;
-    private cdr;
-    private platformId;
-    private renderer;
-    private ngZone;
-    ngOnChanges(): void;
-    imgError($event: ErrorEvent): void;
-    private calcStringSize;
-    private notifyCalc;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsAvatarComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsAvatarComponent, "ns-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "atl": { "alias": "atl"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+type NsDateView = 'day' | 'week' | 'workweek' | 'month' | 'year';
+type NsSize = 'sm' | 'md' | 'lg';
+type NsColor = 'neutral' | 'primary' | 'success' | 'warning' | 'danger';
+type NsVariant = 'solid' | 'soft' | 'outline' | 'ghost';
+type NsOrientation = 'horizontal' | 'vertical';
+type NsSelectionMode = 'none' | 'single' | 'multiple';
+type NsKey = string | number;
+interface NsCollectionItem<T = unknown, TKey extends NsKey = NsKey> {
+    key: TKey;
+    value: T;
+    label?: string;
+    disabled?: boolean;
 }
-
-declare class NsButtonComponent {
-    readonly label: _angular_core.InputSignal<string>;
-    readonly type: _angular_core.InputSignal<"submit" | "button">;
-    readonly theme: _angular_core.InputSignal<"primary" | "secondary" | "success">;
-    readonly block: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly icon: _angular_core.InputSignal<string>;
-    readonly value: _angular_core.InputSignal<string | number>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsButtonComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsButtonComponent, "ns-button", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "block": { "alias": "block"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+interface NsDateRangeValue<TDate = DateValue> {
+    start: TDate | null;
+    end: TDate | null;
 }
+type NsPlacement = 'top' | 'top-start' | 'top-end' | 'right' | 'right-start' | 'right-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end';
 
-declare abstract class NsValueAccessor<T = string> implements ControlValueAccessor {
-    readonly type: _angular_core.InputSignal<string>;
-    readonly placeholder: _angular_core.InputSignal<string>;
+declare class NsAccordionItemComponent {
+    readonly key: _angular_core.InputSignal<NsKey>;
     readonly label: _angular_core.InputSignal<string>;
-    readonly disabled: _angular_core.ModelSignal<boolean>;
-    readonly readonly: _angular_core.InputSignal<boolean>;
-    id: string;
-    readonly value: _angular_core.ModelSignal<T>;
-    setValue(value: T): void;
-    onTouched: () => void;
-    onChange: (value: T) => void;
-    writeValue(value: T): void;
-    registerOnChange(fn: (value: T) => void): void;
-    registerOnTouched(fn: () => void): void;
-    setDisabledState(isDisabled: boolean): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsValueAccessor<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NsValueAccessor<any>, never, never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "value": "valueChange"; }, never, never, true, never>;
-}
-
-declare class NsCheckboxComponent extends NsValueAccessor<boolean> {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsCheckboxComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsCheckboxComponent, "ns-checkbox", never, {}, {}, never, never, true, never>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly expanded: _angular_core.ModelSignal<boolean>;
+    readonly panelId: string;
+    readonly element: ElementRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsAccordionItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsAccordionItemComponent, "ns-accordion-item", never, { "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, never, ["*"], true, never>;
 }
-
-interface DayContext {
-    $implicit: DateValue;
-    month: number;
-    year: number;
-    date: DateValue;
-    disabled: boolean;
-    selected: boolean;
-    isToday: boolean;
-}
-type NsDayView = {
-    number: number;
-    context: DayContext;
-    date: DateValue;
-    tabindex: number;
-    ariaLabel: string;
-};
-type NsWeekView = {
-    number: number;
-    days: NsDayView[];
-};
-type NsMonthView = {
-    label: string;
-    number: number;
-    year: number;
-    weekdays: string[];
-    weeks: NsWeekView[];
-    startDate: DateValue;
-    endDate: DateValue;
-};
-type NsDatepickerView = {
-    visibleMonths: number;
-    startDate?: DateValue;
-    firstDayOfWeek: DayOfWeek;
-    endDate?: DateValue;
-    maxDate?: DateValue;
-    minDate?: DateValue;
-    months: NsMonthView[];
-    locale: string;
-    navigation: 'select' | 'arrows' | 'none';
-    selectedDate?: DateValue;
-    weekdayStyle: WeekdayStyle;
-    weekdaysVisible: boolean;
-    disabled: boolean;
-};
-type WeekdayStyle = 'long' | 'narrow' | 'short';
-
-type NsDateView = 'day' | 'week' | 'workweek' | 'month' | 'year';
-type NsPlacement = 'bottom-start' | 'bottom-end';
-
-declare class NsDatePickerComponent extends NsValueAccessor<string> implements OnInit {
-    model: NsDatepickerView;
-    private readonly service;
-    private readonly parserFormatter;
-    private readonly elRef;
-    private readonly appRef;
-    private readonly cdRef;
-    private readonly destroyRef;
-    private readonly injector;
-    private readonly ngZone;
-    private readonly document;
-    readonly autoClose: _angular_core.InputSignal<boolean | "inside" | "outside">;
-    readonly placement: _angular_core.InputSignal<NsPlacement>;
-    readonly view: _angular_core.InputSignal<NsDateView>;
-    readonly visibleMonths: _angular_core.InputSignal<number>;
-    readonly firstDayOfWeek: _angular_core.InputSignal<DayOfWeek>;
-    readonly maxDate: _angular_core.InputSignal<string | DateValue | Date>;
-    readonly minDate: _angular_core.InputSignal<string | DateValue | Date>;
-    readonly navigation: _angular_core.InputSignal<"select" | "arrows" | "none">;
-    readonly weekdayStyle: _angular_core.InputSignal<WeekdayStyle>;
-    private controlValue;
-    private popupRef;
-    private destroyCloseHandlers$;
-    ngOnInit(): void;
-    writeValue(value: string): void;
-    isOpen(): boolean;
-    toggleCalendar(): void;
-    private open;
-    private _createComponent;
-    private _applyDatepickerInputs;
-    private close;
-    private _setCloseHandlers;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDatePickerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsDatePickerComponent, "ns-date-picker", never, { "autoClose": { "alias": "autoClose"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "visibleMonths": { "alias": "visibleMonths"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "navigation": { "alias": "navigation"; "required": false; "isSignal": true; }; "weekdayStyle": { "alias": "weekdayStyle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+declare class NsAccordionComponent {
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    readonly expandedKeys: _angular_core.ModelSignal<readonly NsKey[]>;
+    readonly items: _angular_core.Signal<readonly NsAccordionItemComponent[]>;
+    constructor();
+    onClick(event: MouseEvent): void;
+    onKeydown(event: KeyboardEvent): void;
+    toggle(key: NsKey): void;
+    private findKey;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsAccordionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsAccordionComponent, "ns-accordion", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "expandedKeys": { "alias": "expandedKeys"; "required": false; "isSignal": true; }; }, { "expandedKeys": "expandedKeysChange"; }, ["items"], ["*"], true, never>;
 }
 
-declare class NsDateRangeStartDirective extends NsValueAccessor<string> {
-    private parserFormatter;
-    writeValue(value: string): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDateRangeStartDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NsDateRangeStartDirective, "ns-date-range-start", never, {}, {}, never, never, true, never>;
-}
-declare class NsDateRangeEndDirective extends NsValueAccessor<string> {
-    private parserFormatter;
-    writeValue(value: string): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDateRangeEndDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NsDateRangeEndDirective, "ns-date-range-end", never, {}, {}, never, never, true, never>;
+type NsAlertVariant = 'info' | 'warning' | 'danger' | 'success';
+declare class NsAlertComponent {
+    readonly variant: _angular_core.InputSignal<NsAlertVariant>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly dismissLabel: _angular_core.InputSignal<string>;
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    iconName(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsAlertComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsAlertComponent, "ns-alert", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "dismissLabel": { "alias": "dismissLabel"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, ["*", "ns-link"], true, never>;
 }
 
-declare class NsDateRangePickerComponent {
-    readonly placeholder: _angular_core.InputSignal<string>;
-    start: NsDateRangeStartDirective;
-    end: NsDateRangeEndDirective;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDateRangePickerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsDateRangePickerComponent, "ns-date-range", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, ["start", "end"], never, true, never>;
+declare class NsAvatarComponent {
+    readonly src: _angular_core.InputSignal<string>;
+    readonly alt: _angular_core.InputSignal<string>;
+    readonly initials: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly shape: _angular_core.InputSignal<"circle" | "square">;
+    readonly size: _angular_core.InputSignal<NsSize>;
+    private readonly imageFailed;
+    readonly showImage: _angular_core.Signal<boolean>;
+    onImageError(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsAvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsAvatarComponent, "ns-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "initials": { "alias": "initials"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare abstract class NsDateParserFormatter {
-    abstract parse(value: string): DateValue | null;
-    abstract format(date: DateValue): string;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDateParserFormatter, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NsDateParserFormatter>;
+type NsBadgeMode = 'count' | 'dot';
+declare class NsBadgeComponent {
+    readonly count: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly mode: _angular_core.InputSignal<NsBadgeMode>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly normalizedCount: _angular_core.Signal<number>;
+    readonly isVisible: _angular_core.Signal<boolean>;
+    readonly displayCount: _angular_core.Signal<string>;
+    readonly appearance: _angular_core.Signal<"single" | "hidden" | "dot" | "double" | "overflow">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsBadgeComponent, "ns-badge", never, { "count": { "alias": "count"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare abstract class NsCalendar {
-    abstract today(): string;
-    abstract add(duration: DateTimeDuration): string;
-    abstract subtract(duration: DateTimeDuration): string;
-    abstract getWeekDays(date: DateValue, weekdayStyle: WeekdayStyle, locale: string, firstDayOfWeek: DayOfWeek): string[];
-    abstract getWeeksInMonth(date: DateValue, locale: string, firstDayOfWeek: DayOfWeek): NsWeekView[];
-    abstract getDatesInWeek(weekIndex: number, from: DateValue, locale: string, firstDayOfWeek: DayOfWeek): NsDayView[];
-    abstract getFormattedMonth(startDate: DateValue, locale: string): string;
-    abstract getHoursInDay(): number[];
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsCalendar, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NsCalendar>;
+declare class NsBreadcrumbItemComponent {
+    readonly href: _angular_core.InputSignal<string>;
+    readonly current: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsBreadcrumbItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsBreadcrumbItemComponent, "ns-breadcrumb-item", never, { "href": { "alias": "href"; "required": false; "isSignal": true; }; "current": { "alias": "current"; "required": false; "isSignal": true; }; }, {}, never, ["*", "*"], true, never>;
 }
 
-declare class NsInputComponent extends NsValueAccessor<string> {
+declare class NsBreadcrumbsComponent {
     readonly ariaLabel: _angular_core.InputSignal<string>;
-    readonly ariaDescribedBy: _angular_core.InputSignal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsInputComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsInputComponent, "ns-input", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsBreadcrumbsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsBreadcrumbsComponent, "ns-breadcrumbs", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
-type NsInputGroupSize = 'sm' | 'md' | 'lg';
-declare class NsInputGroupComponent {
-    readonly label: _angular_core.InputSignal<string>;
-    readonly prepend: _angular_core.InputSignal<string>;
-    readonly append: _angular_core.InputSignal<string>;
-    readonly size: _angular_core.InputSignal<NsInputGroupSize>;
-    readonly wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    primaryInput?: NsInputComponent;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsInputGroupComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsInputGroupComponent, "ns-input-group", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "prepend": { "alias": "prepend"; "required": false; "isSignal": true; }; "append": { "alias": "append"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, {}, ["primaryInput"], ["*"], true, never>;
+type NsButtonVariant = 'primary' | 'secondary' | 'tertiary' | 'success' | 'danger';
+declare class NsButtonComponent {
+    readonly type: _angular_core.InputSignal<"button" | "submit" | "reset">;
+    readonly variant: _angular_core.InputSignal<NsButtonVariant>;
+    readonly size: _angular_core.InputSignal<NsSize>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly iconOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly block: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selected: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsButtonComponent, "ns-button", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "block": { "alias": "block"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
-declare class NsInputGroupAddonComponent {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsInputGroupAddonComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsInputGroupAddonComponent, "ns-input-group-addon", never, {}, {}, never, ["*"], true, never>;
+declare class NsButtonGroupComponent {
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly orientation: _angular_core.InputSignal<NsOrientation>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsButtonGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsButtonGroupComponent, "ns-button-group", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
-declare class NsInputNumberComponent extends NsValueAccessor<string | number> implements OnInit {
-    readonly step: _angular_core.InputSignalWithTransform<number, unknown>;
-    readonly precision: _angular_core.InputSignalWithTransform<number, unknown>;
-    readonly minValue: _angular_core.InputSignalWithTransform<number, unknown>;
-    readonly maxValue: _angular_core.InputSignalWithTransform<number, unknown>;
-    readonly formatStyle: _angular_core.InputSignal<keyof Intl.NumberFormatOptionsStyleRegistry>;
-    input: ElementRef<HTMLInputElement>;
-    numberInput: number;
-    private readonly defaultOptions;
-    private readonly currency;
-    private readonly renderer;
-    private readonly locale;
-    private formatter;
-    private parser;
-    ngOnInit(): void;
-    get formatOptions(): Intl.NumberFormatOptions;
-    writeValue(value: string | number): void;
-    setValue(value: string): void;
-    onInput(event: Event): void;
-    onKeyUp(event: KeyboardEvent): void;
-    onFocusOut(event: FocusEvent): void;
-    private safeNextStep;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsInputNumberComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsInputNumberComponent, "ns-input-number", never, { "step": { "alias": "step"; "required": false; "isSignal": true; }; "precision": { "alias": "precision"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "formatStyle": { "alias": "formatStyle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+declare class NsCardComponent {
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly variant: _angular_core.InputSignal<NsVariant>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsCardComponent, "ns-card", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
-
-declare class NsPasswordComponent extends NsValueAccessor implements OnInit {
-    readonly forgotLink: _angular_core.InputSignal<string>;
-    readonly showAndHide: _angular_core.InputSignal<boolean>;
-    show: boolean;
-    constructor();
-    ngOnInit(): void;
-    toggle(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsPasswordComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsPasswordComponent, "ns-password", never, { "forgotLink": { "alias": "forgotLink"; "required": false; "isSignal": true; }; "showAndHide": { "alias": "showAndHide"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+declare class NsCardHeaderComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsCardHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsCardHeaderComponent, "ns-card-header", never, {}, {}, never, ["*"], true, never>;
 }
-
-declare class NsSwitchComponent extends NsValueAccessor<boolean | string> {
-    readonly boolean: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly size: _angular_core.InputSignal<"large" | "small">;
-    readonly theme: _angular_core.InputSignal<"primary" | "success">;
-    readonly checked: _angular_core.Signal<boolean>;
-    setValue(checked: boolean): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsSwitchComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsSwitchComponent, "ns-switch", never, { "boolean": { "alias": "boolean"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+declare class NsCardBodyComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsCardBodyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsCardBodyComponent, "ns-card-body", never, {}, {}, never, ["*"], true, never>;
 }
-
-declare class NsTextAreaComponent extends NsValueAccessor<string> {
-    readonly rows: _angular_core.InputSignal<number>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsTextAreaComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsTextAreaComponent, "ns-textarea", never, { "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+declare class NsCardFooterComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsCardFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsCardFooterComponent, "ns-card-footer", never, {}, {}, never, ["*"], true, never>;
 }
 
-declare class NsContentEditableComponent extends NsValueAccessor<string> {
-    private elementRef;
-    private renderer;
-    readonly maxLength: _angular_core.InputSignal<number>;
-    enabled: boolean;
-    writeValue(value: string): void;
-    onInput(): void;
-    onBlur(): void;
-    onKeyUp(event: KeyboardEvent): void;
-    setDisabledState(isDisabled: boolean): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsContentEditableComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsContentEditableComponent, "ns-content-editable", never, { "maxLength": { "alias": "maxlength"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+declare class NsChipComponent {
+    readonly color: _angular_core.InputSignal<NsColor>;
+    readonly variant: _angular_core.InputSignal<"solid" | "soft" | "outline">;
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly dismissLabel: _angular_core.InputSignal<string>;
+    readonly removed: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsChipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsChipComponent, "ns-chip", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "dismissLabel": { "alias": "dismissLabel"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["*"], true, never>;
 }
 
-declare class NsButtonGroupComponent extends NsValueAccessor<string | number> {
-    items: QueryList<NsButtonComponent>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsButtonGroupComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsButtonGroupComponent, "ns-button-group", never, {}, {}, ["items"], never, true, never>;
+declare class NsCollectionController<T = unknown, TKey extends NsKey = NsKey> {
+    private readonly selectionMode;
+    private readonly itemsState;
+    private readonly selectedKeysState;
+    readonly items: _angular_core.Signal<readonly NsCollectionItem<T, TKey>[]>;
+    readonly selectedKeys: _angular_core.Signal<ReadonlySet<TKey>>;
+    readonly selectedItems: _angular_core.Signal<NsCollectionItem<T, TKey>[]>;
+    constructor(selectionMode?: NsSelectionMode);
+    setItems(items: readonly NsCollectionItem<T, TKey>[]): void;
+    isSelected(key: TKey): boolean;
+    select(key: TKey): void;
+    toggle(key: TKey): void;
+    clear(): void;
 }
 
 interface NsComment {
@@ -328,42 +207,156 @@ declare class NsCommentComponent implements OnInit {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsCommentComponent, "ns-comment", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "cover": { "alias": "cover"; "required": false; "isSignal": true; }; "submitText": { "alias": "submitText"; "required": false; "isSignal": true; }; "logged": { "alias": "logged"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "commit": "commit"; }, never, ["*"], true, never>;
 }
 
-declare class NsDropdownItemDirective {
-    readonly label: _angular_core.InputSignal<string>;
-    readonly value: _angular_core.InputSignal<string | number>;
-    readonly disabled: _angular_core.InputSignal<boolean>;
+declare class NsDescriptionComponent {
+    private readonly ariaIds;
+    private readonly field;
+    private readonly destroyRef;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly live: _angular_core.InputSignal<"off" | "polite" | "assertive">;
     constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDropdownItemDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NsDropdownItemDirective, "ns-dropdown-item", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-declare class NsDropdownComponent extends NsValueAccessor<string | number> implements OnInit, AfterContentInit {
-    readonly labelField: _angular_core.InputSignal<string>;
-    readonly valueField: _angular_core.InputSignal<string>;
-    readonly iconName: _angular_core.InputSignal<string>;
-    readonly defaultFirst: _angular_core.InputSignal<boolean>;
-    readonly placement: _angular_core.InputSignal<"start" | "end">;
-    readonly filterable: _angular_core.InputSignal<boolean>;
-    readonly collectionInput: _angular_core.InputSignal<Record<string, unknown>[]>;
-    searchRef: ElementRef<HTMLInputElement>;
-    items: QueryList<NsDropdownItemDirective>;
-    show: boolean;
-    private _filtered;
-    private _collection;
-    private _search;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDescriptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsDescriptionComponent, "ns-description", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "live": { "alias": "live"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class NsDividerComponent {
+    readonly orientation: _angular_core.InputSignal<NsOrientation>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsDividerComponent, "ns-divider", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NsOverlayCloseReason = 'dismiss' | 'escape' | 'programmatic';
+interface NsOverlayConfig {
+    origin?: HTMLElement;
+    matchOriginWidth?: boolean;
+    placement?: NsPlacement;
+    offset?: number;
+    closeOnEscape?: boolean;
+    closeOnOutsidePointer?: boolean;
+    trapFocus?: boolean;
+    restoreFocus?: boolean;
+    inert?: boolean;
+    lockScroll?: boolean;
+}
+interface NsOverlayPosition {
+    top: number;
+    left: number;
+    placement: NsPlacement;
+}
+interface NsResolvedOverlayConfig {
+    origin?: HTMLElement;
+    matchOriginWidth: boolean;
+    placement: NsPlacement;
+    offset: number;
+    closeOnEscape: boolean;
+    closeOnOutsidePointer: boolean;
+    trapFocus: boolean;
+    restoreFocus: boolean;
+    inert: boolean;
+    lockScroll: boolean;
+}
+declare class NsOverlayRef {
+    readonly portal: HTMLElement;
+    readonly config: NsResolvedOverlayConfig;
+    private readonly document;
+    private readonly closeOverlay;
+    private readonly closeListeners;
+    private attachedContent?;
+    private closedState;
+    private readonly priorFocusedElement;
+    readonly closed: _angular_core.WritableSignal<NsOverlayCloseReason>;
+    constructor(portal: HTMLElement, config: NsResolvedOverlayConfig, document: Document, closeOverlay: (ref: NsOverlayRef, reason: NsOverlayCloseReason) => void);
+    attach(element: HTMLElement): void;
+    updatePosition(): void;
+    focusInitial(): void;
+    close(reason?: NsOverlayCloseReason): void;
+    onClose(listener: (reason: NsOverlayCloseReason) => void): () => void;
+    isClosed(): boolean;
+    finalizeClose(reason: NsOverlayCloseReason): void;
+    restoreFocus(): void;
+    private detachContent;
+}
+declare class NsOverlayService {
+    private readonly document;
+    private readonly platformId;
+    private readonly browser;
+    private readonly overlays;
+    private readonly inertStates;
+    private readonly overlayStackStates;
+    private scrollOverflow?;
+    private resizeObserver?;
+    open(config?: NsOverlayConfig): NsOverlayRef;
+    closeAll(): void;
+    private close;
+    private syncDocumentState;
+    private addDocumentListeners;
+    private removeDocumentListeners;
+    private readonly handleKeydown;
+    private readonly handlePointerDown;
+    private readonly updatePositions;
+    private lockScroll;
+    private unlockScroll;
+    private applyInert;
+    private syncOverlayStackState;
+    private restoreInert;
+    private restoreDocumentState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsOverlayService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NsOverlayService>;
+}
+declare function getNsOverlayPosition(origin: DOMRect, overlay: DOMRect, placement: NsPlacement, offset: number, viewportWidth: number, viewportHeight: number): NsOverlayPosition;
+
+type NsDrawerPosition = 'start' | 'end';
+interface NsDrawerOptions {
+    title?: string;
+    position?: NsDrawerPosition;
+    closeOnEscape?: boolean;
+}
+type NsDrawerComponentInputs<T extends object> = Partial<Record<Extract<keyof T, string>, unknown>>;
+interface NsDrawerConfig<T extends object> extends NsDrawerOptions {
+    component: Type<T>;
+    inputs?: NsDrawerComponentInputs<T>;
+}
+
+declare class NsDrawerComponent implements AfterViewInit, OnDestroy {
+    readonly isOpen: _angular_core.ModelSignal<boolean>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly position: _angular_core.InputSignal<NsDrawerPosition>;
+    readonly closeLabel: _angular_core.InputSignal<string>;
+    readonly closeOnEscape: _angular_core.InputSignal<boolean>;
+    readonly closed: _angular_core.OutputEmitterRef<NsOverlayCloseReason>;
+    readonly contentComponent: _angular_core.InputSignal<Type<object>>;
+    readonly contentInputs: _angular_core.InputSignal<Record<string, unknown>>;
+    readonly closeReason: _angular_core.WritableSignal<NsOverlayCloseReason>;
+    private contentHost?;
+    private readonly element;
+    private readonly overlay;
+    private overlayRef?;
+    private contentRef?;
+    private viewInitialized;
     constructor();
-    ngOnInit(): void;
-    ngAfterContentInit(): void;
-    private setCollection;
-    get collection(): Record<string, unknown>[];
-    get selected(): Record<string, unknown>;
-    set search(value: string);
-    get search(): string;
-    select(item: Record<string, unknown>): void;
-    toggle(event: MouseEvent): void;
-    keyDown(event: KeyboardEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDropdownComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsDropdownComponent, "ns-dropdown", never, { "labelField": { "alias": "labelField"; "required": false; "isSignal": true; }; "valueField": { "alias": "valueField"; "required": false; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "defaultFirst": { "alias": "defaultFirst"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "required": false; "isSignal": true; }; "collectionInput": { "alias": "collection"; "required": false; "isSignal": true; }; }, {}, ["items"], never, true, never>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    close(): void;
+    getContent<T extends object>(): T;
+    private openOverlay;
+    private createContent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDrawerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsDrawerComponent, "ns-drawer", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "contentComponent": { "alias": "contentComponent"; "required": false; "isSignal": true; }; "contentInputs": { "alias": "contentInputs"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+declare class NsDrawerRef<T> {
+    private readonly componentRef;
+    readonly content: T;
+    readonly closed: Signal<NsOverlayCloseReason | undefined>;
+    constructor(componentRef: ComponentRef<NsDrawerComponent>, content: T, closed: Signal<NsOverlayCloseReason | undefined>);
+    close(): void;
+}
+
+declare class NsDrawerService {
+    private readonly applicationRef;
+    private readonly environmentInjector;
+    open<T extends object>(config: NsDrawerConfig<T>): NsDrawerRef<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDrawerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NsDrawerService>;
 }
 
 declare class NsEditorColorPickerComponent implements OnInit {
@@ -444,6 +437,381 @@ declare class NsEditorToggleCommandComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsEditorToggleCommandComponent, "ns-editor-toggle", never, {}, {}, never, never, true, never>;
 }
 
+declare abstract class NsValueAccessor<T = string> implements ControlValueAccessor {
+    private readonly ariaIds;
+    private readonly field;
+    readonly type: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly description: _angular_core.InputSignal<string>;
+    readonly errorMessage: _angular_core.InputSignal<string>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.ModelSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly ariaDescribedBy: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly color: _angular_core.InputSignal<"neutral" | "primary" | "success" | "warning" | "danger">;
+    readonly variant: _angular_core.InputSignal<"solid" | "soft" | "outline" | "ghost">;
+    readonly id: string;
+    readonly descriptionId: string;
+    readonly errorId: string;
+    readonly controlId: _angular_core.Signal<string>;
+    readonly describedBy: _angular_core.Signal<string>;
+    readonly value: _angular_core.ModelSignal<T>;
+    setValue(value: T): void;
+    onTouched: () => void;
+    onChange: (value: T) => void;
+    writeValue(value: T): void;
+    registerOnChange(fn: (value: T) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsValueAccessor<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NsValueAccessor<any>, never, never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "value": "valueChange"; }, never, never, true, never>;
+}
+
+declare class NsCheckboxComponent extends NsValueAccessor<boolean> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsCheckboxComponent, "ns-checkbox", never, {}, {}, never, never, true, never>;
+}
+
+type PickerView = 'calendar' | 'months' | 'years';
+declare class NsDatePickerComponent extends NsValueAccessor<DateValue | null> {
+    readonly minDate: _angular_core.InputSignal<DateValue>;
+    readonly maxDate: _angular_core.InputSignal<DateValue>;
+    readonly unavailableDates: _angular_core.InputSignal<readonly DateValue[]>;
+    readonly firstDayOfWeek: _angular_core.InputSignal<DayOfWeek>;
+    private calendar?;
+    private trigger?;
+    readonly calendarId: string;
+    readonly calendarLabel = "Date picker";
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly focusedDate: _angular_core.WritableSignal<DateValue>;
+    readonly visibleMonth: _angular_core.WritableSignal<DateValue>;
+    readonly yearAnchor: _angular_core.WritableSignal<number>;
+    private readonly pickerView;
+    private readonly yearPageStart;
+    private readonly overlay;
+    private readonly changeDetector;
+    private readonly destroyRef;
+    private readonly locale;
+    private readonly monthFormatter;
+    private readonly monthOnlyFormatter;
+    private overlayRef;
+    readonly displayValue: _angular_core.Signal<string>;
+    readonly monthLabel: _angular_core.Signal<string>;
+    readonly monthOnlyLabel: _angular_core.Signal<string>;
+    readonly monthOptions: _angular_core.Signal<{
+        current: boolean;
+        selected: boolean;
+        visible: boolean;
+        focused: boolean;
+        value: number;
+        label: string;
+        disabled: boolean;
+    }[]>;
+    readonly yearOptions: _angular_core.Signal<number[]>;
+    readonly yearPageOptions: _angular_core.Signal<number[]>;
+    readonly yearPageOptionStates: _angular_core.Signal<{
+        current: boolean;
+        selected: boolean;
+        visible: boolean;
+        focused: boolean;
+        value: number;
+    }[]>;
+    readonly yearPageLabel: _angular_core.Signal<string>;
+    readonly calendarAnnouncement: _angular_core.Signal<string>;
+    constructor();
+    writeValue(value: DateValue | null): void;
+    toggle(): void;
+    navigate(months: number): void;
+    isPickerView(view: PickerView): boolean;
+    openMonthPicker(): void;
+    openYearPicker(): void;
+    selectMonth(month: number): void;
+    selectYear(year: number): void;
+    canGoToPreviousYearPage(): boolean;
+    canGoToNextYearPage(): boolean;
+    moveYearPage(direction: -1 | 1): void;
+    select(date: DateValue): void;
+    focusDate(date: DateValue): void;
+    private open;
+    private close;
+    private firstSelectableDate;
+    private isSelectable;
+    private updateVisibleMonth;
+    private isMonthAvailable;
+    private daysInMonth;
+    private pageStartForYear;
+    private monthOptionState;
+    private yearOptionState;
+    private isSameMonth;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDatePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsDatePickerComponent, "ns-date-picker", never, { "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "unavailableDates": { "alias": "unavailableDates"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NsDateRangePickerComponent extends NsValueAccessor<NsDateRangeValue<DateValue> | null> {
+    readonly minDate: _angular_core.InputSignal<DateValue>;
+    readonly maxDate: _angular_core.InputSignal<DateValue>;
+    readonly unavailableDates: _angular_core.InputSignal<readonly DateValue[]>;
+    readonly firstDayOfWeek: _angular_core.InputSignal<DayOfWeek>;
+    private calendar?;
+    private trigger?;
+    readonly calendarId: string;
+    readonly calendarLabel = "Date range picker";
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly focusedDate: _angular_core.WritableSignal<DateValue>;
+    readonly visibleMonth: _angular_core.WritableSignal<DateValue>;
+    private readonly overlay;
+    private readonly changeDetector;
+    private readonly destroyRef;
+    private readonly locale;
+    private readonly monthFormatter;
+    private readonly dateFormatter;
+    private overlayRef;
+    readonly displayValue: _angular_core.Signal<string>;
+    readonly monthLabel: _angular_core.Signal<string>;
+    constructor();
+    writeValue(value: NsDateRangeValue<DateValue> | null): void;
+    toggle(): void;
+    navigate(months: number): void;
+    select(date: DateValue): void;
+    focusDate(date: DateValue): void;
+    private open;
+    private close;
+    private normalizeRange;
+    private firstSelectableDate;
+    private isSelectable;
+    private formatDate;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDateRangePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsDateRangePickerComponent, "ns-date-range-picker", never, { "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "unavailableDates": { "alias": "unavailableDates"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NsDropdownItemDirective {
+    readonly key: _angular_core.InputSignal<NsKey>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDropdownItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NsDropdownItemDirective, "ns-dropdown-item", never, { "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface NsDropdownItem<T = unknown> {
+    key: NsKey;
+    label: string;
+    disabled?: boolean;
+    value?: T;
+}
+type NsDropdownValue = NsKey | readonly NsKey[] | null;
+
+interface NsDropdownWorkingItem {
+    readonly key: NsKey;
+    readonly label: string;
+    readonly disabled: boolean;
+}
+declare class NsDropdownComponent extends NsValueAccessor<NsDropdownValue> {
+    readonly collection: _angular_core.InputSignal<readonly NsDropdownItem<unknown>[]>;
+    readonly contentItems: _angular_core.Signal<readonly NsDropdownItemDirective[]>;
+    readonly selectionMode: _angular_core.InputSignal<NsSelectionMode>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly searchable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly searchPlaceholder: _angular_core.InputSignal<string>;
+    readonly emptyText: _angular_core.InputSignal<string>;
+    readonly placement: _angular_core.InputSignal<NsPlacement>;
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private trigger?;
+    private menu?;
+    private searchInput?;
+    private listbox?;
+    private readonly overlay;
+    private readonly destroyRef;
+    private readonly typeahead;
+    private overlayRef?;
+    private destroyed;
+    readonly query: _angular_core.WritableSignal<string>;
+    readonly activeIndex: _angular_core.WritableSignal<number>;
+    readonly listboxId: string;
+    readonly searchId: string;
+    readonly skeletonRows: readonly [0, 1, 2, 3];
+    readonly items: _angular_core.Signal<NsDropdownWorkingItem[]>;
+    readonly visibleItems: _angular_core.Signal<NsDropdownWorkingItem[]>;
+    readonly selectedKeys: _angular_core.Signal<ReadonlySet<NsKey>>;
+    readonly selectedLabel: _angular_core.Signal<string>;
+    readonly activeId: _angular_core.Signal<string>;
+    constructor();
+    toggle(): void;
+    select(key: NsKey): void;
+    onNativeChange(event: Event): void;
+    onSearchInput(event: Event): void;
+    onTriggerKeydown(event: KeyboardEvent): void;
+    onSearchKeydown(event: KeyboardEvent): void;
+    onListboxKeydown(event: KeyboardEvent): void;
+    private show;
+    private close;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsDropdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsDropdownComponent, "ns-dropdown", never, { "collection": { "alias": "collection"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "opened": "opened"; "closed": "closed"; }, ["contentItems"], never, true, never>;
+}
+
+declare class NsInputComponent extends NsValueAccessor<string> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsInputComponent, "ns-input", never, {}, {}, never, never, true, never>;
+}
+
+declare class NsInputCodeComponent extends NsValueAccessor<string> {
+    readonly length: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsInputCodeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsInputCodeComponent, "ns-input-code", never, { "length": { "alias": "length"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Visual-only composition primitive. Projected controls own their form state. */
+declare class NsInputGroupComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsInputGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsInputGroupComponent, "ns-input-group", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class NsInputGroupAddonComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsInputGroupAddonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsInputGroupAddonComponent, "ns-input-group-addon", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class NsInputNumberComponent extends NsValueAccessor<number | null> {
+    private readonly locale;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly currency: _angular_core.InputSignal<string>;
+    readonly format: _angular_core.InputSignal<Intl.NumberFormatOptions>;
+    readonly displayValue: _angular_core.WritableSignal<string>;
+    writeValue(value: number | null): void;
+    onInput(text: string): void;
+    onInputEvent(event: Event): void;
+    formatValue(): void;
+    onKeydown(event: KeyboardEvent): void;
+    stepBy(direction: 1 | -1): void;
+    private get formatter();
+    private parse;
+    private constrain;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsInputNumberComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsInputNumberComponent, "ns-input-number", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "currency": { "alias": "currency"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NsInputSearchComponent extends NsValueAccessor<string> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsInputSearchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsInputSearchComponent, "ns-input-search", never, {}, {}, never, never, true, never>;
+}
+
+declare class NsPasswordComponent extends NsValueAccessor implements OnInit {
+    readonly forgotLink: _angular_core.InputSignal<string>;
+    readonly showAndHide: _angular_core.InputSignal<boolean>;
+    show: boolean;
+    constructor();
+    ngOnInit(): void;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsPasswordComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsPasswordComponent, "ns-password", never, { "forgotLink": { "alias": "forgotLink"; "required": false; "isSignal": true; }; "showAndHide": { "alias": "showAndHide"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NsRadioGroupContext {
+    readonly value: _angular_core.WritableSignal<string>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    select: (value: string) => void;
+    onTouched: () => void;
+}
+
+declare class NsRadioComponent {
+    private readonly ids;
+    readonly group: NsRadioGroupContext;
+    readonly id: string;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    select(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsRadioComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsRadioComponent, "ns-radio", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NsRadioGroupComponent extends NsValueAccessor<string | null> {
+    private readonly context;
+    constructor();
+    writeValue(value: string | null): void;
+    setValue(value: string | null): void;
+    setDisabledState(disabled: boolean): void;
+    registerOnChange(fn: (value: string | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsRadioGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsRadioGroupComponent, "ns-radio-group", never, {}, {}, never, ["*"], true, never>;
+}
+
+type NsSliderValue = number | readonly [number, number];
+declare class NsSliderComponent extends NsValueAccessor<NsSliderValue> {
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly range: _angular_core.InputSignal<boolean>;
+    readonly rangeStartId: string;
+    readonly rangeEndId: string;
+    readonly rangeLabelId: string;
+    readonly rangeStartDescriptionId: string;
+    readonly rangeEndDescriptionId: string;
+    readonly rangeStartLabelledBy: () => string;
+    readonly rangeEndLabelledBy: () => string;
+    single(): number;
+    start(): number;
+    end(): number;
+    setSingle(event: Event): void;
+    setRangeStart(event: Event): void;
+    setRangeEnd(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsSliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsSliderComponent, "ns-slider", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NsSwitchComponent extends NsValueAccessor<boolean> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsSwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsSwitchComponent, "ns-switch", never, {}, {}, never, never, true, never>;
+}
+
+declare class NsTextAreaComponent extends NsValueAccessor<string> {
+    readonly rows: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsTextAreaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsTextAreaComponent, "ns-textarea", never, { "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NsContentEditableComponent extends NsValueAccessor<string> {
+    private elementRef;
+    private renderer;
+    readonly maxLength: _angular_core.InputSignal<number>;
+    enabled: boolean;
+    writeValue(value: string): void;
+    onInput(): void;
+    onBlur(): void;
+    onKeyUp(event: KeyboardEvent): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsContentEditableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsContentEditableComponent, "ns-content-editable", never, { "maxLength": { "alias": "maxlength"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NsFieldContext {
+    private readonly descriptions;
+    private controlId;
+    setControlId(controlId: string): void;
+    getControlId(): string;
+    getDescribedBy(): string | undefined;
+    registerDescription(id: string): void;
+    unregisterDescription(id: string): void;
+}
+declare class NsFieldDirective {
+    private readonly context;
+    private readonly ariaIds;
+    readonly controlId: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsFieldDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NsFieldDirective, "[nsField]", never, { "controlId": { "alias": "nsField"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 declare class NsEditorComponent extends NsValueAccessor<string> implements OnInit, OnDestroy {
     private editor;
     readonly rows: _angular_core.InputSignal<number>;
@@ -486,63 +854,127 @@ declare class NsImageUploadComponent extends NsValueAccessor<NsFile | NsFile[] |
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsImageUploadComponent, "ns-image-upload", never, { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "limit": { "alias": "limit"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class TemplateDirective implements OnInit {
-    readonly name: _angular_core.InputSignal<string>;
-    readonly styleClass: _angular_core.InputSignal<string>;
-    readonly ref: TemplateRef<TemplateDirective>;
-    private readonly modalRef;
-    ngOnInit(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TemplateDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TemplateDirective, "[nsTemplate]", never, { "name": { "alias": "nsTemplate"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+declare class NsLinkComponent {
+    readonly href: _angular_core.InputSignal<string>;
+    readonly target: _angular_core.InputSignal<"" | "_blank" | "_self" | "_parent" | "_top">;
+    readonly rel: _angular_core.InputSignal<string>;
+    readonly color: _angular_core.InputSignal<NsColor>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsLinkComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsLinkComponent, "ns-link", never, { "href": { "alias": "href"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "rel": { "alias": "rel"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
-declare class NsModalComponent implements AfterViewInit, AfterViewChecked {
-    title: string;
-    size: 'lg' | 'sm' | 'xl';
-    component: Type<unknown>;
-    context: Record<string, unknown>;
-    close: () => void;
-    show: boolean;
-    headerRef: TemplateRef<TemplateDirective>;
-    footerRef: TemplateRef<TemplateDirective>;
-    containerRef: ViewContainerRef;
-    private readonly cd;
-    keydown(event: KeyboardEvent): void;
-    ngAfterViewInit(): void;
-    ngAfterViewChecked(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsModalComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsModalComponent, "ns-modal", never, {}, {}, never, never, true, never>;
+declare class NsMeterComponent {
+    readonly value: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly min: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly color: _angular_core.InputSignal<NsColor>;
+    readonly percentage: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsMeterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsMeterComponent, "ns-meter", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class NsModalRef {
-    ref: ComponentRef<NsModalComponent> | null;
-    get instance(): NsModalComponent;
-    addTemplate(template: TemplateDirective): void;
-    close(timeout?: number): void;
-    onDestroy(callback: () => void): void;
+type NsModalSize = 'sm' | 'md' | 'lg' | 'xl';
+interface NsModalOptions {
+    title?: string;
+    size?: NsModalSize;
+    closeOnEscape?: boolean;
+}
+type NsComponentInputs<T extends object> = Partial<Record<Extract<keyof T, string>, unknown>>;
+interface NsModalConfig<T extends object> extends NsModalOptions {
+    component: Type<T>;
+    inputs?: NsComponentInputs<T>;
 }
 
-interface NsModalSetup<T = unknown> {
-    title?: string;
-    context?: Partial<T>;
-    size?: 'lg' | 'sm' | 'xl';
+declare class NsModalComponent implements AfterViewInit, OnDestroy {
+    readonly isOpen: _angular_core.ModelSignal<boolean>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<NsModalSize>;
+    readonly closeLabel: _angular_core.InputSignal<string>;
+    readonly closeOnEscape: _angular_core.InputSignal<boolean>;
+    readonly closed: _angular_core.OutputEmitterRef<NsOverlayCloseReason>;
+    readonly contentComponent: _angular_core.InputSignal<Type<object>>;
+    readonly contentInputs: _angular_core.InputSignal<Record<string, unknown>>;
+    readonly closeReason: _angular_core.WritableSignal<NsOverlayCloseReason>;
+    private contentHost?;
+    private readonly element;
+    private readonly overlay;
+    private overlayRef?;
+    private contentRef?;
+    private viewInitialized;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    close(): void;
+    getContent<T extends object>(): T;
+    private openOverlay;
+    private createContent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsModalComponent, "ns-modal", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "contentComponent": { "alias": "contentComponent"; "required": false; "isSignal": true; }; "contentInputs": { "alias": "contentInputs"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "closed": "closed"; }, never, ["[modal-description]", "*", "[modal-footer]"], true, never>;
 }
 
-declare class NsModalService {
-    private readonly appRef;
-    private readonly injector;
-    private readonly document;
-    private readonly factory;
-    private readonly renderer;
-    private readonly stack;
-    open<T = unknown>(component: Type<T>, setup: NsModalSetup<T>): NsModalRef;
+/** A programmatically opened modal and its typed content instance. */
+declare class NsModalRef<T> {
+    private readonly componentRef;
+    readonly content: T;
+    readonly closed: Signal<NsOverlayCloseReason | undefined>;
+    constructor(componentRef: ComponentRef<NsModalComponent>, content: T, closed: Signal<NsOverlayCloseReason | undefined>);
     close(): void;
-    private attachComponent;
-    private registerModalRef;
+}
+
+declare class NsModalService {
+    private readonly applicationRef;
+    private readonly environmentInjector;
+    open<T extends object>(config: NsModalConfig<T>): NsModalRef<T>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsModalService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<NsModalService>;
 }
 
+declare class NsPaginationComponent {
+    readonly total: _angular_core.InputSignal<number>;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly siblingCount: _angular_core.InputSignal<number>;
+    readonly page: _angular_core.ModelSignal<number>;
+    readonly pageCount: _angular_core.Signal<number>;
+    readonly pages: _angular_core.Signal<number[]>;
+    goTo(page: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsPaginationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsPaginationComponent, "ns-pagination", never, { "total": { "alias": "total"; "required": true; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "siblingCount": { "alias": "siblingCount"; "required": false; "isSignal": true; }; "page": { "alias": "page"; "required": false; "isSignal": true; }; }, { "page": "pageChange"; }, never, never, true, never>;
+}
+
+declare class NsPopoverComponent implements AfterViewInit, OnDestroy {
+    readonly isOpen: _angular_core.ModelSignal<boolean>;
+    readonly origin: _angular_core.InputSignal<HTMLElement>;
+    readonly placement: _angular_core.InputSignal<NsPlacement>;
+    readonly closeOnEscape: _angular_core.InputSignal<boolean>;
+    readonly closed: _angular_core.OutputEmitterRef<NsOverlayCloseReason>;
+    private readonly element;
+    private readonly overlay;
+    private overlayRef?;
+    private viewInitialized;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    close(): void;
+    private openOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsPopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsPopoverComponent, "ns-popover", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "origin": { "alias": "origin"; "required": true; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+declare class NsProgressBarComponent {
+    readonly value: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly min: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly indeterminate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly color: _angular_core.InputSignal<NsColor>;
+    readonly percentage: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsProgressBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsProgressBarComponent, "ns-progress-bar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 declare class NsSchedule {
     id: number;
     subject: string;
@@ -569,13 +1001,15 @@ declare class NsScheduleService {
 declare class NsScheduleComponent {
     readonly view: _angular_core.ModelSignal<NsDateView>;
     readonly selected: _angular_core.ModelSignal<Date>;
+    readonly selectedDay: _angular_core.ModelSignal<DateValue>;
     readonly height: _angular_core.InputSignal<number>;
     readonly data: _angular_core.InputSignal<NsSchedule[]>;
     private readonly service;
     readonly onClick: _angular_core.OutputRef<NsSchedule>;
     goToday(): void;
+    selectDate(date: DateValue): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsScheduleComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsScheduleComponent, "ns-schedule", never, { "view": { "alias": "view"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, { "view": "viewChange"; "selected": "selectedChange"; "onClick": "onClick"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsScheduleComponent, "ns-schedule", never, { "view": { "alias": "view"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "selectedDay": { "alias": "selectedDay"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, { "view": "viewChange"; "selected": "selectedChange"; "selectedDay": "selectedDayChange"; "onClick": "onClick"; }, never, never, true, never>;
 }
 
 type NsSchemaType = 'Person' | 'Organization' | 'MusicGroup' | 'MusicAlbum' | 'MusicEvent' | 'MusicComposition' | 'MusicRecording' | 'MusicRelease' | 'MusicPlaylist' | 'Event';
@@ -675,49 +1109,278 @@ declare class NsSchemaMarkupComponent implements OnInit, OnChanges {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsSchemaMarkupComponent, "ns-schema", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare enum ToastType {
-    SUCCESS = "success",
-    WARNING = "warning",
-    INFO = "info",
-    ERROR = "error"
+declare class NsSkeletonComponent {
+    readonly width: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly animated: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsSkeletonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsSkeletonComponent, "ns-skeleton", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "animated": { "alias": "animated"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class NsToastComponent {
-    readonly type: _angular_core.InputSignal<ToastType>;
-    readonly message: _angular_core.InputSignal<string>;
-    state: 'display' | 'destroy';
-    private readonly element;
-    get marginLeft(): number;
-    get iconName(): "exclamation-triangle" | "exclamation-circle" | "info-circle" | "check-circle";
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsToastComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsToastComponent, "ns-toast", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+declare class TemplateDirective {
+    readonly name: _angular_core.InputSignal<string>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    /** Template handle for consumers that render templates through their own API. */
+    readonly ref: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TemplateDirective, "[nsTemplate]", never, { "name": { "alias": "nsTemplate"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class ToastRef {
-    ref: ComponentRef<NsToastComponent> | null;
-    readonly timeout: Observable<0>;
-    constructor(props?: Partial<ToastRef>);
-    get instance(): NsToastComponent;
-    destroy(timeout: number): Observable<0>;
+type NsToastVariant = 'success' | 'warning' | 'info' | 'danger';
+type NsToastPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end';
+type NsToastCloseReason = 'action' | 'close' | 'timeout' | 'programmatic';
+interface NsToastAction {
+    label: string;
+    handler: () => void;
+}
+interface NsToastOptions {
+    message: string | TemplateRef<unknown>;
+    variant?: NsToastVariant;
+    duration?: number;
+    action?: NsToastAction;
+    closable?: boolean;
+    onClose?: (reason: NsToastCloseReason) => void;
 }
 
-declare class ToastSetup {
-    parent?: string;
-    type?: ToastType;
-    message: string;
-    callback?: () => void;
+type NsColorScheme = 'light' | 'dark' | 'system';
+type NsResolvedColorScheme = Exclude<NsColorScheme, 'system'>;
+type NsPrimitiveTokenValue = string | number;
+type NsPrimitiveReference = `{primitive.${string}}`;
+type NsSemanticReference = `{semantic.${string}}`;
+type NsTokenTree<T> = {
+    [token: string]: T | NsTokenTree<T>;
+};
+interface NsSemanticTokens {
+    common: NsTokenTree<NsPrimitiveReference>;
+    colorScheme: Record<NsResolvedColorScheme, NsTokenTree<NsPrimitiveReference>>;
+}
+interface NsThemePreset {
+    name: string;
+    primitive: NsTokenTree<NsPrimitiveTokenValue>;
+    semantic: NsSemanticTokens;
+    components: NsTokenTree<NsSemanticReference>;
+}
+type NsDeepPartial<T> = {
+    [Property in keyof T]?: T[Property] extends object ? NsDeepPartial<T[Property]> : T[Property];
+};
+type NsThemePresetOverrides = NsDeepPartial<NsThemePreset>;
+interface NsThemeOptions {
+    preset?: NsThemePreset;
+    colorScheme?: NsColorScheme;
+    storageKey?: string | false;
+    toast?: NsToastThemeOptions;
+}
+interface NsResolvedThemeOptions {
+    preset: NsThemePreset;
+    colorScheme: NsColorScheme;
+    storageKey: string | false;
+    toast: NsResolvedToastThemeOptions;
+}
+interface NsToastThemeOptions {
+    placement?: NsToastPlacement;
 }
+interface NsResolvedToastThemeOptions {
+    placement: NsToastPlacement;
+}
+
+declare const Arvisfy: NsThemePreset;
 
-declare class NsToastService {
-    private readonly appRef;
+declare class NsThemeService {
     private readonly document;
-    private readonly stack;
-    add(setup: ToastSetup): ToastRef;
-    private attachComponent;
-    private registerToast;
+    private readonly platformId;
+    private readonly destroyRef;
+    private readonly options;
+    private readonly browser;
+    private readonly activeVariables;
+    private readonly mediaQuery;
+    private readonly systemScheme;
+    private readonly presetState;
+    private readonly schemeState;
+    readonly preset: _angular_core.Signal<NsThemePreset>;
+    readonly colorScheme: _angular_core.Signal<NsColorScheme>;
+    readonly scheme: _angular_core.Signal<NsColorScheme>;
+    readonly resolvedColorScheme: _angular_core.Signal<NsResolvedColorScheme>;
+    constructor();
+    setPreset(preset: NsThemePreset): void;
+    setColorScheme(colorScheme: NsColorScheme): void;
+    setScheme(colorScheme: NsColorScheme): void;
+    private readonly onSystemSchemeChange;
+    private applyTheme;
+    private createMediaQuery;
+    private readStoredScheme;
+    private persistScheme;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsThemeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NsThemeService>;
+}
+
+declare const NS_THEME_OPTIONS: InjectionToken<NsResolvedThemeOptions>;
+declare const NS_TOAST_OPTIONS: InjectionToken<NsResolvedToastThemeOptions>;
+declare function provideNsTheme(options?: NsThemeOptions): EnvironmentProviders;
+
+declare function defineNsPreset(base: NsThemePreset, overrides: NsThemePresetOverrides): NsThemePreset;
+declare function validateNsPreset(preset: NsThemePreset): void;
+declare function flattenTokens<T>(tree: NsTokenTree<T>): Map<string, T>;
+declare function tokenPathToCssVariable(tier: 'primitive' | 'semantic' | 'component', path: string): string;
+declare function referenceToCssVariable(reference: NsPrimitiveReference | NsSemanticReference): string;
+type NsFlattenedPrimitiveTokens = Map<string, NsPrimitiveTokenValue>;
+
+declare class NsToastHandle {
+    private readonly closeToast;
+    private readonly closeReason;
+    readonly closed: Signal<NsToastCloseReason | undefined>;
+    constructor(closeToast: (reason: NsToastCloseReason) => void);
+    dismiss(): void;
+    resolve(reason: NsToastCloseReason): void;
+}
+
+declare class NsToastService implements OnDestroy {
+    private readonly leaveDuration;
+    private readonly applicationRef;
+    private readonly environmentInjector;
+    private readonly document;
+    private readonly platformId;
+    private readonly browser;
+    private readonly toastOptions;
+    private readonly pending;
+    private readonly visible;
+    private region?;
+    get maxVisible(): number;
+    /** SSR resolves immediately because notifications have no browser region. */
+    show(options: NsToastOptions): NsToastHandle;
+    private showPending;
+    private showToast;
+    private dismiss;
+    ngOnDestroy(): void;
+    private destroyToast;
+    private getRegion;
+    private destroyRegionIfEmpty;
+    private destroyRegion;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsToastService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<NsToastService>;
 }
 
-export { NsAvatarComponent, NsButtonComponent, NsButtonGroupComponent, NsCalendar, NsCheckboxComponent, NsCommentComponent, NsContentEditableComponent, NsDateParserFormatter, NsDatePickerComponent, NsDateRangeEndDirective, NsDateRangePickerComponent, NsDateRangeStartDirective, NsDropdownComponent, NsDropdownItemDirective, NsEditorColorPickerComponent, NsEditorComponent, NsEditorLinkComponent, NsEditorListComponent, NsEditorParagraphComponent, NsEditorToggleCommandComponent, NsImageUploadComponent, NsInputComponent, NsInputGroupAddonComponent, NsInputGroupComponent, NsInputNumberComponent, NsModalComponent, NsModalService, NsPasswordComponent, NsScheduleComponent, NsScheduleService, NsSchemaMarkupComponent, NsSwitchComponent, NsTextAreaComponent, NsToastComponent, NsToastService, NsValueAccessor, TemplateDirective, ToastRef, ToastSetup, ToastType };
-export type { NsComment, NsInputGroupSize, NsSchemaMarkup, NsSchemaType };
+declare class NsToastComponent implements AfterViewInit, OnDestroy {
+    readonly message: _angular_core.InputSignal<string | TemplateRef<unknown>>;
+    readonly variant: _angular_core.InputSignal<NsToastVariant>;
+    readonly placement: _angular_core.InputSignal<NsToastPlacement>;
+    readonly duration: _angular_core.InputSignal<number>;
+    readonly action: _angular_core.InputSignal<NsToastAction>;
+    readonly closable: _angular_core.InputSignal<boolean>;
+    readonly dismissed: _angular_core.OutputEmitterRef<NsToastCloseReason>;
+    private readonly element;
+    private timer?;
+    private remaining;
+    private startedAt;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    textMessage(): string | null;
+    templateMessage(): TemplateRef<unknown> | null;
+    pause(): void;
+    resume(): void;
+    dismiss(reason: NsToastCloseReason): void;
+    triggerAction(): void;
+    onFocusOut(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsToastComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsToastComponent, "ns-toast", never, { "message": { "alias": "message"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "action": { "alias": "action"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, never, true, never>;
+}
+
+declare class NsSurfaceComponent {
+    readonly variant: _angular_core.InputSignal<NsVariant>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsSurfaceComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsSurfaceComponent, "ns-surface", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class NsTabComponent {
+    readonly key: _angular_core.InputSignal<NsKey>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly selected: _angular_core.WritableSignal<boolean>;
+    readonly tabId: string;
+    readonly panelId: string;
+    readonly element: ElementRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsTabComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsTabComponent, "ns-tab", never, { "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class NsTabsComponent {
+    readonly orientation: _angular_core.InputSignal<NsOrientation>;
+    readonly selectedKey: _angular_core.ModelSignal<NsKey>;
+    readonly tabs: _angular_core.Signal<readonly NsTabComponent[]>;
+    private readonly element;
+    constructor();
+    select(key: NsKey): void;
+    onKeydown(event: KeyboardEvent, index: number): void;
+    private syncSelection;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsTabsComponent, "ns-tabs", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "selectedKey": { "alias": "selectedKey"; "required": false; "isSignal": true; }; }, { "selectedKey": "selectedKeyChange"; }, ["tabs"], ["*"], true, never>;
+}
+
+declare class NsTagComponent {
+    readonly key: _angular_core.InputSignal<NsKey>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly selected: _angular_core.WritableSignal<boolean>;
+    readonly active: _angular_core.WritableSignal<boolean>;
+    readonly element: ElementRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsTagComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsTagComponent, "ns-tag", never, { "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class NsTagGroupComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly selectionMode: _angular_core.InputSignal<NsSelectionMode>;
+    readonly selectedKeys: _angular_core.ModelSignal<readonly NsKey[]>;
+    readonly tags: _angular_core.Signal<readonly NsTagComponent[]>;
+    private readonly typeahead;
+    private activeIndex;
+    constructor();
+    onClick(event: MouseEvent): void;
+    onKeydown(event: KeyboardEvent): void;
+    select(key: NsKey): void;
+    private focus;
+    private syncState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsTagGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsTagGroupComponent, "ns-tag-group", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "selectedKeys": { "alias": "selectedKeys"; "required": false; "isSignal": true; }; }, { "selectedKeys": "selectedKeysChange"; }, ["tags"], ["*"], true, never>;
+}
+
+declare class NsTooltipComponent implements AfterViewInit, OnDestroy {
+    readonly isOpen: _angular_core.ModelSignal<boolean>;
+    readonly origin: _angular_core.InputSignal<HTMLElement>;
+    readonly message: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly placement: _angular_core.InputSignal<NsPlacement>;
+    readonly closed: _angular_core.OutputEmitterRef<NsOverlayCloseReason>;
+    private readonly element;
+    private readonly overlay;
+    private overlayRef?;
+    private viewInitialized;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private openOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsTooltipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NsTooltipComponent, "ns-tooltip", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "origin": { "alias": "origin"; "required": true; "isSignal": true; }; "message": { "alias": "message"; "required": true; "isSignal": true; }; "id": { "alias": "id"; "required": true; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class NsTooltipDirective implements OnDestroy {
+    readonly message: _angular_core.InputSignal<string>;
+    readonly placement: _angular_core.InputSignal<NsPlacement>;
+    readonly delay: _angular_core.InputSignal<number>;
+    private readonly origin;
+    private readonly viewContainer;
+    private readonly id;
+    private componentRef?;
+    private timer?;
+    private previousDescription;
+    show(): void;
+    hide(): void;
+    ngOnDestroy(): void;
+    private open;
+    private createComponent;
+    private addDescription;
+    private removeDescription;
+    private cancelPendingHide;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NsTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NsTooltipDirective, "[nsTooltip]", never, { "message": { "alias": "nsTooltip"; "required": true; "isSignal": true; }; "placement": { "alias": "nsTooltipPlacement"; "required": false; "isSignal": true; }; "delay": { "alias": "nsTooltipDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { Arvisfy, NS_THEME_OPTIONS, NS_TOAST_OPTIONS, NsAccordionComponent, NsAccordionItemComponent, NsAlertComponent, NsAvatarComponent, NsBadgeComponent, NsBreadcrumbItemComponent, NsBreadcrumbsComponent, NsButtonComponent, NsButtonGroupComponent, NsCardBodyComponent, NsCardComponent, NsCardFooterComponent, NsCardHeaderComponent, NsCheckboxComponent, NsChipComponent, NsCollectionController, NsCommentComponent, NsContentEditableComponent, NsDatePickerComponent, NsDateRangePickerComponent, NsDescriptionComponent, NsDividerComponent, NsDrawerComponent, NsDrawerRef, NsDrawerService, NsDropdownComponent, NsDropdownItemDirective, NsEditorColorPickerComponent, NsEditorComponent, NsEditorLinkComponent, NsEditorListComponent, NsEditorParagraphComponent, NsEditorToggleCommandComponent, NsFieldContext, NsFieldDirective, NsImageUploadComponent, NsInputCodeComponent, NsInputComponent, NsInputGroupAddonComponent, NsInputGroupComponent, NsInputNumberComponent, NsInputSearchComponent, NsLinkComponent, NsMeterComponent, NsModalComponent, NsModalRef, NsModalService, NsOverlayRef, NsOverlayService, NsPaginationComponent, NsPasswordComponent, NsPopoverComponent, NsProgressBarComponent, NsRadioComponent, NsRadioGroupComponent, NsSchedule, NsScheduleComponent, NsScheduleService, NsSchemaMarkupComponent, NsSkeletonComponent, NsSliderComponent, NsSurfaceComponent, NsSwitchComponent, NsTabComponent, NsTabsComponent, NsTagComponent, NsTagGroupComponent, NsTextAreaComponent, NsThemeService, NsToastComponent, NsToastHandle, NsToastService, NsTooltipComponent, NsTooltipDirective, NsValueAccessor, TemplateDirective, defineNsPreset, flattenTokens, getNsOverlayPosition, provideNsTheme, referenceToCssVariable, tokenPathToCssVariable, validateNsPreset };
+export type { NsAlertVariant, NsBadgeMode, NsButtonVariant, NsCollectionItem, NsColor, NsColorScheme, NsComment, NsComponentInputs, NsDateRangeValue, NsDateView, NsDeepPartial, NsDrawerComponentInputs, NsDrawerConfig, NsDrawerOptions, NsDrawerPosition, NsDropdownItem, NsDropdownValue, NsFlattenedPrimitiveTokens, NsKey, NsModalConfig, NsModalOptions, NsModalSize, NsOrientation, NsOverlayCloseReason, NsOverlayConfig, NsOverlayPosition, NsPlacement, NsPrimitiveReference, NsPrimitiveTokenValue, NsResolvedColorScheme, NsResolvedThemeOptions, NsResolvedToastThemeOptions, NsSchemaMarkup, NsSchemaType, NsSelectionMode, NsSemanticReference, NsSemanticTokens, NsSize, NsSliderValue, NsThemeOptions, NsThemePreset, NsThemePresetOverrides, NsToastAction, NsToastCloseReason, NsToastOptions, NsToastPlacement, NsToastThemeOptions, NsToastVariant, NsTokenTree, NsVariant };