@ngbase/adk 0.1.11 → 0.1.12

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

package/autocomplete/autocomplete.d.ts

@@ -1,34 +0,0 @@
-import { Type } from '@angular/core';
-import { NgbChip } from '@ngbase/adk/chip';
-import { SelectBase } from '@ngbase/adk/select';
-import { FilterOptions } from '@ngbase/adk/utils';
-import { NgbAutocompleteInput } from './autocomplete-input';
-import * as i0 from "@angular/core";
-export declare class NgbAutocomplete<T> extends SelectBase<T> {
-    readonly searchInput: import("@angular/core").Signal<NgbAutocompleteInput<any> | undefined>;
-    readonly chips: import("@angular/core").Signal<readonly NgbChip<any>[]>;
-    readonly filterFn: import("@angular/core").InputSignal<(option: string) => string>;
-    readonly queryFn: import("@angular/core").InputSignal<((query: string, option: any) => boolean) | undefined>;
-    readonly filterOptions: import("@angular/core").InputSignal<FilterOptions<T> | undefined>;
-    readonly optionsFilter: {
-        search: import("@angular/core").WritableSignal<string>;
-        list: import("@angular/core").WritableSignal<T[]>;
-        filteredList: import("@angular/core").Signal<T[]>;
-    };
-    constructor();
-    prevent(ev: MouseEvent): void;
-    private updateInputValue;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbAutocomplete<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbAutocomplete<any>, "[ngbAutocomplete]", never, { "filterFn": { "alias": "filterFn"; "required": false; "isSignal": true; }; "queryFn": { "alias": "queryFn"; "required": false; "isSignal": true; }; "filterOptions": { "alias": "filterOptions"; "required": false; "isSignal": true; }; }, {}, ["searchInput", "chips"], never, true, never>;
-}
-export declare function aliasAutocomplete<T>(autocomplete: Type<NgbAutocomplete<T>>): (({
-    provide: import("@angular/core").InjectionToken<readonly import("@angular/forms").ControlValueAccessor[]>;
-    useExisting: Type<any>;
-    multi: boolean;
-} | {
-    provide: typeof SelectBase;
-    useExisting: Type<NgbAutocomplete<T>>;
-})[] | {
-    provide: typeof NgbAutocomplete;
-    useExisting: Type<NgbAutocomplete<T>>;
-})[];

package/autocomplete/public-api.d.ts

@@ -1,2 +0,0 @@
-export * from './autocomplete';
-export * from './autocomplete-input';

package/avatar/avatar.d.ts

