@ngbase/adk 0.1.11 → 0.1.14

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

package/stepper/index.d.ts

@@ -1,5 +1,54 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/stepper" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import * as _angular_animations from '@angular/animations';
+
+declare class NgbStep {
+    readonly stepper: NgbStepper;
+    readonly header: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly stepContainer: _angular_core.Signal<TemplateRef<any>>;
+    readonly title: _angular_core.InputSignal<any>;
+    readonly index: _angular_core.Signal<number>;
+    readonly active: _angular_core.Signal<boolean>;
+    private readonly template;
+    readonly horizontalTemplate: _angular_core.Signal<false | TemplateRef<any> | null>;
+    readonly verticalTemplate: _angular_core.Signal<false | TemplateRef<any> | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbStep, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbStep, "[ngbStep]", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, ["header"], never, true, never>;
+}
+declare class NgbStepHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbStepHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbStepHeader, "[ngbStepHeader]", never, {}, {}, never, never, true, never>;
+}
+declare const provideStep: (step: typeof NgbStep) => {
+    provide: typeof NgbStep;
+    useExisting: typeof NgbStep;
+};
+
+declare class NgbStepperStep {
+    readonly stepper: NgbStepper;
+    readonly ngbStepperStep: _angular_core.InputSignal<number>;
+    readonly last: _angular_core.Signal<boolean>;
+    readonly status: _angular_core.Signal<"completed" | "active" | "inactive">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbStepperStep, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbStepperStep, "[ngbStepperStep]", never, { "ngbStepperStep": { "alias": "ngbStepperStep"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class NgbStepper {
+    readonly steps: _angular_core.Signal<readonly NgbStep[]>;
+    readonly activeIndex: _angular_core.ModelSignal<number>;
+    readonly direction: _angular_core.InputSignal<"horizontal" | "vertical">;
+    readonly first: _angular_core.Signal<boolean>;
+    readonly last: _angular_core.Signal<boolean>;
+    readonly completed: _angular_core.Signal<boolean>;
+    nextStep(): void;
+    prevStep(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbStepper, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbStepper, "[ngbStepper]", ["ngbStepper"], { "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; }, ["steps"], never, true, never>;
+}
+declare const aliasStepper: (stepper: typeof NgbStepper) => {
+    provide: typeof NgbStepper;
+    useExisting: typeof NgbStepper;
+};
+
+declare const stepperAnimation: _angular_animations.AnimationTriggerMetadata;
+
+export { NgbStep, NgbStepHeader, NgbStepper, NgbStepperStep, aliasStepper, provideStep, stepperAnimation };

package/switch/index.d.ts

@@ -1,5 +1,47 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/switch" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { Type } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare class NgbSwitchTrack {
+    readonly switch: NgbSwitch;
+    readonly checked: i0.Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSwitchTrack, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbSwitchTrack, "button[ngbSwitchTrack]", ["ngbSwitchTrack"], {}, {}, never, never, true, never>;
+}
+declare class NgbSwitchThumb {
+    readonly switch: NgbSwitch;
+    private readonly dir;
+    readonly checked: i0.Signal<boolean>;
+    readonly rtl: i0.Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSwitchThumb, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbSwitchThumb, "[ngbSwitchThumb]", ["ngbSwitchThumb"], {}, {}, never, never, true, never>;
+}
+declare class NgbSwitchLabel {
+    readonly switch: NgbSwitch;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSwitchLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbSwitchLabel, "[ngbSwitchLabel]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbSwitch implements ControlValueAccessor {
+    readonly id: string;
+    readonly change: i0.OutputEmitterRef<boolean>;
+    readonly checked: i0.ModelSignal<boolean>;
+    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    private onChange?;
+    private onTouched?;
+    updateValue(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSwitch, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbSwitch, "[ngbSwitch]", ["ngbSwitch"], { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "change": "change"; "checked": "checkedChange"; }, never, never, true, never>;
+}
+declare function aliasSwitch(ngbSwitch: Type<NgbSwitch>): ({
+    provide: i0.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: Type<any>;
+    multi: boolean;
+}[] | {
+    provide: typeof NgbSwitch;
+    useExisting: Type<NgbSwitch>;
+})[];
+
+export { NgbSwitch, NgbSwitchLabel, NgbSwitchThumb, NgbSwitchTrack, aliasSwitch };

package/table/index.d.ts

@@ -1,5 +1,143 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/table" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, WritableSignal, OnDestroy, ViewContainerRef, EmbeddedViewRef } from '@angular/core';
+
+declare class NgbColumn {
+    readonly ngbColumn: _angular_core.InputSignal<string>;
+    readonly sticky: _angular_core.InputSignal<"" | "start" | "end">;
+    readonly cells: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly heads: _angular_core.Signal<TemplateRef<any> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbColumn, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbColumn, "[ngbColumn]", never, { "ngbColumn": { "alias": "ngbColumn"; "required": true; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; }, {}, ["cells", "heads"], never, true, never>;
+}
+
+declare class NgbCell {
+    readonly column: NgbColumn;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbCell, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbCell, "[ngbCell]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbCellDef {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbCellDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbCellDef, "[ngbCellDef]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NgbTable<T> {
+    private readonly injector;
+    private readonly differs;
+    private readonly thead;
+    private readonly tbody;
+    private readonly bodyRowDef;
+    private readonly headRowDef;
+    readonly columns: _angular_core.Signal<readonly NgbColumn[]>;
+    readonly plugins: WritableSignal<Set<(data: T[]) => T[]>>;
+    readonly data: _angular_core.InputSignal<T[]>;
+    readonly trackBy: _angular_core.InputSignal<(index: number, item: T) => any>;
+    protected readonly pluggedData: _angular_core.Signal<T[]>;
+    private _dataDiffers?;
+    private readonly _values;
+    constructor();
+    private _updateItemIndexContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTable<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTable<any>, "table[ngbTable]", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; }, {}, ["bodyRowDef", "headRowDef", "columns"], never, true, never>;
+}
+declare function aliasTable(table: typeof NgbTable): {
+    provide: typeof NgbTable;
+    useExisting: typeof NgbTable;
+};
+
+declare class NgbBodyRowDef {
+    readonly ngbBodyRowDefColumns: _angular_core.InputSignal<string[]>;
+    context: any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbBodyRowDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbBodyRowDef, "[ngbBodyRowDef]", never, { "ngbBodyRowDefColumns": { "alias": "ngbBodyRowDefColumns"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class NgbBodyRow implements OnDestroy {
+    readonly rowData: _angular_core.WritableSignal<any>;
+    readonly table: NgbTable<any>;
+    readonly rowDef: NgbBodyRowDef;
+    readonly container: _angular_core.Signal<ViewContainerRef>;
+    readonly ref: Map<NgbColumn, EmbeddedViewRef<any>>;
+    readonly sortedColumns: _angular_core.Signal<NgbColumn[]>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbBodyRow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbBodyRow, "[ngbBodyRow]", never, {}, {}, never, never, true, never>;
+}
+declare function aliasBodyRow(row: typeof NgbBodyRow): {
+    provide: typeof NgbBodyRow;
+    useExisting: typeof NgbBodyRow;
+};
+
+declare class NgbHead {
+    readonly column: NgbColumn;
+    readonly sticky: _angular_core.InputSignal<"" | "start" | "end">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbHead, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbHead, "[ngbHead]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbHeadDef {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbHeadDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbHeadDef, "[ngbHeadDef]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NgbHeadRowDef {
+    readonly ngbHeadRowDef: _angular_core.InputSignal<string[]>;
+    readonly ngbHeadRowDefSticky: _angular_core.InputSignal<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbHeadRowDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbHeadRowDef, "[ngbHeadRowDef]", never, { "ngbHeadRowDef": { "alias": "ngbHeadRowDef"; "required": true; "isSignal": true; }; "ngbHeadRowDefSticky": { "alias": "ngbHeadRowDefSticky"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class NgbHeadRow implements OnDestroy {
+    readonly headDef: NgbHeadRowDef;
+    readonly table: NgbTable<any>;
+    readonly container: _angular_core.Signal<ViewContainerRef>;
+    readonly ref: Map<NgbColumn, EmbeddedViewRef<any>>;
+    readonly sortedColumns: _angular_core.Signal<NgbColumn[]>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbHeadRow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbHeadRow, "[ngbHeadRow]", never, {}, {}, never, never, true, never>;
+}
+declare function aliasHeadRow(headRow: typeof NgbHeadRow): {
+    provide: typeof NgbHeadRow;
+    useExisting: typeof NgbHeadRow;
+};
+
+type SortDirection = 'asc' | 'desc' | '';
+interface Sort {
+    active: string;
+    direction: SortDirection;
+}
+type SortFn<T> = (data: T[], column: string, direction: SortDirection) => T[];
+declare class NgbSort<T> {
+    private readonly table;
+    readonly sortFn: _angular_core.InputSignal<SortFn<T> | undefined>;
+    readonly disableClear: _angular_core.InputSignal<boolean>;
+    readonly sortColumn: _angular_core.ModelSignal<string>;
+    readonly sortDirection: _angular_core.ModelSignal<SortDirection>;
+    readonly sortMode: _angular_core.InputSignal<"client" | "server">;
+    readonly sortChange: _angular_core.OutputEmitterRef<Sort>;
+    constructor();
+    private defaultSortFn;
+    sort(column: string, direction?: SortDirection): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSort<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSort<any>, "[ngbSort]", ["ngbSort"], { "sortFn": { "alias": "sortFn"; "required": false; "isSignal": true; }; "disableClear": { "alias": "disableClear"; "required": false; "isSignal": true; }; "sortColumn": { "alias": "sortColumn"; "required": false; "isSignal": true; }; "sortDirection": { "alias": "sortDirection"; "required": false; "isSignal": true; }; "sortMode": { "alias": "sortMode"; "required": false; "isSignal": true; }; }, { "sortColumn": "sortColumnChange"; "sortDirection": "sortDirectionChange"; "sortChange": "sortChange"; }, never, never, true, never>;
+}
+declare class NgbSortHeader<T extends NgbSort<U>, U = any> {
+    readonly sort: T;
+    readonly column: NgbColumn;
+    readonly disableClear: _angular_core.InputSignal<boolean>;
+    readonly sortDirection: _angular_core.Signal<SortDirection | undefined>;
+    setDirections(direction: SortDirection): void;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbSortHeader<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbSortHeader<any, any>, "[ngbSortHeader]", never, { "disableClear": { "alias": "disableClear"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare function aliasSort(directive: typeof NgbSort): {
+    provide: typeof NgbSort;
+    useExisting: typeof NgbSort;
+};
+declare function aliasSortHeader(directive: typeof NgbSortHeader<any, any>): {
+    provide: typeof NgbSortHeader;
+    useExisting: typeof NgbSortHeader<any, any>;
+};
+
+export { NgbBodyRow, NgbBodyRowDef, NgbCell, NgbCellDef, NgbColumn, NgbHead, NgbHeadDef, NgbHeadRow, NgbHeadRowDef, NgbSort, NgbSortHeader, NgbTable, aliasBodyRow, aliasHeadRow, aliasSort, aliasSortHeader, aliasTable };
+export type { SortDirection, SortFn };

package/tabs/index.d.ts

@@ -1,5 +1,85 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/tabs" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, ElementRef } from '@angular/core';
+import * as i1 from '@ngbase/adk/a11y';
+
+declare class NgbTabHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTabHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTabHeader, "[ngbTabHeader]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbTabLazy {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTabLazy, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTabLazy, "[ngbTabLazy]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbTab {
+    readonly header: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly lazy: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly mode: _angular_core.InputSignal<"hidden" | "lazy" | undefined>;
+    readonly value: _angular_core.InputSignal<string | number | undefined>;
+    readonly id: string;
+    readonly index: _angular_core.WritableSignal<number>;
+    readonly tabId: _angular_core.Signal<string | number>;
+    readonly active: _angular_core.WritableSignal<boolean>;
+    private activated;
+    readonly activeMode: _angular_core.Signal<boolean>;
+    readonly lazyTemplate: _angular_core.Signal<false | TemplateRef<any> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTab, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTab, "ngb-tab", ["ngbTab"], { "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, ["header", "lazy"], never, true, never>;
+}
+declare function aliasTab(tab: typeof NgbTab): {
+    provide: typeof NgbTab;
+    useExisting: typeof NgbTab;
+};
+
+interface NgbTabChangeEvent {
+    tab: NgbTab;
+    index: number;
+}
+declare class TabButtonsGroup {
+    private readonly tabGroup;
+    private readonly accessibleGroup;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabButtonsGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabButtonsGroup, "[ngbTabButtonsGroup]", never, {}, {}, never, never, true, [{ directive: typeof i1.AccessibleGroup; inputs: {}; outputs: {}; }]>;
+}
+declare class TabButton {
+    protected readonly tabGroup: NgbTabs<any>;
+    private readonly accessibleItem;
+    readonly ngbTabButton: _angular_core.InputSignal<NgbTab>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabButton, "button[ngbTabButton]", never, { "ngbTabButton": { "alias": "ngbTabButton"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.AccessibleItem; inputs: {}; outputs: {}; }]>;
+}
+declare class TabScroll {
+    readonly ngbTabScroll: _angular_core.InputSignal<"left" | "right">;
+    readonly tabGroup: NgbTabs<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabScroll, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabScroll, "button[ngbTabScroll]", never, { "ngbTabScroll": { "alias": "ngbTabScroll"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class NgbTabs<T extends NgbTab = NgbTab> {
+    readonly tabList: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly tabListContainer: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly tabButtons: _angular_core.Signal<readonly ElementRef<HTMLElement>[]>;
+    readonly scrollButtons: _angular_core.Signal<readonly ElementRef<HTMLElement>[]>;
+    readonly tabs: _angular_core.Signal<readonly T[]>;
+    readonly selectedIndex: _angular_core.ModelSignal<any>;
+    readonly selectedTabChange: _angular_core.OutputEmitterRef<NgbTabChangeEvent>;
+    private selectedId?;
+    private readonly tabMap;
+    readonly ayId: string;
+    constructor();
+    private updateScrollDisplay;
+    scroll(direction: 'left' | 'right'): void;
+    setActive(tab: NgbTab): void;
+    private scrollToActive;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTabs<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTabs<any>, "ngb-tabs", ["ngbTabs"], { "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; "selectedTabChange": "selectedTabChange"; }, ["tabs"], never, true, never>;
+}
+declare function aliasTabs<T extends NgbTab>(tab: typeof NgbTabs<T>): {
+    provide: typeof NgbTabs;
+    useExisting: typeof NgbTabs<T>;
+};
+
+export { NgbTab, NgbTabHeader, NgbTabLazy, NgbTabs, TabButton, TabButtonsGroup, TabScroll, aliasTab, aliasTabs };
+export type { NgbTabChangeEvent };

package/test/index.d.ts

@@ -1,5 +1,81 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/test" />
-export * from './public-api';
+import { DebugElement, Type, Component, Directive, Pipe, OutputEmitterRef, Provider, EnvironmentProviders } from '@angular/core';
+import { ComponentFixture } from '@angular/core/testing';
+
+declare class AngularQuery {
+    dEl: DebugElement;
+    constructor(dEl: DebugElement);
+    viewChild<U>(directive: Type<U>, selector?: string | Type<any>): U;
+    viewChildren<U>(directive: Type<U>, selector?: string): U[];
+    viewChildrenDebug<U>(directive: string | Type<U>): DebugElement[];
+    queryNative<U>(directive: string | Type<U>): DebugElement;
+    private getDirectiveType;
+}
+declare class ElementHelper<T extends HTMLElement> extends AngularQuery {
+    dEl: DebugElement;
+    el: T;
+    constructor(dEl: DebugElement);
+    get textContent(): string;
+    $<U extends HTMLElement>(selector: string | Type<any>): ElementHelper<U>;
+    $All<U extends HTMLElement>(selector: string | Type<any>): ElementHelper<U>[];
+    getByText(text: string, root?: string | Type<any>): HTMLElement | null;
+    hasClass(...classNames: string[]): boolean;
+    attr(name: string, value?: string): string | null;
+    css(name: string, value?: string): string;
+    click(): void;
+    focus(): void;
+    keydown(key: string, options?: KeyboardEventInit): KeyboardEvent;
+    mouseDown(options?: MouseEventInit): MouseEvent;
+    mouseEnter(options?: MouseEventInit): MouseEvent;
+    mouseLeave(options?: MouseEventInit): MouseEvent;
+    input(value: string | ((v: any) => any)): void;
+    paste(text: string): CustomEvent<unknown>;
+    type(value: string | string[], clear?: boolean): KeyboardEvent | MouseEvent;
+}
+declare class RenderResult<T> extends ElementHelper<HTMLElement> {
+    fixture: ComponentFixture<T>;
+    host: T;
+    constructor(fixture: ComponentFixture<T>);
+    detectChanges(): void;
+    whenStable(): Promise<void>;
+    formStable(): Promise<void>;
+    sleep(ms: number): Promise<void>;
+    inject<U>(directive: Type<U>): U;
+    injectHost<U>(directive: Type<U>): U;
+    queryRoot<U extends HTMLElement>(selector: string): ElementHelper<U>;
+    setInput(name: string, value: any): void;
+}
+interface FakeServiceResult<T extends Type<any>, C = any> {
+    provide: T;
+    useFactory: () => any;
+    v: InstanceType<T>;
+    _: C;
+}
+declare function fakeService<T extends Type<any>, I extends Partial<InstanceType<T>> | (() => Partial<InstanceType<T>> & {
+    __?: any;
+})>(service: T, impl: I): {
+    provide: T;
+    useFactory: () => any;
+    readonly v: InstanceType<T>;
+    readonly _: I extends () => Partial<InstanceType<T>> & {
+        __: infer C;
+    } ? C : never;
+};
+type FakeService<T extends Type<any>, I extends Partial<InstanceType<T>> | (() => Partial<InstanceType<T>> & {
+    __?: any;
+}) = any> = FakeServiceResult<T, I extends () => Partial<InstanceType<T>> & {
+    __: infer C;
+} ? C : never>;
+type RenderProvider = Provider | EnvironmentProviders | FakeService<any>;
+declare function render<T>(component: Type<T>, providers?: RenderProvider[], options?: {
+    inputs?: [string, any][];
+    components?: [Partial<Component>, Partial<Component>][];
+    directives?: [Partial<Directive>, Partial<Directive>][];
+    pipes?: [Partial<Pipe>, Partial<Pipe>][];
+    providers?: FakeService<any>[];
+}): Promise<RenderResult<T>>;
+declare function injectService<T>(service: Type<T>, providers?: RenderProvider[]): T;
+declare function firstOutputFrom<T>(observable: OutputEmitterRef<T>): Promise<T>;
+declare function sleep(ms: number): Promise<void>;
+
+export { ElementHelper, RenderResult, fakeService, firstOutputFrom, injectService, render, sleep };
+export type { FakeService, FakeServiceResult };

package/toggle/index.d.ts

@@ -1,5 +1,16 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/toggle" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare class NgbToggle implements ControlValueAccessor {
+    value: i0.ModelSignal<boolean>;
+    onChange: (_: boolean) => void;
+    onTouched: () => void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: VoidFunction): void;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbToggle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbToggle, "button[ngbToggle]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+export { NgbToggle };

package/toggle-group/index.d.ts

@@ -1,5 +1,39 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/toggle-group" />
-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 NgbToggleItem<T> {
+    private accessibleItem;
+    readonly toggleGroup: NgbToggleGroup<T>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly value: _angular_core.InputSignal<any>;
+    readonly active: _angular_core.Signal<boolean>;
+    constructor();
+    updateValue(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbToggleItem<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbToggleItem<any>, "button[ngbToggleItem]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.AccessibleItem; inputs: { "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+declare class NgbToggleGroup<T> implements ControlValueAccessor {
+    readonly accessibleGroup: AccessibleGroup;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly toggleItems: _angular_core.Signal<readonly NgbToggleItem<any>[]>;
+    readonly ayId: string;
+    readonly value: _angular_core.ModelSignal<T | T[] | undefined>;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    readonly disabled: _angular_core.ModelSignal<boolean>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string>;
+    constructor();
+    updateValue(value: T[]): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbToggleGroup<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbToggleGroup<any>, "[ngbToggleGroup]", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "disabled": "disabledChange"; }, ["toggleItems"], never, true, [{ directive: typeof i1.AccessibleGroup; inputs: {}; outputs: {}; }]>;
+}
+
+export { NgbToggleGroup, NgbToggleItem };

package/tooltip/index.d.ts

@@ -1,5 +1,60 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/tooltip" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { OnDestroy, ElementRef, InjectionToken, Type } from '@angular/core';
+import * as _ngbase_adk_popover from '@ngbase/adk/popover';
+import { PopoverPosition } from '@ngbase/adk/popover';
+import * as _angular_animations from '@angular/animations';
+
+declare const tooltipAnimation: _angular_animations.AnimationTriggerMetadata;
+declare class NgbTooltipTemplate implements OnDestroy {
+    readonly el: ElementRef<HTMLElement>;
+    readonly arrowTracker: {
+        values: _angular_core.WritableSignal<_ngbase_adk_popover.PopoverArrowTracker>;
+    } | null;
+    readonly content: _angular_core.WritableSignal<string>;
+    private target;
+    private position;
+    private hide;
+    private observer?;
+    constructor();
+    update(content: string, target: HTMLElement, position: PopoverPosition, hide: VoidFunction): void;
+    private setTarget;
+    private listenTarget;
+    private onRemoved;
+    setPosition(target: HTMLElement): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTooltipTemplate, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTooltipTemplate, "[ngbTooltip]", never, {}, {}, never, never, true, never>;
+}
+
+declare function provideNgbTooltipOptions(options: TooltipOptions): {
+    provide: InjectionToken<TooltipOptions>;
+    useValue: TooltipOptions;
+};
+interface TooltipOptions {
+    showDelay?: number;
+    hideDelay?: number;
+    position?: PopoverPosition;
+    component?: Type<NgbTooltipTemplate>;
+}
+declare class NgbTooltip implements OnDestroy {
+    private defaultOptions;
+    private el;
+    private tooltipService;
+    readonly ngbTooltip: _angular_core.InputSignal<string | undefined>;
+    readonly ngbTooltipPosition: _angular_core.InputSignal<("top" | "bottom" | "left" | "right" | "rs" | "re" | "ls" | "le" | "tl" | "tr" | "bl" | "br") | undefined>;
+    readonly delay: _angular_core.InputSignal<number>;
+    readonly options: _angular_core.Signal<TooltipOptions>;
+    timer: any;
+    constructor();
+    show: () => void;
+    removed: () => void;
+    hide: () => void;
+    quickHide: () => void;
+    private remove;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTooltip, "[ngbTooltip]", never, { "ngbTooltip": { "alias": "ngbTooltip"; "required": false; "isSignal": true; }; "ngbTooltipPosition": { "alias": "ngbTooltipPosition"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NgbTooltip, NgbTooltipTemplate, provideNgbTooltipOptions, tooltipAnimation };
+export type { TooltipOptions };