@ngbase/adk 0.1.16 → 0.1.18

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

@@ -0,0 +1,64 @@
+import * as _angular_core from '@angular/core';
+import { Observable } from 'rxjs';
+
+interface JwtOptions {
+    tokenGetter: () => string | null | undefined;
+    tokenSetter?: (token: string | null) => void;
+    refreshTokenGetter?: () => string | null | undefined;
+    refreshTokenSetter?: (token: string | null) => void;
+}
+declare function provideJwt(options: () => JwtOptions): _angular_core.EnvironmentProviders;
+declare class JwtService<T> {
+    private options;
+    private accessTokenKey;
+    private refreshTokenKey;
+    private _accessToken;
+    private _refreshToken;
+    getAccessToken: _angular_core.Signal<string | null>;
+    getRefreshToken: _angular_core.Signal<string | null>;
+    setTokens(accessToken: string, refreshToken: string): void;
+    clearTokens(): void;
+    isAccessTokenExpired: () => boolean;
+    isRefreshTokenExpired: () => boolean;
+    isAccessTokenNearExpiry(minutesBeforeExpiry?: number): boolean;
+    decodeToken: _angular_core.Signal<T | null>;
+    getTokenExpirationDate: _angular_core.Signal<Date | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JwtService<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<JwtService<any>>;
+}
+declare const injectJwt: <T>() => JwtService<T>;
+
+/**
+ * Centralized authentication service for guards and interceptors
+ * Handles token validation and refresh logic consistently
+ */
+declare class TokenGuardHelper {
+    private refreshApi;
+    private logout;
+    private readonly tokenRefreshService;
+    private readonly jwt;
+    constructor(refreshApi: () => Observable<any>, logout: () => void);
+    /**
+     * Checks if user is authenticated, handles token refresh if needed
+     * Returns Observable<boolean> - true if authenticated, false if should redirect to login
+     */
+    checkAuthentication: () => Observable<boolean>;
+    /**
+     * Enhanced authentication check with automatic retry
+     * Attempts refresh once, then falls back to login redirect
+     */
+    ensureAuthenticated: () => Observable<boolean>;
+    /**
+     * Quick synchronous check for authentication status
+     * Use this only when you don't need token refresh
+     */
+    isQuickAuthenticated: () => boolean;
+    /**
+     * Validates and refreshes token for HTTP requests
+     * Returns Observable<string> with valid access token or throws error
+     * Used by interceptors
+     */
+    getValidAccessToken: () => Observable<string>;
+}
+
+export { JwtService, TokenGuardHelper, injectJwt, provideJwt };

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 };

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

@@ -1,19 +1,21 @@
 import * as _angular_core from '@angular/core';
-import { Type, TemplateRef, ElementRef, ViewContainerRef, InjectionToken, Injector, ComponentRef, EmbeddedViewRef } from '@angular/core';
+import { ElementRef, ViewContainerRef, InjectionToken, Type, TemplateRef, Injector, ComponentRef, EmbeddedViewRef } from '@angular/core';
 import * as rxjs from 'rxjs';
