@bootkit/ng0 0.0.0-alpha.1 → 0.0.0-alpha.3

package/common/index.d.ts

@@ -1,5 +1,12 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@bootkit/ng0/common" />
-export * from './public-api';
+import { InjectionToken } from '@angular/core';
+
+type Placement = 'start' | 'end' | 'top' | 'bottom';
+type Alignment = 'start' | 'center' | 'end';
+declare const RTL: InjectionToken<boolean>;
+
+declare function numberRange(start: number, end: number): number[];
+declare function fillArray(start: number, end: number): number[];
+declare function flipPlacement(placement: Placement): "start" | "end" | "top" | "bottom";
+
+export { RTL, fillArray, flipPlacement, numberRange };
+export type { Alignment, Placement };

package/components/accordion/index.d.ts

@@ -0,0 +1,32 @@
+import * as i0 from '@angular/core';
+import { ElementRef, Renderer2, QueryList } from '@angular/core';
+
+declare class AccordionItemComponent {
+    private _element;
+    private _renderer;
+    private _accordion;
+    header: i0.InputSignal<string>;
+    collapsed: i0.ModelSignal<boolean>;
+    constructor(_element: ElementRef, _renderer: Renderer2, _accordion: AccordionComponent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionItemComponent, "ng0-accordion-item", ["ng0AccordionItem"], { "header": { "alias": "header"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, ["*"], true, never>;
+}
+
+declare class AccordionComponent {
+    private _element;
+    private _renderer;
+    /** Items open mode */
+    mode: i0.InputSignal<"single" | "multiple">;
+    readonly items: QueryList<AccordionItemComponent>;
+    constructor(_element: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionComponent, "ng0-accordion", ["ng0Accordion"], { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
+}
+
+declare class AccordionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AccordionModule, never, [typeof AccordionComponent, typeof AccordionItemComponent], [typeof AccordionComponent, typeof AccordionItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AccordionModule>;
+}
+
+export { AccordionComponent, AccordionItemComponent, AccordionModule };

package/components/collapse/index.d.ts

@@ -0,0 +1,59 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, ElementRef, Renderer2 } from '@angular/core';
+import { AnimationBuilder } from '@angular/animations';
+
+/**
+ * Directive to handle the collapse and expand functionality of a host element.
+ */
+declare class CollapseDirective implements OnInit, OnDestroy {
+    private el;
+    private builder;
+    private renderer;
+    /**
+     * Indicates whether the host element is collapsed.
+     * @input
+     */
+    collapsed: i0.InputSignal<boolean>;
+    /** Animation timings for collapse/expand animations.
+     * @input
+     */
+    timings: i0.InputSignal<string | number>;
+    private _player?;
+    private _firstExecution;
+    constructor(el: ElementRef, builder: AnimationBuilder, renderer: Renderer2);
+    ngOnInit(): void;
+    private _collapse;
+    private _expand;
+    private _playAnimation;
+    private _addClass;
+    private _removeClass;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CollapseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CollapseDirective, "[ng0Collapse]", ["ng0Collapse"], { "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "timings": { "alias": "timings"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A component that provides collapse and expand functionality.
+*/
+declare class CollapseComponent {
+    /**
+     * Indicates whether the host element is collapsed.
+     * @model
+     */
+    collapsed: i0.ModelSignal<boolean>;
+    /** Animation timings for collapse/expand animations.
+     * @input
+     */
+    timings: i0.InputSignal<string | number>;
+    private get _collapseExpand();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CollapseComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CollapseComponent, "ng0-collapse", never, { "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "timings": { "alias": "timings"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, ["*"], true, never>;
+}
+
+declare class CollapseModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CollapseModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CollapseModule, never, [typeof CollapseDirective, typeof CollapseComponent], [typeof CollapseDirective, typeof CollapseComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CollapseModule>;
+}
+
+export { CollapseComponent, CollapseDirective, CollapseModule };

package/components/form-field/index.d.ts

@@ -0,0 +1,72 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, AfterContentInit, OnDestroy, Renderer2, DestroyRef } from '@angular/core';
+import { NgForm } from '@angular/forms';
+import { LocalizationService } from '@bootkit/ng0/localization';
+import * as i1 from '@angular/common';
+
+declare class FormFieldComponent implements OnInit, AfterContentInit, OnDestroy {
+    private _renderer;
+    private _destroyRef;
+    private _form;
+    private _ls;
+    /**
+     * The label text for the form field.
+     */
+    label: _angular_core.InputSignal<string>;
+    /**
+     * The hint text to display below the form field.
+     * This is typically used to provide additional information or instructions to the user.
+     */
+    hint: _angular_core.InputSignal<string>;
+    /**
+     * If true, the form-field will show validation errors.
+     * This is useful for displaying validation messages when the form control is invalid.
+     */
+    showErrors: _angular_core.InputSignal<boolean>;
+    /**
+     * If true, the form-field will show a red asterisk for required fields.
+     * This is only a visual indicator and does not enforce validation.
+     */
+    showRequiredIndicator: _angular_core.InputSignal<boolean>;
+    /**
+     * If true, the form-field will show subscripts (e.g. hints, errors) for the field label.
+     * This is useful for displaying additional information or validation messages.
+     */
+    showSubscripts: _angular_core.InputSignal<boolean>;
+    /**
+     * If true, the form-field will be rendered inside a ".input-group" element.
+     */
+    inputGroup: _angular_core.InputSignal<boolean>;
+    /**
+     * Returns the first localized error of the control
+     */
+    get errorText(): string;
+    /** Reports whether the control is touched. */
+    get touched(): boolean | null | undefined;
+    /** Reports whether the control is dirty. */
+    get dirty(): boolean | null | undefined;
+    /** Returns true if this form-field is required, otherwise returns false. */
+    get isRequired(): boolean;
+    private _onFocusOut;
+    private _ngControl?;
+    private _ngControlElement?;
+    private _isRequired;
+    private _locale?;
+    private _errorText?;
+    constructor(_renderer: Renderer2, _destroyRef: DestroyRef, _form: NgForm, _ls: LocalizationService);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    private _validate;
+    private _isRequiredField;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldComponent, [null, null, { optional: true; }, null]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormFieldComponent, "ng0-form-field, ng0-field", ["ng0FormField"], { "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "showErrors": { "alias": "showErrors"; "required": false; "isSignal": true; }; "showRequiredIndicator": { "alias": "showRequiredIndicator"; "required": false; "isSignal": true; }; "showSubscripts": { "alias": "showSubscripts"; "required": false; "isSignal": true; }; "inputGroup": { "alias": "inputGroup"; "required": false; "isSignal": true; }; }, {}, ["_ngControl", "_ngControlElement"], ["*"], true, never>;
+}
+
+declare class FormFieldModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<FormFieldModule, never, [typeof i1.CommonModule, typeof FormFieldComponent], [typeof FormFieldComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<FormFieldModule>;
+}
+
+export { FormFieldComponent, FormFieldModule };

package/components/modal/index.d.ts

@@ -0,0 +1,29 @@
+import * as _angular_core from '@angular/core';
+import { EventEmitter } from '@angular/core';
+
+interface ModalCloseRequest {
+}
+
+declare class ModalComponent {
+    scrollable: _angular_core.InputSignal<boolean>;
+    /** Is modal vertically centered? */
+    centered: _angular_core.InputSignal<boolean>;
+    size: _angular_core.InputSignal<"sm" | "default" | "lg" | "xl">;
+    fullscreen: _angular_core.InputSignal<"sm" | "lg" | "xl" | "always" | "md" | "xxl">;
+    closeRequest: EventEmitter<ModalCloseRequest>;
+    backdropClick: EventEmitter<any>;
+    protected _modalStatic: _angular_core.WritableSignal<boolean>;
+    constructor();
+    protected _onBackdropClick(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalComponent, "ng0-modal", ["ng0Modal"], { "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; "centered": { "alias": "centered"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "fullscreen": { "alias": "fullscreen"; "required": false; "isSignal": true; }; }, { "closeRequest": "closeRequest"; "backdropClick": "backdropClick"; }, never, ["*"], true, never>;
+}
+
+declare class ModalModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ModalModule, never, [typeof ModalComponent], [typeof ModalComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ModalModule>;
+}
+
+export { ModalComponent, ModalModule };

package/components/nav/index.d.ts

@@ -0,0 +1,64 @@
+import * as i0 from '@angular/core';
+import { ElementRef, Renderer2, TemplateRef, OnInit, QueryList } from '@angular/core';
+
+declare class NavDirective {
+    private _elementRef;
+    private _renderer;
+    activeItem: i0.ModelSignal<any>;
+    disabled: i0.InputSignal<boolean>;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NavDirective, "[ng0Nav]", ["ng0Nav"], { "activeItem": { "alias": "activeItem"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "activeItem": "activeItemChange"; }, never, never, true, never>;
+}
+
+declare class NavItemDirective {
+    elementRef: ElementRef;
+    private _renderer;
+    private _nav;
+    id: i0.InputSignal<any>;
+    disabled: i0.InputSignal<boolean>;
+    constructor(elementRef: ElementRef, _renderer: Renderer2, _nav: NavDirective);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NavItemDirective, "[ng0NavItem]", ["ng0NavItem"], { "id": { "alias": "ng0NavItem"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NavLinkDirective {
+    elementRef: ElementRef;
+    private _renderer;
+    private _nav;
+    private _navItem;
+    constructor(elementRef: ElementRef, _renderer: Renderer2, _nav: NavDirective, _navItem: NavItemDirective);
+    private _onClick;
+    private get _active();
+    private get _disabled();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NavLinkDirective, "[ng0NavLink]", ["ng0NavLink"], {}, {}, never, never, true, never>;
+}
+
+declare class TabPaneDirective {
+    templateRef: TemplateRef<any>;
+    id: i0.InputSignal<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPaneDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabPaneDirective, "[ng0TabPane]", ["ng0TabPane"], { "id": { "alias": "ng0TabPane"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TabContentComponent implements OnInit {
+    private _elementRef;
+    private _renderer;
+    nav: i0.InputSignal<NavDirective>;
+    protected _panes: QueryList<TabPaneDirective>;
+    disabled: i0.InputSignal<boolean>;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabContentComponent, "ng0-tab-content", ["ng0TabContent"], { "nav": { "alias": "nav"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["_panes"], never, true, never>;
+}
+
+declare class NavModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NavModule, never, [typeof NavDirective, typeof NavItemDirective, typeof NavLinkDirective, typeof TabContentComponent, typeof TabPaneDirective], [typeof NavDirective, typeof NavItemDirective, typeof NavLinkDirective, typeof TabContentComponent, typeof TabPaneDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NavModule>;
+}
+
+export { NavDirective, NavItemDirective, NavLinkDirective, NavModule, TabContentComponent, TabPaneDirective };

package/{offcanvas/offcanvas.directive.d.ts → components/offcanvas/index.d.ts}

@@ -1,10 +1,11 @@
-import { OnInit, ElementRef, Renderer2, EventEmitter, OnDestroy } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare class OffcanvasDirective implements OnInit, OnDestroy {
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, EventEmitter, ElementRef, Renderer2 } from '@angular/core';
+
+declare class OffcanvasDirective implements OnInit, OnDestroy {
     private _el;
     private _renderer;
-    show: import("@angular/core").InputSignal<boolean>;
-    hasBackdrop: import("@angular/core").InputSignal<boolean>;
+    show: i0.InputSignal<boolean>;
+    hasBackdrop: i0.InputSignal<boolean>;
     backdropClick: EventEmitter<MouseEvent>;
     private _firstShowEffectRun;
     private _firstBackdropEffectRun;
@@ -22,3 +23,11 @@ export declare class OffcanvasDirective implements OnInit, OnDestroy {
     static ɵfac: i0.ɵɵFactoryDeclaration<OffcanvasDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<OffcanvasDirective, "[ng0Offcanvas]", ["ng0Offcanvas"], { "show": { "alias": "show"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; }, { "backdropClick": "backdropClick"; }, never, never, true, never>;
 }
+
+declare class OffcanvasModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OffcanvasModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<OffcanvasModule, never, [typeof OffcanvasDirective], [typeof OffcanvasDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<OffcanvasModule>;
+}
+
+export { OffcanvasDirective, OffcanvasModule };

package/components/overlay/index.d.ts

@@ -0,0 +1,40 @@
+import * as _angular_cdk_overlay from '@angular/cdk/overlay';
+import { ConnectedPosition } from '@angular/cdk/overlay';
+import { Placement, Alignment } from '@bootkit/ng0/common';
+
+/**
+ * Get the overlay position based on the provided placement and alignment.
+ *
+ * @param placement - The placement of the overlay (e.g., 'bottom', 'top', 'start', 'end').
+ * @param alignment - The alignment of the overlay (e.g., 'start', 'center', 'end').
+ * @returns The connected position for the overlay.
+ */
+declare function getConnectedPosition(placement: Placement, alignment: Alignment): ConnectedPosition;
+declare function getConnectedPositions(placement: Placement, alignment: Alignment, includeFlippedPlacement?: boolean): ConnectedPosition[];
+
+declare const START_START_POS: _angular_cdk_overlay.ConnectedPosition;
+declare const START_CENTER_POS: _angular_cdk_overlay.ConnectedPosition;
+declare const START_END_POS: _angular_cdk_overlay.ConnectedPosition;
+declare const END_START_POS: _angular_cdk_overlay.ConnectedPosition;
+declare const END_CENTER_POS: _angular_cdk_overlay.ConnectedPosition;
+declare const END_END_POS: _angular_cdk_overlay.ConnectedPosition;
+declare const TOP_START_POS: _angular_cdk_overlay.ConnectedPosition;
+declare const TOP_END_POS: _angular_cdk_overlay.ConnectedPosition;
+declare const TOP_CENTER_POS: _angular_cdk_overlay.ConnectedPosition;
+declare const BOTTOM_START_POS: _angular_cdk_overlay.ConnectedPosition;
+declare const BOTTOM_CENTER_POS: _angular_cdk_overlay.ConnectedPosition;
+declare const BOTTOM_END_POS: _angular_cdk_overlay.ConnectedPosition;
+declare const START_START_FLIPPED_POS: _angular_cdk_overlay.ConnectedPosition[];
+declare const START_CENTER_FLIPPED_POS: _angular_cdk_overlay.ConnectedPosition[];
+declare const START_END_FLIPPED_POS: _angular_cdk_overlay.ConnectedPosition[];
+declare const END_START_FLIPPED_POS: _angular_cdk_overlay.ConnectedPosition[];
+declare const END_CENTER_FLIPPED_POS: _angular_cdk_overlay.ConnectedPosition[];
+declare const END_END_FLIPPED_POS: _angular_cdk_overlay.ConnectedPosition[];
+declare const TOP_START_FLIPPED_POS: _angular_cdk_overlay.ConnectedPosition[];
+declare const TOP_END_FLIPPED_POS: _angular_cdk_overlay.ConnectedPosition[];
+declare const TOP_CENTER_FLIPPED_POS: _angular_cdk_overlay.ConnectedPosition[];
+declare const BOTTOM_START_FLIPPED_POS: _angular_cdk_overlay.ConnectedPosition[];
+declare const BOTTOM_CENTER_FLIPPED_POS: _angular_cdk_overlay.ConnectedPosition[];
+declare const BOTTOM_END_FLIPPED_POS: _angular_cdk_overlay.ConnectedPosition[];
+
+export { BOTTOM_CENTER_FLIPPED_POS, BOTTOM_CENTER_POS, BOTTOM_END_FLIPPED_POS, BOTTOM_END_POS, BOTTOM_START_FLIPPED_POS, BOTTOM_START_POS, END_CENTER_FLIPPED_POS, END_CENTER_POS, END_END_FLIPPED_POS, END_END_POS, END_START_FLIPPED_POS, END_START_POS, START_CENTER_FLIPPED_POS, START_CENTER_POS, START_END_FLIPPED_POS, START_END_POS, START_START_FLIPPED_POS, START_START_POS, TOP_CENTER_FLIPPED_POS, TOP_CENTER_POS, TOP_END_FLIPPED_POS, TOP_END_POS, TOP_START_FLIPPED_POS, TOP_START_POS, getConnectedPosition, getConnectedPositions };

package/components/pagination/index.d.ts

@@ -0,0 +1,30 @@
+import * as _angular_core from '@angular/core';
+import { EventEmitter } from '@angular/core';
+
+declare class PaginationComponent {
+    itemClick: EventEmitter<number>;
+    totalRecords: _angular_core.InputSignal<number>;
+    pageSize: _angular_core.InputSignal<number>;
+    /**
+     * Selected page. starts from 1.
+     */
+    selectedPage: _angular_core.InputSignal<number>;
+    maxVisiblePages: _angular_core.InputSignal<number>;
+    showNextButton: _angular_core.InputSignal<boolean>;
+    showPreviousButton: _angular_core.InputSignal<boolean>;
+    showFirstButton: _angular_core.InputSignal<boolean>;
+    showLastButton: _angular_core.InputSignal<boolean>;
+    get totalPagesCount(): number;
+    protected _totalPagesCount: number;
+    protected _visiblePages: _angular_core.Signal<any[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaginationComponent, "ng0-pagination", ["ng0Pagination"], { "totalRecords": { "alias": "totalRecords"; "required": true; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "selectedPage": { "alias": "selectedPage"; "required": false; "isSignal": true; }; "maxVisiblePages": { "alias": "maxVisiblePages"; "required": false; "isSignal": true; }; "showNextButton": { "alias": "showNextButton"; "required": false; "isSignal": true; }; "showPreviousButton": { "alias": "showPreviousButton"; "required": false; "isSignal": true; }; "showFirstButton": { "alias": "showFirstButton"; "required": false; "isSignal": true; }; "showLastButton": { "alias": "showLastButton"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, never, ["first", "previous", "next", "last"], true, never>;
+}
+
+declare class PaginationModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginationModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<PaginationModule, never, [typeof PaginationComponent], [typeof PaginationComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<PaginationModule>;
+}
+
+export { PaginationComponent, PaginationModule };

package/components/popover/index.d.ts

@@ -0,0 +1,36 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, OnInit, OnDestroy, ElementRef, ViewContainerRef } from '@angular/core';
+import { Overlay } from '@angular/cdk/overlay';
+
+type PopoverPlacement = 'top' | 'bottom' | 'start' | 'end';
+type PopoverTrigger = 'click' | 'dblclick' | 'hover' | 'focus';
+type PopoverContent = string | TemplateRef<any> | undefined | null;
+
+declare class PopoverDirective implements OnInit, OnDestroy {
+    private _overlayService;
+    private _elementRef;
+    private _viewRef;
+    header: _angular_core.InputSignal<string>;
+    content: _angular_core.InputSignal<PopoverContent>;
+    placement: _angular_core.InputSignal<PopoverPlacement>;
+    triggerBy: _angular_core.InputSignal<PopoverTrigger>;
+    private _portal;
+    private _overlayRef?;
+    constructor(_overlayService: Overlay, _elementRef: ElementRef, _viewRef: ViewContainerRef);
+    ngOnInit(): void;
+    private _createOverlay;
+    private _disposeOverlay;
+    private _toggleOverlay;
+    private _getPositions;
+    private _onClick;
+    private _onDblclick;
+    private _onMouseEnter;
+    private _onMouseLeave;
+    private _onFocus;
+    private _onFocusout;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverDirective, "[ng0Popover]", ["ng0Popover"], { "header": { "alias": "header"; "required": false; "isSignal": true; }; "content": { "alias": "ng0Popover"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "triggerBy": { "alias": "triggerBy"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { PopoverDirective };

package/components/toast/index.d.ts

@@ -0,0 +1,101 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, Injector } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { OverlayRef, Overlay } from '@angular/cdk/overlay';
+
+type ToastHorizontalPosition = 'start' | 'center' | 'end';
+type ToastVerticalPosition = 'top' | 'bottom';
+/**
+ * Configuration interface for toast notifications
+ */
+interface ToastConfig {
+    /**
+     * Main content of the toast. Can be a string, number, boolean or template reference
+     */
+    body?: string | number | boolean | TemplateRef<any>;
+    /**
+     * Header content of the toast. Can be a string, number, boolean or template reference
+     */
+    header?: string | number | boolean | TemplateRef<any>;
+    /**
+     * Additional hint text for the toast. Accepts string, number or boolean
+     */
+    hint?: string | number | boolean;
+    /**
+     * Icon to be displayed in the toast. Expects a string reference to the icon
+     */
+    icon?: string;
+    /**
+     * toast style: primary, secondary, danger, ...
+     */
+    style?: string;
+    /**
+     * Duration in milliseconds for how long the toast should be displayed
+     */
+    duration?: number;
+    /**
+     * Whether to show a close button on the toast
+     */
+    closeButton?: boolean;
+    /**
+     * Horizontal alignment of the toast. Can be 'start', 'center', or 'end'
+     */
+    horizontalPosition?: ToastHorizontalPosition;
+    /**
+     * Vertical alignment of the toast. Can be 'top' or 'bottom'
+     */
+    verticalPosition?: ToastVerticalPosition;
+}
+
+declare class ToastRef {
+    readonly config: ToastConfig;
+    private overlayRef;
+    private _isOpen;
+    private _closedSubject;
+    closed: rxjs.Observable<any>;
+    constructor(config: ToastConfig, overlayRef: OverlayRef);
+    get isOpen(): boolean;
+    close(): void;
+}
+
+/**
+ * Service for displaying toast notifications in the application.
+ *
+ * The `ToastService` provides methods to open toast messages with customizable content,
+ * header, style, position, and duration. It manages the lifecycle of toast notifications,
+ * ensuring only one toast is visible at a time.
+ *
+ * @example
+ * // Open a simple toast
+ * toastService.open('Message body', 'Header', 'success');
+ *
+ * @example
+ * // Open a toast with configuration
+ * toastService.open({
+ *   body: 'Message body',
+ *   header: 'Header',
+ *   style: 'success',
+ *   verticalPosition: 'bottom',
+ *   horizontalPosition: 'end',
+ *   duration: 5000
+ * });
+ *
+ * @remarks
+ * - Only one toast can be displayed at a time; opening a new toast closes the previous one.
+ * - The toast will automatically close after the specified duration (default: 3000ms).
+ *
+ * @publicApi
+ */
+declare class ToastService {
+    private _overlayService;
+    private _injector;
+    private _toastRef;
+    constructor(_overlayService: Overlay, _injector: Injector);
+    open(body: string, header?: string, style?: string): ToastRef;
+    open(config: ToastConfig): ToastRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
+}
+
+export { ToastRef, ToastService };
+export type { ToastConfig, ToastHorizontalPosition, ToastVerticalPosition };

package/components/tooltip/index.d.ts

@@ -0,0 +1,30 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, OnInit, OnDestroy, ElementRef, DestroyRef, ViewContainerRef } from '@angular/core';
+import { Overlay } from '@angular/cdk/overlay';
+
+type TooltipPlacement = 'top' | 'bottom' | 'start' | 'end';
+type TooltipContent = string | TemplateRef<any>;
+
+declare class TooltipDirective implements OnInit, OnDestroy {
+    private overlayService;
+    private elementRef;
+    private destroyRef;
+    private viewRef;
+    content: _angular_core.InputSignal<string | TemplateRef<any>>;
+    placement: _angular_core.InputSignal<TooltipPlacement>;
+    private portal;
+    private overlayRef?;
+    constructor(overlayService: Overlay, elementRef: ElementRef, destroyRef: DestroyRef, viewRef: ViewContainerRef);
+    ngOnInit(): void;
+    private onMouseEnter;
+    private onMouseLeave;
+    private createOverlay;
+    private disposeOverlay;
+    private getPositions;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipDirective, "[ng0Tooltip]", ["ng0Tooltip"], { "content": { "alias": "ng0Tooltip"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { TooltipDirective };
+export type { TooltipContent, TooltipPlacement };

package/data/index.d.ts

@@ -0,0 +1,74 @@
+import * as rxjs from 'rxjs';
+import { Subject, Observable } from 'rxjs';
+
+declare class DataRequest {
+    pageIndex: number;
+    pageSize: number;
+    computeTotal: boolean;
+    filters: DataRequestFilter[];
+    sort?: DataRequestSort;
+    constructor(pageIndex?: number, pageSize?: number, computeTotal?: boolean, filters?: DataRequestFilter[], sort?: DataRequestSort);
+    addFilter(field: string, value: string, operator?: DataRequestFilterOperator): this;
+    sortDescending(field: string): this;
+    sortAscending(field: string): this;
+    static all(): DataRequest;
+}
+declare class DataRequestSort {
+    field: string;
+    asc: boolean;
+    constructor(field: string, asc?: boolean);
+}
+declare class DataRequestFilter {
+    field: string;
+    value?: string;
+    operator: DataRequestFilterOperator;
+    constructor(field: string, value?: string, operator?: DataRequestFilterOperator);
+}
+declare enum DataRequestFilterOperator {
+    EQ = 0,
+    NEQ = 1,
+    LT = 2,
+    LTE = 3,
+    GT = 4,
+    GTE = 5,
+    LI = 6,
+    SW = 7
+}
+
+declare class DataResult<T = any> {
+    readonly request: DataRequest;
+    readonly data: T[];
+    readonly total?: number;
+    constructor(request: DataRequest, data: T[], total?: number);
+}
+
+declare abstract class DataSource<T = any> {
+    protected _loading: boolean;
+    protected changeSubject: Subject<unknown>;
+    readonly change: Observable<unknown>;
+    constructor();
+    get loading(): boolean;
+    protected setLoading(value: boolean): void;
+    abstract load(request: DataRequest): Observable<DataResult>;
+}
+
+type DataLoaderFunc = (request: DataRequest) => Observable<DataResult>;
+declare class AsyncDataSource extends DataSource {
+    private readonly loader;
+    constructor(loader: DataLoaderFunc);
+    load(request: DataRequest): Observable<DataResult<any>>;
+}
+
+declare class ArrayDataSource extends DataSource {
+    private items;
+    constructor(items: any[]);
+    load(request: DataRequest): rxjs.Observable<DataResult<any>>;
+    remove(item: any): void;
+    insert(item: any): void;
+    set(items: any[]): void;
+}
+
+declare function toDataResult<T = any>(dr: DataRequest): (source: Observable<any>) => Observable<DataResult<T>>;
+
+export { ArrayDataSource, AsyncDataSource, DataRequest, DataRequestFilter, DataRequestFilterOperator, DataRequestSort, DataResult, DataSource, toDataResult };
+export type { DataLoaderFunc };

package/fesm2022/bootkit-ng0-common.mjs

@@ -2,6 +2,16 @@ import { InjectionToken } from '@angular/core';
 
 const RTL = new InjectionToken('RTL Direction');
 
+function numberRange(start, end) {
+    return Array.from({ length: end - start + 1 }, (_, i) => i + start);
+}
+function fillArray(start, end) {
+    const result = [];
+    for (let i = start; i <= end; i++) {
+        result.push(i);
+    }
+    return result;
+}
 function flipPlacement(placement) {
     switch (placement) {
         case 'bottom':
@@ -14,13 +24,10 @@ function flipPlacement(placement) {
             return 'start';
     }
 }
-function numberRange(start, end) {
-    return Array.from({ length: end - start + 1 }, (_, i) => i + start);
-}
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { RTL, flipPlacement, numberRange };
+export { RTL, fillArray, flipPlacement, numberRange };
 //# sourceMappingURL=bootkit-ng0-common.mjs.map