@ngbase/adk 0.1.0

package/slider/slider.d.ts

@@ -0,0 +1,73 @@
+import { ElementRef, Type } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngbase/adk/drag";
+export declare class SliderTrack {
+    readonly slider: NgbSlider;
+    private readonly drag;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliderTrack, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SliderTrack, "[ngbSliderTrack]", never, {}, {}, never, never, true, [{ directive: typeof i1.Drag; inputs: {}; outputs: {}; }]>;
+}
+export declare class SliderRange {
+    readonly slider: NgbSlider;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliderRange, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SliderRange, "[ngbSliderRange]", never, {}, {}, never, never, true, never>;
+}
+export declare class SliderThumb {
+    readonly slider: NgbSlider;
+    readonly el: ElementRef<any>;
+    readonly index: import("@angular/core").Signal<number>;
+    readonly value: import("@angular/core").Signal<number | number[] | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliderThumb, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SliderThumb, "[ngbSliderThumb]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgbSlider implements ControlValueAccessor {
+    private readonly el;
+    private readonly dir;
+    private readonly drag;
+    private readonly track;
+    readonly thumbs: import("@angular/core").Signal<readonly ElementRef<HTMLElement>[]>;
+    readonly value: import("@angular/core").ModelSignal<number | number[] | undefined>;
+    readonly step: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    readonly min: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    readonly max: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    readonly range: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly orientation: import("@angular/core").InputSignal<"horizontal" | "vertical">;
+    private onChange?;
+    private onTouched?;
+    readonly noOfThumbs: import("@angular/core").Signal<number[]>;
+    private readonly totalSteps;
+    private values;
+    private activeIndex;
+    private totalWidth;
+    private totalSliderWidth;
+    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: i0.ɵɵFactoryDeclaration<NgbSlider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<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"; }, never, never, true, never>;
+}
+export declare const provideSlider: (slider: Type<NgbSlider>) => ({
+    provide: import("@angular/core").InjectionToken<readonly import("@angular/forms").ControlValueAccessor[]>;
+    useExisting: Type<any>;
+    multi: boolean;
+} | {
+    provide: typeof NgbSlider;
+    useExisting: Type<NgbSlider>;
+})[];

package/sonner/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/sonner" />
+export * from './public-api';

package/sonner/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './sonner.service';
+export * from './sonner';

package/sonner/sonner.d.ts

@@ -0,0 +1,24 @@
+import * as i0 from "@angular/core";
+export declare class SonnerBase {
+    readonly ngbSonnerBase: import("@angular/core").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>;
+}
+export declare class NgbSonner {
+    readonly messages: import("@angular/core").WritableSignal<SonnerMessage[]>;
+    addMessage(message: string, type: SonnerType, data?: SonnerData): void;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSonner, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbSonner, "ngb-sonner", never, {}, {}, never, never, true, never>;
+}
+export interface SonnerMessage {
+    message: string;
+    data?: SonnerData;
+    type?: SonnerType;
+    id?: string;
+}
+export type SonnerType = 'default' | 'success' | 'error' | 'warning' | 'info';
+export interface SonnerData {
+    description?: string;
+    timeout?: number;
+}

package/sonner/sonner.service.d.ts

@@ -0,0 +1,21 @@
+import { Type } from '@angular/core';
+import { NgbSonner, SonnerData, SonnerType } from './sonner';
+import * as i0 from "@angular/core";
+export 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>;
+}
+export 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;
+};

package/stepper/animation.d.ts

@@ -0,0 +1 @@
+export declare const slideAnimation: import("@angular/animations").AnimationTriggerMetadata;

package/stepper/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/stepper" />
+export * from './public-api';

package/stepper/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './stepper';
+export * from './step';
+export * from './animation';

package/stepper/step.d.ts

