@ngbase/adk 0.1.17 → 0.1.18

package/schematics/components/files/theme/theme.service.ts.template

@@ -8,15 +8,15 @@ export class ThemeService {
   constructor() {
     if (isClient()) {
       const theme = localStorage.getItem('theme');
-      this._update((theme as 'light' | 'dark') || 'light');
+      this.setMode((theme as 'light' | 'dark') || 'light');
     }
   }
 
   toggle() {
-    this._update(this.mode() === 'dark' ? 'light' : 'dark');
+    this.setMode(this.mode() === 'dark' ? 'light' : 'dark');
   }
 
-  private _update(mode: 'light' | 'dark' = 'light') {
+  setMode(mode: 'light' | 'dark' = 'light') {
     const body = document.body;
     if (mode === 'dark') {
       body.classList.add('dark');

package/schematics/components/files/toggle/toggle.ts.template

@@ -7,7 +7,7 @@ import { NgbToggle } from '@ngbase/adk/toggle';
   hostDirectives: [{ directive: NgbToggle, inputs: ['value'], outputs: ['valueChange'] }],
   template: `<ng-content />`,
   host: {
-    class: 'block w-9 h-9 rounded relative aria-[pressed=true]:bg-foreground',
+    class: 'block w-9 h-9 rounded relative aria-[pressed=true]:bg-muted',
   },
 })
 export class Toggle {}

package/schematics/components/files/toggle-group/toggle-group.ts.template

@@ -19,7 +19,7 @@ export class ToggleGroup<T> {}
   hostDirectives: [{ directive: NgbToggleItem, inputs: ['disabled', 'value'] }],
   host: {
     class:
-      'inline-block rounded h-9 px-3 hover:bg-opacity-80 active:bg-opacity-70 aria-[selected=true]:bg-foreground',
+      'inline-block rounded h-9 px-3 hover:bg-opacity-80 active:bg-opacity-70 aria-[selected=true]:bg-muted',
   },
 })
 export class ToggleItem<T> {}

package/schematics/components/files/tooltip/tooltip.ts.template

@@ -1,11 +1,10 @@
 import { ChangeDetectionStrategy, Component, Directive } from '@angular/core';
 import { injectTheme } from '<%= basepath %>/theme';
-import { NgbPopoverArrow, providePopoverArrowTracker } from '@ngbase/adk/popover';
+import { NgbPopoverArrow, NgbPopoverArrowHost, providePopoverArrowTracker } from '@ngbase/adk/popover';
 import {
   NgbTooltip,
   NgbTooltipTemplate,
   provideNgbTooltipOptions,
-  tooltipAnimation,
   TooltipOptions,
 } from '@ngbase/adk/tooltip';
 
@@ -24,6 +23,7 @@ export class Tooltip {}
   selector: '<%= name %>-tooltip',
   changeDetection: ChangeDetectionStrategy.OnPush,
   providers: [providePopoverArrowTracker()],
+  hostDirectives: [NgbPopoverArrowHost],
   imports: [NgbPopoverArrow],
   template: `<div ngbPopoverArrow>{{ content() }}</div>`,
   host: {
@@ -31,7 +31,6 @@ export class Tooltip {}
       'fixed inline-block rounded-lg bg-background px-3 py-1 border shadow-md z-p whitespace-pre-line max-w-[15rem] text-text',
     '[class]': `theme.mode() === 'dark' ? 'light' : 'dark'`,
   },
