@bootkit/ng0 0.0.0-alpha.2 → 0.0.0-alpha.20

package/common/index.d.ts

@@ -1,12 +1,124 @@
 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>;
+/**
+ * List item interface.
+ */
+interface SelectOption {
+    id: string;
+    value: any;
+    show?: boolean;
+}
+
+/**
+ * Represents a claim object that can contain multiple claims.
+ */
+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;
 
-declare function numberRange(start: number, end: number): number[];
-declare function fillArray(start: number, end: number): number[];
+type Placement = 'start' | 'end' | 'top' | 'bottom';
+type Alignment = 'start' | 'center' | 'end';
+/**
+ * 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";
 
-export { RTL, fillArray, flipPlacement, numberRange };
-export type { Alignment, Placement };
+/**
+ * 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;
+
+/** Menu item  */
+interface MenuItem {
+    type?: string;
+    id?: any;
+    disabled?: boolean;
+    active?: boolean;
+    show?: boolean;
+    claim?: ClaimLike;
+    parent?: MenuItem;
+    text?: string;
+    expanded?: boolean;
+    icon?: string;
+    children?: MenuItem[];
+    routerLink?: string | string[];
+}
+
+/**
+ * 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>;
+
+/**
+ * Creates an array of numbers within a specified range.
+ * @param start The starting number of the range (inclusive).
+ * @param end The ending number of the range (inclusive).
+ * @returns An array of numbers within the specified range.
+ */
+declare function numberArray(start: number, end: number): number[];
+
+declare function getEnumValues(enumClass: Record<string, string | number>): Array<string | number>;
+
+declare abstract class _IdGenerator {
+    private static _idCounter;
+    static next(): number;
+}
+/**
+ * Type definition for an ID generator function.
+ */
+type IdGenerator = (param?: any) => string;
+/**
+ * Creates a sequential ID generator function with an optional prefix.
+ * @param prefix Optional prefix for the generated IDs.
+ * @returns A function that generates sequential IDs with the given prefix.
+ */
+declare function sequentialIdGenerator(prefix?: string): IdGenerator;
+
+/**
+ * CSS class type which can be a string, array of strings, set of strings, or an object with class names as keys.
+ */
+type CssClass = string | string[] | Set<string> | {
+    [klass: string]: any;
+} | null | undefined;
+/**
+ * A function that takes an item and returns a CssClass.
+ * @param item The item to get the CSS class for.
+ * @returns The CSS class for the item.
+ */
+type CssClassGetter = (item: any) => CssClass;
+/**
+ * A type that represents a CSS class or a function that returns a CSS class.
+ */
+type CssClassLike = CssClass | CssClassGetter | null | undefined;
+/**
+ * Converts a CssClassLike to a CssClassGetter function.
+ * @param v The CssClassLike to convert.
+ * @returns A function that returns the desired CSS class.
+ */
+declare function CssClassAttribute(v: CssClassLike): CssClassGetter;
+
+export { CssClassAttribute, RTL, _IdGenerator, flipPlacement, formatString, getEnumValues, numberArray, sequentialIdGenerator, toObservable };
+export type { Alignment, ClaimLike, ClaimObject, CssClass, CssClassGetter, CssClassLike, IdGenerator, MenuItem, Placement, SelectOption };

package/components/accordion/index.d.ts