-import { BehaviorSubject, Subject } from 'rxjs';
+import { Subject } from 'rxjs';
 
 type DialogInput<T = any> = Type<T> | TemplateRef<any>;
 declare abstract class BaseDialog {
     dialogRef: DialogRef<any>;
     document: Document;
     el: ElementRef<any>;
-    _afterViewSource: BehaviorSubject<ViewContainerRef | null>;
-    afterView: rxjs.Observable<ViewContainerRef>;
+    abstract readonly contentContainer: () => ViewContainerRef | undefined;
+    get vcRef(): ViewContainerRef;
     target: _angular_core.WritableSignal<HTMLElement | null>;
-    count: number;
+    private enterAnimationDone;
     private isFirst;
     private currentActiveElement;
+    readonly closing: _angular_core.WritableSignal<boolean>;
+    protected readonly hasAnimations: boolean;
     constructor();
     setOptions(_: DialogOptions): void;
     close(): void;
@@ -22,20 +24,36 @@ declare abstract class BaseDialog {
     getTarget(): HTMLElement;
     onClose: () => void;
 }
+interface CloseOptions {
+    closeParent?: boolean;
+}
 declare class DialogRef<T = any> {
     options: DialogOptions<T>;
     private destroyParent;
     private closeAllFn;
     private animation;
     data: T | undefined;
-    private backdropSub;
+    private baseDialog;
+    private pendingCloseData;
+    private _isClosing;
+    get isClosing(): boolean;
     private onDestroySource;
     onDestroy: rxjs.Observable<unknown>;
     private afterClosedSource;
     afterClosed: rxjs.Observable<any>;
     events: Subject<"created">;
+    private _parent;
+    private _children;
+    get parent(): DialogRef | null;
+    get children(): ReadonlySet<DialogRef>;
+    get root(): DialogRef;
     constructor(options: DialogOptions<T>, destroyParent: VoidFunction, closeAllFn: VoidFunction, animation?: boolean);
-    close: (data?: any) => void;
+    _setParent(parent: DialogRef): void;
+    _addChild(child: DialogRef): void;
+    _removeChild(child: DialogRef): void;
+    setBaseDialog(baseDialog: BaseDialog): void;
+    close: (data?: any, options?: CloseOptions) => void;
+    _completeClose: () => void;
     closeAll(): void;
     destroy(): void;
 }
@@ -58,6 +76,8 @@ declare class DialogOptions<T = any> {
     ayId?: string;
     focusTrap?: boolean | undefined;
     afterFocusEl?: HTMLElement;
+    parent?: DialogRef;
+    closeChildrenOnClose?: boolean | undefined;
 }
 declare const DIALOG_INJ: InjectionToken<unknown>;
 declare function createInj(parent: Injector, data: any, diaRef: DialogRef): _angular_core.DestroyableInjector;
@@ -100,6 +120,7 @@ declare class PortalService {
     private appRef;
     private environmentInjector;
     private trackElements;
+    constructor();
     private componentCreator;
     appendComponentToBody<T>(component: Type<T>): ComponentRef<T>;
     create<T>(component: Type<T>, injector: Injector, container: string): ComponentRef<T>;
@@ -110,4 +131,4 @@ declare class PortalService {
 }
 
 export { BaseDialog, DIALOG_INJ, DialogOptions, DialogRef, NgbPortalClose, Portal, PortalService, basePortal, createInj };
-export type { DialogInput };
+export type { CloseOptions, DialogInput };

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

@@ -1,22 +1,19 @@
 import * as _angular_core from '@angular/core';
 import * as i1 from '@ngbase/adk/a11y';
 import { AccessibleGroup, AccessibleItem } from '@ngbase/adk/a11y';
-import { ControlValueAccessor } from '@angular/forms';
+import { FormValueControl } from '@angular/forms/signals';
 
-declare class NgbRadioGroup implements ControlValueAccessor {
+declare class NgbRadioGroup<T = any> implements FormValueControl<T> {
     readonly allyGroup: AccessibleGroup;
     readonly radios: _angular_core.Signal<readonly any[]>;
-    readonly value: _angular_core.ModelSignal<any>;
+    readonly value: _angular_core.ModelSignal<T>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
     readonly ayId: string;
-    onChange?: (value: any) => {};
-    onTouched?: () => {};
     constructor();
-    updateValue(value: any): void;
-    writeValue(value: any): void;
-    registerOnChange(fn: any): void;
-    registerOnTouched(fn: any): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbRadioGroup, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbRadioGroup, "[ngbRadioGroup]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["radios"], never, true, [{ directive: typeof i1.AccessibleGroup; inputs: {}; outputs: {}; }]>;
+    updateValue(value: T): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbRadioGroup<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbRadioGroup<any>, "[ngbRadioGroup]", never, { "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"; }, ["radios"], never, true, [{ directive: typeof i1.AccessibleGroup; inputs: {}; outputs: {}; }]>;
 }
 
 declare class NgbRadioIndicator {
@@ -28,7 +25,7 @@ declare class NgbRadioIndicator {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgbRadioIndicator, "[ngbRadioIndicator]", ["ngbRadioIndicator"], {}, {}, never, ["*"], true, [{ directive: typeof i1.AccessibleItem; inputs: {}; outputs: {}; }]>;
 }
 declare class NgbRadio {
-    readonly radio: NgbRadioGroup;
+    readonly radio: NgbRadioGroup<any>;
     readonly value: _angular_core.InputSignal<any>;
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly checked: _angular_core.Signal<boolean>;

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

@@ -6,7 +6,7 @@ import { Drag, DragData } from '@ngbase/adk/drag';
 declare class NgbResizableGroup {
     readonly document: Document;
     readonly el: ElementRef<HTMLElement>;
-    readonly panels: _angular_core.Signal<readonly any[]>;
+    readonly panels: _angular_core.Signal<readonly NgbResizable[]>;
     readonly direction: _angular_core.InputSignal<"horizontal" | "vertical">;
     readonly id: string;
     private overlayDiv?;
@@ -44,10 +44,10 @@ declare class NgbResizable {
     readonly max: _angular_core.InputSignal<string | number | undefined>;
     readonly lSize: _angular_core.WritableSignal<string | number>;
     readonly draggable: _angular_core.WritableSignal<boolean>;
-    private reducedSize;
+    reducedSize: number;
     private localMinSize;
     private localMaxSize;
-    private lastReducedSize;
+    private initialReducedSize;
     index: number;
     str: string;
     constructor();
@@ -58,7 +58,7 @@ declare class NgbResizable {
     onDrag(data: DragData): void;
     handleDrag(event?: DragData): void;
     private getUpdatedSize;
-    updateSize(px: number, direct: 'both' | 'prev' | 'next'): void;
+    updateSize(delta: number, direct: 'prev' | 'next', force?: boolean): void;
     private calculateSize;
     private updateFlex;
     updateElementSize(str: string): void;

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

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { ElementRef } from '@angular/core';
 import * as i1 from '@ngbase/adk/drag';
-import { Drag, DragData } from '@ngbase/adk/drag';
+import { DragData, Drag } from '@ngbase/adk/drag';
 
 type ScrollBarOrientation = 'vertical' | 'horizontal' | 'both';
 declare class NgbScrollBar {
@@ -48,6 +48,7 @@ declare class NgbScrollArea {
     constructor();
     private updateDimensions;
     private handleScroll;
+    private _updateScroll;
     private scrollbarVerticalTransform;
     private scrollbarHorizontalTransform;
     startDraggingVertical(data: DragData): void;

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

@@ -1,13 +1,12 @@
-import * as _angular_forms from '@angular/forms';
-import { ControlValueAccessor } from '@angular/forms';
 import * as _angular_core from '@angular/core';
-import { ElementRef, OnDestroy, TemplateRef, EffectRef } from '@angular/core';
+import { ElementRef, OnDestroy, TemplateRef } from '@angular/core';
 import * as i1 from '@ngbase/adk/a11y';
 import { AccessibleItem, AccessibleGroup } from '@ngbase/adk/a11y';
 import { FilterOptions } from '@ngbase/adk/utils';
 import * as _ngbase_adk_popover from '@ngbase/adk/popover';
 import { PopoverOptions } from '@ngbase/adk/popover';
 import * as _ngbase_adk_portal from '@ngbase/adk/portal';
+import { FormValueControl } from '@angular/forms/signals';
 import { Directionality } from '@ngbase/adk/bidi';
 import { Subject } from 'rxjs';
 import * as i2 from '@ngbase/adk/form-field';
@@ -40,7 +39,7 @@ declare class NgbSelectTarget {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSelectTarget, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSelectTarget, "[ngbSelectTarget]", never, {}, {}, never, never, true, never>;
 }
-declare abstract class SelectBase<T> implements ControlValueAccessor, OnDestroy {
+declare abstract class SelectBase<T> implements FormValueControl<T | T[]>, OnDestroy {
     private isSelect;
     readonly el: ElementRef<any>;
     readonly dir: Directionality;
@@ -54,7 +53,8 @@ declare abstract class SelectBase<T> implements ControlValueAccessor, OnDestroy
     readonly container: _angular_core.Signal<ElementRef<any> | undefined>;
     readonly optionsGroup: _angular_core.Signal<ElementRef<any> | undefined>;
     readonly value: _angular_core.ModelSignal<any>;
-    readonly disabled: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
     readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly noAutoClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly options: _angular_core.InputSignal<T[]>;
@@ -66,15 +66,12 @@ declare abstract class SelectBase<T> implements ControlValueAccessor, OnDestroy
     readonly panelOpen: _angular_core.WritableSignal<boolean>;
     readonly values: _angular_core.WritableSignal<T[]>;
     readonly status: _angular_core.WritableSignal<"opening" | "opened" | "closed">;
-    onChange?: (value: any) => void;
-    onTouched?: () => void;
     popClose?: VoidFunction;
     private previousValue;
     events: Subject<"open" | "close">;
     readonly ayId: string;
     readonly cValue: _angular_core.Signal<string>;
     private withInPopup;
-    valueRef: EffectRef;
     protected constructor(isSelect: boolean);
     open(): void;
     popValue(): void;
@@ -85,14 +82,10 @@ declare abstract class SelectBase<T> implements ControlValueAccessor, OnDestroy
     private focusOut;
     private setValue;
     removeValue(value: T): void;
-    writeValue(value: T[] | T): void;
     private updateValues;
-    registerOnChange(fn: (value: any) => void): void;
-    registerOnTouched(fn: VoidFunction): void;
-    setDisabledState(isDisabled: boolean): void;
     ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectBase<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SelectBase<any>, never, never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "noAutoClose": { "alias": "noAutoClose"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "disabled": "disabledChange"; "opened": "opened"; "closed": "closed"; }, ["list"], never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SelectBase<any>, never, never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "noAutoClose": { "alias": "noAutoClose"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "opened": "opened"; "closed": "closed"; }, ["list"], never, true, never>;
 }
 
 interface OptionContext<T> {
@@ -130,17 +123,10 @@ declare class NgbSelect<T> extends SelectBase<T> {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSelect<any>, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSelect<any>, "[ngbSelect]", never, { "search": { "alias": "search"; "required": false; "isSignal": true; }; "filterFn": { "alias": "filterFn"; "required": false; "isSignal": true; }; "filterOptions": { "alias": "filterOptions"; "required": false; "isSignal": true; }; }, { "search": "searchChange"; }, ["optionTemplate"], never, true, never>;
 }
-declare function aliasSelect(select: typeof NgbSelect): (({
-    provide: _angular_core.InjectionToken<readonly _angular_forms.ControlValueAccessor[]>;
-    useExisting: _angular_core.Type<any>;
-    multi: boolean;
-} | {
+declare function aliasSelect(select: typeof NgbSelect): {
     provide: typeof SelectBase;
     useExisting: typeof NgbSelect;
-})[] | {
-    provide: typeof NgbSelect;
-    useExisting: typeof NgbSelect;
-})[];
+}[];
 
 declare class NgbOptionGroup {
     readonly label: _angular_core.InputSignal<string>;

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

@@ -1,22 +1,18 @@
 import * as _angular_core from '@angular/core';
-import { ControlValueAccessor } from '@angular/forms';
+import { FormValueControl } from '@angular/forms/signals';
 import * as i1 from '@ngbase/adk/a11y';
 import { AccessibleGroup } from '@ngbase/adk/a11y';
 
-declare class NgbSelectable<T> implements ControlValueAccessor {
+declare class NgbSelectable<T> implements FormValueControl<T | undefined> {
     readonly allyGroup: AccessibleGroup;
-    readonly activeIndex: _angular_core.ModelSignal<T | undefined>;
-    readonly valueChanged: _angular_core.OutputEmitterRef<T>;
+    readonly value: _angular_core.ModelSignal<T | undefined>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
     readonly ayId: string;
-    onChange: (_: T) => void;
-    onTouched: () => void;
     constructor();
     setValue(value: T): void;
-    writeValue(v: T): void;
-    registerOnChange(fn: (v: T) => void): void;
-    registerOnTouched(fn: () => void): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSelectable<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSelectable<any>, "[ngbSelectable]", never, { "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; "valueChanged": "valueChanged"; }, never, never, true, [{ directive: typeof i1.AccessibleGroup; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSelectable<any>, "[ngbSelectable]", never, { "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, [{ directive: typeof i1.AccessibleGroup; inputs: {}; outputs: {}; }]>;
 }
 
 declare class NgbSelectableItem<T> {

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

@@ -1,11 +1,12 @@
-import * as rxjs from 'rxjs';
+import * as _ngbase_adk_portal from '@ngbase/adk/portal';
 import { BaseDialog, DialogOptions, DialogInput } from '@ngbase/adk/portal';
+import * as rxjs from 'rxjs';
 import * as _ngbase_adk_bidi from '@ngbase/adk/bidi';
 import * as _angular_core from '@angular/core';
 import { OnDestroy, ViewContainerRef } from '@angular/core';
 
 declare class NgbSheetContainer extends BaseDialog implements OnDestroy {
-    myDialog: _angular_core.Signal<ViewContainerRef | undefined>;
+    readonly contentContainer: _angular_core.Signal<ViewContainerRef | undefined>;
     readonly dir: _ngbase_adk_bidi.Directionality;
     backdropColor: boolean;
     options: SheetOptions;
@@ -34,7 +35,7 @@ declare class SheetOptions extends DialogOptions {
 declare function ngbSheetPortal(component: typeof NgbSheetContainer): {
     open: <T>(component: DialogInput, opt?: SheetOptions) => {
         afterClosed: rxjs.Observable<any>;
-        close: (data?: any) => void;
+        close: (data?: any, options?: _ngbase_adk_portal.CloseOptions) => void;
     };
     closeAll: () => void;
 };

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

@@ -2,7 +2,6 @@ import * as _angular_core from '@angular/core';
 import { Type, ElementRef } from '@angular/core';
 import * as _ngbase_adk_bidi from '@ngbase/adk/bidi';
 import { Directionality } from '@ngbase/adk/bidi';
-import * as _angular_animations from '@angular/animations';
 
 type SidenavType = 'side' | 'over' | 'partial';
 declare class SidenavService {
@@ -53,22 +52,23 @@ declare class NgbSidenavHeaderTrack {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSidenavHeaderTrack, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSidenavHeaderTrack, "[ngbSidenavHeaderTrack]", never, {}, {}, never, never, true, never>;
 }
-declare function slideAnimation(ease: string): _angular_animations.AnimationTriggerMetadata;
 declare class NgbSidenavHeader {
     readonly sidenav: SidenavService;
     readonly el: ElementRef<any>;
     readonly dir: Directionality;
     readonly width: _angular_core.InputSignal<string>;
     readonly minWidth: _angular_core.InputSignal<string>;
-    private initial;
-    readonly isAnimationDisabled: _angular_core.WritableSignal<boolean>;
+    private skipTransition;
     readonly w: _angular_core.Signal<string>;
     readonly actualWidth: _angular_core.Signal<string>;
-    readonly headerStyles: _angular_core.Signal<{}>;
+    readonly translateX: _angular_core.Signal<string>;
+    readonly headerStyles: _angular_core.Signal<Record<string, string>>;
     constructor();
+    onTransitionEnd(event: TransitionEvent): void;
+    onTransitionStart(event: TransitionEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSidenavHeader, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSidenavHeader, "[ngbSidenavHeader]", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { NgbSidenav, NgbSidenavHeader, NgbSidenavHeaderContent, NgbSidenavHeaderTrack, NgbSidenavOverlay, aliasSidenav, slideAnimation };
+export { NgbSidenav, NgbSidenavHeader, NgbSidenavHeaderContent, NgbSidenavHeaderTrack, NgbSidenavOverlay, aliasSidenav };
 export type { SidenavType };

package/{slider/index.d.ts → types/ngbase-adk-slider.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/drag';
 
 declare class SliderTrack {
@@ -23,23 +23,21 @@ declare class SliderThumb {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SliderThumb, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SliderThumb, "[ngbSliderThumb]", never, {}, {}, never, never, true, never>;
 }
-declare class NgbSlider implements ControlValueAccessor {
+declare class NgbSlider implements FormValueControl<number | number[] | undefined> {
     private readonly el;
     private readonly dir;
-    private cdr;
     private readonly drag;
     private readonly track;
     readonly thumbs: _angular_core.Signal<readonly ElementRef<HTMLElement>[]>;
     readonly value: _angular_core.ModelSignal<number | number[] | undefined>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
     readonly step: _angular_core.InputSignalWithTransform<number, unknown>;
-    readonly min: _angular_core.InputSignalWithTransform<number, unknown>;
-    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly minValue: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly maxValue: _angular_core.InputSignalWithTransform<number, unknown>;
     readonly range: _angular_core.InputSignalWithTransform<number, unknown>;
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
     readonly afterChange: _angular_core.OutputEmitterRef<number | number[]>;
-    private onChange?;
-    private onTouched?;
     readonly noOfThumbs: _angular_core.Signal<number[]>;
     private readonly totalSteps;
     private values;
@@ -51,9 +49,6 @@ declare class NgbSlider implements ControlValueAccessor {
     private handleValueUpdate;
     private updateElement;
     private getThumbSize;
-    writeValue(value: number | number[]): void;
-    registerOnChange(fn: any): void;
-    registerOnTouched(fn: any): void;
     private get width();
     private toPercentage;
     private fromPercentage;
@@ -65,15 +60,11 @@ declare class NgbSlider implements ControlValueAccessor {
     private updateValue;
     private notifyChange;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSlider, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSlider, "[ngbSlider]", ["ngbSlider"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "afterChange": "afterChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSlider, "[ngbSlider]", ["ngbSlider"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "minValue": { "alias": "min"; "required": false; "isSignal": true; }; "maxValue": { "alias": "max"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "afterChange": "afterChange"; }, never, never, true, never>;
 }
-declare const aliasSlider: (slider: typeof NgbSlider) => ({
-    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
-    useExisting: _angular_core.Type<any>;
-    multi: boolean;
-} | {
+declare const aliasSlider: (slider: typeof NgbSlider) => {
     provide: typeof NgbSlider;
     useExisting: typeof NgbSlider;
-})[];
+}[];
 
 export { NgbSlider, SliderRange, SliderThumb, SliderTrack, aliasSlider };

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

@@ -1,8 +1,6 @@
 import * as i0 from '@angular/core';
 import { Type } from '@angular/core';
-import * as _angular_animations from '@angular/animations';
 
-declare const sonnerAnimation: _angular_animations.AnimationTriggerMetadata;
 declare class SonnerBase {
     readonly ngbSonnerBase: i0.InputSignal<number>;
     static ɵfac: i0.ɵɵFactoryDeclaration<SonnerBase, never>;
@@ -46,5 +44,5 @@ declare function ngbSonnerPortal(component?: Type<NgbSonner>): {
     closeAll: () => void;
 };
 
-export { NgbSonner, SonnerBase, SonnerService, ngbSonnerPortal, sonnerAnimation };
+export { NgbSonner, SonnerBase, SonnerService, ngbSonnerPortal };
 export type { SonnerData, SonnerMessage, SonnerType };