-  animations: [tooltipAnimation],
 })
 export class TooltipComponent extends NgbTooltipTemplate {
   readonly theme = injectTheme();

package/{accordion/index.d.ts → types/ngbase-adk-accordion.d.ts}

@@ -1,6 +1,5 @@
 import * as _angular_core from '@angular/core';
 import * as i1 from '@ngbase/adk/utils';
-import * as _angular_animations from '@angular/animations';
 
 declare class NgbAccordion {
     private accordionService;
@@ -39,6 +38,5 @@ declare class NgbAccordionContent {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbAccordionContent, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbAccordionContent, "[ngbAccordionContent]", ["ngbAccordionContent"], {}, {}, never, never, true, never>;
 }
-declare const slideAnimation: _angular_animations.AnimationTriggerMetadata;
 
-export { NgbAccordion, NgbAccordionContent, NgbAccordionGroup, NgbAccordionHeader, aliasAccordion, slideAnimation };
+export { NgbAccordion, NgbAccordionContent, NgbAccordionGroup, NgbAccordionHeader, aliasAccordion };

package/{autocomplete/index.d.ts → types/ngbase-adk-autocomplete.d.ts}

@@ -1,4 +1,3 @@
-import * as _angular_forms from '@angular/forms';
 import * as _angular_core from '@angular/core';
 import { ElementRef, Type } from '@angular/core';
 import { NgbChip } from '@ngbase/adk/chip';
@@ -39,14 +38,10 @@ declare class NgbAutocomplete<T> extends SelectBase<T> {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbAutocomplete<any>, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbAutocomplete<any>, "[ngbAutocomplete]", never, { "filterFn": { "alias": "filterFn"; "required": false; "isSignal": true; }; "queryFn": { "alias": "queryFn"; "required": false; "isSignal": true; }; "filterOptions": { "alias": "filterOptions"; "required": false; "isSignal": true; }; }, {}, ["searchInput", "chips"], never, true, never>;
 }
-declare function aliasAutocomplete<T>(autocomplete: Type<NgbAutocomplete<T>>): (({
-    provide: _angular_core.InjectionToken<readonly _angular_forms.ControlValueAccessor[]>;
-    useExisting: Type<any>;
-    multi: boolean;
-} | {
+declare function aliasAutocomplete<T>(autocomplete: Type<NgbAutocomplete<T>>): ({
     provide: typeof SelectBase;
     useExisting: Type<NgbAutocomplete<T>>;
-})[] | {
+}[] | {
     provide: typeof NgbAutocomplete;
     useExisting: Type<NgbAutocomplete<T>>;
 })[];

package/{checkbox/index.d.ts → types/ngbase-adk-checkbox.d.ts}

@@ -1,33 +1,27 @@
 import * as _angular_core from '@angular/core';
-import { ControlValueAccessor } from '@angular/forms';
+import { FormCheckboxControl } from '@angular/forms/signals';
 
 declare class CheckboxButton {
     readonly checkbox: NgbCheckbox;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxButton, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CheckboxButton, "button[ngbCheckboxButton]", never, {}, {}, never, never, true, never>;
 }
-declare class NgbCheckbox implements ControlValueAccessor {
+declare class NgbCheckbox implements FormCheckboxControl {
     readonly id: string;
     readonly checked: _angular_core.ModelSignal<boolean>;
     readonly disabled: _angular_core.InputSignal<boolean>;
     readonly indeterminate: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
     readonly change: _angular_core.OutputEmitterRef<boolean>;
-    onChange: (_: any) => void;
-    onTouched: () => void;
     updateValue(): void;
-    writeValue(value: any): void;
-    registerOnChange(fn: any): void;
-    registerOnTouched(fn: any): void;
+    onTouched(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbCheckbox, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbCheckbox, "[ngbCheckbox]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "change": "change"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbCheckbox, "[ngbCheckbox]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "touched": "touchedChange"; "change": "change"; }, never, never, true, never>;
 }
-declare function aliasCheckbox(checkbox: typeof NgbCheckbox): ({
-    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
-    useExisting: _angular_core.Type<any>;
-    multi: boolean;
-} | {
+declare function aliasCheckbox(checkbox: typeof NgbCheckbox): {
     provide: typeof NgbCheckbox;
     useExisting: typeof NgbCheckbox;
-})[];
+}[];
 
 export { CheckboxButton, NgbCheckbox, aliasCheckbox };

package/types/ngbase-adk-clipboard.d.ts

@@ -0,0 +1,12 @@
+import * as _angular_core from '@angular/core';
+
+declare class CopyToClipboard {
+    readonly ngbCopyToClipboard: _angular_core.InputSignal<string | undefined>;
+    readonly afterCopy: _angular_core.OutputEmitterRef<void>;
+    onClick(event: MouseEvent): void;
+    _copyToClipboard(text: string): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopyToClipboard, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CopyToClipboard, "[ngbCopyToClipboard]", never, { "ngbCopyToClipboard": { "alias": "ngbCopyToClipboard"; "required": false; "isSignal": true; }; }, { "afterCopy": "afterCopy"; }, never, never, true, never>;
+}
+
+export { CopyToClipboard };

package/{color-picker/index.d.ts → types/ngbase-adk-color-picker.d.ts}

@@ -1,8 +1,7 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, EffectRef } from '@angular/core';
 import * as i1 from '@ngbase/adk/drag';
-import * as _angular_forms from '@angular/forms';
-import { ControlValueAccessor } from '@angular/forms';
+import { FormValueControl } from '@angular/forms/signals';
 
 type ColorFormat = 'hex' | 'rgb' | 'hsl' | 'hsb';
 declare class ColorSpectrum {
@@ -75,32 +74,10 @@ declare class NgbColorPicker {
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgbColorPicker, "ngb-color-picker-container", never, { "format": { "alias": "format"; "required": false; "isSignal": true; }; "presetColors": { "alias": "presetColors"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
 }
 
-declare class NgbColorInput implements ControlValueAccessor {
-    readonly format: i0.InputSignal<ColorFormat>;
-    readonly presetColors: i0.InputSignal<string[] | undefined>;
-    readonly value: i0.ModelSignal<string>;
-    onChange: (_: string) => void;
-    onTouched: () => void;
-    updateValue(value?: string): void;
-    writeValue(value: string): void;
-    registerOnChange(fn: any): void;
-    registerOnTouched(fn: any): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbColorInput, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbColorInput, "[ngbColorInput]", never, { "format": { "alias": "format"; "required": false; "isSignal": true; }; "presetColors": { "alias": "presetColors"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
-}
-
-interface ColorPickerOptions {
-    picker: typeof NgbColorPicker;
-    accessor: typeof NgbColorInput;
-}
-declare const registerColorPicker: ({ picker, accessor }: ColorPickerOptions) => ({
-    provide: InjectionToken<readonly _angular_forms.ControlValueAccessor[]>;
-    useExisting: i0.Type<any>;
-    multi: boolean;
-} | {
+declare const registerColorPicker: (picker: typeof NgbColorPicker) => {
     provide: InjectionToken<typeof NgbColorPicker>;
     useValue: typeof NgbColorPicker;
-})[];
+}[];
 declare class ColorPickerTrigger {
     private el;
     private colorPicker;
@@ -115,5 +92,16 @@ declare class ColorPickerTrigger {
     static ɵdir: i0.ɵɵDirectiveDeclaration<ColorPickerTrigger, "[ngbColorPickerTrigger]", never, { "format": { "alias": "format"; "required": false; "isSignal": true; }; "presetColors": { "alias": "presetColors"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
 }
 
+declare class NgbColorInput implements FormValueControl<string> {
+    readonly format: i0.InputSignal<ColorFormat>;
+    readonly presetColors: i0.InputSignal<string[] | undefined>;
+    readonly value: i0.ModelSignal<string>;
+    readonly touched: i0.ModelSignal<boolean>;
+    readonly disabled: i0.InputSignal<boolean>;
+    updateValue(val?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbColorInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbColorInput, "[ngbColorInput]", never, { "format": { "alias": "format"; "required": false; "isSignal": true; }; "presetColors": { "alias": "presetColors"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
 export { ColorAlpha, ColorAlphaThumb, ColorHue, ColorHueThumb, ColorPickerTrigger, ColorSelected, ColorSpectrum, ColorSpectrumSelector, NgbColorInput, NgbColorPicker, registerColorPicker };
 export type { ColorFormat };

package/{datepicker/index.d.ts → types/ngbase-adk-datepicker.d.ts}

@@ -1,6 +1,6 @@
 import * as _ngbase_adk_datepicker from '@ngbase/adk/datepicker';
 import * as _angular_core from '@angular/core';
-import { ElementRef, TemplateRef, Signal, InjectionToken, Injector, OnDestroy } from '@angular/core';
+import { Signal, TemplateRef, ElementRef, InjectionToken, Injector, OnDestroy } from '@angular/core';
 import * as i1$1 from '@ngbase/adk/a11y';
 import { AccessibleGroup, AccessibleItem } from '@ngbase/adk/a11y';
 import { Directionality } from '@ngbase/adk/bidi';
@@ -9,7 +9,7 @@ import * as _ngbase_adk_portal from '@ngbase/adk/portal';
 import * as i1 from '@ngbase/adk/form-field';
 import { InputBase } from '@ngbase/adk/form-field';
 import { NgbSelectTarget } from '@ngbase/adk/select';
-import { ControlValueAccessor } from '@angular/forms';
+import { FormValueControl } from '@angular/forms/signals';
 import * as i1$2 from '@ngbase/adk/utils';
 import { NumberOnly } from '@ngbase/adk/utils';
 
@@ -249,36 +249,27 @@ declare class NgbTimeInput {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTimeInput, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTimeInput, "[ngbTimeInput]", never, { "ngbTimeInput": { "alias": "ngbTimeInput"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.NumberOnly; inputs: { "value": "value"; }; outputs: { "valueChange": "valueChange"; }; }]>;
 }
-declare class NgbTimePicker implements ControlValueAccessor {
+declare class NgbTimePicker implements FormValueControl<string | null | undefined> {
     readonly is24: _angular_core.InputSignal<boolean>;
-    readonly value: _angular_core.InputSignal<string | null | undefined>;
-    readonly valueChange: _angular_core.OutputEmitterRef<string | null | undefined>;
+    readonly value: _angular_core.ModelSignal<string | null | undefined>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
     private time;
     readonly hours: _angular_core.WritableSignal<string>;
     readonly minutes: _angular_core.WritableSignal<string>;
     readonly seconds: _angular_core.WritableSignal<string>;
     readonly am: _angular_core.WritableSignal<boolean>;
-    private onChange;
-    private onTouched;
     constructor();
     private parseValue;
     changeAm(active: boolean): void;
     updateValue(): void;
-    private notify;
-    writeValue(value: string): void;
-    registerOnChange(fn: any): void;
-    registerOnTouched(fn: any): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTimePicker, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTimePicker, "[ngbTime]", never, { "is24": { "alias": "is24"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTimePicker, "[ngbTime]", never, { "is24": { "alias": "is24"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
 }
-declare function aliasTimePicker(picker: typeof NgbTimePicker): ({
-    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
-    useExisting: _angular_core.Type<any>;
-    multi: boolean;
-}[] | {
+declare function aliasTimePicker(picker: typeof NgbTimePicker): {
     provide: typeof NgbTimePicker;
     useExisting: typeof NgbTimePicker;
-})[];
+}[];
 
 type NgbDateUnits = 'year' | 'month' | 'date' | 'hour' | 'minute' | 'second' | 'millisecond';
 interface NgbAdpterInterface<D> {

package/{dialog/index.d.ts → types/ngbase-adk-dialog.d.ts}

@@ -1,10 +1,9 @@
 import * as i2 from '@ngbase/adk/portal';
-import { DialogOptions, BaseDialog, DialogInput } from '@ngbase/adk/portal';
+import { BaseDialog, DialogOptions, DialogInput } from '@ngbase/adk/portal';
 import * as i0 from '@angular/core';
 import { ViewContainerRef } from '@angular/core';
 import { Subject } from 'rxjs';
 import * as i1 from '@ngbase/adk/a11y';
-import { AnimationTriggerMetadata } from '@angular/animations';
 
 declare class NgbDialogMain {
     readonly dialog: NgbDialogContainer;
@@ -29,14 +28,13 @@ declare class NgbDialogBackdrop {
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDialogBackdrop, "[ngbDialogBackdrop]", never, {}, {}, never, never, true, never>;
 }
 declare class NgbDialogContainer extends BaseDialog {
-    readonly myDialog: i0.Signal<ViewContainerRef | undefined>;
+    readonly contentContainer: i0.Signal<ViewContainerRef | undefined>;
     backdropColor: boolean;
     isSidePopup: boolean;
     readonly onDone: Subject<any>;
     readonly options: i0.WritableSignal<DialogOptions<any>>;
     readonly showBackdrop: i0.Signal<boolean | undefined>;
     isHideHeader: boolean;
-    constructor();
     setOptions(options: DialogOptions): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgbDialogContainer, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDialogContainer, "[ngbDialog]", never, {}, {}, never, never, true, [{ directive: typeof i1.FocusTrap; inputs: {}; outputs: {}; }]>;
@@ -56,8 +54,5 @@ declare function ngbDialogPortal(component: typeof NgbDialogContainer): {
 };
 type NgbDialog = ReturnType<typeof ngbDialogPortal>;
 
-declare const sideAnimation: AnimationTriggerMetadata;
-declare const viewAnimation: AnimationTriggerMetadata;
-
-export { NgbDialogBackdrop, NgbDialogClose, NgbDialogContainer, NgbDialogMain, aliasDialog, ngbDialogPortal, sideAnimation, viewAnimation };
+export { NgbDialogBackdrop, NgbDialogClose, NgbDialogContainer, NgbDialogMain, aliasDialog, ngbDialogPortal };
 export type { NgbDialog };

package/types/ngbase-adk-form-field.d.ts

@@ -0,0 +1,88 @@
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+import { AbstractControl } from '@angular/forms';
+import * as _angular_forms_signals from '@angular/forms/signals';
+import { FormField, FormValueControl } from '@angular/forms/signals';
+
+declare class NgbInputError {
+    private readonly formField;
+    readonly ngbError: _angular_core.InputSignal<string>;
+    readonly invalid: _angular_core.InputSignal<boolean | undefined>;
+    readonly animate: _angular_core.WritableSignal<boolean>;
+    private readonly errorNames;
+    readonly isFieldInvalid: _angular_core.Signal<boolean>;
+    fieldInvalidFn(control: FormField<any>): boolean;
+    readonly isInvalid: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbInputError, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbInputError, "[ngbError]", never, { "ngbError": { "alias": "ngbError"; "required": true; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare function markControlsTouched(control: AbstractControl, options?: {
+    touched: boolean;
+    dirty: boolean;
+}): void;
+
+declare class NgbFormField {
+    readonly _control: Signal<FormField<any> | undefined>;
+    readonly _id: string;
+    readonly status: Signal<_angular_forms_signals.CompatFieldState<any, string | number> | undefined>;
+    private readonly _invalid;
+    readonly errors: Signal<readonly NgbInputError[]>;
+    readonly hasErrors: Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbFormField, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbFormField, "ngb-form-field, [ngbFormField]", never, {}, {}, ["_control", "errors"], never, true, never>;
+}
+
+declare class InputBase<T = unknown> implements FormValueControl<T> {
+    readonly formField: NgbFormField | null;
+    readonly value: _angular_core.ModelSignal<T>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly id: string;
+    readonly displayValue: _angular_core.Signal<any>;
+    protected setInputValue(ev: Event): void;
+    onTouched(): void;
+    setValue(value: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputBase<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InputBase<any>, "input[ngbInputBase]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+declare class AutoHeight {
+    private el;
+    private model;
+    private ngbInput;
+    readonly maxHeight: _angular_core.InputSignal<number | undefined>;
+    constructor();
+    private update;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutoHeight, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AutoHeight, "textarea[ngbAutoHeight]", never, { "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NgbLabel {
+    private readonly formField;
+    readonly id: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbLabel, "[ngbLabel]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NumberFormat extends InputBase {
+    private readonly el;
+    readonly decimals: _angular_core.InputSignal<number>;
+    readonly decimalSeparator: _angular_core.InputSignal<string>;
+    readonly thousandSeparator: _angular_core.InputSignal<string>;
+    displayValue: _angular_core.Signal<any>;
+    private readonly specialKeys;
+    setValue(value: any): void;
+    onKeyDown(event: KeyboardEvent): void;
+    private cleanValue;
+    private isValidNumber;
+    private formatDisplayValue;
+    private updateCursorPosition;
+    private countSeparators;
+    private isDecimalPartFull;
+    private escapeRegExp;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberFormat, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NumberFormat, "[numberFormat]", never, { "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "decimalSeparator": { "alias": "decimalSeparator"; "required": false; "isSignal": true; }; "thousandSeparator": { "alias": "thousandSeparator"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { AutoHeight, InputBase, NgbFormField, NgbInputError, NgbLabel, NumberFormat, markControlsTouched };

package/{inline-edit/index.d.ts → types/ngbase-adk-inline-edit.d.ts}

@@ -1,6 +1,6 @@
 import * as _angular_core from '@angular/core';
 import { ElementRef } from '@angular/core';
-import { ControlValueAccessor } from '@angular/forms';
+import { FormValueControl } from '@angular/forms/signals';
 import * as i1 from '@ngbase/adk/form-field';
 import { InputBase } from '@ngbase/adk/form-field';
 
@@ -16,38 +16,30 @@ declare class NgbInlineValue {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbInlineValue, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbInlineValue, "[ngbInlineValue]", never, {}, {}, never, never, true, never>;
 }
-declare class NgbInlineEdit implements ControlValueAccessor {
+declare class NgbInlineEdit implements FormValueControl<string> {
     private readonly el;
     private readonly disposals;
     readonly inputElement: _angular_core.Signal<ElementRef<any> | undefined>;
-    readonly value: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
     readonly editOn: _angular_core.InputSignal<"click" | "dblclick">;
-    readonly valueChange: _angular_core.OutputEmitterRef<string>;
     readonly afterEdit: _angular_core.OutputEmitterRef<string>;
     readonly localValue: _angular_core.WritableSignal<string>;
     readonly isEditing: _angular_core.WritableSignal<boolean>;
     readonly inputWidth: _angular_core.WritableSignal<number>;
-    onChange?: (value: string) => void;
-    onTouched?: () => void;
     onClick(): void;
     onDoubleClick(): void;
     startEditing(): void;
     onBlur(): void;
     onEnter(ev: Event): void;
     updateValue(newValue: string): void;
-    registerOnChange(fn: any): void;
-    registerOnTouched(fn: any): void;
-    writeValue(value: string): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbInlineEdit, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbInlineEdit, "[ngbInlineEdit]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "editOn": { "alias": "editOn"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "afterEdit": "afterEdit"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbInlineEdit, "[ngbInlineEdit]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "editOn": { "alias": "editOn"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "afterEdit": "afterEdit"; }, never, never, true, never>;
 }
-declare function aliasInlineEdit(inlineEdit: typeof NgbInlineEdit): ({
-    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
-    useExisting: _angular_core.Type<any>;
-    multi: boolean;
-} | {
+declare function aliasInlineEdit(inlineEdit: typeof NgbInlineEdit): {
     provide: typeof NgbInlineEdit;
     useExisting: typeof NgbInlineEdit;
-})[];
+}[];
 
 export { NgbInlineEdit, NgbInlineInput, NgbInlineValue, aliasInlineEdit };

package/{menu/index.d.ts → types/ngbase-adk-menu.d.ts}

@@ -27,9 +27,6 @@ declare class NgbMenuTrigger {
         type: "enter" | "leave" | "click";
         menu: NgbMenuTrigger;
     }>;
-    private closeParent;
-    private delayTimer;
-    private isMouseOverTrigger;
     constructor();
     private get menu();
     get rootParent(): NgbMenu | null;
@@ -45,6 +42,7 @@ declare class NgpMenuGroup {
     readonly menu: NgbMenu;
     readonly allyGroup: AccessibleGroup;
     constructor();
+    onClick(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpMenuGroup, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpMenuGroup, "[ngbMenuGroup]", never, {}, {}, never, never, true, [{ directive: typeof i1.AccessibleGroup; inputs: {}; outputs: {}; }]>;
 }
@@ -76,10 +74,13 @@ declare class NgbMenu implements OnDestroy {
     readonly activeOption: BehaviorSubject<NgbOption<any> | NgbList | null>;
     isOpen: boolean;
     constructor();
-    open(options: PopoverOptions, subMenu?: boolean): void;
+    open(options: PopoverOptions, subMenu?: boolean, parentDiaRef?: DialogRef): void;
     opened(): void;
     get rootParent(): NgbMenu | undefined;
-    close: (data?: any) => void;
+    close: (data?: any, options?: {
+        closeParent?: boolean;
+    }) => void;
+    closeWithParent: (data?: any) => void;
     ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbMenu, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbMenu, "[ngbMenu]", ["ngbMenu"], { "noAutoClose": { "alias": "noAutoClose"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, ["content", "options", "lists"], never, true, never>;

package/{otp/index.d.ts → types/ngbase-adk-otp.d.ts}

@@ -1,6 +1,6 @@
 import * as _angular_core from '@angular/core';
 import { ElementRef } from '@angular/core';
-import { ControlValueAccessor } from '@angular/forms';
+import { FormValueControl } from '@angular/forms/signals';
 
 declare class NgbOtpInput {
     readonly otp: NgbInputOtp;
@@ -18,34 +18,26 @@ declare class NgbOtpValue {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbOtpValue, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbOtpValue, "[ngbOtpValue]", never, {}, {}, never, never, true, never>;
 }
-declare class NgbInputOtp implements ControlValueAccessor {
+declare class NgbInputOtp implements FormValueControl<string> {
     private readonly inputs;
     readonly _otpValues: _angular_core.Signal<readonly NgbOtpValue[]>;
     readonly size: _angular_core.InputSignal<number[]>;
     readonly masked: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly disabled: _angular_core.InputSignal<boolean>;
     readonly no: _angular_core.Signal<number>;
-    private onChange?;
-    private onTouched?;
     private lastValue;
-    readonly values: _angular_core.WritableSignal<string>;
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
     readonly focused: _angular_core.WritableSignal<boolean>;
     constructor();
     private updateNewValue;
-    writeValue(value: string): void;
-    updateValue(values: string): void;
-    registerOnChange(fn: any): void;
-    registerOnTouched(fn: any): void;
+    updateValue(val: string): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbInputOtp, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbInputOtp, "[ngbInputOtp]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "masked": { "alias": "masked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbInputOtp, "[ngbInputOtp]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "masked": { "alias": "masked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
 }
-declare function aliasInputOtp(otp: typeof NgbInputOtp): ({
-    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
-    useExisting: _angular_core.Type<any>;
-    multi: boolean;
-}[] | {
+declare function aliasInputOtp(otp: typeof NgbInputOtp): {
     provide: typeof NgbInputOtp;
     useExisting: typeof NgbInputOtp;
-})[];
+}[];
 
 export { NgbInputOtp, NgbOtpInput, NgbOtpValue, aliasInputOtp };

package/{popover/index.d.ts → types/ngbase-adk-popover.d.ts}

@@ -21,11 +21,11 @@ declare class NgbPopoverMain {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbPopoverMain, "[ngbPopoverMain]", never, {}, {}, never, never, true, never>;
 }
 declare class NgbPopover extends BaseDialog {
+    readonly contentContainer: _angular_core.Signal<ViewContainerRef | undefined>;
     readonly arrowTracker: {
         values: _angular_core.WritableSignal<_ngbase_adk_popover.PopoverArrowTracker>;
     };
     private readonly disposals;
-    readonly myDialog: _angular_core.Signal<ViewContainerRef>;
     readonly container: _angular_core.Signal<ElementRef<HTMLElement>>;
     readonly backdropElement: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
     readonly options: _angular_core.WritableSignal<PopoverOptions>;
@@ -177,6 +177,17 @@ declare function basePopoverPortal<T>(component: Type<T>): {
     closeAll: () => void;
 };
 
+/**
+ * Directive to mark the host element for arrow positioning.
+ * Apply this to the parent component that contains the arrow.
+ * The arrow will calculate offset based on the difference between
+ * the host element and the arrow element positions.
+ */
+declare class NgbPopoverArrowHost {
+    readonly el: ElementRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbPopoverArrowHost, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbPopoverArrowHost, "[ngbPopoverArrowHost]", ["ngbPopoverArrowHost"], {}, {}, never, never, true, never>;
+}
 declare class PopoverArrowTracker {
     top?: number | undefined;
     left?: number | undefined;
@@ -202,11 +213,12 @@ declare class NgbPopoverArrow {
     };
     readonly anchor: _angular_core.InputSignal<boolean>;
     readonly el: ElementRef<any>;
+    readonly arrowHost: NgbPopoverArrowHost | null;
     readonly styles: _angular_core.Signal<{}>;
     private updateAnchorPosition;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbPopoverArrow, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgbPopoverArrow, "[ngbPopoverArrow]", never, { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
-export { NgbPopover, NgbPopoverArrow, NgbPopoverBackdrop, NgbPopoverClose, NgbPopoverMain, NgbPopoverTrigger, POPOVER_ARROW_TRACKER, PopoverArrowTracker, PopoverOptions, aliasPopover, basePopoverPortal, ngbPopoverPortal, providePopoverArrowTracker, registerNgbPopover, tooltipPosition };
+export { NgbPopover, NgbPopoverArrow, NgbPopoverArrowHost, NgbPopoverBackdrop, NgbPopoverClose, NgbPopoverMain, NgbPopoverTrigger, POPOVER_ARROW_TRACKER, PopoverArrowTracker, PopoverOptions, aliasPopover, basePopoverPortal, ngbPopoverPortal, providePopoverArrowTracker, registerNgbPopover, tooltipPosition };
 export type { PopoverOpen, PopoverPosition, PopoverType };