@ngbase/adk 0.1.10 → 0.1.12

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

package/tree/index.d.ts

@@ -1,5 +1,95 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/tree" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, ViewContainerRef, EmbeddedViewRef, Type } from '@angular/core';
+import * as i1 from '@ngbase/adk/a11y';
+import * as _ngbase_adk_bidi from '@ngbase/adk/bidi';
+
+interface FlatNode {
+    expandable: boolean;
+    id: string;
+    level: number;
+    isExpanded?: boolean;
+    parentId?: string;
+    index: number;
+    childrenCount: number;
+}
+interface TreeNodeData<T> {
+    level: number;
+    details: FlatNode;
+    data: T;
+}
+interface TreeNodeImplicit<T> {
+    $implicit: T;
+    level: number;
+}
+declare class NgbTree<T> {
+    private readonly injector;
+    private readonly differs;
+    readonly ayId: string;
+    readonly treeNodeDef: _angular_core.Signal<TemplateRef<any>>;
+    readonly container: _angular_core.Signal<ViewContainerRef>;
+    readonly dataSource: _angular_core.InputSignal<T[]>;
+    readonly trackBy: _angular_core.InputSignal<(index: number, item: T) => any>;
+    readonly children: _angular_core.InputSignal<(node: T) => T[]>;
+    readonly opened: _angular_core.WritableSignal<Set<string>>;
+    readonly trace: Map<string, {
+        ref: EmbeddedViewRef<TreeNodeImplicit<T>>;
+        parent: FlatNode;
+    }>;
+    private readonly _dataDiffers;
+    private readonly flattener;
+    private expanded;
+    constructor();
+    private removeNode;
+    getNode(id: string): T | undefined;
+    private renderNode;
+    toggle(data: FlatNode): void;
+    foldAll(): void;
+    expandAll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTree<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTree<any>, "[ngbTree]", ["ngbTree"], { "dataSource": { "alias": "dataSource"; "required": true; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": true; "isSignal": true; }; "children": { "alias": "children"; "required": true; "isSignal": true; }; }, {}, ["treeNodeDef"], never, true, [{ directive: typeof i1.AccessibleGroup; inputs: {}; outputs: {}; }]>;
+}
+declare function aliasTree<T>(tree: Type<NgbTree<T>>): {
+    provide: typeof NgbTree;
+    useExisting: Type<NgbTree<T>>;
+};
+
+declare class NgbTreeNodeToggle {
+    treeNode: NgbTreeNode<any>;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTreeNodeToggle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTreeNodeToggle, "[ngbTreeNodeToggle]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbTreeNodeDef<T> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTreeNodeDef<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTreeNodeDef<any>, "[ngbTreeNodeDef]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbTreeNodeContent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTreeNodeContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTreeNodeContent, "[ngbTreeNodeContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NgbTreeNode<T> {
+    readonly treeNodeDef: NgbTreeNodeDef<any>;
+    readonly tree: NgbTree<T>;
+    readonly data: TreeNodeData<T>;
+    readonly container: _angular_core.Signal<ViewContainerRef | undefined>;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    readonly parent: _angular_core.Signal<T | undefined>;
+    private readonly children;
+    readonly hasChildren: _angular_core.Signal<boolean>;
+    readonly dir: _ngbase_adk_bidi.Directionality;
+    readonly size: _angular_core.WritableSignal<number>;
+    readonly padding: _angular_core.Signal<{
+        [x: string]: string;
+    }>;
+    constructor();
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbTreeNode<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbTreeNode<any>, "[ngbTreeNode]", ["ngbTreeNode"], {}, {}, never, never, true, [{ directive: typeof i1.AccessibleItem; inputs: {}; outputs: {}; }]>;
+}
+declare function aliasTreeNode<T>(treeNode: Type<NgbTreeNode<T>>): {
+    provide: typeof NgbTreeNode;
+    useExisting: Type<NgbTreeNode<T>>;
+};
+
+export { NgbTree, NgbTreeNode, NgbTreeNodeContent, NgbTreeNodeDef, NgbTreeNodeToggle, aliasTree, aliasTreeNode };

package/utils/index.d.ts

@@ -1,5 +1,82 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/utils" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { PipeTransform, Type, Injector, Signal, ElementRef } from '@angular/core';
+import * as _angular_forms from '@angular/forms';
+import { AnimationTriggerMetadata } from '@angular/animations';
+
+declare class RangePipe implements PipeTransform {
+    transform(value: number): number[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RangePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<RangePipe, "range", true>;
+}
+
+declare function uniqueId(length?: number): string;
+declare function provideValueAccessor<T>(valueAccessor: Type<T>): {
+    provide: _angular_core.InjectionToken<readonly _angular_forms.ControlValueAccessor[]>;
+    useExisting: Type<any>;
+    multi: boolean;
+};
+interface ListenerOut {
+    on: () => void;
+    off: () => void;
+}
+declare function documentListener<T extends Event>(ev: string, fn: (e: T) => void, data?: Partial<AddEventListenerOptions & {
+    injector?: Injector;
+    lazy?: boolean;
+    skip?: number;
+    element?: HTMLElement | Document | Window;
+}>): ListenerOut;
+type FilterOptions<T, V = any> = {
+    filter: (v: V) => string;
+    query?: (v: V, search: string) => boolean;
+    key?: keyof T;
+    childrenFilter?: (v: T) => V[];
+};
+declare function filterFunction<T, V = T>(data: Signal<T[]> | T[], ops: Signal<FilterOptions<T, V>>): {
+    search: _angular_core.WritableSignal<string>;
+    list: _angular_core.WritableSignal<T[]>;
+    filteredList: Signal<T[]>;
+};
+
+type Cleanup = () => void;
+type CleanupRegisterFn = (fn: Cleanup) => void;
+declare function disposals(): {
+    afterNextRender: (fn: (cleanup: CleanupRegisterFn) => void) => () => void;
+};
+declare function cleanup(fn: () => void): void;
+
+declare function isServer(): boolean;
+declare function isClient(): boolean;
+
+declare const createHostAnimation: (animationNames: string[]) => AnimationTriggerMetadata;
+declare function fadeAnimation(time: string): AnimationTriggerMetadata;
+declare class DisableAnimation {
+    readonly animationDisabled: _angular_core.WritableSignal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DisableAnimation, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DisableAnimation, "[disableAnimation]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NumberOnly {
+    readonly el: ElementRef<HTMLInputElement>;
+    readonly min: _angular_core.InputSignal<number | undefined>;
+    readonly max: _angular_core.InputSignal<number | undefined>;
+    readonly len: _angular_core.InputSignal<number | undefined>;
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly _min: _angular_core.WritableSignal<number | undefined>;
+    readonly _max: _angular_core.WritableSignal<number | undefined>;
+    readonly _len: _angular_core.WritableSignal<number | undefined>;
+    constructor();
+    setValue(ev: Event): void;
+    private readonly allowedKeys;
+    onKeyDown: (e: KeyboardEvent) => void;
+    private isCtrlKey;
+    private handleArrowUpDown;
+    private getNewValue;
+    private validateValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberOnly, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NumberOnly, "input[ngbNumberOnly]", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "len": { "alias": "len"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+declare function padString(num: number | string): string;
+
+export { DisableAnimation, NumberOnly, RangePipe, cleanup, createHostAnimation, disposals, documentListener, fadeAnimation, filterFunction, isClient, isServer, padString, provideValueAccessor, uniqueId };
+export type { FilterOptions, ListenerOut };

package/virtualizer/index.d.ts

@@ -1,5 +1,45 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/virtualizer" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+
+type Orientation = 'vertical' | 'horizontal';
+interface VirtualForContext<T> {
+    $implicit: T;
+    index: number;
+}
+declare class VirtualFor<T> {
+    template: TemplateRef<VirtualForContext<T>>;
+    readonly virtualForOf: _angular_core.InputSignal<T[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VirtualFor<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<VirtualFor<any>, "[virtualFor][virtualForOf]", never, { "virtualForOf": { "alias": "virtualForOf"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+interface VirtualItem {
+    index: number;
+    position: number;
+}
+declare class Virtualizer<T> {
+    private readonly containerRef;
+    readonly virtualFor: _angular_core.Signal<VirtualFor<T>>;
+    readonly itemSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly buffer: _angular_core.InputSignal<number>;
+    readonly orientation: _angular_core.InputSignal<Orientation>;
+    private readonly scrollPosition;
+    private readonly containerSize;
+    readonly items: _angular_core.Signal<T[]>;
+    private readonly totalItems;
+    readonly totalContentSize: _angular_core.Signal<number>;
+    readonly isVertical: _angular_core.Signal<boolean>;
+    private readonly visibleIndexes;
+    readonly visibleItems: _angular_core.Signal<VirtualItem[]>;
+    private readonly client;
+    constructor();
+    getTransform(item: VirtualItem): string;
+    onScroll(event: Event): void;
+    onKeyDown(event: KeyboardEvent): void;
+    scrollToIndex(index: number, behavior?: ScrollBehavior): void;
+    private updateContainerSize;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Virtualizer<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Virtualizer<any>, "ngb-virtualizer, [ngbVirtualizer]", never, { "itemSize": { "alias": "itemSize"; "required": true; "isSignal": true; }; "buffer": { "alias": "buffer"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, ["virtualFor"], never, true, never>;
+}
+
+export { VirtualFor, Virtualizer };
+export type { Orientation, VirtualForContext };

package/a11y/accessibility-group.d.ts

@@ -1,46 +0,0 @@
-import { AccessibleItem } from './accessibility-item';
-import * as i0 from "@angular/core";
-export declare class AccessibleGroup {
-    private readonly allyService;
-    private readonly el;
-    private readonly document;
-    private readonly dir;
-    readonly ayId: import("@angular/core").ModelSignal<string | undefined>;
-    readonly columns: import("@angular/core").InputSignal<number | undefined>;
-    readonly ariaLabel: import("@angular/core").InputSignal<string>;
-    readonly ariaLabelledby: import("@angular/core").InputSignal<string>;
-    readonly isPopup: import("@angular/core").InputSignal<boolean>;
-    readonly loop: import("@angular/core").InputSignal<boolean>;
-    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-    readonly clickable: import("@angular/core").ModelSignal<boolean>;
-    readonly initialFocus: import("@angular/core").InputSignal<boolean>;
-    _ayId: import("@angular/core").WritableSignal<string | undefined>;
-    _disabled: import("@angular/core").WritableSignal<boolean>;
-    _ariaLabel: import("@angular/core").WritableSignal<string>;
-    _ariaLabelledby: import("@angular/core").WritableSignal<string>;
-    _isPopup: import("@angular/core").WritableSignal<boolean>;
-    _loop: import("@angular/core").WritableSignal<boolean>;
-    _columns: import("@angular/core").WritableSignal<number | undefined>;
-    _initialFocus: import("@angular/core").WritableSignal<boolean>;
-    private focusedItem?;
-    private isOn;
-    readonly elements: import("@angular/core").WritableSignal<AccessibleItem<any>[]>;
-    readonly items: import("@angular/core").Signal<AccessibleItem<any>[]>;
-    constructor();
-    private itemChanged;
-    handleFocusIn: (_: FocusEvent) => void;
-    handleFocusOut: (event: FocusEvent) => void;
-    on: () => void;
-    off: () => void;
-    onKeyDown: (event: KeyboardEvent) => void;
-    private findNextOrPreviousLevelItem;
-    focusItem(item?: AccessibleItem): void;
-    private focusIndex;
-    private getNextItem;
-    private findNextEnabledItem;
-    log(...args: any[]): void;
-    register(item: AccessibleItem): void;
-    unregister(item: AccessibleItem): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AccessibleGroup, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AccessibleGroup, "[ngbAccessibleGroup]", never, { "ayId": { "alias": "ayId"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; "isPopup": { "alias": "isPopup"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "initialFocus": { "alias": "initialFocus"; "required": false; "isSignal": true; }; }, { "ayId": "ayIdChange"; "clickable": "clickableChange"; }, never, never, true, never>;
-}

package/a11y/accessibility-item.d.ts

@@ -1,49 +0,0 @@
-import { ElementRef, OnDestroy, Signal } from '@angular/core';
-import { Subject } from 'rxjs';
-import { AccessibilityService } from './accessibility.service';
-import * as i0 from "@angular/core";
-export declare class AccessibleItem<T = any> implements OnDestroy {
-    readonly allyService: AccessibilityService;
-    readonly host: ElementRef<HTMLElement>;
-    readonly id: import("@angular/core").InputSignal<string>;
-    readonly ayId: import("@angular/core").InputSignal<string>;
-    readonly role: import("@angular/core").InputSignal<string>;
-    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-    readonly selected: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-    readonly data: import("@angular/core").InputSignal<T | undefined>;
-    readonly skip: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-    readonly level: import("@angular/core").ModelSignal<number>;
-    readonly expandable: import("@angular/core").ModelSignal<boolean>;
-    readonly expanded: import("@angular/core").ModelSignal<boolean>;
-    readonly selectedChange: import("@angular/core").OutputEmitterRef<number>;
-    _disabled: Signal<boolean>;
-    _selected: Signal<boolean>;
-    _ayId: import("@angular/core").WritableSignal<string>;
-    _data: import("@angular/core").WritableSignal<T | undefined>;
-    _id: import("@angular/core").WritableSignal<string>;
-    _skip: import("@angular/core").WritableSignal<boolean>;
-    _expandable: import("@angular/core").WritableSignal<boolean>;
-    _expanded: import("@angular/core").WritableSignal<boolean>;
-    readonly group: Signal<import("@ngbase/adk/a11y").AccessibleGroup | undefined>;
-    readonly pressed: import("@angular/core").WritableSignal<boolean>;
-    readonly hasPopup: Signal<boolean>;
-    readonly events: Subject<{
-        event: KeyboardEvent;
-        type: "enter" | "leave" | "click" | "keyRight" | "keyLeft";
-        item: AccessibleItem;
-    }>;
-    private count;
-    /**
-     * @internal when component is destroyed, we don't want to emit events
-     */
-    private isDestroyed;
-    constructor();
-    get el(): HTMLElement;
-    private onFocus;
-    focus(focus: boolean, isKeyboard: boolean): void;
-    blur: () => void;
-    click(): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AccessibleItem<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AccessibleItem<any>, "[ngbAccessibleItem]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "ayId": { "alias": "ayId"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "skip": { "alias": "skip"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "level": "levelChange"; "expandable": "expandableChange"; "expanded": "expandedChange"; "selectedChange": "selectedChange"; }, never, never, true, never>;
-}

package/a11y/accessibility.service.d.ts

@@ -1,17 +0,0 @@
-import { AccessibleGroup } from './accessibility-group';
-import * as i0 from "@angular/core";
-export declare class AccessibilityService {
-    readonly groups: import("@angular/core").WritableSignal<Map<string, AccessibleGroup>>;
-    private activeGroupOrder;
-    usingMouse: boolean;
-    constructor();
-    setActiveGroup(id: string): void;
-    removeActiveGroup(id: string): void;
-    isActive(key: string): boolean;
-    getPreviousGroup(): AccessibleGroup | undefined;
-    getGroup(key: string): AccessibleGroup | undefined;
-    addGroup(key: string, group: AccessibleGroup): void;
-    removeGroup(key: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AccessibilityService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AccessibilityService>;
-}

package/a11y/autofocus.d.ts

@@ -1,18 +0,0 @@
-import { OnDestroy } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare class Autofocus implements OnDestroy {
-    private el;
-    private applicationRef;
-    private intersectionObserver?;
-    private document;
-    readonly focusDelay: import("@angular/core").InputSignal<number>;
-    private subscription?;
-    private isFocused;
-    private client;
-    constructor();
-    private elWatcher;
-    private focusElement;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<Autofocus, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<Autofocus, "[ngbAutofocus]", never, { "focusDelay": { "alias": "focusDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/a11y/focus-trap.d.ts

@@ -1,15 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class FocusTrap {
-    private el;
-    readonly ngbFocusTrap: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-    readonly focusInitial: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-    _focusTrap: import("@angular/core").WritableSignal<boolean>;
-    _focusInitial: import("@angular/core").WritableSignal<boolean>;
-    private firstFocusableElement;
-    private lastFocusableElement;
-    constructor();
-    private setFocusableElements;
-    onKeydown: (event: KeyboardEvent) => void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FocusTrap, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusTrap, "[ngbFocusTrap]", never, { "ngbFocusTrap": { "alias": "ngbFocusTrap"; "required": false; "isSignal": true; }; "focusInitial": { "alias": "focusInitial"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/a11y/public-api.d.ts

@@ -1,4 +0,0 @@
-export { AccessibleGroup } from './accessibility-group';
-export { AccessibleItem } from './accessibility-item';
-export { FocusTrap } from './focus-trap';
-export { Autofocus } from './autofocus';

package/accordion/accordion-content.d.ts

@@ -1,8 +0,0 @@
-import { NgbAccordion } from './accordion-item';
-import * as i0 from "@angular/core";
-export declare class NgbAccordionContent {
-    readonly accordion: NgbAccordion;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbAccordionContent, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbAccordionContent, "[ngbAccordionContent]", never, {}, {}, never, never, true, never>;
-}
-export declare const slideAnimation: import("@angular/animations").AnimationTriggerMetadata;

package/accordion/accordion-group.d.ts

@@ -1,10 +0,0 @@
-import { NgbAccordion } from './accordion-item';
-import * as i0 from "@angular/core";
-export declare class NgbAccordionGroup {
-    readonly items: import("@angular/core").Signal<readonly NgbAccordion[]>;
-    readonly multiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-    readonly activeId: import("@angular/core").WritableSignal<string>;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbAccordionGroup, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbAccordionGroup, "[ngbAccordionGroup]", ["ngbAccordionGroup"], { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; }, {}, ["items"], never, true, never>;
-}

package/accordion/accordion-header.d.ts

@@ -1,7 +0,0 @@
-import { NgbAccordion } from './accordion-item';
-import * as i0 from "@angular/core";
-export declare class NgbAccordionHeader {
-    accordion: NgbAccordion;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbAccordionHeader, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbAccordionHeader, "[ngbAccordionHeader]", never, {}, {}, never, never, true, never>;
-}

package/accordion/accordion-item.d.ts

@@ -1,16 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class NgbAccordion {
-    private accordionService;
-    readonly expanded: import("@angular/core").ModelSignal<boolean>;
-    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-    readonly opened: import("@angular/core").OutputEmitterRef<boolean>;
-    readonly closed: import("@angular/core").OutputEmitterRef<boolean>;
-    readonly id: string;
-    toggle(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbAccordion, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbAccordion, "[ngbAccordion]", ["ngbAccordion"], { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
-}
-export declare function aliasAccordion(accordion: typeof NgbAccordion): {
-    provide: typeof NgbAccordion;
-    useExisting: typeof NgbAccordion;
-};

package/accordion/public-api.d.ts

@@ -1,4 +0,0 @@
-export { NgbAccordionGroup } from './accordion-group';
-export { NgbAccordion, aliasAccordion } from './accordion-item';
-export { NgbAccordionHeader } from './accordion-header';
-export { NgbAccordionContent, slideAnimation } from './accordion-content';

package/autocomplete/autocomplete-input.d.ts

@@ -1,19 +0,0 @@
-import { ElementRef } from '@angular/core';
-import { InputBase } from '@ngbase/adk/form-field';
-import { NgbAutocomplete } from './autocomplete';
-import * as i0 from "@angular/core";
-import * as i1 from "@ngbase/adk/form-field";
-export declare class NgbAutocompleteInput<T> {
-    readonly autoComplete: NgbAutocomplete<any>;
-    readonly input: InputBase<any>;
-    readonly el: ElementRef<HTMLInputElement>;
-    readonly isChip: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-    readonly ngbAutocompleteInput: import("@angular/core").OutputEmitterRef<string>;
-    constructor();
-    onFocus(): void;
-    close(): void;
-    updateValue(value: string): void;
-    updateSearch(value: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbAutocompleteInput<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbAutocompleteInput<any>, "[ngbAutocompleteInput]", ["ngbAutocompleteInput"], { "isChip": { "alias": "isChip"; "required": false; "isSignal": true; }; }, { "ngbAutocompleteInput": "ngbAutocompleteInput"; }, never, never, true, [{ directive: typeof i1.InputBase; inputs: { "value": "value"; }; outputs: { "valueChange": "valueChange"; }; }]>;
-}