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

package/common/index.d.ts

@@ -1,5 +1,84 @@
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+
+type Placement = 'start' | 'end' | 'top' | 'bottom';
+type Alignment = 'start' | 'center' | 'end';
+declare const RTL: InjectionToken<boolean>;
+
 /**
- * Generated bundle index. Do not edit.
+ * Represents a claim object that can contain multiple claims.
  */
-/// <amd-module name="@bootkit/ng0/common" />
-export * from './public-api';
+interface ClaimObject {
+    all?: string[];
+    any?: string[];
+}
+/**
+ * Represents a claim that can be a string or an object containing claims.
+ * This is useful for defining permissions or roles in a security context.
+ * It allows for both simple string claims and more complex claims that can include multiple values.
+ * For example:
+ * - A simple claim: 'admin'
+ * - A complex claim: { all: ['read', 'write']'] }
+ *
+ */
+type ClaimLike = string | ClaimObject;
+
+/**
+ * Flips the placement direction.
+ * @param placement The placement direction to flip.
+ * @returns The flipped placement direction.
+ */
+declare function flipPlacement(placement: Placement): "start" | "end" | "top" | "bottom";
+
+/**
+ * Formats a string by replacing placeholders with the provided arguments.
+ * @param str The string to format, containing placeholders in the form of {0}, {1}, etc.
+ * @param args The values to replace the placeholders with.
+ * @returns The formatted string.
+ */
+declare function formatString(str: string, ...args: any[]): string;
+
+/** Base class of all menu items  */
+interface MenuItemBase<DataType = any> {
+    type: 'group' | 'text' | 'divider';
+    id?: any;
+    disabled?: boolean;
+    active?: boolean;
+    show?: boolean;
+    claim?: ClaimLike;
+    parent?: MenuItem;
+    data?: DataType;
+}
+/** Section Menu Item  */
+interface GroupMenuItem<DataType = any> extends MenuItemBase<DataType> {
+    type: 'group';
+    text: string;
+    expanded?: boolean;
+    icon?: string;
+    children: Array<MenuItem<DataType>>;
+}
+/** Text Menu Item */
+interface TextMenuItem<DataType = any> extends MenuItemBase<DataType> {
+    type: 'text';
+    text: string;
+    routerLink?: string[];
+    icon?: string;
+}
+/** Divider Menu Item */
+interface DividerMenuItem<DataType = any> extends MenuItemBase<DataType> {
+    type: 'divider';
+}
+type MenuItem<DataType = any> = TextMenuItem<DataType> | DividerMenuItem<DataType> | GroupMenuItem<DataType>;
+
+/**
+ * Converts a value to an Observable.
+ * If the value is already an Observable, it returns it directly.
+ * If the value is a Promise, it converts it to an Observable.
+ * If the value is neither, it wraps it in an Observable using `of`.
+ * @param value The value to convert.
+ * @returns An Observable that emits the value.
+ */
+declare function toObservable<T>(value: T | Observable<T> | Promise<T>): Observable<T>;
+
+export { RTL, flipPlacement, formatString, toObservable };
+export type { Alignment, ClaimLike, ClaimObject, DividerMenuItem, GroupMenuItem, MenuItem, MenuItemBase, Placement, TextMenuItem };

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 | undefined>;
+    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/backdrop/index.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from '@angular/core';
+
+declare class BackdropComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackdropComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BackdropComponent, "ng0-backdrop", never, {}, {}, never, never, true, never>;
+}
+
+export { BackdropComponent };

package/components/button/index.d.ts

