@ngbase/adk 0.1.11 → 0.1.12

package/a11y/index.d.ts

@@ -1,5 +1,151 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/a11y" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { OnDestroy, ElementRef, Signal, Provider } from '@angular/core';
+import * as _ngbase_adk_a11y from '@ngbase/adk/a11y';
+import { Subject } from 'rxjs';
+
+declare class AccessibilityService {
+    readonly groups: _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: _angular_core.ɵɵFactoryDeclaration<AccessibilityService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AccessibilityService>;
+}
+
+declare class AccessibleItem<T = any> implements OnDestroy {
+    readonly allyService: AccessibilityService;
+    readonly host: ElementRef<HTMLElement>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly ayId: _angular_core.InputSignal<string>;
+    readonly role: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selected: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly data: _angular_core.InputSignal<T | undefined>;
+    readonly skip: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly level: _angular_core.ModelSignal<number>;
+    readonly expandable: _angular_core.ModelSignal<boolean>;
+    readonly expanded: _angular_core.ModelSignal<boolean>;
+    readonly selectedChange: _angular_core.OutputEmitterRef<number>;
+    _disabled: Signal<boolean>;
+    _selected: Signal<boolean>;
+    _ayId: _angular_core.WritableSignal<string>;
+    _data: _angular_core.WritableSignal<T | undefined>;
+    _id: _angular_core.WritableSignal<string>;
+    _skip: _angular_core.WritableSignal<boolean>;
+    _expandable: _angular_core.WritableSignal<boolean>;
+    _expanded: _angular_core.WritableSignal<boolean>;
+    readonly group: Signal<_ngbase_adk_a11y.AccessibleGroup | undefined>;
+    readonly pressed: _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;
+    protected onFocus: () => void;
+    focus(focus: boolean, isKeyboard: boolean): void;
+    blur: () => void;
+    click(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccessibleItem<any>, never>;
+    static ɵdir: _angular_core.ɵɵ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>;
+}
+
+declare class AccessibleGroup {
+    private readonly allyService;
+    private readonly el;
+    private readonly document;
+    private readonly dir;
+    readonly ayId: _angular_core.ModelSignal<string | undefined>;
+    readonly columns: _angular_core.InputSignal<number | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string>;
+    readonly isPopup: _angular_core.InputSignal<boolean>;
+    readonly loop: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly clickable: _angular_core.ModelSignal<boolean>;
+    readonly initialFocus: _angular_core.InputSignal<boolean>;
+    _ayId: _angular_core.WritableSignal<string | undefined>;
+    _disabled: _angular_core.WritableSignal<boolean>;
+    _ariaLabel: _angular_core.WritableSignal<string>;
+    _ariaLabelledby: _angular_core.WritableSignal<string>;
+    _isPopup: _angular_core.WritableSignal<boolean>;
+    _loop: _angular_core.WritableSignal<boolean>;
+    _columns: _angular_core.WritableSignal<number | undefined>;
+    _initialFocus: _angular_core.WritableSignal<boolean>;
+    private focusedItem?;
+    private isOn;
+    readonly elements: _angular_core.WritableSignal<AccessibleItem<any>[]>;
+    readonly items: _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: _angular_core.ɵɵFactoryDeclaration<AccessibleGroup, never>;
+    static ɵdir: _angular_core.ɵɵ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>;
+}
+
+interface FocusTrapOptions {
+    initial?: boolean;
+}
+declare function provideFocusTrapOptions(optionsFn: () => FocusTrapOptions): Provider;
+declare class FocusTrap {
+    private el;
+    private readonly options;
+    readonly ngbFocusTrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly focusInitial: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    _focusTrap: _angular_core.WritableSignal<boolean>;
+    _focusInitial: _angular_core.WritableSignal<boolean>;
+    private cachedFocusableElements;
+    constructor();
+    private isElementFocusable;
+    private getFocusableElements;
+    private invalidateCache;
+    onKeydown: (event: KeyboardEvent) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FocusTrap, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FocusTrap, "[ngbFocusTrap]", never, { "ngbFocusTrap": { "alias": "ngbFocusTrap"; "required": false; "isSignal": true; }; "focusInitial": { "alias": "focusInitial"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class Autofocus implements OnDestroy {
+    private el;
+    private applicationRef;
+    private intersectionObserver?;
+    private document;
+    readonly focusDelay: _angular_core.InputSignal<number>;
+    private isFocused;
+    private client;
+    constructor();
+    private elWatcher;
+    private focusElement;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Autofocus, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Autofocus, "[ngbAutofocus]", never, { "focusDelay": { "alias": "focusDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { AccessibleGroup, AccessibleItem, Autofocus, FocusTrap, provideFocusTrapOptions };
+export type { FocusTrapOptions };

package/accordion/index.d.ts

@@ -1,5 +1,44 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/accordion" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import * as i1 from '@ngbase/adk/utils';
+import * as _angular_animations from '@angular/animations';
+
+declare class NgbAccordion {
+    private accordionService;
+    readonly expanded: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly opened: _angular_core.OutputEmitterRef<boolean>;
+    readonly closed: _angular_core.OutputEmitterRef<boolean>;
+    readonly id: string;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbAccordion, never>;
+    static ɵdir: _angular_core.ɵɵ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, [{ directive: typeof i1.DisableAnimation; inputs: {}; outputs: {}; }]>;
+}
+declare function aliasAccordion(accordion: typeof NgbAccordion): {
+    provide: typeof NgbAccordion;
+    useExisting: typeof NgbAccordion;
+};
+
+declare class NgbAccordionGroup {
+    readonly items: _angular_core.Signal<readonly NgbAccordion[]>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly expandAll: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly activeId: _angular_core.WritableSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbAccordionGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbAccordionGroup, "[ngbAccordionGroup]", ["ngbAccordionGroup"], { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "expandAll": { "alias": "expandAll"; "required": false; "isSignal": true; }; }, {}, ["items"], never, true, never>;
+}
+
+declare class NgbAccordionHeader {
+    accordion: NgbAccordion;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbAccordionHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbAccordionHeader, "[ngbAccordionHeader]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NgbAccordionContent {
+    readonly accordion: NgbAccordion;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbAccordionContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbAccordionContent, "[ngbAccordionContent]", ["ngbAccordionContent"], {}, {}, never, never, true, never>;
+}
+declare const slideAnimation: _angular_animations.AnimationTriggerMetadata;
+
+export { NgbAccordion, NgbAccordionContent, NgbAccordionGroup, NgbAccordionHeader, aliasAccordion, slideAnimation };

package/autocomplete/index.d.ts

@@ -1,5 +1,54 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/autocomplete" />
-export * from './public-api';
+import * as _angular_forms from '@angular/forms';
+import * as _angular_core from '@angular/core';
+import { ElementRef, Type } from '@angular/core';
+import { NgbChip } from '@ngbase/adk/chip';
+import { SelectBase } from '@ngbase/adk/select';
+import { FilterOptions } from '@ngbase/adk/utils';
+import * as i1 from '@ngbase/adk/form-field';
+import { InputBase } from '@ngbase/adk/form-field';
+
+declare class NgbAutocompleteInput<T> {
+    readonly autoComplete: NgbAutocomplete<any>;
+    readonly input: InputBase<any>;
+    readonly el: ElementRef<HTMLInputElement>;
+    readonly isChip: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ngbAutocompleteInput: _angular_core.OutputEmitterRef<string>;
+    constructor();
+    onFocus(): void;
+    close(): void;
+    updateValue(value: string): void;
+    protected updateSearch(ev: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbAutocompleteInput<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbAutocompleteInput<any>, "input[ngbAutocompleteInput]", ["ngbAutocompleteInput"], { "isChip": { "alias": "isChip"; "required": false; "isSignal": true; }; }, { "ngbAutocompleteInput": "ngbAutocompleteInput"; }, never, never, true, [{ directive: typeof i1.InputBase; inputs: { "value": "value"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+
+declare class NgbAutocomplete<T> extends SelectBase<T> {
+    readonly searchInput: _angular_core.Signal<NgbAutocompleteInput<any> | undefined>;
+    readonly chips: _angular_core.Signal<readonly NgbChip<any>[]>;
+    readonly filterFn: _angular_core.InputSignal<(option: string) => string>;
+    readonly queryFn: _angular_core.InputSignal<((query: string, option: any) => boolean) | undefined>;
+    readonly filterOptions: _angular_core.InputSignal<FilterOptions<T> | undefined>;
+    readonly optionsFilter: {
+        search: _angular_core.WritableSignal<string>;
+        list: _angular_core.WritableSignal<T[]>;
+        filteredList: _angular_core.Signal<T[]>;
+    };
+    constructor();
+    prevent(ev: MouseEvent): void;
+    private updateInputValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbAutocomplete<any>, never>;
+    static ɵdir: _angular_core.ɵɵ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>;
+}
+declare function aliasAutocomplete<T>(autocomplete: Type<NgbAutocomplete<T>>): (({
+    provide: _angular_core.InjectionToken<readonly _angular_forms.ControlValueAccessor[]>;
+    useExisting: Type<any>;
+    multi: boolean;
+} | {
+    provide: typeof SelectBase;
+    useExisting: Type<NgbAutocomplete<T>>;
+})[] | {
+    provide: typeof NgbAutocomplete;
+    useExisting: Type<NgbAutocomplete<T>>;
+})[];
+
+export { NgbAutocomplete, NgbAutocompleteInput, aliasAutocomplete };

package/avatar/index.d.ts

@@ -1,5 +1,25 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/avatar" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { ElementRef, Type } from '@angular/core';
+
+declare class NgbAvatar {
+    readonly src: _angular_core.InputSignal<string | undefined>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly text: _angular_core.InputSignal<string | number | undefined>;
+    readonly nameChar: _angular_core.Signal<string | number | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbAvatar, never>;
+    static ɵdir: _angular_core.ɵɵ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>;
+}
+declare class NgbAvatarGroup {
+    readonly avatars: _angular_core.Signal<readonly ElementRef<HTMLElement>[]>;
+    readonly reverse: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly left: _angular_core.InputSignalWithTransform<number, unknown>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbAvatarGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbAvatarGroup, "[ngbAvatarGroup]", never, { "reverse": { "alias": "reverse"; "required": false; "isSignal": true; }; "left": { "alias": "left"; "required": false; "isSignal": true; }; }, {}, ["avatars"], never, true, never>;
+}
+declare function aliasAvatar(avatar: Type<NgbAvatar>): {
+    provide: typeof NgbAvatar;
+    useExisting: Type<NgbAvatar>;
+};
+
+export { NgbAvatar, NgbAvatarGroup, aliasAvatar };

package/bidi/index.d.ts

@@ -1,5 +1,17 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/bidi" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+
+declare class Directionality {
+    private document;
+    private readonly direction;
+    readonly isRtl: i0.Signal<boolean>;
+    constructor();
+    private getInitialDirection;
+    setDirection(isRtl: boolean): void;
+    toggleDirection(): void;
+    private updateDir;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Directionality, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Directionality>;
+}
+declare const injectDirectionality: () => Directionality;
+
+export { Directionality, injectDirectionality };

package/breadcrumb/index.d.ts

@@ -1,5 +1,36 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/breadcrumb" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import * as _ngbase_adk_bidi from '@ngbase/adk/bidi';
+
+declare class NgbBreadcrumb {
+    private breadcrumbs;
+    readonly active: i0.Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbBreadcrumb, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbBreadcrumb, "[ngbBreadcrumb]", never, {}, {}, never, never, true, never>;
+}
+declare function aliasBreadcrumb(breadcrumb: typeof NgbBreadcrumb): {
+    provide: typeof NgbBreadcrumb;
+    useExisting: typeof NgbBreadcrumb;
+};
+
+declare class NgbBreadcrumbs {
+    readonly items: i0.Signal<readonly NgbBreadcrumb[]>;
+    readonly separator: i0.Signal<TemplateRef<any> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbBreadcrumbs, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbBreadcrumbs, "[ngbBreadcrumbs]", never, {}, {}, ["items", "separator"], never, true, never>;
+}
+
+declare class NgbBreadcrumbLink {
+    readonly breadcrumb: NgbBreadcrumb;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbBreadcrumbLink, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbBreadcrumbLink, "[ngbBreadcrumbLink]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NgbBreadcrumbSeparator {
+    readonly dir: _ngbase_adk_bidi.Directionality;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbBreadcrumbSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbBreadcrumbSeparator, "[ngbBreadcrumbsSeparator]", never, {}, {}, never, never, true, never>;
+}
+
+export { NgbBreadcrumb, NgbBreadcrumbLink, NgbBreadcrumbSeparator, NgbBreadcrumbs, aliasBreadcrumb };

package/cache/index.d.ts

@@ -1,5 +1,46 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/cache" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import * as _angular_common_http from '@angular/common/http';
+import { HttpInterceptorFn } from '@angular/common/http';
+
+interface CacheConfig {
+    timeToLive: number;
+}
+declare class Cache {
+    private cache;
+    private defaultConfig;
+    setConfig(config: Partial<CacheConfig>): void;
+    get<T>(url: string): T;
+    clearCache(url?: string): void;
+    isCached(url: string): boolean;
+    private getFromCache;
+    addToCache(url: string, response: any, config: CacheConfig): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Cache, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Cache>;
+}
+declare const injectCache: () => Cache;
+
+declare const cacheInterceptor: HttpInterceptorFn;
+
+type CacheInterceptorConfig = Partial<InternalCacheInterceptorConfig>;
+interface InternalCacheInterceptorConfig {
+    enabled: boolean;
+    cacheable: {
+        methods: string[];
+        urls: string[];
+    };
+    excludeUrls: string[];
+    defaultTimeToLive: number;
+}
+declare function provideCache(fn: () => CacheInterceptorConfig): (typeof Cache | {
+    provide: InjectionToken<Partial<InternalCacheInterceptorConfig>>;
+    useFactory: () => CacheInterceptorConfig;
+    multi?: undefined;
+} | {
+    provide: InjectionToken<readonly _angular_common_http.HttpInterceptor[]>;
+    useFactory: _angular_common_http.HttpInterceptorFn;
+    multi: boolean;
+})[];
+
+export { cacheInterceptor, injectCache, provideCache };
+export type { CacheConfig, CacheInterceptorConfig };

package/carousel/index.d.ts

@@ -1,5 +1,79 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/carousel" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+import * as i1 from '@ngbase/adk/drag';
+
+declare class NgbCarouselContainer {
+    readonly el: ElementRef<any>;
+    get width(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbCarouselContainer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbCarouselContainer, "[ngbCarouselContainer]", never, {}, {}, never, never, true, [{ directive: typeof i1.Drag; inputs: {}; outputs: {}; }]>;
+}
+declare class NgbCarouselSubContainer {
+    private el;
+    private dir;
+    updateScrollPosition(x: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbCarouselSubContainer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbCarouselSubContainer, "[ngbCarouselSubContainer]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbCarousel {
+    private dir;
+    private drag;
+    private mainContainer;
+    private subContainer;
+    private items;
+    readonly current: i0.WritableSignal<number>;
+    private animationId;
+    velocity: number;
+    readonly itemsPerStep: i0.Signal<number>;
+    private readonly totalWidth;
+    /**
+     * This is the total number of steps that can be taken.
+     * It is computed based on the container width and the width of the last item.
+     * It is used to determine the number of steps that can be taken.
+     * We have to consider gap between items like padding or margin or flex gap.
+     */
+    readonly totalSteps: i0.Signal<number>;
+    private readonly isReady;
+    readonly isFirst: i0.Signal<boolean>;
+    readonly isLast: i0.Signal<boolean>;
+    private currentScroll;
+    constructor();
+    x(): number;
+    private get containerWidth();
+    next(step?: number): void;
+    prev(step?: number): void;
+    go(step: number, velocity?: number, withoutAnimation?: boolean): void;
+    /**
+     * Determines the appropriate step based on scroll position, direction and velocity
+     * @param scrollX Current scroll position
+     * @param direction Drag direction
+     * @param velocity Drag velocity
+     * @returns The calculated step index
+     */
+    private getStepBasedOnX;
+    private animateToX;
+    private snapToNearest;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbCarousel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbCarousel, "[ngbCarousel]", ["ngbCarousel"], {}, {}, ["items"], never, true, never>;
+}
+declare function aliasCarousel(carousel: typeof NgbCarousel): {
+    provide: typeof NgbCarousel;
+    useExisting: typeof NgbCarousel;
+};
+
+declare class NgbCarouselItem {
+    private readonly el;
+    get width(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbCarouselItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbCarouselItem, "[ngbCarouselItem]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NgbCarouselButton {
+    private readonly carousel;
+    readonly ngbCarouselButton: i0.InputSignal<number | "next" | "prev">;
+    clicked(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbCarouselButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbCarouselButton, "[ngbCarouselButton]", never, { "ngbCarouselButton": { "alias": "ngbCarouselButton"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NgbCarousel, NgbCarouselButton, NgbCarouselContainer, NgbCarouselItem, NgbCarouselSubContainer, aliasCarousel };

package/checkbox/index.d.ts

@@ -1,5 +1,33 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/checkbox" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare class CheckboxButton {
+    readonly checkbox: NgbCheckbox;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CheckboxButton, "button[ngbCheckboxButton]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbCheckbox implements ControlValueAccessor {
+    readonly id: string;
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly indeterminate: _angular_core.InputSignal<boolean>;
+    readonly change: _angular_core.OutputEmitterRef<boolean>;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    updateValue(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbCheckbox, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbCheckbox, "[ngbCheckbox]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "change": "change"; }, never, never, true, never>;
+}
+declare function aliasCheckbox(checkbox: typeof NgbCheckbox): ({
+    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: _angular_core.Type<any>;
+    multi: boolean;
+} | {
+    provide: typeof NgbCheckbox;
+    useExisting: typeof NgbCheckbox;
+})[];
+
+export { CheckboxButton, NgbCheckbox, aliasCheckbox };

package/chip/index.d.ts

@@ -1,5 +1,28 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/chip" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { Directionality } from '@ngbase/adk/bidi';
+
+declare class NgbChipRemove {
+    readonly chip: NgbChip<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbChipRemove, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbChipRemove, "[ngbChipRemove]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbChip<T = any> {
+    readonly dir: Directionality;
+    readonly removable: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly value: i0.InputSignal<T | undefined>;
+    readonly close: i0.OutputEmitterRef<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbChip<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbChip<any>, "[ngbChip]", never, { "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "close": "close"; }, never, never, true, never>;
+}
+declare function aliasChip(chip: typeof NgbChip): {
+    provide: typeof NgbChip;
+    useExisting: typeof NgbChip;
+};
+
+declare class NgbChipGroup<T> {
+    readonly chips: i0.Signal<readonly NgbChip<T>[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbChipGroup<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbChipGroup<any>, "[ngbChipGroup]", never, {}, {}, ["chips"], never, true, never>;
+}
+
+export { NgbChip, NgbChipGroup, NgbChipRemove, aliasChip };

package/clipboard/index.d.ts

@@ -1,5 +1,11 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/clipboard" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+
+declare class CopyToClipboard {
+    readonly ngbCopyToClipboard: i0.InputSignal<string | undefined>;
+    onClick(event: MouseEvent): void;
+    _copyToClipboard(text: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopyToClipboard, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CopyToClipboard, "[ngbCopyToClipboard]", never, { "ngbCopyToClipboard": { "alias": "ngbCopyToClipboard"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { CopyToClipboard };

package/collections/index.d.ts

@@ -1,5 +1,23 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/collections" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+
+declare class SelectionModel<T> {
+    multiple: boolean;
+    items: Signal<T[]>;
+    readonly selected: _angular_core.WritableSignal<T[]>;
+    readonly hasValue: Signal<boolean>;
+    readonly isEmpty: Signal<boolean>;
+    readonly isAllSelected: Signal<boolean>;
+    readonly isIndeterminate: Signal<boolean>;
+    constructor(multiple?: boolean, selected?: T[], items?: Signal<T[]>);
+    clear(): void;
+    select(item: T): void;
+    deselect(item: T): void;
+    selectAll(items: T[]): void;
+    isSelected(item: T): boolean;
+    toggle(item: T): void;
+    toggleAll(): void;
+    sort(fn: (a: T, b: T) => number): void;
+}
+
+export { SelectionModel };