@ngbase/adk 0.1.10 → 0.1.12

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

@@ -1,4 +1,11 @@
-import { ChangeDetectionStrategy, Component, computed, Directive, input } from '@angular/core';
+import {
+  ChangeDetectionStrategy,
+  Component,
+  computed,
+  Directive,
+  inject,
+  input,
+} from '@angular/core';
 import {
   aliasBodyRow,
   aliasHeadRow,
@@ -22,7 +29,12 @@ import { Select, Option, SelectTrigger } from '<%= basepath %>/select';
 import { FormField, InputSuffix } from '<%= basepath %>/form-field';
 import { Icon } from '<%= basepath %>/icon';
 import { provideIcons } from '@ng-icons/core';
-import { lucideArrowDown, lucideArrowUp, lucideChevronsUpDown } from '@ng-icons/lucide';
+import {
+  lucideArrowDown,
+  lucideArrowUp,
+  lucideArrowUpDown,
+  lucideChevronsUpDown,
+} from '@ng-icons/lucide';
 import { Button } from '<%= basepath %>/button';
 import { NgTemplateOutlet } from '@angular/common';
 
@@ -36,13 +48,31 @@ import { NgTemplateOutlet } from '@angular/common';
     </thead>
     <tbody>
       <ng-container #tbody />
+      @if (isEmpty()) {
+        <ng-content select="[<%= name %>EmptyState]" />
+      }
     </tbody>
   `,
   host: {
     class: 'w-full text-sm border-separate border-spacing-0',
   },
 })
-export class Table<T> extends NgbTable<T> {}
+export class Table<T> extends NgbTable<T> {
+  readonly isEmpty = computed(() => this.pluggedData().length === 0);
+}
+
+@Component({
+  selector: '[<%= name %>EmptyState]',
+  template: `<td class="h-24 p-2 text-center align-middle" [attr.colspan]="table.columns().length">
+    <ng-content />
+  </td>`,
+  host: {
+    class: 'border-b hover:bg-muted/50 data-[state=selected]:bg-muted',
+  },
+})
+export class EmptyState {
+  readonly table = inject(Table);
+}
 
 // Cell
 @Component({
@@ -135,6 +165,7 @@ export class HeadRowDef {}
 
 @Directive({
   selector: '[<%= name %>Sort]',
+  exportAs: '<%= name %>Sort',
   providers: [aliasSort(Sort)],
 })
 export class Sort extends NgbSort<any> {
@@ -144,7 +175,9 @@ export class Sort extends NgbSort<any> {
 @Component({
   selector: '[<%= name %>SortHeader]',
   changeDetection: ChangeDetectionStrategy.OnPush,
-  viewProviders: [provideIcons({ lucideChevronsUpDown, lucideArrowDown, lucideArrowUp })],
+  viewProviders: [
+    provideIcons({ lucideChevronsUpDown, lucideArrowDown, lucideArrowUp, lucideArrowUpDown }),
+  ],
   providers: [aliasSortHeader(SortHeader)],
   imports: [Select, Option, SelectTrigger, FormField, InputSuffix, Icon, Button, NgTemplateOutlet],
   template: `
@@ -175,6 +208,8 @@ export class SortHeader extends NgbSortHeader<Sort> {
       ? 'lucideArrowDown'
       : this.sortDirection() === 'desc'
         ? 'lucideArrowUp'
-        : 'lucideChevronsUpDown';
+        : this.sort.mode() === 'selection'
+          ? 'lucideChevronsUpDown'
+          : 'lucideArrowUpDown';
   });
 }

package/scroll-area/index.d.ts