@@ -5,7 +5,7 @@ declare class AccordionItemComponent {
     private _element;
     private _renderer;
     private _accordion;
-    header: i0.InputSignal<string>;
+    header: i0.InputSignal<string | undefined>;
     collapsed: i0.ModelSignal<boolean>;
     constructor(_element: ElementRef, _renderer: Renderer2, _accordion: AccordionComponent);
     static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemComponent, never>;

package/components/backdrop/index.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from '@angular/core';
+
+/**
+ * This component is used to display a backdrop behind another component.
+ */
+declare class BackdropComponent {
+    readonly fixed: i0.WritableSignal<boolean>;
+    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/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/list/index.d.ts

@@ -0,0 +1,127 @@
+import * as _bootkit_ng0_common from '@bootkit/ng0/common';
+import { CssClassLike, IdGenerator } from '@bootkit/ng0/common';
+import * as _bootkit_ng0_localization from '@bootkit/ng0/localization';
+import * as _bootkit_ng0_data from '@bootkit/ng0/data';
+import { DataSource, DataSourceLike, FilterPredicate } from '@bootkit/ng0/data';
+import * as _angular_core from '@angular/core';
+import { OnInit, ElementRef, TemplateRef, Renderer2, DestroyRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+interface ListItem {
+    id: string;
+    value: any;
+    selected?: boolean;
+    disabled?: boolean;
+    filtered?: boolean;
+}
+
+/**
+ * Select component that allows users to choose an option from a dropdown list.
+ */
+declare class ListComponent implements OnInit, ControlValueAccessor {
+    protected _el: ElementRef<HTMLDivElement>;
+    private _renderer;
+    private _destroyRef;
+    private _document;
+    private _ls;
+    private _changeDetector;
+    protected _value: _angular_core.WritableSignal<any>;
+    private _onChangeCallback;
+    private _onTouchedCallback;
+    protected readonly _items: _angular_core.WritableSignal<ListItem[]>;
+    protected readonly _isDisabled: _angular_core.WritableSignal<boolean>;
+    protected readonly _activeOptionIndex: _angular_core.WritableSignal<number>;
+    protected _itemTemplate?: TemplateRef<any>;
+    /**
+     * The data source for the select component.
+     * This can be an array of data, a function that returns an observable of data,
+     * or an instance of DataSource.
+     */
+    readonly source: _angular_core.InputSignalWithTransform<DataSource<any>, DataSourceLike<any>>;
+    /**
+     * Indicates whether multi selection is enabled or not.
+     */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Indicates whether to show selection indicator (checkbox/radio) next to each item.
+     * Default is false.
+     */
+    readonly showIndicator: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+    * A custom comparer function or the name of a field for comparing two objects.
+    */
+    readonly compareBy: _angular_core.InputSignalWithTransform<_bootkit_ng0_data.BooleanValueComparer, _bootkit_ng0_data.BooleanValueComparerLike>;
+    /**
+     * Custom format function to convert an item to a string for display.
+     * Default converts the item to a string using its toString method.
+     */
+    readonly formatBy: _angular_core.InputSignalWithTransform<_bootkit_ng0_localization.ValueFormatterFunction, _bootkit_ng0_localization.ValueFormatterLike>;
+    /**
+     * Custom value extractor function to extract the value of any object while writing values.
+     */
+    readonly writeValueBy: _angular_core.InputSignalWithTransform<_bootkit_ng0_data.ValueExtractor, _bootkit_ng0_data.ValueExtractorLike>;
+    /**
+     * A custom filter predicate function to filter items based on a search string.
+     * Default checks if the item's string representation contains the filter string (case-insensitive).
+     * The filter predicate can be a function or a string representing the property name to filter.
+     */
+    readonly filterBy: _angular_core.InputSignalWithTransform<FilterPredicate, _bootkit_ng0_data.FilterPredicateLike>;
+    /**
+     * CSS class or classes to apply to the list container.
+     * Default is undefined.
+     */
+    readonly itemClass: _angular_core.InputSignalWithTransform<_bootkit_ng0_common.CssClassGetter, CssClassLike>;
+    readonly focus: _angular_core.InputSignal<"none" | "roving" | "activeDescendant">;
+    readonly idGenerator: _angular_core.InputSignal<IdGenerator | undefined>;
+    constructor(_el: ElementRef<HTMLDivElement>, _renderer: Renderer2, _destroyRef: DestroyRef);
+    ngOnInit(): void;
+    /**
+     * Sets an option as active
+     */
+    active(index: number): void;
+    /**
+     * Filters the list items based on the provided criteria.
+     * @param params The filter parameters to apply.
+     * @returns void
+     */
+    filter(...params: any[]): void;
+    /**
+     * Clears any applied filters and shows all items in the list.
+     * @returns void
+     */
+    clearFilter(): void;
+    /**
+     * Scrolls the item at the specified index into view within the dropdown list.
+     * @param index The index of the item to scroll into view.
+     * @param position The vertical alignment of the item after scrolling.
+     *                 Can be 'start', 'center', 'end', or 'nearest'.
+     *                 Default is 'nearest'.
+     * @param behavior The scrolling behavior.
+     */
+    scrollItemIntoView(index: number, position?: ScrollLogicalPosition, behavior?: ScrollBehavior): void;
+    /**
+     * Toggles the selection of an option by index
+     */
+    toggleSelection(index: number): void;
+    writeValue(v: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    protected _onKeydown(e: KeyboardEvent, firedByFilter?: boolean): void;
+    private _loadItems;
+    private _listenToDataSourceChanges;
+    private _insertItems;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListComponent, "ng0-list", ["ng0List"], { "source": { "alias": "source"; "required": true; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "showIndicator": { "alias": "showIndicator"; "required": false; "isSignal": true; }; "compareBy": { "alias": "compareBy"; "required": false; "isSignal": true; }; "formatBy": { "alias": "formatBy"; "required": false; "isSignal": true; }; "writeValueBy": { "alias": "writeValueBy"; "required": false; "isSignal": true; }; "filterBy": { "alias": "filterBy"; "required": false; "isSignal": true; }; "itemClass": { "alias": "itemClass"; "required": false; "isSignal": true; }; "focus": { "alias": "focus"; "required": false; "isSignal": true; }; "idGenerator": { "alias": "idGenerator"; "required": false; "isSignal": true; }; }, {}, ["_itemTemplate"], never, true, never>;
+}
+
+/**
+ * List module.
+ */
+declare class ListModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ListModule, never, [typeof ListComponent], [typeof ListComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ListModule>;
+}
+
+export { ListComponent, ListModule };

package/components/modal/index.d.ts

@@ -2,20 +2,38 @@ import * as _angular_core from '@angular/core';
 import { EventEmitter } from '@angular/core';
 
 interface ModalCloseRequest {
+    reason: 'backdrop' | 'escape';
+    event: Event;
 }
 
 declare class ModalComponent {
+    /**
+     * Is modal scrollable?
+     */
     scrollable: _angular_core.InputSignal<boolean>;
     /** Is modal vertically centered? */
     centered: _angular_core.InputSignal<boolean>;
+    /**
+     * Size of the modal.
+     */
     size: _angular_core.InputSignal<"sm" | "default" | "lg" | "xl">;
-    fullscreen: _angular_core.InputSignal<"sm" | "lg" | "xl" | "always" | "md" | "xxl">;
+    /**
+     * Is modal fullscreen?
+     */
+    fullscreen: _angular_core.InputSignal<"sm" | "lg" | "xl" | "always" | "md" | "xxl" | undefined>;
+    /**
+     * Emitted when user clicks the backdrop or presses the escape key.
+     */
     closeRequest: EventEmitter<ModalCloseRequest>;
-    backdropClick: EventEmitter<any>;
+    /**
+     * Emitted when the backdrop is clicked.
+     */
+    backdropClick: EventEmitter<Event>;
     protected _modalStatic: _angular_core.WritableSignal<boolean>;
     constructor();
-    protected _onBackdropClick(): void;
-    onKeyDown(event: KeyboardEvent): void;
+    protected _onBackdropClick(event: MouseEvent): void;
+    private _onDocumentKeyDown;
+    private _shakeModal;
     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>;
 }