@@ -0,0 +1,24 @@
+import { TemplateRef } from '@angular/core';
+import { NgbStepper } from './stepper';
+import * as i0 from "@angular/core";
+export declare class NgbStep {
+    readonly stepper: NgbStepper;
+    readonly header: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    readonly stepContainer: import("@angular/core").Signal<TemplateRef<any>>;
+    readonly title: import("@angular/core").InputSignal<any>;
+    readonly index: import("@angular/core").Signal<number>;
+    readonly active: import("@angular/core").Signal<boolean>;
+    private readonly template;
+    readonly horizontalTemplate: import("@angular/core").Signal<false | TemplateRef<any> | null>;
+    readonly verticalTemplate: import("@angular/core").Signal<false | TemplateRef<any> | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbStep, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbStep, "[ngbStep]", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, ["header"], ["*"], true, never>;
+}
+export declare class NgbStepHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbStepHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbStepHeader, "[ngbStepHeader]", never, {}, {}, never, never, true, never>;
+}
+export declare const provideStep: (step: typeof NgbStep) => {
+    provide: typeof NgbStep;
+    useExisting: typeof NgbStep;
+};

package/stepper/stepper.d.ts

@@ -0,0 +1,26 @@
+import { NgbStep } from './step';
+import * as i0 from "@angular/core";
+export declare class NgbStepperStep {
+    readonly stepper: NgbStepper;
+    readonly ngbStepperStep: import("@angular/core").InputSignal<number>;
+    readonly last: import("@angular/core").Signal<boolean>;
+    readonly status: import("@angular/core").Signal<"completed" | "active" | "inactive">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbStepperStep, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbStepperStep, "[ngbStepperStep]", never, { "ngbStepperStep": { "alias": "ngbStepperStep"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class NgbStepper {
+    readonly steps: import("@angular/core").Signal<readonly NgbStep[]>;
+    readonly activeIndex: import("@angular/core").ModelSignal<number>;
+    readonly direction: import("@angular/core").InputSignal<"horizontal" | "vertical">;
+    readonly first: import("@angular/core").Signal<boolean>;
+    readonly last: import("@angular/core").Signal<boolean>;
+    readonly completed: import("@angular/core").Signal<boolean>;
+    nextStep(): void;
+    prevStep(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbStepper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbStepper, "[ngbStepper]", ["ngbStepper"], { "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; }, ["steps"], ["*"], true, never>;
+}
+export declare const provideStepper: (stepper: typeof NgbStepper) => {
+    provide: typeof NgbStepper;
+    useExisting: typeof NgbStepper;
+};

package/switch/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/switch" />
+export * from './public-api';

package/switch/public-api.d.ts

@@ -0,0 +1 @@
+export * from './switch';

package/switch/switch.d.ts

@@ -0,0 +1,44 @@
+import { Type } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class NgbSwitchTrack {
+    readonly switch: NgbSwitch;
+    readonly checked: import("@angular/core").Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSwitchTrack, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbSwitchTrack, "button[ngbSwitchTrack]", ["ngbSwitchTrack"], {}, {}, never, never, true, never>;
+}
+export declare class NgbSwitchThumb {
+    readonly switch: NgbSwitch;
+    private readonly dir;
+    readonly checked: import("@angular/core").Signal<boolean>;
+    readonly rtl: import("@angular/core").Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSwitchThumb, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbSwitchThumb, "[ngbSwitchThumb]", ["ngbSwitchThumb"], {}, {}, never, never, true, never>;
+}
+export declare class NgbSwitchLabel {
+    readonly switch: NgbSwitch;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSwitchLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbSwitchLabel, "[ngbSwitchLabel]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgbSwitch implements ControlValueAccessor {
+    readonly id: string;
+    readonly change: import("@angular/core").OutputEmitterRef<boolean>;
+    readonly checked: import("@angular/core").ModelSignal<boolean>;
+    readonly disabled: import("@angular/core").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>;
+}
+export declare function provideSwitch(ngbSwitch: Type<NgbSwitch>): ({
+    provide: import("@angular/core").InjectionToken<readonly import("@angular/forms").ControlValueAccessor[]>;
+    useExisting: Type<any>;
+    multi: boolean;
+}[] | {
+    provide: typeof NgbSwitch;
+    useExisting: Type<NgbSwitch>;
+})[];

package/table/body-cell.d.ts

@@ -0,0 +1,11 @@
+import { NgbColumn } from './column';
+import * as i0 from "@angular/core";
+export declare class NgbCell {
+    readonly column: NgbColumn;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbCell, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbCell, "[ngbCell]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgbCellDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbCellDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbCellDef, "[ngbCellDef]", never, {}, {}, never, never, true, never>;
+}

package/table/body-row.d.ts

@@ -0,0 +1,21 @@
+import { ViewContainerRef, OnDestroy, EmbeddedViewRef } from '@angular/core';
+import { NgbTable } from './table';
+import { NgbColumn } from './column';
+import * as i0 from "@angular/core";
+export declare class NgbBodyRowDef {
+    readonly ngbBodyRowDefColumns: import("@angular/core").InputSignal<string[]>;
+    context: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbBodyRowDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbBodyRowDef, "[ngbBodyRowDef]", never, { "ngbBodyRowDefColumns": { "alias": "ngbBodyRowDefColumns"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class NgbBodyRow implements OnDestroy {
+    readonly def: any;
+    readonly table: NgbTable<any>;
+    readonly rowDef: NgbBodyRowDef;
+    readonly container: import("@angular/core").Signal<ViewContainerRef | undefined>;
+    readonly ref: Map<NgbColumn, EmbeddedViewRef<any>>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbBodyRow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbBodyRow, "[ngbBodyRow]", never, {}, {}, never, never, true, never>;
+}

package/table/column.d.ts

@@ -0,0 +1,10 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class NgbColumn {
+    readonly ngbColumn: import("@angular/core").InputSignal<string>;
+    readonly sticky: import("@angular/core").InputSignal<"" | "start" | "end">;
+    readonly cells: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    readonly heads: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbColumn, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbColumn, "[ngbColumn]", never, { "ngbColumn": { "alias": "ngbColumn"; "required": true; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; }, {}, ["cells", "heads"], never, true, never>;
+}

package/table/head-cell.d.ts

@@ -0,0 +1,12 @@
+import { NgbColumn } from './column';
+import * as i0 from "@angular/core";
+export declare class NgbHead {
+    readonly column: NgbColumn;
+    readonly sticky: import("@angular/core").InputSignal<"" | "start" | "end">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbHead, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbHead, "[ngbHead]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgbHeadDef {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbHeadDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbHeadDef, "[ngbHeadDef]", never, {}, {}, never, never, true, never>;
+}

package/table/head-row.d.ts

@@ -0,0 +1,21 @@
+import { ViewContainerRef, EmbeddedViewRef, OnDestroy } from '@angular/core';
+import { NgbTable } from './table';
+import { NgbColumn } from './column';
+import * as i0 from "@angular/core";
+export declare class NgbHeadRowDef {
+    readonly ngbHeadRowDef: import("@angular/core").InputSignal<string[] | undefined>;
+    readonly ngbHeadRowDefSticky: import("@angular/core").InputSignal<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbHeadRowDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbHeadRowDef, "[ngbHeadRowDef]", never, { "ngbHeadRowDef": { "alias": "ngbHeadRowDef"; "required": false; "isSignal": true; }; "ngbHeadRowDefSticky": { "alias": "ngbHeadRowDefSticky"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class NgbHeadRow implements OnDestroy {
+    def: any;
+    table: NgbTable<any>;
+    container: import("@angular/core").Signal<ViewContainerRef | undefined>;
+    ref: Map<NgbColumn, EmbeddedViewRef<any>>;
+    headDef: NgbHeadRowDef;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbHeadRow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbHeadRow, "[ngbHeadRow]", never, {}, {}, never, never, true, never>;
+}

package/table/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/table" />
+export * from './public-api';

package/table/public-api.d.ts

@@ -0,0 +1,8 @@
+import { NgbCell, NgbCellDef } from './body-cell';
+import { NgbBodyRow, NgbBodyRowDef } from './body-row';
+import { NgbColumn } from './column';
+import { NgbHead, NgbHeadDef } from './head-cell';
+import { NgbHeadRow, NgbHeadRowDef } from './head-row';
+import { NgbTable } from './table';
+declare const TableComponents: (typeof NgbHeadDef)[];
+export { NgbBodyRow, NgbBodyRowDef, NgbCell, NgbCellDef, NgbHead, NgbHeadDef, NgbHeadRow, NgbHeadRowDef, NgbColumn, NgbTable, TableComponents, };

package/table/table.d.ts

@@ -0,0 +1,32 @@
+import { InjectionToken } from '@angular/core';
+import { NgbColumn } from './column';
+import * as i0 from "@angular/core";
+export declare const ROW_TOKEN: InjectionToken<any>;
+export declare class NgbTable<T> {
+    private readonly thead;
+    private readonly tbody;
+    private readonly bodyRowDef;
+    private readonly headRowDef;
+    readonly columns: import("@angular/core").Signal<readonly NgbColumn[]>;
+    readonly data: import("@angular/core").InputSignal<T[]>;
+    readonly trackBy: import("@angular/core").InputSignal<(index: number, item: T) => any>;
+    private readonly injector;
+    private readonly differs;
+    private _dataDiffers?;
+    private readonly _values;
+    private readonly valuesTracker;
+    constructor();
+    private _updateItemIndexContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTable<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<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>;
+}
+export declare class TableOutletContext<T> {
+    $implicit: T;
+    index?: number;
+    count?: number;
+    first?: boolean;
+    last?: boolean;
+    even?: boolean;
+    odd?: boolean;
+    constructor(data: T);
+}

package/tabs/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/tabs" />
+export * from './public-api';

package/tabs/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './tab';
+export * from './tab-group';

package/tabs/tab-group.d.ts

@@ -0,0 +1,52 @@
+import { ElementRef } from '@angular/core';
+import { NgbTab } from './tab';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngbase/adk/a11y";
+export interface TabChangeEvent {
+    tab: NgbTab;
+    index: number;
+}
+export declare class TabButtonsGroup {
+    private readonly tabGroup;
+    private readonly accessibleGroup;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabButtonsGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabButtonsGroup, "[ngbTabButtonsGroup]", never, {}, {}, never, never, true, [{ directive: typeof i1.AccessibleGroup; inputs: {}; outputs: {}; }]>;
+}
+export declare class TabButton {
+    private readonly tabGroup;
+    private readonly accessibleItem;
+    readonly ngbTabButton: import("@angular/core").InputSignal<NgbTab>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabButton, "button[ngbTabButton]", never, { "ngbTabButton": { "alias": "ngbTabButton"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.AccessibleItem; inputs: {}; outputs: {}; }]>;
+}
+export declare class TabScroll {
+    readonly ngbTabScroll: import("@angular/core").InputSignal<"left" | "right">;
+    readonly tabGroup: NgbTabs<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabScroll, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabScroll, "button[ngbTabScroll]", never, { "ngbTabScroll": { "alias": "ngbTabScroll"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class NgbTabs<T extends NgbTab = NgbTab> {
+    readonly tabList: import("@angular/core").Signal<ElementRef<HTMLElement>>;
+    readonly tabListContainer: import("@angular/core").Signal<ElementRef<HTMLElement>>;
+    readonly tabButtons: import("@angular/core").Signal<readonly ElementRef<HTMLElement>[]>;
+    readonly scrollButtons: import("@angular/core").Signal<readonly ElementRef<HTMLElement>[]>;
+    readonly tabs: import("@angular/core").Signal<readonly T[]>;
+    readonly selectedIndex: import("@angular/core").ModelSignal<any>;
+    readonly selectedTabChange: import("@angular/core").OutputEmitterRef<TabChangeEvent>;
+    private selectedId?;
+    private readonly tabMap;
+    readonly ayId: string;
+    constructor();
+    private updateScrollDisplay;
+    scroll(direction: 'left' | 'right'): void;
+    setActive(tab: NgbTab): void;
+    private scrollToActive;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTabs<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbTabs<any>, "ngb-tabs", ["ngbTabs"], { "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; "selectedTabChange": "selectedTabChange"; }, ["tabs"], [".tab-start-header-content", ".tab-header-content", "*"], true, never>;
+}
+export declare function provideTabs<T extends NgbTab>(tab: typeof NgbTabs<T>): {
+    provide: typeof NgbTabs;
+    useExisting: typeof NgbTabs<T>;
+};

package/tabs/tab.d.ts

@@ -0,0 +1,31 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class NgbTabHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTabHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbTabHeader, "[ngbTabHeader]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgbTabLazy {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTabLazy, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbTabLazy, "[ngbTabLazy]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgbTab {
+    readonly header: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    readonly lazy: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    readonly label: import("@angular/core").InputSignal<string>;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly mode: import("@angular/core").InputSignal<"hidden" | "lazy" | undefined>;
+    readonly value: import("@angular/core").InputSignal<string | number | undefined>;
+    readonly id: string;
+    readonly index: import("@angular/core").WritableSignal<number>;
+    readonly tabId: import("@angular/core").Signal<string | number>;
+    readonly active: import("@angular/core").WritableSignal<boolean>;
+    private activated;
+    readonly activeMode: import("@angular/core").Signal<boolean>;
+    readonly lazyTemplate: import("@angular/core").Signal<false | TemplateRef<any> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTab, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<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"], ["*"], true, never>;
+}
+export declare function provideTab(tab: typeof NgbTab): {
+    provide: typeof NgbTab;
+    useExisting: typeof NgbTab;
+};

package/test/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/test" />
+export * from './public-api';

package/test/public-api.d.ts

@@ -0,0 +1 @@
+export * from './utils';

package/test/utils.d.ts

@@ -0,0 +1,62 @@
+import { Component, DebugElement, Directive, EnvironmentProviders, OutputEmitterRef, Pipe, Provider, Type } 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;
+}
+export declare class ElementHelper<T extends HTMLElement> extends AngularQuery {
+    dEl: DebugElement;
+    el: T;
+    constructor(dEl: DebugElement);
+    get textContent(): string | null;
+    $<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;
+}
+export 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;
+}
+export declare function fakeService<T extends Type<any>>(service: T, impl: Partial<InstanceType<T>> | (() => Partial<InstanceType<T>>)): {
+    provide: T;
+    useFactory: () => Partial<InstanceType<T>>;
+};
+type FakeService<T extends Type<any>> = ReturnType<typeof fakeService<T>>;
+type RenderProvider = Provider | EnvironmentProviders | FakeService<any>;
+export 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>>;
+export declare function injectService<T>(service: Type<T>, providers?: RenderProvider[]): T;
+export declare function firstOutputFrom<T>(observable: OutputEmitterRef<T>): Promise<T>;
+export declare function sleep(ms: number): Promise<void>;
+export {};

package/toggle/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/toggle" />
+export * from './public-api';

package/toggle/public-api.d.ts

@@ -0,0 +1 @@
+export * from './toggle';

package/toggle/toggle.d.ts

@@ -0,0 +1,13 @@
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class NgbToggle implements ControlValueAccessor {
+    value: import("@angular/core").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>;
+}

package/toggle-group/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngbase/adk/toggle-group" />
+export * from './public-api';

package/toggle-group/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './toggle-group';
+export * from './toggle-item';

package/toggle-group/toggle-group.d.ts

@@ -0,0 +1,25 @@
+import { ControlValueAccessor } from '@angular/forms';
+import { AccessibleGroup } from '@ngbase/adk/a11y';
+import { NgbToggleItem } from './toggle-item';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngbase/adk/a11y";
+export declare class NgbToggleGroup<T> implements ControlValueAccessor {
+    readonly accessibleGroup: AccessibleGroup;
+    readonly multiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly toggleItems: import("@angular/core").Signal<readonly NgbToggleItem<any>[]>;
+    readonly ayId: string;
+    readonly value: import("@angular/core").ModelSignal<T | T[] | undefined>;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    readonly disabled: import("@angular/core").ModelSignal<boolean>;
+    readonly ariaLabel: import("@angular/core").InputSignal<string>;
+    readonly ariaLabelledby: import("@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: i0.ɵɵFactoryDeclaration<NgbToggleGroup<any>, never>;
+    static ɵdir: i0.ɵɵ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: {}; }]>;
+}