@@ -1,5 +1,60 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/scroll-area" />
-export * from './public-api';
+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';
+
+type ScrollBarOrientation = 'vertical' | 'horizontal' | 'both';
+declare class NgbScrollBar {
+    readonly el: ElementRef<HTMLDivElement>;
+    readonly scrollArea: NgbScrollArea;
+    readonly drag: Drag;
+    readonly ngbScrollBar: _angular_core.InputSignal<"vertical" | "horizontal">;
+    readonly visible: _angular_core.Signal<boolean>;
+    readonly show: _angular_core.Signal<boolean>;
+    readonly size: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbScrollBar, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbScrollBar, "[ngbScrollBar]", never, { "ngbScrollBar": { "alias": "ngbScrollBar"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.Drag; inputs: {}; outputs: {}; }]>;
+}
+declare class NgbScrollArea {
+    readonly scrollAreaViewport: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    readonly scrollbars: _angular_core.Signal<readonly NgbScrollBar[]>;
+    readonly scrollbarVertical: _angular_core.Signal<NgbScrollBar | undefined>;
+    readonly scrollbarHorizontal: _angular_core.Signal<NgbScrollBar | undefined>;
+    readonly orientation: _angular_core.InputSignal<ScrollBarOrientation>;
+    readonly hideDelay: _angular_core.InputSignal<number>;
+    readonly alwaysShow: _angular_core.InputSignal<boolean>;
+    private viewportHeight;
+    private viewportWidth;
+    private contentHeight;
+    private contentWidth;
+    private isScrolling;
+    private hideTimeout;
+    readonly isDragging: _angular_core.WritableSignal<boolean>;
+    private startY;
+    private startX;
+    private startScrollTop;
+    private startScrollLeft;
+    private client;
+    protected readonly showScrollbar: _angular_core.Signal<boolean>;
+    protected readonly hasVertical: _angular_core.Signal<boolean>;
+    protected readonly hasHorizontal: _angular_core.Signal<boolean>;
+    readonly showVerticalBar: _angular_core.Signal<boolean>;
+    readonly showHorizontalBar: _angular_core.Signal<boolean>;
+    readonly showVerticalScroll: _angular_core.Signal<boolean>;
+    readonly showHorizontalScroll: _angular_core.Signal<boolean>;
+    readonly scrollbarHeight: _angular_core.Signal<number>;
+    readonly scrollbarWidth: _angular_core.Signal<number>;
+    constructor();
+    private updateDimensions;
+    private handleScroll;
+    private scrollbarVerticalTransform;
+    private scrollbarHorizontalTransform;
+    startDraggingVertical(data: DragData): void;
+    startDraggingHorizontal(data: DragData): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbScrollArea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgbScrollArea, "[ngbScrollArea]", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "hideDelay"; "required": false; "isSignal": true; }; "alwaysShow": { "alias": "alwaysShow"; "required": false; "isSignal": true; }; }, {}, ["scrollbars"], ["*", "[ngbScrollBar]", ".scroll-area-corner"], true, never>;
+}
+
+export { NgbScrollArea, NgbScrollBar };
+export type { ScrollBarOrientation };

package/select/index.d.ts

