@nxa-lab/nxa-ui 0.3.6

package/types/nxa-lab-nxa-ui.d.ts

@@ -0,0 +1,1463 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, EventEmitter, OnInit, InjectionToken, Type, AfterContentInit, InputSignal, OnDestroy, AfterViewInit } from '@angular/core';
+import { UrlTree } from '@angular/router';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import { ControlValueAccessor } from '@angular/forms';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import * as _nxa_lab_nxa_ui from '@nxa-lab/nxa-ui';
+import { HttpContextToken, HttpInterceptorFn } from '@angular/common/http';
+import { ComponentType, OverlayConfig, OverlayRef } from '@angular/cdk/overlay';
+
+declare class NxaFormControl {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaFormControl, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaFormControl, "nxa-form-control", never, {}, {}, never, ["[top-left]", "[top-right]", "[leading]", "*", "[trailing]", "[bottom-left]", "[bottom-right]", "[error-message]"], true, never>;
+}
+
+declare const NXA_HOST_CONTENTS_ONLY = "contents";
+declare const NXA_HOST_BLOCK = "block min-h-0 basis-fit h-fit flex-1 max-h-full w-full max-w-full inset-0 box-border";
+declare const NXA_HOST_LAYOUT = "w-full h-full min-h-0 flex flex-col flex-1";
+declare function sanitizeIcon(icon: string, sanitizer: DomSanitizer): SafeHtml;
+declare function isBrowserContext(): boolean;
+declare function isServerContext(): boolean;
+declare function shallowEqual<T = any>(obj1: Record<string, T>, obj2: Record<string, T>): boolean;
+declare function deepEqual<T = any>(a: T, b: T): boolean;
+declare function getStyleVariable(name: string): string;
+type Nullable<T> = T | null | undefined;
+
+declare const NXA_COLORS_ALL: readonly ["primary", "secondary", "accent", "neutral", "info", "warning", "error", "success", "content", "ghost", "link"];
+declare const NXA_NEUTRAL_COLORS: readonly ["neutral"];
+declare const NXA_CONTENT_COLORS: readonly ["content"];
+declare const NXA_BRAND_COLORS: readonly ["primary", "secondary", "accent"];
+declare const NXA_STATUS_COLORS: readonly ["info", "success", "warning", "error"];
+type NxaBrandColor = typeof NXA_BRAND_COLORS[number];
+type NxaStatusColor = typeof NXA_STATUS_COLORS[number];
+type NxaNeutralColor = typeof NXA_NEUTRAL_COLORS[number];
+type NxaContentColor = typeof NXA_CONTENT_COLORS[number];
+type NxaColorAll = typeof NXA_COLORS_ALL[number];
+
+type NxaConstructor<T = object> = new (...args: any[]) => T;
+declare function applyMixins(derivedCtor: any, constructors: any[]): void;
+
+type NxaCssLength = `${number}${'px' | '%' | 'em' | 'rem' | 'vh' | 'vw' | 'dvw' | 'dvh'}` | `calc(${string})` | 'auto' | '0';
+type NxaDirection = 'left' | 'top-left' | 'top' | 'top-right' | 'right' | 'bottom-right' | 'bottom' | 'bottom-left' | 'center-left' | 'center' | 'center-right';
+declare const NXA_SIZES: readonly ["xs", "sm", "md", "lg", "xl"];
+type NxaSize = typeof NXA_SIZES[number];
+
+declare class NxaButton {
+    /**
+     * @ignore
+     */
+    protected readonly _color: _angular_core.WritableSignal<"primary" | "secondary" | "accent" | "neutral" | "info" | "warning" | "error" | "success" | "content" | "ghost" | "link">;
+    /**
+     * @ignore
+     */
+    protected readonly _size: _angular_core.WritableSignal<"xs" | "sm" | "md" | "lg" | "xl">;
+    /**
+     * @ignore
+     */
+    protected readonly _disabled: _angular_core.WritableSignal<boolean>;
+    /**
+     * @ignore
+     */
+    protected readonly _loading: _angular_core.WritableSignal<boolean>;
+    /**
+     * @ignore
+     */
+    protected readonly _routerLink: _angular_core.WritableSignal<Nullable<string | any[] | UrlTree>>;
+    /**
+     * @ignore
+     */
+    protected readonly _outlined: _angular_core.WritableSignal<boolean>;
+    /**
+     * @ignore
+     */
+    private readonly _className;
+    /**
+     * @ignore
+     */
+    protected readonly _type: _angular_core.WritableSignal<"button" | "submit" | "reset">;
+    /**
+     * @ignore
+     */
+    protected readonly _spinnerTemplateRef: _angular_core.WritableSignal<Nullable<TemplateRef<any>>>;
+    /**
+     *
+     */
+    protected readonly _label: _angular_core.WritableSignal<string>;
+    set label(value: string);
+    get label(): string;
+    set color(value: NxaColorAll);
+    /**
+     * Size of the button based on DaisyUI Theme Sizes
+     */
+    set size(value: NxaSize);
+    /**
+     * Disabled button effect + handleClick won't fire an event
+     */
+    set disabled(value: boolean);
+    /**
+   * show a loading spinner + diabled fire events from button
+   */
+    set loading(value: boolean);
+    /**
+     * if value is provided it change the button into a link that is navigable
+     */
+    set routerLink(value: Nullable<string | any[] | UrlTree>);
+    /**
+     * set the style to outlinee
+     */
+    set outlined(value: boolean);
+    /**
+   * classes provided will be injected into the button
+   */
+    set className(value: string);
+    /**
+   * type of button, work only if it's a button without routerLink
+   */
+    set type(value: 'button' | 'submit' | 'reset');
+    /**
+     * custom spinner for the loading state
+     */
+    set spinnerTemplateRef(value: Nullable<TemplateRef<any>>);
+    /**
+     * click event handled with disabled & loading condition to prevent multiple clicks
+     */
+    nxaClick: EventEmitter<Event>;
+    /**
+     * @ignore
+     */
+    protected computedClasses: _angular_core.Signal<{
+        btn: boolean;
+        'btn-disabled': boolean;
+        'btn-outline': boolean;
+        "pointer-events-none": boolean;
+    }>;
+    handleClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaButton, "nxa-button", never, { "label": { "alias": "label"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "routerLink": { "alias": "routerLink"; "required": false; }; "outlined": { "alias": "outlined"; "required": false; }; "className": { "alias": "className"; "required": false; }; "type": { "alias": "type"; "required": false; }; "spinnerTemplateRef": { "alias": "spinnerTemplateRef"; "required": false; }; }, { "nxaClick": "nxaClick"; }, never, ["[leading]", "*", "[trailing]"], true, never>;
+}
+
+declare class NxaCheckbox implements ControlValueAccessor {
+    protected _value: {
+        sig: _angular_core.WritableSignal<boolean>;
+        emitter: _angular_core.EventEmitter<boolean>;
+        get: () => boolean;
+        set: (v: boolean) => void;
+        update: (updateFn: (old: boolean) => boolean) => void;
+    };
+    protected _disabled: _angular_core.WritableSignal<boolean>;
+    protected _color: _angular_core.WritableSignal<"primary" | "secondary" | "accent" | "neutral" | "info" | "warning" | "error" | "success">;
+    protected _size: _angular_core.WritableSignal<"xs" | "sm" | "md" | "lg">;
+    protected _displayAs: _angular_core.WritableSignal<"checkbox" | "toggle">;
+    protected _id: _angular_core.WritableSignal<string>;
+    protected _className: _angular_core.WritableSignal<string>;
+    private onChange;
+    private onTouched;
+    /**
+     * Checkbox Value
+     * @type {boolean}
+     * @default false
+     */
+    set value(value: boolean);
+    get value(): boolean;
+    /**
+     * Checkbox disabled state
+     * @type {boolean}
+     * @default false
+     * @description If true, the checkbox will be disabled and cannot be interacted with.
+     */
+    set disabled(value: boolean);
+    /**
+     * Checkbox color
+     * @type {NxaBrandColor | NxaStatusColor | NxaNeutralColor}
+     * @default 'neutral'
+     */
+    set color(value: NxaBrandColor | NxaStatusColor | NxaNeutralColor);
+    /**
+   * Checkbox size
+   * @type {NxaSize}
+   * @default 'md'
+   */
+    set size(value: Exclude<NxaSize, 'xl'>);
+    /**
+   * Show checkbox as checkbox or toggle
+   * @type {'checkbox' | 'toggle'}
+   * @default 'checkbox'
+   * @description If 'checkbox', it will show as a checkbox, if 'toggle', it will show as a toggle switch.
+   * This is useful for different use cases where you want to show a checkbox or a toggle switch.
+   */
+    set displayAs(value: 'checkbox' | 'toggle');
+    set id(value: string);
+    set className(value: string);
+    valueChange: _angular_core.EventEmitter<boolean>;
+    /**
+     * @ignore
+     * Control value accessor write value function
+     * update state value when form inject current value
+     */
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onBlur(): void;
+    protected computedNgClasses: _angular_core.Signal<{
+        [x: string]: boolean;
+        disabled: boolean;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaCheckbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaCheckbox, "nxa-checkbox", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "displayAs": { "alias": "displayAs"; "required": false; }; "id": { "alias": "id"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, { "valueChange": "valueChange"; }, never, ["[label]"], true, never>;
+}
+
+declare class NxaDateTimeInput implements OnInit, ControlValueAccessor {
+    protected _type: _angular_core.WritableSignal<"date" | "datetime-local">;
+    set type(value: 'date' | 'datetime-local');
+    get type(): 'date' | 'datetime-local';
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaDateTimeInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaDateTimeInput, "nxa-date-time-input", never, { "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface NxaDrawerState {
+    id: string;
+    state: "OPEN" | "CLOSE" | "REMOVED";
+    side: "LEFT" | "RIGHT";
+}
+declare class NxaDrawerService {
+    /**
+     * store state of any drawer
+     */
+    private _drawerStates$;
+    /**
+     * register a drawer so that it can be used
+     * @param drawerState initial drawer state
+     */
+    registerDrawer(drawerState: NxaDrawerState): void;
+    /**
+     * remove drawer state
+     * @param id id of the drawer
+     */
+    unregisterDrawer(id: string): void;
+    /**
+     * get drawer state stream by Id
+     * @param id id of the drawer
+     * @returns Observable state of the drawer
+     */
+    getDrawerState$(id: string): Observable<NxaDrawerState | null | undefined>;
+    /**
+     * get current drawer state by Id
+     * @param id id of the drawer
+     * @returns NxaDrawerState
+     */
+    getDrawerState(id: string): NxaDrawerState | null | undefined;
+    /**
+     * update state of a drawer
+     * @param drawerState
+     */
+    updateDrawerState(drawerState: NxaDrawerState): void;
+    /**
+     * Toggle State of a drawer
+     * @param id drawer Id
+     */
+    toggle(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaDrawerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NxaDrawerService>;
+}
+
+type NxaBreakpoint = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+type NxaBreakpointMap = Partial<Record<Exclude<NxaBreakpoint, 'xs'>, number>>;
+declare const DEFAULT_TAILWIND_BREAKPOINTS: NxaBreakpointMap;
+declare const NXA_BREAKPOINTS: InjectionToken<Partial<Record<"sm" | "md" | "lg" | "xl" | "2xl", number>>>;
+declare class NxaLayoutService {
+    private breakpoints;
+    private _breakpoint$;
+    private _resizeObserver?;
+    constructor();
+    get breakpoint$(): rxjs.Observable<NxaBreakpoint>;
+    get current(): NxaBreakpoint;
+    private getBreakpoint;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaLayoutService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NxaLayoutService>;
+}
+
+declare const SKIP_LOADING: HttpContextToken<boolean>;
+declare class NxaLoadingService {
+    private _isLoading$;
+    get isLoading$(): Observable<boolean>;
+    get isLoading(): boolean;
+    addLoading(): void;
+    removeLoading(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaLoadingService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NxaLoadingService>;
+}
+
+declare class NxaOverlayRef<T> {
+    overlayRef: OverlayRef;
+    private _afterClose$;
+    readonly afterClose$: rxjs.Observable<Nullable<T>>;
+    constructor(overlayRef: OverlayRef);
+    close(returnValue?: T): void;
+}
+type NxaOverlayConfig = OverlayConfig & {
+    backdropClickDismiss?: boolean;
+};
+declare const NXA_OVERLAY_DATA: InjectionToken<any>;
+declare const NXA_OVERLAY_CONFIG_DEFAULTS: InjectionToken<NxaOverlayConfig>;
+declare class NxaOverlayService {
+    private readonly overlay;
+    private readonly defaultConfig;
+    private readonly positionBuilder;
+    create<TComponent, TData, TReturn>(component: ComponentType<TComponent>, data?: Nullable<TData>, config?: Partial<NxaOverlayConfig>): NxaOverlayRef<TReturn>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaOverlayService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NxaOverlayService>;
+}
+
+declare const NXA_DEFAULT_THEME_BRIGHTNESS_MAP: Record<string, "light" | "dark">;
+declare const NXA_THEME_BRIGHTNESS_MAP: InjectionToken<Record<string, "light" | "dark">>;
+/**
+ * Default Light theme name
+ */
+declare const NXA_DEFAULT_LIGHT_THEME: InjectionToken<string>;
+/**
+ * Default Dark theme name
+ */
+declare const NXA_DEFAULT_DARK_THEME: InjectionToken<string>;
+/**
+ * Preference for dark theme
+ * If true, the service will set the default theme to dark
+ * If false, it will set the default theme to light
+ */
+declare const NXA_PREFER_DARK_THEME: InjectionToken<boolean>;
+type NxaThemeLoaderFn = () => string | null | Promise<string | null> | Observable<string | null>;
+/**
+ * Theme Loader function
+ * allow to load theme dynamically
+ * can be override to load theme from local storage, server or any other source
+ */
+declare const NXA_THEME_LOADER: InjectionToken<NxaThemeLoaderFn>;
+/**
+ * Theme Saving function
+ * allow to save theme name when it is changed
+ * can be override to save theme in local storage, server or any other source
+ */
+declare const NXA_THEME_SAVING: InjectionToken<(themeName: string) => void>;
+declare class NxaThemeService {
+    private _defaultLightTheme;
+    private _defaultDarkTheme;
+    private _preferDarkTheme;
+    private _themeBrightnessMap;
+    private _themeLoaderFn;
+    private _themeSavingFn;
+    private _currentTheme;
+    get currentTheme(): string | null;
+    set currentTheme(value: string | null);
+    private _currentBrightness$;
+    get currentBrightness$(): Observable<"light" | "dark">;
+    getTheme(): string | null;
+    private getColorScheme;
+    setTheme(theme: string): void;
+    constructor();
+    private _initializeTheme;
+    private _resolveTheme;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaThemeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NxaThemeService>;
+}
+
+interface NxaToastModel {
+    title: string;
+    message: string;
+    color: NxaStatusColor;
+    duration: number;
+}
+interface NxaToastConfig {
+    component: Type<any>;
+    direction: NxaDirection;
+    distance: [NxaCssLength, NxaCssLength];
+    width: NxaCssLength;
+    height: NxaCssLength;
+    maxWidth: NxaCssLength;
+    maxHeight: NxaCssLength;
+    panelClass?: string;
+}
+declare const NXA_TOAST_CONFIG_DEFAULTS: InjectionToken<NxaToastConfig>;
+declare class NxaToastService {
+    private static count;
+    private overlayService;
+    private toastDefaultConfig;
+    private overlay;
+    show(title: string, message: string, color: NxaStatusColor, duration?: number, config?: Partial<NxaToastConfig>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NxaToastService>;
+}
+
+declare const NxaOverlayBase: {
+    new (...args: any[]): {
+        overlayService: NxaOverlayService;
+        overlayRef: NxaOverlayRef<any>;
+        overlayData: any;
+    };
+} & NxaConstructor;
+interface INxaOverlay<TData> {
+    overlayService: NxaOverlayService;
+    overlayRef: NxaOverlayRef<TData>;
+    overlayData: TData;
+}
+declare function NxaOverlayBaseMixin<TData, TBase extends NxaConstructor<object>>(Base: TBase): {
+    new (...args: any[]): {
+        overlayService: NxaOverlayService;
+        overlayRef: NxaOverlayRef<TData>;
+        overlayData: TData;
+    };
+} & TBase;
+
+type NxaClassList = string | Record<string, boolean>;
+declare const WithClassName: {
+    new (...args: any[]): {
+        /** Raw internal value from the component's @Input() */
+        _className: _angular_core.WritableSignal<NxaClassList | null>;
+        /** Normalized final string */
+        readonly _classNameObject: _angular_core.Signal<"" | Record<string, boolean>>;
+    };
+} & NxaConstructor;
+declare function WithClassNameMixin<TBase extends NxaConstructor>(Base: TBase): {
+    new (...args: any[]): {
+        /** Raw internal value from the component's @Input() */
+        _className: _angular_core.WritableSignal<NxaClassList | null>;
+        /** Normalized final string */
+        readonly _classNameObject: _angular_core.Signal<"" | Record<string, boolean>>;
+    };
+} & TBase;
+declare function WithClassHeaderMixin<TBase extends NxaConstructor>(base: TBase): {
+    new (...args: any[]): {
+        _classHeader: _angular_core.WritableSignal<NxaClassList | null>;
+        _classHeaderObject: _angular_core.Signal<Record<string, boolean>>;
+    };
+} & TBase;
+declare function WithClassBodyMixin<TBase extends NxaConstructor>(base: TBase): {
+    new (...args: any[]): {
+        _classBody: _angular_core.WritableSignal<NxaClassList | null>;
+        _classBodyObject: _angular_core.Signal<Record<string, boolean>>;
+    };
+} & TBase;
+declare function WithClassFooterMixin<TBase extends NxaConstructor>(base: TBase): {
+    new (...args: any[]): {
+        _classFooter: _angular_core.WritableSignal<NxaClassList | null>;
+        _classFooterObject: _angular_core.Signal<Record<string, boolean>>;
+    };
+} & TBase;
+
+interface INxaDropDownOption<T = any> {
+    label: string;
+    value: T;
+}
+declare const NxaDropdown_base: {
+    new (...args: any[]): {
+        _className: _angular_core.WritableSignal<NxaClassList | null>;
+        readonly _classNameObject: _angular_core.Signal<"" | Record<string, boolean>>;
+    };
+} & {
+    new (): {};
+};
+declare class NxaDropdown<T = any> extends NxaDropdown_base {
+    protected _isOpen: _angular_core.WritableSignal<boolean>;
+    protected _label: _angular_core.WritableSignal<string>;
+    protected _options: _angular_core.WritableSignal<string[] | INxaDropDownOption<any>[]>;
+    protected _buttonTemplateRef: _angular_core.WritableSignal<Nullable<TemplateRef<any>>>;
+    protected _itemTemplateRef: _angular_core.WritableSignal<Nullable<TemplateRef<INxaDropDownOption<any>>>>;
+    protected _value: {
+        sig: _angular_core.WritableSignal<Nullable<INxaDropDownOption<any>>>;
+        emitter: _angular_core.EventEmitter<Nullable<INxaDropDownOption<any>>>;
+        get: () => Nullable<INxaDropDownOption<any>>;
+        set: (v: Nullable<INxaDropDownOption<any>>) => void;
+        update: (updateFn: (old: Nullable<INxaDropDownOption<any>>) => Nullable<INxaDropDownOption<any>>) => void;
+    };
+    set isOpen(value: boolean);
+    get isOpen(): boolean;
+    set label(value: string);
+    get label(): string;
+    set options(value: INxaDropDownOption[] | string[]);
+    get options(): INxaDropDownOption[] | string[];
+    set buttonTemplateRef(value: Nullable<TemplateRef<any>>);
+    get buttonTemplateRef(): Nullable<TemplateRef<any>>;
+    set itemTemplateRef(value: Nullable<TemplateRef<INxaDropDownOption>>);
+    get itemTemplateRef(): Nullable<TemplateRef<INxaDropDownOption>>;
+    set className(value: NxaClassList | null);
+    get className(): NxaClassList | null;
+    set value(value: Nullable<INxaDropDownOption> | T);
+    get value(): Nullable<INxaDropDownOption>;
+    valueChange: _angular_core.EventEmitter<Nullable<INxaDropDownOption<any>>>;
+    selectByValue(value: T): void;
+    selectItem(selectedItem: {
+        label: string;
+        value: any;
+    }): void;
+    protected _normalizedOptions: _angular_core.Signal<INxaDropDownOption<any>[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaDropdown<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaDropdown<any>, "nxa-dropdown", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "label": { "alias": "label"; "required": false; }; "options": { "alias": "options"; "required": false; }; "buttonTemplateRef": { "alias": "buttonTemplateRef"; "required": false; }; "itemTemplateRef": { "alias": "itemTemplateRef"; "required": false; }; "className": { "alias": "className"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class NxaFileInput implements ControlValueAccessor {
+    protected _multiFile: _angular_core.WritableSignal<boolean>;
+    protected _disabled: _angular_core.WritableSignal<boolean>;
+    protected _color: _angular_core.WritableSignal<"primary" | "secondary" | "accent" | "neutral" | "info" | "warning" | "error" | "success">;
+    protected _size: _angular_core.WritableSignal<"xs" | "sm" | "md" | "lg">;
+    protected _className: _angular_core.WritableSignal<string>;
+    protected _value: {
+        sig: _angular_core.WritableSignal<Nullable<FileList>>;
+        emitter: _angular_core.EventEmitter<Nullable<FileList>>;
+        get: () => Nullable<FileList>;
+        set: (v: Nullable<FileList>) => void;
+        update: (updateFn: (old: Nullable<FileList>) => Nullable<FileList>) => void;
+    };
+    set multiFile(value: boolean);
+    set disabled(value: boolean);
+    set color(value: NxaBrandColor | NxaStatusColor | NxaNeutralColor);
+    set size(value: Exclude<NxaSize, 'xl'>);
+    set className(value: string);
+    set value(value: Nullable<FileList>);
+    valueChange: _angular_core.EventEmitter<Nullable<FileList>>;
+    private onChange;
+    private onTouched;
+    protected computedInputNgClasses: _angular_core.Signal<{
+        [x: string]: boolean;
+    }>;
+    writeValue(obj: FileList): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    onFileSelected(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaFileInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaFileInput, "nxa-file-input", never, { "multiFile": { "alias": "multiFile"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "className": { "alias": "className"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class NxaRadio<T = any> {
+    protected _id: _angular_core.WritableSignal<string>;
+    set id(value: string);
+    get id(): string;
+    protected _name: _angular_core.WritableSignal<string>;
+    set name(value: string);
+    get name(): string;
+    protected _value: _angular_core.WritableSignal<Nullable<T>>;
+    set value(value: Nullable<T>);
+    get value(): Nullable<T>;
+    protected _checked: {
+        sig: _angular_core.WritableSignal<boolean>;
+        emitter: EventEmitter<boolean>;
+        get: () => boolean;
+        set: (v: boolean) => void;
+        update: (updateFn: (old: boolean) => boolean) => void;
+    };
+    set checked(value: boolean);
+    get checked(): boolean;
+    protected _disabled: _angular_core.WritableSignal<boolean>;
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    protected _color: _angular_core.WritableSignal<"primary" | "secondary" | "accent" | "neutral" | "info" | "warning" | "error" | "success">;
+    set color(value: NxaBrandColor | NxaStatusColor | NxaNeutralColor);
+    protected _size: _angular_core.WritableSignal<"xs" | "sm" | "md" | "lg">;
+    set size(value: Exclude<NxaSize, 'xl'>);
+    protected _className: _angular_core.WritableSignal<string>;
+    set className(value: string);
+    get className(): string;
+    private selectedChangeEffect;
+    selected: EventEmitter<void>;
+    checkedChange: EventEmitter<boolean>;
+    protected computedNgClasses: _angular_core.Signal<{
+        [x: string]: boolean;
+        disabled: boolean;
+        checked: boolean;
+    }>;
+    /** Called by group to set checked state */
+    setChecked(value: boolean): void;
+    /** Trigger selection event */
+    select(): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** For native input change if used directly */
+    onNativeChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaRadio<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaRadio<any>, "nxa-radio", never, { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, { "selected": "selected"; "checkedChange": "checkedChange"; }, never, ["[label]"], true, never>;
+}
+
+declare class NxaRadioGroup<T = any> implements AfterContentInit, ControlValueAccessor {
+    protected _radiosSig: _angular_core.Signal<readonly NxaRadio<any>[]>;
+    protected _selectedValue: {
+        sig: _angular_core.WritableSignal<Nullable<T>>;
+        emitter: _angular_core.EventEmitter<Nullable<T>>;
+        get: () => Nullable<T>;
+        set: (v: Nullable<T>) => void;
+        update: (updateFn: (old: Nullable<T>) => Nullable<T>) => void;
+    };
+    get selectedValue(): Nullable<T>;
+    set selectedValue(value: Nullable<T>);
+    protected _name: _angular_core.WritableSignal<string>;
+    set name(value: string);
+    get name(): string;
+    private onChange;
+    private onTouched;
+    ngAfterContentInit(): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    /** Sync all radios with the selected value */
+    private updateRadios;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaRadioGroup<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaRadioGroup<any>, "nxa-radio-group", never, { "selectedValue": { "alias": "selectedValue"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, {}, ["_radiosSig"], ["*"], true, never>;
+}
+
+declare class NxaRange implements ControlValueAccessor {
+    protected _min: _angular_core.WritableSignal<number>;
+    set min(value: number);
+    get min(): number;
+    protected _max: _angular_core.WritableSignal<number>;
+    set max(value: number);
+    get max(): number;
+    protected _step: _angular_core.WritableSignal<number>;
+    set step(value: number);
+    get step(): number;
+    protected _value: {
+        sig: _angular_core.WritableSignal<number>;
+        emitter: _angular_core.EventEmitter<number>;
+        get: () => number;
+        set: (v: number) => void;
+        update: (updateFn: (old: number) => number) => void;
+    };
+    set value(value: number);
+    get value(): number;
+    valueChange: _angular_core.EventEmitter<number>;
+    protected _disabled: _angular_core.WritableSignal<boolean>;
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    protected _size: _angular_core.WritableSignal<"xs" | "sm" | "md" | "lg">;
+    set size(size: Exclude<NxaSize, "xl">);
+    get size(): Exclude<NxaSize, "xl">;
+    protected _color: _angular_core.WritableSignal<"primary" | "secondary" | "accent" | "neutral" | "info" | "warning" | "error" | "success">;
+    set color(color: NxaBrandColor | NxaStatusColor | NxaNeutralColor);
+    get color(): NxaBrandColor | NxaStatusColor | NxaNeutralColor;
+    protected _className: _angular_core.WritableSignal<string>;
+    set className(value: string);
+    get className(): string;
+    protected computedNgClasses: _angular_core.Signal<Record<string, boolean>>;
+    private onChange;
+    private onTouched;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    onValueChange($event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaRange, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaRange, "nxa-range", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class NxaSelect<T = any> implements ControlValueAccessor {
+    /**
+     * doc protected
+     */
+    protected _id: _angular_core.WritableSignal<string>;
+    /**
+     * doc setter
+     */
+    set id(value: string);
+    /**
+     * doc getter
+     */
+    get id(): string;
+    protected _optionTemplateRef: _angular_core.WritableSignal<Nullable<TemplateRef<{
+        $implicit: T;
+    }>>>;
+    set optionTemplateRef(value: TemplateRef<{
+        $implicit: T;
+    }>);
+    get optionTemplateRef(): Nullable<TemplateRef<{
+        $implicit: T;
+    }>>;
+    protected _value: {
+        sig: _angular_core.WritableSignal<Nullable<T>>;
+        emitter: _angular_core.EventEmitter<Nullable<T>>;
+        get: () => Nullable<T>;
+        set: (v: Nullable<T>) => void;
+        update: (updateFn: (old: Nullable<T>) => Nullable<T>) => void;
+    };
+    set selected(value: Nullable<T>);
+    get selected(): Nullable<T>;
+    protected _options: _angular_core.WritableSignal<(T | {
+        label: string;
+        options: T[];
+    })[]>;
+    set options(values: (T | {
+        label: string;
+        options: T[];
+    })[]);
+    protected _disabled: _angular_core.WritableSignal<boolean>;
+    set disabled(value: boolean);
+    protected _color: _angular_core.WritableSignal<"primary" | "secondary" | "accent" | "neutral" | "info" | "warning" | "error" | "success">;
+    set color(value: NxaBrandColor | NxaStatusColor | NxaNeutralColor);
+    protected _size: _angular_core.WritableSignal<"xs" | "sm" | "md" | "lg">;
+    set size(value: Exclude<NxaSize, 'xl'>);
+    protected _className: _angular_core.WritableSignal<string>;
+    set className(value: string);
+    protected _compareFn: (a: T, b: T) => boolean;
+    set compareFn(value: (a: T, b: T) => boolean);
+    nxaSelectedChange: _angular_core.EventEmitter<Nullable<T>>;
+    protected computeNgClasses: _angular_core.Signal<{
+        [x: string]: boolean;
+    }>;
+    private onChange;
+    private onTouched;
+    isGroup(item: any): item is {
+        label: string;
+        options: T[];
+    };
+    protected getIndexFromValue(): number;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    selectedChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaSelect<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaSelect<any>, "nxa-select", never, { "id": { "alias": "id"; "required": false; }; "optionTemplateRef": { "alias": "optionTemplateRef"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "options": { "alias": "options"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "className": { "alias": "className"; "required": false; }; "compareFn": { "alias": "compareFn"; "required": false; }; }, { "nxaSelectedChange": "nxaSelectedChange"; }, never, ["[top-left]", "[top-right]", "[label]", "[bottom-left]", "[bottom-right]"], true, never>;
+}
+
+type NxaTextInputType = 'text' | 'email' | 'password' | 'search' | 'url' | 'tel' | 'number';
+declare const NxaTextInput_base: {
+    new (...args: any[]): {
+        _classBody: _angular_core.WritableSignal<NxaClassList | null>;
+        _classBodyObject: _angular_core.Signal<Record<string, boolean>>;
+    };
+} & {
+    new (...args: any[]): {
+        _className: _angular_core.WritableSignal<NxaClassList | null>;
+        readonly _classNameObject: _angular_core.Signal<"" | Record<string, boolean>>;
+    };
+} & {
+    new (): {};
+};
+declare class NxaTextInput extends NxaTextInput_base implements ControlValueAccessor, OnInit {
+    protected _placeholder: _angular_core.WritableSignal<string>;
+    /**
+     * Placeholder displayed Text
+     *  */
+    set placeholder(value: string);
+    get placeholder(): string;
+    protected _type: _angular_core.WritableSignal<NxaTextInputType>;
+    /**
+     * Input type (text, email, password, search, url, tel, number)
+     */
+    set type(value: NxaTextInputType);
+    get type(): NxaTextInputType;
+    protected _name: _angular_core.WritableSignal<Nullable<string>>;
+    /**
+     * Name Of Input Element
+     */
+    set name(value: Nullable<string>);
+    get name(): Nullable<string>;
+    protected _id: _angular_core.WritableSignal<Nullable<string>>;
+    /**
+     * Html element id
+     */
+    set id(value: Nullable<string>);
+    get id(): Nullable<string>;
+    protected _color: _angular_core.WritableSignal<"primary" | "secondary" | "accent" | "neutral" | "info" | "warning" | "error" | "success">;
+    /**
+     * Color of the input ( "primary" | "secondary" | "accent" | "info" | "success" | "warning" | "error" | "neutral")
+     */
+    set color(value: NxaBrandColor | NxaStatusColor | NxaNeutralColor);
+    get color(): NxaBrandColor | NxaStatusColor | NxaNeutralColor;
+    protected _size: _angular_core.WritableSignal<"xs" | "sm" | "md" | "lg">;
+    set size(value: Exclude<NxaSize, 'xl'>);
+    get size(): Exclude<NxaSize, "xl">;
+    protected _autocomplete: _angular_core.WritableSignal<string | undefined>;
+    set autocomplete(value: string | undefined);
+    get autocomplete(): string | undefined;
+    _maxlength: _angular_core.WritableSignal<number | undefined>;
+    set maxlength(value: number | undefined);
+    get maxlength(): number | undefined;
+    _minlength: _angular_core.WritableSignal<number | undefined>;
+    set minlength(value: number | undefined);
+    get minlength(): number | undefined;
+    _required: _angular_core.WritableSignal<boolean | undefined>;
+    set required(value: boolean | undefined);
+    get required(): boolean | undefined;
+    _readonly: _angular_core.WritableSignal<boolean | undefined>;
+    set readonly(value: boolean | undefined);
+    get readonly(): boolean | undefined;
+    set classBody(value: NxaClassList | null);
+    get classBody(): Nullable<NxaClassList>;
+    set className(value: NxaClassList | null);
+    get className(): Nullable<NxaClassList>;
+    _value: {
+        sig: _angular_core.WritableSignal<Nullable<string>>;
+        emitter: _angular_core.EventEmitter<Nullable<string>>;
+        get: () => Nullable<string>;
+        set: (v: Nullable<string>) => void;
+        update: (updateFn: (old: Nullable<string>) => Nullable<string>) => void;
+    };
+    set value(value: Nullable<string>);
+    get value(): Nullable<string>;
+    nxValueChange: _angular_core.EventEmitter<Nullable<string>>;
+    _disabled: _angular_core.WritableSignal<boolean>;
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    /** @ignore */
+    protected computedNgClasses: _angular_core.Signal<{
+        [x: string]: boolean;
+        disabled: boolean;
+    }>;
+    private onChange;
+    private onTouched;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onBlur(): void;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaTextInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaTextInput, "nxa-text-input", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "type": { "alias": "type"; "required": false; }; "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "classBody": { "alias": "classBody"; "required": false; }; "className": { "alias": "className"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "nxValueChange": "nxValueChange"; }, never, ["[left]", "[leading]", "[trailing]", "[right]", "[error-message]"], true, never>;
+}
+
+declare class NxaLinearLayout {
+    protected _className: _angular_core.WritableSignal<string>;
+    /**
+     * Allows the consumer to pass additional CSS classes to the component.
+     * These classes will be merged with the component's own classes,
+     * allowing for further customization of the layout's appearance and behavior.
+     * className="flex-col"
+     */
+    set className(value: string);
+    get className(): string;
+    protected _gap: _angular_core.WritableSignal<NxaCssLength>;
+    set gap(value: NxaCssLength);
+    get gap(): NxaCssLength;
+    protected _justify: _angular_core.WritableSignal<"center" | "start" | "end" | "between" | "around">;
+    set justify(value: 'start' | 'end' | 'center' | 'between' | 'around');
+    get justify(): "start" | "end" | "center" | "between" | "around";
+    protected _align: _angular_core.WritableSignal<"center" | "start" | "end" | "between" | "around">;
+    set align(value: 'start' | 'end' | 'center' | 'between' | 'around');
+    get align(): "start" | "end" | "center" | "between" | "around";
+    protected _wrap: _angular_core.WritableSignal<"nowrap" | "wrap" | "wrap-reverse">;
+    set wrap(value: "nowrap" | "wrap" | "wrap-reverse");
+    get wrap(): "nowrap" | "wrap" | "wrap-reverse";
+    protected _direction: _angular_core.WritableSignal<"col" | "row">;
+    set direction(value: 'col' | 'row');
+    get direction(): "col" | "row";
+    protected computedClasses: _angular_core.Signal<{}>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaLinearLayout, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaLinearLayout, "nxa-linear-layout", never, { "className": { "alias": "className"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; "justify": { "alias": "justify"; "required": false; }; "align": { "alias": "align"; "required": false; }; "wrap": { "alias": "wrap"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class NxaContainer {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaContainer, "nxa-container", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class NxaExpansionPanel {
+    protected _isOpen: {
+        sig: _angular_core.WritableSignal<boolean>;
+        emitter: _angular_core.EventEmitter<boolean>;
+        get: () => boolean;
+        set: (v: boolean) => void;
+        update: (updateFn: (old: boolean) => boolean) => void;
+    };
+    protected _className: _angular_core.WritableSignal<string>;
+    protected _classHeader: _angular_core.WritableSignal<string>;
+    protected _classBody: _angular_core.WritableSignal<string>;
+    set isOpen(value: boolean);
+    get isOpen(): boolean;
+    set className(value: string);
+    set classHeader(value: string);
+    set classBody(value: string);
+    isOpenChange: _angular_core.EventEmitter<boolean>;
+    headerClicked(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaExpansionPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaExpansionPanel, "nxa-expansion-panel", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "className": { "alias": "className"; "required": false; }; "classHeader": { "alias": "classHeader"; "required": false; }; "classBody": { "alias": "classBody"; "required": false; }; }, { "isOpenChange": "isOpenChange"; }, never, ["[expansion-header]", "[expansion-body]"], true, never>;
+}
+
+declare class NxaAccordion implements AfterContentInit {
+    /**
+     * Get Expansion Panel Children
+     */
+    protected expansionPanelsSig: _angular_core.Signal<readonly NxaExpansionPanel[]>;
+    /**
+     * Map Expansion Panel state into a signal
+     */
+    private expansionPanelStateSig;
+    /**
+     * Store old state
+     */
+    private _oldState?;
+    /**
+     * detect index of changed expansion panel (toggled) or NaN
+     */
+    private changedPanel;
+    private updatePanels;
+    ngAfterContentInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaAccordion, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaAccordion, "nxa-accordion", never, {}, {}, ["expansionPanelsSig"], ["nxa-expansion-panel"], true, never>;
+}
+
+declare const NxaCard_base: {
+    new (...args: any[]): {
+        _className: _angular_core.WritableSignal<NxaClassList | null>;
+        readonly _classNameObject: _angular_core.Signal<"" | Record<string, boolean>>;
+    };
+} & {
+    new (...args: any[]): {
+        _classHeader: _angular_core.WritableSignal<NxaClassList | null>;
+        _classHeaderObject: _angular_core.Signal<Record<string, boolean>>;
+    };
+} & {
+    new (...args: any[]): {
+        _classBody: _angular_core.WritableSignal<NxaClassList | null>;
+        _classBodyObject: _angular_core.Signal<Record<string, boolean>>;
+    };
+} & {
+    new (...args: any[]): {
+        _classFooter: _angular_core.WritableSignal<NxaClassList | null>;
+        _classFooterObject: _angular_core.Signal<Record<string, boolean>>;
+    };
+} & {
+    new (): {};
+};
+declare class NxaCard extends NxaCard_base {
+    protected _size: _angular_core.WritableSignal<"xs" | "sm" | "md" | "lg" | "xl">;
+    protected sizeComputed: _angular_core.Signal<{
+        [x: string]: boolean;
+    }>;
+    set size(size: NxaSize);
+    get size(): NxaSize;
+    set className(value: NxaClassList);
+    get className(): Nullable<NxaClassList>;
+    set classHeader(value: NxaClassList);
+    get classHeader(): Nullable<NxaClassList>;
+    set classBody(value: NxaClassList);
+    get classBody(): Nullable<NxaClassList>;
+    set classFooter(value: NxaClassList);
+    get classFooter(): Nullable<NxaClassList>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaCard, "nxa-card", never, { "size": { "alias": "size"; "required": false; }; "className": { "alias": "className"; "required": false; }; "classHeader": { "alias": "classHeader"; "required": false; }; "classBody": { "alias": "classBody"; "required": false; }; "classFooter": { "alias": "classFooter"; "required": false; }; }, {}, never, ["[card-image]", "[card-header]", "[card-body]", "[card-footer]", "[card-image-bottom]"], true, never>;
+}
+
+interface INxaDataGridHeader {
+    label: string;
+}
+interface INxaDataGrid<T = any> {
+    data: InputSignal<T[]>;
+    headers: InputSignal<T[]>;
+    headerRowTemplate: InputSignal<TemplateRef<any> | undefined>;
+    dataRowTemplate?: InputSignal<TemplateRef<any> | undefined>;
+}
+declare class NxaDatagrid<T = any> {
+    protected _data: _angular_core.WritableSignal<T[]>;
+    set data(value: T[]);
+    get data(): T[];
+    protected _headers: _angular_core.WritableSignal<INxaDataGridHeader[]>;
+    set headers(value: INxaDataGridHeader[]);
+    get headers(): INxaDataGridHeader[];
+    protected _headerRowTemplate: _angular_core.WritableSignal<TemplateRef<any> | undefined>;
+    set headerRowTemplate(value: TemplateRef<any> | undefined);
+    get headerRowTemplate(): TemplateRef<any> | undefined;
+    protected _dataRowTemplate: _angular_core.WritableSignal<TemplateRef<any> | undefined>;
+    set dataRowTemplate(value: TemplateRef<any> | undefined);
+    get dataRowTemplate(): TemplateRef<any> | undefined;
+    protected getObjectKeys(value: any): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaDatagrid<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaDatagrid<any>, "nxa-datagrid", never, { "data": { "alias": "data"; "required": false; }; "headers": { "alias": "headers"; "required": false; }; "headerRowTemplate": { "alias": "headerRowTemplate"; "required": false; }; "dataRowTemplate": { "alias": "dataRowTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface INxaListElement {
+    id: string | number;
+}
+declare class NxaDynamicList<T = INxaListElement> {
+    protected _rowTemplateRef: _angular_core.WritableSignal<Nullable<TemplateRef<any>>>;
+    set rowTemplateRef(value: Nullable<TemplateRef<any>>);
+    get rowTemplateRef(): Nullable<TemplateRef<any>>;
+    protected _data: _angular_core.WritableSignal<Nullable<T[]>>;
+    set data(value: Nullable<T[]>);
+    get data(): Nullable<T[]>;
+    protected _enableSorting: _angular_core.WritableSignal<boolean>;
+    set enableSorting(value: boolean);
+    get enableSorting(): boolean;
+    protected _enableDrop: _angular_core.WritableSignal<boolean>;
+    set enableDrop(value: boolean);
+    get enableDrop(): boolean;
+    protected _enableDrag: _angular_core.WritableSignal<boolean>;
+    set enableDrag(value: boolean);
+    get enableDrag(): boolean;
+    protected _rowHeight: _angular_core.WritableSignal<number>;
+    set rowHeight(value: number);
+    get rowHeight(): number;
+    elementSorted: EventEmitter<{
+        prevIndex: number;
+        currentIndex: number;
+    }>;
+    elementDropped(event: CdkDragDrop<T[]>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaDynamicList<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaDynamicList<any>, "nxa-dynamic-list", never, { "rowTemplateRef": { "alias": "rowTemplateRef"; "required": false; }; "data": { "alias": "data"; "required": false; }; "enableSorting": { "alias": "enableSorting"; "required": false; }; "enableDrop": { "alias": "enableDrop"; "required": false; }; "enableDrag": { "alias": "enableDrag"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; }, { "elementSorted": "elementSorted"; }, never, never, true, never>;
+}
+
+declare class NxaListTile {
+    protected _className: _angular_core.WritableSignal<string>;
+    set className(value: string);
+    get className(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaListTile, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaListTile, "nxa-list-tile", never, { "className": { "alias": "className"; "required": false; }; }, {}, never, ["[leading]", "*", "[trailing]"], true, never>;
+}
+
+declare const NxaNavbar_base: {
+    new (...args: any[]): {
+        _className: _angular_core.WritableSignal<NxaClassList | null>;
+        readonly _classNameObject: _angular_core.Signal<"" | Record<string, boolean>>;
+    };
+} & {
+    new (): {};
+};
+declare class NxaNavbar extends NxaNavbar_base {
+    protected _leadingTemplate: _angular_core.WritableSignal<Nullable<TemplateRef<any>>>;
+    set leadingTemplate(value: TemplateRef<any>);
+    get leadingTemplate(): Nullable<TemplateRef<any>>;
+    protected _contentTemplate: _angular_core.WritableSignal<Nullable<TemplateRef<any>>>;
+    set contentTemplate(value: TemplateRef<any>);
+    get contentTemplate(): Nullable<TemplateRef<any>>;
+    protected _trailingTemplate: _angular_core.WritableSignal<Nullable<TemplateRef<any>>>;
+    set trailingTemplate(value: TemplateRef<any>);
+    get trailingTemplate(): Nullable<TemplateRef<any>>;
+    set className(value: NxaClassList);
+    get className(): Nullable<NxaClassList>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaNavbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaNavbar, "nxa-navbar", never, { "leadingTemplate": { "alias": "leadingTemplate"; "required": false; }; "contentTemplate": { "alias": "contentTemplate"; "required": false; }; "trailingTemplate": { "alias": "trailingTemplate"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, {}, never, ["[leading]", "[content]", "[trailing]"], true, never>;
+}
+
+declare const NxaPage_base: {
+    new (...args: any[]): {
+        _className: _angular_core.WritableSignal<NxaClassList | null>;
+        readonly _classNameObject: _angular_core.Signal<"" | Record<string, boolean>>;
+    };
+} & {
+    new (...args: any[]): {
+        _classBody: _angular_core.WritableSignal<NxaClassList | null>;
+        _classBodyObject: _angular_core.Signal<Record<string, boolean>>;
+    };
+} & {
+    new (): {};
+};
+declare class NxaPage extends NxaPage_base implements OnInit, OnDestroy {
+    /**
+     *
+     */
+    protected drawerService: NxaDrawerService;
+    protected layoutService: NxaLayoutService;
+    protected nxaBreakpoints: Partial<Record<"sm" | "md" | "lg" | "xl" | "2xl", number>>;
+    protected _isRoot: _angular_core.WritableSignal<boolean>;
+    protected _drawer: _angular_core.WritableSignal<Nullable<TemplateRef<any>>>;
+    protected _navBar: _angular_core.WritableSignal<Nullable<TemplateRef<any>>>;
+    protected _contentFooter: _angular_core.WritableSignal<Nullable<TemplateRef<any>>>;
+    protected _pageFooter: _angular_core.WritableSignal<Nullable<TemplateRef<any>>>;
+    protected _sidebar: _angular_core.WritableSignal<Nullable<TemplateRef<any>>>;
+    protected _drawerId: _angular_core.WritableSignal<string>;
+    protected _drawerDefaultOpen: _angular_core.WritableSignal<boolean>;
+    protected _overlayFrom: _angular_core.WritableSignal<NxaBreakpoint>;
+    protected _currentBreakpoint: _angular_core.Signal<NxaBreakpoint | undefined>;
+    protected _oldBreakpoint: _angular_core.WritableSignal<NxaBreakpoint>;
+    protected _isOverlay: _angular_core.Signal<boolean>;
+    protected _computedNgClasses: _angular_core.Signal<{
+        'is-root': boolean;
+        'nxa-drawer-overlay': boolean;
+    }>;
+    /**
+   * fetch drawer state for this drawer
+   */
+    protected _drawerState$: Observable<NxaDrawerState | null | undefined>;
+    /**
+     * fetch drawe state for this drawer again
+     */
+    protected _drawerState: _angular_core.Signal<NxaDrawerState | null | undefined>;
+    set className(value: NxaClassList);
+    get className(): Nullable<NxaClassList>;
+    set classBody(value: NxaClassList);
+    get classBody(): Nullable<NxaClassList>;
+    /**
+     * if this page is root of the website page,
+     * set true if it's the base container of the app
+     */
+    set root(value: boolean);
+    /**
+     * drawer layout to display
+     */
+    set drawerTemplate(value: TemplateRef<any>);
+    /**
+     * navbar to display
+     */
+    set navBarTemplate(value: TemplateRef<any>);
+    /**
+     * footer for content
+     */
+    set contentFooterTemplate(value: TemplateRef<any>);
+    /**
+     * footer for the entire page
+     */
+    set pageFooterTemplate(value: TemplateRef<any>);
+    /**
+     * sidenav on the side of the page
+     */
+    set sidebarTemplate(value: TemplateRef<any>);
+    /**
+     *
+     */
+    set drawerId(value: string);
+    set drawerDefaultOpen(value: boolean);
+    set overlayFrom(value: NxaBreakpoint);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * handle changes in the value of the checkbox
+     * this sync the state between daisy ui component and service status
+     * @param event
+     */
+    protected valueChange(event: Event): void;
+    protected closeDrawer(): void;
+    /**
+     * handle the injection on host element of class root
+     * this is needed to allow the switch of style if root page
+     * */
+    get isRoot(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaPage, "nxa-page", never, { "className": { "alias": "className"; "required": false; }; "classBody": { "alias": "classBody"; "required": false; }; "root": { "alias": "root"; "required": false; }; "drawerTemplate": { "alias": "drawerTemplate"; "required": false; }; "navBarTemplate": { "alias": "navBarTemplate"; "required": false; }; "contentFooterTemplate": { "alias": "contentFooterTemplate"; "required": false; }; "pageFooterTemplate": { "alias": "pageFooterTemplate"; "required": false; }; "sidebarTemplate": { "alias": "sidebarTemplate"; "required": false; }; "drawerId": { "alias": "drawerId"; "required": false; }; "drawerDefaultOpen": { "alias": "drawerDefaultOpen"; "required": false; }; "overlayFrom": { "alias": "overlayFrom"; "required": false; }; }, {}, never, ["[navbar]", "*", "[sidenav]", "[content-footer]", "[drawer]", "[page-footer]"], true, never>;
+}
+
+declare class NxaTabDirective implements OnInit {
+    private readonly _tabId;
+    private readonly _tabIndex;
+    private readonly _openingIndex;
+    private readonly _isActive;
+    private readonly _title;
+    private readonly _icon;
+    private readonly _disabled;
+    private readonly _animationDuration;
+    private readonly _defaultAnimation;
+    get tabId(): string;
+    set tabId(value: string);
+    get tabIndex(): number;
+    set tabIndex(value: number);
+    get openingIndex(): number;
+    set openingIndex(value: number);
+    get isActive(): boolean;
+    set isActive(value: boolean);
+    get title(): string;
+    set title(value: string);
+    get icon(): string;
+    set icon(value: string);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get animationDuration(): number;
+    set animationDuration(value: number);
+    get defaultAnimation(): boolean;
+    set defaultAnimation(value: boolean);
+    private _tabState;
+    private _animationDelayEffect;
+    protected nxaTab: boolean;
+    protected fullHeight: boolean;
+    protected fullWidth: boolean;
+    protected left: number;
+    protected top: number;
+    protected right: number;
+    protected bottom: number;
+    protected position: string;
+    get display(): "none" | "block";
+    get isTabOpening(): boolean;
+    get isTabOpen(): boolean;
+    get isTabClosing(): boolean;
+    get isTabClose(): boolean;
+    get isClosingLeft(): boolean;
+    get isClosingRight(): boolean;
+    get isOpeningLeft(): boolean;
+    get isOpeningRight(): boolean;
+    protected get animateDefault(): boolean;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaTabDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NxaTabDirective, "[nxaTab]", never, { "tabId": { "alias": "tabId"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "openingIndex": { "alias": "openingIndex"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; "title": { "alias": "title"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "animationDuration": { "alias": "animationDuration"; "required": false; }; "defaultAnimation": { "alias": "defaultAnimation"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NxaTabView {
+    protected _tabType: _angular_core.WritableSignal<"border" | "lift" | "box">;
+    set tabType(value: 'border' | 'lift' | 'box');
+    get tabType(): "border" | "lift" | "box";
+    protected _tabSize: _angular_core.WritableSignal<"xs" | "sm" | "md" | "lg">;
+    set tabSize(value: Exclude<NxaSize, 'xl'>);
+    get tabSize(): Exclude<NxaSize, "xl">;
+    protected _className: _angular_core.WritableSignal<string>;
+    set className(value: string);
+    get className(): string;
+    protected _animate: _angular_core.WritableSignal<boolean>;
+    set animate(value: boolean);
+    get animate(): boolean;
+    tabs: _angular_core.Signal<readonly NxaTabDirective[]>;
+    updateTabState: _angular_core.EffectRef;
+    tabsLabelState: _angular_core.Signal<{
+        label: string;
+        active: boolean;
+    }[]>;
+    protected computedNgTabClass: _angular_core.Signal<{
+        [x: string]: boolean;
+    }>;
+    protected onTabclick(tabIndex: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaTabView, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaTabView, "nxa-tab-view", never, { "tabType": { "alias": "tabType"; "required": false; }; "tabSize": { "alias": "tabSize"; "required": false; }; "className": { "alias": "className"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; }, {}, ["tabs"], ["[nxaTab]"], true, never>;
+}
+
+declare const NxaBadge_base: {
+    new (...args: any[]): {
+        _className: _angular_core.WritableSignal<NxaClassList | null>;
+        readonly _classNameObject: _angular_core.Signal<"" | Record<string, boolean>>;
+    };
+} & {
+    new (): {};
+};
+declare class NxaBadge extends NxaBadge_base {
+    private domSanitizer;
+    protected _color: _angular_core.WritableSignal<"primary" | "secondary" | "accent" | "neutral" | "info" | "warning" | "error" | "success" | "content" | "ghost" | "link">;
+    protected _outlined: _angular_core.WritableSignal<boolean>;
+    protected _size: _angular_core.WritableSignal<"xs" | "sm" | "md" | "lg" | "xl">;
+    protected _label: _angular_core.WritableSignal<Nullable<string>>;
+    protected _icon: _angular_core.WritableSignal<Nullable<string>>;
+    set color(value: NxaColorAll);
+    get color(): NxaColorAll;
+    set outlined(value: boolean);
+    get outlined(): boolean;
+    set size(value: NxaSize);
+    get size(): NxaSize;
+    set label(value: Nullable<string>);
+    get label(): Nullable<string>;
+    set icon(value: Nullable<string>);
+    get icon(): string | null | undefined;
+    set className(value: NxaClassList | null);
+    get className(): NxaClassList | null;
+    protected computedClasses: _angular_core.Signal<{
+        [x: string]: boolean;
+        "badge-outline": boolean;
+    }>;
+    getIconHTML(): _angular_platform_browser.SafeHtml | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaBadge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaBadge, "nxa-badge", never, { "color": { "alias": "color"; "required": false; }; "outlined": { "alias": "outlined"; "required": false; }; "size": { "alias": "size"; "required": false; }; "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, {}, never, ["[leading]", "*", "[trailing]"], true, never>;
+}
+
+interface INxaDrawerBadge {
+    label?: string;
+    color?: NxaColorAll;
+    size?: NxaSize;
+    icon?: string;
+}
+interface INxaDrawerSection {
+    label: string;
+    entries: INxaDrawerEntry[];
+}
+interface INxaDrawerEntry {
+    label: string;
+    routerLink?: string[];
+    fragment?: string;
+    onClick?: () => void;
+    id?: string;
+    badge?: INxaDrawerBadge;
+    icon?: string;
+    defaultOpen?: boolean;
+    subEntries?: INxaDrawerEntry[];
+}
+declare class NxaDrawer {
+    private domSanitizer;
+    protected _headerContent: _angular_core.WritableSignal<TemplateRef<any> | null>;
+    set headerContent(value: TemplateRef<any> | null);
+    get headerContent(): TemplateRef<any> | null;
+    protected _footerContent: _angular_core.WritableSignal<TemplateRef<any> | null>;
+    set footerContent(value: TemplateRef<any> | null);
+    get footerContent(): TemplateRef<any> | null;
+    protected _menuEntries: _angular_core.WritableSignal<INxaDrawerSection[]>;
+    set menuEntries(value: INxaDrawerSection[]);
+    get menuEntries(): INxaDrawerSection[];
+    protected _className: _angular_core.WritableSignal<string>;
+    set className(value: string);
+    get className(): string;
+    getIconHtml(icon: string): _angular_platform_browser.SafeHtml;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaDrawer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaDrawer, "nxa-drawer", never, { "headerContent": { "alias": "headerContent"; "required": false; }; "footerContent": { "alias": "footerContent"; "required": false; }; "menuEntries": { "alias": "menuEntries"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NxaPagination {
+    protected _label: _angular_core.WritableSignal<string>;
+    set label(value: string);
+    get label(): string;
+    protected _totalPages: _angular_core.WritableSignal<number>;
+    set totalPages(value: number);
+    get totalPages(): number;
+    protected _currentPage: {
+        sig: _angular_core.WritableSignal<number>;
+        emitter: _angular_core.EventEmitter<number>;
+        get: () => number;
+        set: (v: number) => void;
+        update: (updateFn: (old: number) => number) => void;
+    };
+    set currentPage(value: number);
+    get currentPage(): number;
+    currentPageChange: _angular_core.EventEmitter<number>;
+    nextPage(): void;
+    prevPage(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaPagination, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaPagination, "nxa-pagination", never, { "label": { "alias": "label"; "required": false; }; "totalPages": { "alias": "totalPages"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; }, { "currentPageChange": "currentPageChange"; }, never, never, true, never>;
+}
+
+declare class NxaProgressApiCall {
+    private loadingService;
+    private isLoading;
+    get hidden(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaProgressApiCall, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaProgressApiCall, "nxa-progress-api-call", never, {}, {}, never, never, true, never>;
+}
+
+declare class NxaText {
+    private _layoutService;
+    private _screenSizeChanged;
+    protected _for: _angular_core.WritableSignal<string>;
+    set for(value: string);
+    get for(): string;
+    protected _useLabelTag: _angular_core.Signal<boolean>;
+    /**
+     * The type of text to render.
+     */
+    protected _type: _angular_core.WritableSignal<"label" | "title" | "paragraph" | "subtitle" | "caption">;
+    set type(value: 'title' | 'paragraph' | 'subtitle' | 'caption' | 'label');
+    get type(): "title" | "paragraph" | "subtitle" | "caption" | "label";
+    /**
+     * The size of the text.
+     * default depends on the type of text
+     */
+    protected _size: _angular_core.WritableSignal<Nullable<"xs" | "sm" | "md" | "lg" | "xl" | Partial<Record<NxaBreakpoint, "xs" | "sm" | "md" | "lg" | "xl">>>>;
+    set size(value: Nullable<NxaSize | Partial<Record<NxaBreakpoint, NxaSize>>>);
+    get size(): Nullable<NxaSize | Partial<Record<NxaBreakpoint, NxaSize>>>;
+    protected _computeSizeSuffix: _angular_core.Signal<"xs" | "sm" | "md" | "lg" | "xl">;
+    /**
+     * The weight of the text.
+     * default depends on the type of text
+     * Possible values: 'extralight', 'thin', 'light', 'normal', 'medium', 'semibold', 'bold', 'extrabold'
+     */
+    protected _weight: _angular_core.WritableSignal<Nullable<"light" | "extralight" | "thin" | "normal" | "medium" | "semibold" | "bold" | "extrabold">>;
+    set weight(value: Nullable<'extralight' | 'thin' | 'light' | 'normal' | 'medium' | 'semibold' | 'bold' | 'extrabold'>);
+    get weight(): Nullable<'extralight' | 'thin' | 'light' | 'normal' | 'medium' | 'semibold' | 'bold' | 'extrabold'>;
+    /**
+     * The italic style of the text.
+     * default false
+     */
+    protected _italic: _angular_core.WritableSignal<boolean>;
+    set italic(value: boolean);
+    get italic(): boolean;
+    /**
+     * The color of the text.
+     * default 'content'
+     * Possible values: 'primary', 'secondary', 'success', 'warning', 'error', 'content', 'info', 'neutral'
+     *
+     * Note: This is a custom color, not a tailwind color.
+     * You can use this to set the color of the text to any color you want.
+     */
+    protected _color: _angular_core.WritableSignal<Nullable<"primary" | "secondary" | "accent" | "neutral" | "info" | "warning" | "error" | "success" | "content">>;
+    set color(value: Nullable<NxaBrandColor | NxaStatusColor | NxaContentColor | NxaNeutralColor>);
+    get color(): Nullable<NxaBrandColor | NxaStatusColor | NxaContentColor | NxaNeutralColor>;
+    /**
+     * Custom class name to add to the text element.
+     * This can be used to add additional styles to the text element.
+     * It will be added to the computed classes of the text element.
+     *
+     * Note: use tailwind/ global classes to override local value, some time !important is required.
+     */
+    protected _className: _angular_core.WritableSignal<string>;
+    set className(value: string);
+    get className(): string;
+    protected computedClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaText, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaText, "nxa-text", never, { "for": { "alias": "for"; "required": false; }; "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "weight": { "alias": "weight"; "required": false; }; "italic": { "alias": "italic"; "required": false; }; "color": { "alias": "color"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const NxaToast_base: {
+    new (...args: any[]): {
+        overlayService: _nxa_lab_nxa_ui.NxaOverlayService;
+        overlayRef: _nxa_lab_nxa_ui.NxaOverlayRef<NxaToastModel>;
+        overlayData: NxaToastModel;
+    };
+} & NxaConstructor;
+declare class NxaToast extends NxaToast_base implements OnInit {
+    protected isVisible: _angular_core.WritableSignal<boolean>;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaToast, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaToast, "nxa-toast", never, {}, {}, never, never, true, never>;
+}
+
+declare class NxaTooltipDirective {
+    private viewContainerRef;
+    private tooltipComponentRef?;
+    private readonly _anchorId;
+    private readonly _tooltipMessage;
+    private readonly _direction;
+    set anchorId(value: string | null);
+    get anchorId(): string | null;
+    set tooltipMessage(value: string | null);
+    get tooltipMessage(): string | null;
+    set direction(value: NxaDirection | null);
+    get direction(): NxaDirection | null;
+    protected _relativeClass: boolean;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NxaTooltipDirective, "[nxaTooltip]", never, { "anchorId": { "alias": "anchorId"; "required": false; }; "tooltipMessage": { "alias": "tooltipMessage"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NxaTooltip {
+    protected _tooltipMessage: _angular_core.WritableSignal<string>;
+    set tooltipMessage(value: string);
+    get tooltipMessage(): string;
+    protected _anchorId: _angular_core.WritableSignal<string>;
+    set anchorId(value: string);
+    get anchorId(): string;
+    protected tooltipRef: _angular_core.Signal<HTMLElement>;
+    protected setAnchorEffect: _angular_core.EffectRef;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaTooltip, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxaTooltip, "nxa-tooltip", never, { "tooltipMessage": { "alias": "tooltipMessage"; "required": false; }; "anchorId": { "alias": "anchorId"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NxaAutoSizeDirective {
+    private _nxaAutoSize;
+    set nxaAutoSize(value: 'x' | 'y' | 'xy');
+    get height(): "100%" | null;
+    get flexGrow(): "1" | null;
+    get flexShrink(): "1" | null;
+    get flexBasis(): "0" | null;
+    get minHeight(): "0" | null;
+    get width(): "100%" | null;
+    get minWidth(): "0" | null;
+    position: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaAutoSizeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NxaAutoSizeDirective, "[nxaAutoSize]", never, { "nxaAutoSize": { "alias": "nxaAutoSize"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NxaForceSizeDirective implements AfterViewInit, OnDestroy {
+    private el;
+    private zone;
+    set nxaForceSize(value: 'x' | 'y' | 'xy');
+    private _nxaForceSize;
+    private _resizeObserver?;
+    hostWidth?: string;
+    hostHeight?: string;
+    ngAfterViewInit(): void;
+    private setDimensions;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxaForceSizeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NxaForceSizeDirective, "[nxaForceSize]", never, { "nxaForceSize": { "alias": "nxaForceSize"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const NxaLoadingInterceptor: HttpInterceptorFn;
+
+export { DEFAULT_TAILWIND_BREAKPOINTS, NXA_BRAND_COLORS, NXA_BREAKPOINTS, NXA_COLORS_ALL, NXA_CONTENT_COLORS, NXA_DEFAULT_DARK_THEME, NXA_DEFAULT_LIGHT_THEME, NXA_DEFAULT_THEME_BRIGHTNESS_MAP, NXA_HOST_BLOCK, NXA_HOST_CONTENTS_ONLY, NXA_HOST_LAYOUT, NXA_NEUTRAL_COLORS, NXA_OVERLAY_CONFIG_DEFAULTS, NXA_OVERLAY_DATA, NXA_PREFER_DARK_THEME, NXA_SIZES, NXA_STATUS_COLORS, NXA_THEME_BRIGHTNESS_MAP, NXA_THEME_LOADER, NXA_THEME_SAVING, NXA_TOAST_CONFIG_DEFAULTS, NxaAccordion, NxaAutoSizeDirective, NxaBadge, NxaButton, NxaCard, NxaCheckbox, NxaContainer, NxaDatagrid, NxaDateTimeInput, NxaDrawer, NxaDrawerService, NxaDropdown, NxaDynamicList, NxaExpansionPanel, NxaFileInput, NxaForceSizeDirective, NxaFormControl, NxaLayoutService, NxaLinearLayout, NxaListTile, NxaLoadingInterceptor, NxaLoadingService, NxaNavbar, NxaOverlayBase, NxaOverlayBaseMixin, NxaOverlayRef, NxaOverlayService, NxaPage, NxaPagination, NxaProgressApiCall, NxaRadio, NxaRadioGroup, NxaRange, NxaSelect, NxaTabDirective, NxaTabView, NxaText, NxaTextInput, NxaThemeService, NxaToast, NxaToastService, NxaTooltip, NxaTooltipDirective, SKIP_LOADING, WithClassBodyMixin, WithClassFooterMixin, WithClassHeaderMixin, WithClassName, WithClassNameMixin, applyMixins, deepEqual, getStyleVariable, isBrowserContext, isServerContext, sanitizeIcon, shallowEqual };
+export type { INxaDataGrid, INxaDataGridHeader, INxaDrawerBadge, INxaDrawerEntry, INxaDrawerSection, INxaDropDownOption, INxaListElement, INxaOverlay, Nullable, NxaBrandColor, NxaBreakpoint, NxaBreakpointMap, NxaClassList, NxaColorAll, NxaConstructor, NxaContentColor, NxaCssLength, NxaDirection, NxaDrawerState, NxaNeutralColor, NxaOverlayConfig, NxaSize, NxaStatusColor, NxaTextInputType, NxaThemeLoaderFn, NxaToastConfig, NxaToastModel };