@@ -0,0 +1,48 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, ElementRef, Renderer2, DestroyRef } from '@angular/core';
+import { HttpService } from '@bootkit/ng0/http';
+
+declare class ButtonDirective implements OnInit, OnDestroy {
+    private _element;
+    private _renderer;
+    private _http;
+    private _destroyRef;
+    private _loadingElement;
+    /**
+     * The IDs of the HTTP requests that this button listens to.
+     * If one of these requests is in progress, it will show a loading indicator or will be disabled based on 'showLoading' and 'disableOnLoading' properties.
+     */
+    request: i0.InputSignal<string | string[] | undefined>;
+    /**
+     * Whether the button is disabled or not.
+     */
+    disabled: i0.ModelSignal<boolean>;
+    /**
+     * Whether to wait for the HTTP response before enabling the button again.
+     * If true, the button will remain disabled until the HTTP request completes.
+     * This is useful for preventing multiple clicks while waiting for a response.
+     * Default is true.
+     */
+    disableDuringRequest: i0.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether to show a loading indicator when the HTTP request is in progress.
+     * If true, a loading spinner will be displayed on the button while the request is being processed.
+     * Default is true.
+     */
+    loadingIndicator: i0.InputSignalWithTransform<boolean, unknown>;
+    constructor(_element: ElementRef, _renderer: Renderer2, _http: HttpService, _destroyRef: DestroyRef);
+    ngOnInit(): void;
+    private _showLoading;
+    private _hideLoading;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ButtonDirective, "button[ng0Button], a[ng0Button], input[type=button][ng0Button], input[type=submit][ng0Button], input[type=reset][ng0Button]", ["ng0Button"], { "request": { "alias": "request"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "disableDuringRequest": { "alias": "disableDuringRequest"; "required": false; "isSignal": true; }; "loadingIndicator": { "alias": "loadingIndicator"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; }, never, never, true, never>;
+}
+
+declare class ButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ButtonModule, never, [typeof ButtonDirective], [typeof ButtonDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ButtonModule>;
+}
+
+export { ButtonDirective, ButtonModule };

package/components/card/index.d.ts

@@ -0,0 +1,27 @@
+import * as i0 from '@angular/core';
+import { ElementRef, Renderer2 } from '@angular/core';
+
+declare class CardComponent {
+    private _element;
+    private _renderer;
+    header: i0.InputSignal<string | undefined>;
+    constructor(_element: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent, "ng0-card", ["ng0Card"], { "header": { "alias": "header"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class CardHeaderComponent {
+    private _element;
+    private _renderer;
+    constructor(_element: ElementRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardHeaderComponent, "ng0-card-header", ["ng0CardHeader"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class CardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CardModule, never, [typeof CardComponent, typeof CardHeaderComponent], [typeof CardComponent, typeof CardHeaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CardModule>;
+}
+
+export { CardComponent, CardHeaderComponent, CardModule };

package/components/code/index.d.ts

@@ -0,0 +1,35 @@
+import * as i0 from '@angular/core';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { DomSanitizer } from '@angular/platform-browser';
+
+type CodeFormatterFunc = (code: string) => string;
+declare class CodeFormatter {
+    readonly name: string;
+    readonly format: CodeFormatterFunc;
+    constructor(name: string, format: CodeFormatterFunc);
+}
+
+declare class CodeFormatters {
+    private _formatters;
+    constructor();
+    add(name: string, func: CodeFormatterFunc): CodeFormatter;
+    find(name: string): CodeFormatter | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CodeFormatters, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CodeFormatters>;
+}
+
+declare class CodeComponent {
+    private formatters;
+    private domSanitizer;
+    /** Code formatter name */
+    formatter: i0.InputSignal<string>;
+    /** Code */
+    code: i0.InputSignal<string>;
+    protected _safeHtml: i0.Signal<_angular_platform_browser.SafeHtml | undefined>;
+    constructor(formatters: CodeFormatters, domSanitizer: DomSanitizer);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CodeComponent, "ng0-code", ["ng0Code"], { "formatter": { "alias": "formatter"; "required": true; "isSignal": true; }; "code": { "alias": "code"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { CodeComponent, CodeFormatter, CodeFormatters };
+export type { CodeFormatterFunc };

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/confirmation/index.d.ts

@@ -0,0 +1,66 @@
+import * as i0 from '@angular/core';
+import { OnInit, EventEmitter } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { DialogRef, Dialog } from '@angular/cdk/dialog';
+
+interface ConfirmationConfig {
+    message?: string;
+    title?: string;
+    icon?: 'loading' | 'check';
+    /** automaticaly close confirmation after confirmation/cancelation. default is true */
+    autoClose?: boolean;
+}
+declare class ConfirmationRef {
+    private _dialogRef;
+    private _config;
+    private _configChangeSubject;
+    configChanged: rxjs.Observable<ConfirmationConfig>;
+    private _confirmSubject;
+    confirmed: rxjs.Observable<unknown>;
+    private _cancelSubject;
+    canceled: rxjs.Observable<unknown>;
+    constructor(_dialogRef: DialogRef<any, any>, _config: ConfirmationConfig);
+    confirm(): void;
+    cancel(): void;
+    close(): void;
+    update(config: ConfirmationConfig): void;
+}
+
+declare class ConfirmationComponent implements OnInit {
+    confirmationRef: ConfirmationRef;
+    _config?: ConfirmationConfig;
+    _clicked: boolean;
+    constructor();
+    _onClick(result: boolean): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmationComponent, "ng0-confirmation", ["ng0Confirmation"], {}, {}, never, never, true, never>;
+}
+
+declare class ConfirmationService {
+    private dialog;
+    constructor(dialog: Dialog);
+    open(config?: ConfirmationConfig): ConfirmationRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmationService>;
+}
+
+declare class ConfirmationDirective {
+    private confirmationService;
+    config?: ConfirmationConfig;
+    confirm: EventEmitter<ConfirmationRef>;
+    cancel: EventEmitter<ConfirmationRef>;
+    constructor(confirmationService: ConfirmationService);
+    private _onClick;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ConfirmationDirective, "[ng0Confirmation]", ["ng0Confirmation"], { "config": { "alias": "config"; "required": false; }; }, { "confirm": "confirm"; "cancel": "cancel"; }, never, never, true, never>;
+}
+
+declare class ConfirmationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfirmationModule, never, [typeof ConfirmationComponent, typeof ConfirmationDirective], [typeof ConfirmationComponent, typeof ConfirmationDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ConfirmationModule>;
+}
+
+export { ConfirmationComponent, ConfirmationDirective, ConfirmationModule, ConfirmationRef, ConfirmationService };
+export type { ConfirmationConfig };

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 | undefined>;
+    /**
+     * 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 | undefined>;
+    /**
+     * 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 | undefined;
+    /** 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" | undefined>;
+    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,68 @@
+import * as i0 from '@angular/core';
+import { ElementRef, TemplateRef, OnInit, QueryList, Renderer2 } from '@angular/core';
+
+declare class NavDirective {
+    /**
+     * The active item.
+     */
+    activeItem: i0.ModelSignal<any>;
+    /**
+     * Whether the navigation is disabled.
+     */
+    disabled: i0.InputSignal<boolean>;
+    constructor();
+    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;
+    id: i0.InputSignal<any>;
+    disabled: i0.InputSignal<boolean>;
+    constructor(elementRef: ElementRef);
+    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 _nav;
+    private _navItem;
+    constructor(elementRef: ElementRef, _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 NavContentDirective {
+    templateRef: TemplateRef<any>;
+    id: i0.InputSignal<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NavContentDirective, "[ng0NavContent]", ["ng0NavContent"], { "id": { "alias": "ng0NavContent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NavContentContainerComponent implements OnInit {
+    private _elementRef;
+    private _renderer;
+    /**
+     * The navigation directive that this content belongs to.
+     */
+    nav: i0.InputSignal<NavDirective>;
+    protected _contents: QueryList<NavContentDirective>;
+    protected _activeItem: i0.Signal<any>;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavContentContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavContentContainerComponent, "ng0-navcontent-container", ["ng0Navcontent"], { "nav": { "alias": "nav"; "required": true; "isSignal": true; }; }, {}, ["_contents"], 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 NavContentContainerComponent, typeof NavContentDirective], [typeof NavDirective, typeof NavItemDirective, typeof NavLinkDirective, typeof NavContentContainerComponent, typeof NavContentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NavModule>;
+}
+
+export { NavContentContainerComponent, NavContentDirective, NavDirective, NavItemDirective, NavLinkDirective, NavModule };

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