@@ -1,22 +0,0 @@
-import { ElementRef, Type } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare class NgbAvatar {
-    readonly src: import("@angular/core").InputSignal<string | undefined>;
-    readonly name: import("@angular/core").InputSignal<string | undefined>;
-    readonly text: import("@angular/core").InputSignal<string | undefined>;
-    readonly nameChar: import("@angular/core").Signal<string | undefined>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbAvatar, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbAvatar, "[ngbAvatar]", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-export declare class NgbAvatarGroup {
-    readonly avatars: import("@angular/core").Signal<readonly ElementRef<HTMLElement>[]>;
-    readonly reverse: import("@angular/core").InputSignal<boolean>;
-    readonly left: import("@angular/core").InputSignal<number>;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbAvatarGroup, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbAvatarGroup, "[ngbAvatarGroup]", never, { "reverse": { "alias": "reverse"; "required": false; "isSignal": true; }; "left": { "alias": "left"; "required": false; "isSignal": true; }; }, {}, ["avatars"], never, true, never>;
-}
-export declare function aliasAvatar(avatar: Type<NgbAvatar>): {
-    provide: typeof NgbAvatar;
-    useExisting: Type<NgbAvatar>;
-};

package/avatar/public-api.d.ts

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

package/bidi/direction.service.d.ts

@@ -1,14 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class Directionality {
-    private document;
-    private readonly direction;
-    readonly isRtl: import("@angular/core").Signal<boolean>;
-    constructor();
-    private getInitialDirection;
-    setDirection(isRtl: boolean): void;
-    toggleDirection(): void;
-    private updateDir;
-    static ɵfac: i0.ɵɵFactoryDeclaration<Directionality, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<Directionality>;
-}
-export declare const injectDirectionality: () => Directionality;

package/bidi/public-api.d.ts

@@ -1 +0,0 @@
-export { Directionality, injectDirectionality } from './direction.service';

package/breadcrumb/breadcrumb-link.d.ts

@@ -1,7 +0,0 @@
-import { NgbBreadcrumb } from './public-api';
-import * as i0 from "@angular/core";
-export declare class NgbBreadcrumbLink {
-    readonly breadcrumb: NgbBreadcrumb;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbBreadcrumbLink, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbBreadcrumbLink, "[ngbBreadcrumbLink]", never, {}, {}, never, never, true, never>;
-}

package/breadcrumb/breadcrumb-separator.d.ts

@@ -1,6 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class NgbBreadcrumbSeparator {
-    readonly dir: import("@ngbase/adk/bidi").Directionality;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbBreadcrumbSeparator, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbBreadcrumbSeparator, "[ngbBreadcrumbsSeparator]", never, {}, {}, never, never, true, never>;
-}

package/breadcrumb/breadcrumb.d.ts

@@ -1,12 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class NgbBreadcrumb {
-    private breadcrumbs;
-    readonly active: import("@angular/core").Signal<boolean>;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbBreadcrumb, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbBreadcrumb, "[ngbBreadcrumb]", never, {}, {}, never, never, true, never>;
-}
-export declare function aliasBreadcrumb(breadcrumb: typeof NgbBreadcrumb): {
-    provide: typeof NgbBreadcrumb;
-    useExisting: typeof NgbBreadcrumb;
-};

package/breadcrumb/breadcrumbs.d.ts

@@ -1,9 +0,0 @@
-import { TemplateRef } from '@angular/core';
-import { NgbBreadcrumb } from './breadcrumb';
-import * as i0 from "@angular/core";
-export declare class NgbBreadcrumbs {
-    readonly items: import("@angular/core").Signal<readonly NgbBreadcrumb[]>;
-    readonly separator: import("@angular/core").Signal<TemplateRef<any> | undefined>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbBreadcrumbs, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbBreadcrumbs, "[ngbBreadcrumbs]", never, {}, {}, ["items", "separator"], never, true, never>;
-}

package/breadcrumb/public-api.d.ts

@@ -1,4 +0,0 @@
-export { NgbBreadcrumbs } from './breadcrumbs';
-export { NgbBreadcrumb, aliasBreadcrumb } from './breadcrumb';
-export { NgbBreadcrumbLink } from './breadcrumb-link';
-export { NgbBreadcrumbSeparator } from './breadcrumb-separator';

package/cache/cache-config.d.ts

@@ -1,22 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { Cache } from './cache';
-export type CacheInterceptorConfig = Partial<InternalCacheInterceptorConfig>;
-export interface InternalCacheInterceptorConfig {
-    enabled: boolean;
-    cacheable: {
-        methods: string[];
-        urls: string[];
-    };
-    excludeUrls: string[];
-    defaultTimeToLive: number;
-}
-export declare const CACHE_CONFIG: InjectionToken<Partial<InternalCacheInterceptorConfig>>;
-export declare function provideCache(fn: () => CacheInterceptorConfig): (typeof Cache | {
-    provide: InjectionToken<Partial<InternalCacheInterceptorConfig>>;
-    useFactory: () => CacheInterceptorConfig;
-    multi?: undefined;
-} | {
-    provide: InjectionToken<readonly import("@angular/common/http").HttpInterceptor[]>;
-    useFactory: import("@angular/common/http").HttpInterceptorFn;
-    multi: boolean;
-})[];