@@ -1,5 +1,177 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/select" />
-export * from './public-api';
+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 * 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 { Directionality } from '@ngbase/adk/bidi';
+import { Subject } from 'rxjs';
+import * as i2 from '@ngbase/adk/form-field';
+import { InputBase } from '@ngbase/adk/form-field';
+
+declare class NgbOption<T> {
+    readonly allyItem: AccessibleItem<any>;
+    readonly el: ElementRef<HTMLElement>;
+    readonly value: _angular_core.InputSignal<T | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ayId: _angular_core.InputSignal<string | undefined>;
+    readonly onSelectionChange: _angular_core.OutputEmitterRef<T>;
+    readonly multiple: _angular_core.WritableSignal<boolean>;
+    readonly checked: _angular_core.WritableSignal<boolean>;
+    readonly active: _angular_core.WritableSignal<boolean>;
+    private _ayId;
+    constructor();
+    selectOption(): void;
+    setAyId(id: string): void;
+    label(): string;
+    focus(): void;
+    unselect(): void;
+    getValue(): string | T | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbOption<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbOption<any>, "[ngbOption]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ayId": { "alias": "ayId"; "required": false; "isSignal": true; }; }, { "onSelectionChange": "onSelectionChange"; }, never, never, true, [{ directive: typeof i1.AccessibleItem; inputs: {}; outputs: {}; }]>;
+}
+
+declare class NgbSelectTarget {
+    readonly target: _angular_core.WritableSignal<HTMLDivElement | null>;
+    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 {
+    private isSelect;
+    readonly el: ElementRef<any>;
+    readonly dir: Directionality;
+    readonly target: NgbSelectTarget | null;
+    readonly list: _angular_core.Signal<readonly NgbOption<any>[]>;
+    readonly popover: {
+        open: <T_1>(component: _ngbase_adk_portal.DialogInput<T_1>, options: PopoverOptions) => _ngbase_adk_popover.PopoverOpen<T_1>;
+        closeAll: () => void;
+    };
+    readonly optionsTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    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 multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly noAutoClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly options: _angular_core.InputSignal<T[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<"target" | "free">;
+    readonly opened: _angular_core.OutputEmitterRef<boolean>;
+    readonly closed: _angular_core.OutputEmitterRef<boolean>;
+    defaultOptions: Partial<PopoverOptions>;
+    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;
+    close(): void;
+    private afterOpen;
+    private afterClose;
+    private clickHandler;
+    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>;
+}
+
+interface OptionContext<T> {
+    $implicit: T;
+    index: number;
+}
+declare class NgbSelectOption<T> {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSelectOption<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSelectOption<any>, "[ngbSelectOption]", never, {}, {}, never, never, true, never>;
+}
+declare class SelectValue {
+    readonly select: NgbSelect<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectValue, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SelectValue, "button[ngbSelectValue]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbSelectOptionGroup {
+    readonly group: AccessibleGroup;
+    readonly select: SelectBase<any>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSelectOptionGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSelectOptionGroup, "[ngbSelectOptionGroup]", never, {}, {}, never, never, true, [{ directive: typeof i1.AccessibleGroup; inputs: {}; outputs: {}; }]>;
+}
+declare class NgbSelect<T> extends SelectBase<T> {
+    readonly optionTemplate: _angular_core.Signal<NgbSelectOption<any> | undefined>;
+    readonly search: _angular_core.ModelSignal<string>;
+    readonly filterFn: _angular_core.InputSignal<(option: T) => string>;
+    readonly filterOptions: _angular_core.InputSignal<FilterOptions<T> | undefined>;
+    readonly optionsFilter: {
+        search: _angular_core.WritableSignal<string>;
+        list: _angular_core.WritableSignal<T[]>;
+        filteredList: _angular_core.Signal<T[]>;
+    };
+    constructor();
+    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;
+} | {
+    provide: typeof SelectBase;
+    useExisting: typeof NgbSelect;
+})[] | {
+    provide: typeof NgbSelect;
+    useExisting: typeof NgbSelect;
+})[];
+
+declare class NgbOptionGroup {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbOptionGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbOptionGroup, "[ngbOptionGroup]", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NgbSelectInput<T> {
+    readonly el: ElementRef<HTMLInputElement>;
+    readonly select: NgbSelect<T> | null;
+    readonly inputBase: InputBase<any>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly options: _angular_core.InputSignal<T[]>;
+    readonly filterFn: _angular_core.InputSignal<((query: string, value: T, values: T[]) => boolean) | undefined>;
+    readonly filteredOptions: _angular_core.Signal<T[]>;
+    constructor();
+    updateSearch(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSelectInput<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSelectInput<any>, "input[ngbSelectInput]", ["ngbSelectInput"], { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "filterFn": { "alias": "filterFn"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.Autofocus; inputs: {}; outputs: {}; }, { directive: typeof i2.InputBase; inputs: { "value": "value"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+declare class NgbSelectTrigger {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSelectTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSelectTrigger, "[ngbSelectTrigger]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ListSelection<T> extends SelectBase<T> {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListSelection<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListSelection<any>, "[ngbListSelection]", never, {}, {}, never, never, true, never>;
+}
+
+export { ListSelection, NgbOption, NgbOptionGroup, NgbSelect, NgbSelectInput, NgbSelectOption, NgbSelectOptionGroup, NgbSelectTarget, NgbSelectTrigger, SelectBase, SelectValue, aliasSelect };
+export type { OptionContext };

package/selectable/index.d.ts

@@ -1,5 +1,32 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/selectable" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i1 from '@ngbase/adk/a11y';
+import { AccessibleGroup } from '@ngbase/adk/a11y';
+
+declare class NgbSelectable<T> implements ControlValueAccessor {
+    readonly allyGroup: AccessibleGroup;
+    readonly activeIndex: _angular_core.ModelSignal<T | undefined>;
+    readonly valueChanged: _angular_core.OutputEmitterRef<T>;
+    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: {}; }]>;
+}
+
+declare class NgbSelectableItem<T> {
+    readonly selectable: NgbSelectable<T>;
+    readonly value: _angular_core.InputSignal<T>;
+    readonly selected: _angular_core.Signal<boolean>;
+    constructor();
+    select(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSelectableItem<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSelectableItem<any>, "[ngbSelectableItem]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.AccessibleItem; inputs: {}; outputs: {}; }]>;
+}
+
+export { NgbSelectable, NgbSelectableItem };

package/sheet/index.d.ts

@@ -1,5 +1,44 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/sheet" />
-export * from './public-api';
+import * as rxjs from 'rxjs';
+import { BaseDialog, DialogOptions, DialogInput } from '@ngbase/adk/portal';
+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 dir: _ngbase_adk_bidi.Directionality;
+    backdropColor: boolean;
+    options: SheetOptions;
+    classNames: string;
+    isHideHeader: boolean;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly position: _angular_core.Signal<{
+        params: {
+            slideFrom: string;
+        };
+    }>;
+    constructor();
+    setOptions(options: SheetOptions): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSheetContainer, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSheetContainer, "mee-sheet", never, {}, {}, never, never, true, never>;
+}
+declare function aliasSheet(dialog: typeof NgbSheetContainer): {
+    provide: typeof NgbSheetContainer;
+    useExisting: typeof NgbSheetContainer;
+};
+
+declare class SheetOptions extends DialogOptions {
+    position?: 'left' | 'right';
+}
+declare function ngbSheetPortal(component: typeof NgbSheetContainer): {
+    open: <T>(component: DialogInput, opt?: SheetOptions) => {
+        afterClosed: rxjs.Observable<any>;
+        close: (data?: any) => void;
+    };
+    closeAll: () => void;
+};
+type NgbSheet = ReturnType<typeof ngbSheetPortal>;
+
+export { NgbSheetContainer, SheetOptions, aliasSheet, ngbSheetPortal };
+export type { NgbSheet };

package/sidenav/index.d.ts

@@ -1,5 +1,74 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/sidenav" />
-export * from './public-api';
+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 {
+    readonly dir: _ngbase_adk_bidi.Directionality;
+    width: _angular_core.WritableSignal<string>;
+    show: _angular_core.WritableSignal<boolean>;
+    mode: _angular_core.WritableSignal<"side" | "over" | "partial">;
+    minWidth: _angular_core.WritableSignal<string>;
+    readonly status: _angular_core.WritableSignal<number>;
+    readonly visibility: _angular_core.Signal<number | true>;
+    readonly animate: _angular_core.Signal<boolean>;
+    readonly w: _angular_core.Signal<string>;
+    readonly styles: _angular_core.Signal<any>;
+    animationDone(): void;
+    animationStart(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidenavService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SidenavService>;
+}
+
+declare class NgbSidenavOverlay {
+    readonly sidenav: NgbSidenav;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSidenavOverlay, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgbSidenavOverlay, "[ngbSidenavOverlay]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbSidenav {
+    readonly sidenavService: SidenavService;
+    readonly show: _angular_core.ModelSignal<boolean>;
+    readonly mode: _angular_core.InputSignal<SidenavType>;
+    readonly showOverlay: _angular_core.Signal<boolean>;
+    constructor();
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSidenav, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSidenav, "[ngbSidenav]", ["ngbSidenav"], { "show": { "alias": "show"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, { "show": "showChange"; }, never, never, true, never>;
+}
+declare const aliasSidenav: (sidenav: Type<NgbSidenav>) => (typeof SidenavService | {
+    provide: typeof NgbSidenav;
+    useExisting: Type<NgbSidenav>;
+})[];
+
+declare class NgbSidenavHeaderContent {
+    readonly sidenav: SidenavService;
+    readonly w: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSidenavHeaderContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSidenavHeaderContent, "[ngbSidenavHeaderContent]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbSidenavHeaderTrack {
+    readonly sidenav: SidenavService;
+    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>;
+    readonly w: _angular_core.Signal<string>;
+    readonly actualWidth: _angular_core.Signal<string>;
+    readonly headerStyles: _angular_core.Signal<{}>;
+    constructor();
+    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 type { SidenavType };

package/slider/index.d.ts

@@ -1,5 +1,79 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/slider" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i1 from '@ngbase/adk/drag';
+
+declare class SliderTrack {
+    readonly slider: NgbSlider;
+    private readonly drag;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SliderTrack, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SliderTrack, "[ngbSliderTrack]", never, {}, {}, never, never, true, [{ directive: typeof i1.Drag; inputs: {}; outputs: {}; }]>;
+}
+declare class SliderRange {
+    readonly slider: NgbSlider;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SliderRange, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SliderRange, "[ngbSliderRange]", never, {}, {}, never, never, true, never>;
+}
+declare class SliderThumb {
+    readonly slider: NgbSlider;
+    readonly el: ElementRef<any>;
+    readonly index: _angular_core.Signal<number>;
+    readonly value: _angular_core.Signal<number | number[] | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SliderThumb, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SliderThumb, "[ngbSliderThumb]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbSlider implements ControlValueAccessor {
+    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 step: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly min: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly max: _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;
+    private activeIndex;
+    private totalWidth;
+    private totalSliderWidth;
+    private isChanged;
+    constructor();
+    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;
+    private move;
+    private clicked;
+    private perRound;
+    private fixStep;
+    private moveSlider;
+    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>;
+}
+declare const aliasSlider: (slider: typeof NgbSlider) => ({
+    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: _angular_core.Type<any>;
+    multi: boolean;
+} | {
+    provide: typeof NgbSlider;
+    useExisting: typeof NgbSlider;
+})[];
+
+export { NgbSlider, SliderRange, SliderThumb, SliderTrack, aliasSlider };

package/sonner/index.d.ts

@@ -1,5 +1,50 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/sonner" />
-export * from './public-api';
+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>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SonnerBase, "[ngbSonnerBase]", ["ngbSonnerBase"], { "ngbSonnerBase": { "alias": "ngbSonnerBase"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class NgbSonner {
+    readonly messages: i0.WritableSignal<SonnerMessage[]>;
+    addMessage(message: string, type: SonnerType, data?: SonnerData): void;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSonner, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbSonner, "ngb-sonner", never, {}, {}, never, never, true, never>;
+}
+interface SonnerMessage {
+    message: string;
+    data?: SonnerData;
+    type?: SonnerType;
+    id?: string;
+}
+type SonnerType = 'default' | 'success' | 'error' | 'warning' | 'info';
+interface SonnerData {
+    description?: string;
+    timeout?: number;
+}
+
+declare class SonnerService {
+    private NAME;
+    private base;
+    private sonner;
+    updateSonner(component?: Type<NgbSonner>): void;
+    addMessage(message: string, type: SonnerType, data?: SonnerData): void;
+    closeAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SonnerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SonnerService>;
+}
+declare function ngbSonnerPortal(component?: Type<NgbSonner>): {
+    message: (message: string, data?: SonnerData) => void;
+    success: (message: string, data?: SonnerData) => void;
+    error: (message: string, data?: SonnerData) => void;
+    warning: (message: string, data?: SonnerData) => void;
+    info: (message: string, data?: SonnerData) => void;
+    closeAll: () => void;
+};
+
+export { NgbSonner, SonnerBase, SonnerService, ngbSonnerPortal, sonnerAnimation };
+export type { SonnerData, SonnerMessage, SonnerType };