@ngbase/adk 0.1.11 → 0.1.12

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

package/tour/index.d.ts

@@ -1,5 +1,70 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/tour" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { ElementRef, OnDestroy, ViewContainerRef } from '@angular/core';
+import { DialogInput, BaseDialog, DialogOptions } from '@ngbase/adk/portal';
+import { PopoverOptions } from '@ngbase/adk/popover';
+import * as _angular_animations from '@angular/animations';
+
+declare class NgbTourService {
+    private readonly popover;
+    readonly steps: _angular_core.WritableSignal<NgbTourStep[]>;
+    readonly step: _angular_core.WritableSignal<number>;
+    private readonly ids;
+    readonly currentStep: _angular_core.Signal<NgbTourStep | undefined>;
+    private diaRef?;
+    private id;
+    private template;
+    readonly showPrev: _angular_core.Signal<boolean>;
+    readonly showNext: _angular_core.Signal<boolean>;
+    readonly isLast: _angular_core.Signal<boolean>;
+    readonly totalSteps: _angular_core.Signal<number>;
+    scrolled: _angular_core.WritableSignal<number>;
+    private readonly clipPath;
+    addStep(step: NgbTourStep): void;
+    start<T>(comp: DialogInput<T>, ids: string[]): void;
+    prev(): void;
+    next(): void;
+    go(id: number): void;
+    stop(): void;
+    private showOverlay;
+    private hideOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTourService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NgbTourService>;
+}
+
+declare class NgbTourStep {
+    readonly el: ElementRef<any>;
+    readonly tourService: NgbTourService;
+    readonly ngbTourStep: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTourStep, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTourStep, "[ngbTourStep]", never, { "ngbTourStep": { "alias": "ngbTourStep"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NgbTour {
+    readonly tourService: NgbTourService;
+    readonly steps: _angular_core.Signal<readonly NgbTourStep[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTour, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTour, "[ngbTour]", never, {}, {}, ["steps"], never, true, never>;
+}
+
+declare class NgbBaseTour extends BaseDialog implements OnDestroy {
+    readonly tourService: NgbTourService;
+    readonly myDialog: _angular_core.Signal<ViewContainerRef | undefined>;
+    readonly container: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    options: DialogOptions;
+    tooltipOptions: PopoverOptions;
+    private lastPosition;
+    readonly scrolled: _angular_core.WritableSignal<number>;
+    readonly clipPath: _angular_core.Signal<string>;
+    constructor();
+    private updateDimension;
+    setOptions(options: DialogOptions): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbBaseTour, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgbBaseTour, "[ngbTour]", never, {}, {}, never, never, true, never>;
+}
+
+declare const slideInOutAnimation: _angular_animations.AnimationTriggerMetadata;
+declare const tourAnimation: _angular_animations.AnimationTriggerMetadata[];
+
+export { NgbBaseTour, NgbTour, NgbTourService, NgbTourStep, slideInOutAnimation, tourAnimation };

package/translate/index.d.ts

@@ -1,5 +1,58 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/translate" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { PipeTransform, EnvironmentInjector, InjectionToken } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+
+declare class Translate implements PipeTransform {
+    private translate;
+    private value;
+    private linkedValue;
+    transform(value: string, ...args: any[]): _angular_core.WritableSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Translate, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<Translate, "t", true>;
+}
+declare function translate(): (value: string, ...args: any[]) => string;
+
+declare class TranslateService {
+    private config;
+    private readonly _defaultLang;
+    private readonly _currentLang;
+    readonly defaultLang: _angular_core.Signal<string>;
+    readonly currentLang: _angular_core.Signal<string>;
+    private lastLang;
+    private readonly cachedTranslations;
+    private readonly _translationData;
+    readonly translations: _angular_core.Signal<Translation>;
+    readonly envInjector: EnvironmentInjector;
+    readonly status: _angular_core.WritableSignal<"error" | "loading" | "done">;
+    init(): rxjs.Observable<Translation<any>>;
+    setDefaultLang(lang: string): void;
+    use(lang: string): void;
+    private loadTranslations;
+    /**
+     * @key - The key to translate.
+     * @data - The data to pass to the translation.
+     * @returns The translated value.
+     * The key can be a string or a nested key.
+     * The data is used to interpolate the translation.
+     */
+    translate: (key: string, params?: Record<string, any>, translationData?: Translation) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TranslateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TranslateService>;
+}
+declare const injectTranslate: () => TranslateService;
+
+type Translation<T = any> = Record<string, T>;
+interface TranslateConfig {
+    defaultLang: string;
+    preloadedLanguages?: Record<string, Translation>;
+    path?: string;
+    loader?: (lang: string, fallbackLang: string, config: TranslateConfig) => Observable<Translation>;
+}
+declare function provideTranslate(config: TranslateConfig): (typeof TranslateService | _angular_core.EnvironmentProviders | {
+    provide: InjectionToken<TranslateConfig>;
+    useValue: TranslateConfig;
+})[];
+
+export { Translate, injectTranslate, provideTranslate, translate };
+export type { TranslateConfig };