@ardium-pl/ui 5.0.0-alpha.106

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ardium-pl/ui" />
+export * from './public-api';

package/lib/_internal/boolean-component.d.ts

@@ -0,0 +1,65 @@
+import { ControlValueAccessor } from '@angular/forms';
+import { BooleanLike } from '@ardium-ui/devkit';
+import { _NgModelComponentBase, _NgModelComponentDefaults } from './ngmodel-component';
+import * as i0 from "@angular/core";
+export interface _BooleanComponentDefaults extends _NgModelComponentDefaults {
+    reverseSelected: boolean;
+}
+export declare const _booleanComponentDefaults: _BooleanComponentDefaults;
+/**
+ * Common code for components, which only operate on the "selected" state.
+ */
+export declare abstract class _BooleanComponentBase extends _NgModelComponentBase implements ControlValueAccessor {
+    protected readonly _DEFAULTS: _BooleanComponentDefaults;
+    protected abstract readonly _componentId: string;
+    protected abstract readonly _componentName: string;
+    writeValue(v: any): void;
+    /**
+     * Emits all select-state-related events.
+     */
+    protected _emitChange(): void;
+    /**
+     * The event emitter responsible for firing `select` events. Fired when the `selected` state is set to true.
+     */
+    readonly selectEvent: import("@angular/core").OutputEmitterRef<null>;
+    /**
+     * The event emitter responsible for firing `unselect` events. Fired when the `selected` state is set to false.
+     */
+    readonly unselectEvent: import("@angular/core").OutputEmitterRef<null>;
+    /**
+     * The event emitter responsible for firing `change` events. Fired when the `selected` state is changed.
+     */
+    readonly changeEvent: import("@angular/core").OutputEmitterRef<boolean>;
+    readonly selected: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * The selection state of the component. Coercible into a boolean.
+     */
+    set _selected(v: any);
+    get _selectedHostAttribute(): boolean;
+    /**
+     * The event emitter responsible for firing `selectedChange` events. Fired when the `selected` state is changed.
+     */
+    readonly selectedChange: import("@angular/core").OutputEmitterRef<boolean>;
+    /**
+     * The reverse of the `selected` state. Coercible into a boolean. Useful for cases where the "selected" state is semantically reversed, e.g. "disabled".
+     */
+    readonly reverseSelected: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    /**
+     * The "selected" state, accounting for the `reverseSelected` input.
+     */
+    readonly selectedAccountingForReverse: import("@angular/core").Signal<boolean>;
+    /**
+     * Toggles the selected state. Emits all appropriate events.
+     */
+    toggleSelected(): void;
+    /**
+     * Sets the state to "selected". Emits all appropriate events only if the state changes.
+     */
+    select(): void;
+    /**
+     * Sets the state to "unselected". Emits all appropriate events only if the state changes.
+     */
+    unselect(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_BooleanComponentBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_BooleanComponentBase, never, never, { "_selected": { "alias": "selected"; "required": false; }; "reverseSelected": { "alias": "reverseSelected"; "required": false; "isSignal": true; }; }, { "selectEvent": "select"; "unselectEvent": "unselect"; "changeEvent": "change"; "selectedChange": "selectedChange"; }, never, never, true, never>;
+}

package/lib/_internal/clear-button/clear-button.component.d.ts

@@ -0,0 +1,7 @@
+import { _FocusableComponentBase } from './../focusable-component';
+import * as i0 from "@angular/core";
+export declare class _ClearButtonComponent extends _FocusableComponentBase {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<_ClearButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<_ClearButtonComponent, "ard-clear-button", never, {}, {}, never, never, false, never>;
+}

package/lib/_internal/clear-button/clear-button.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./clear-button.component";
+import * as i2 from "@angular/common";
+export declare class _ClearButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<_ClearButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<_ClearButtonModule, [typeof i1._ClearButtonComponent], [typeof i2.CommonModule], [typeof i1._ClearButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<_ClearButtonModule>;
+}

package/lib/_internal/disablable-component.d.ts

@@ -0,0 +1,24 @@
+import * as i0 from "@angular/core";
+export interface _DisablableComponentDefaults {
+    readonly: boolean;
+    disabled: boolean;
+}
+export declare const _disablableComponentDefaults: _DisablableComponentDefaults;
+export declare abstract class _DisablableComponentBase {
+    protected readonly _DEFAULTS: _DisablableComponentDefaults;
+    constructor(_DEFAULTS: _DisablableComponentDefaults);
+    /**
+     * Whether the component is read-only. Defines the `readonly` host attribute and `ard-readonly` host class. Coercible into a boolean.
+     */
+    readonly readonly: import("@angular/core").WritableSignal<boolean>;
+    set _readonly(v: any);
+    /**
+     * Whether the component is disabled. Defines the `disabled` host attribute and `ard-disabled` host class. Coercible into a boolean.
+     */
+    readonly disabled: import("@angular/core").WritableSignal<boolean>;
+    set _disabled(v: any);
+    get _readonlyHostAttribute(): boolean;
+    get _disabledHostAttribute(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_DisablableComponentBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_DisablableComponentBase, never, never, { "_readonly": { "alias": "readonly"; "required": false; }; "_disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/_internal/focusable-component.d.ts

@@ -0,0 +1,56 @@
+import { NumberLike } from '@ardium-ui/devkit';
+import { _DisablableComponentBase, _DisablableComponentDefaults } from './disablable-component';
+import * as i0 from "@angular/core";
+export interface _FocusableComponentDefaults extends _DisablableComponentDefaults {
+    tabIndex: number;
+}
+export declare const _focusableComponentDefaults: _FocusableComponentDefaults;
+export declare abstract class _FocusableComponentBase extends _DisablableComponentBase {
+    protected readonly _DEFAULTS: _FocusableComponentDefaults;
+    private readonly _focusableElement;
+    /**
+     * Focuses the correct element in the component.
+     */
+    focus(): void;
+    /**
+     * Focuses the first of all available elements in the component.
+     */
+    focusFirst(): void;
+    /**
+     * Focuses the last of all available elements in the component.
+     */
+    focusLast(): void;
+    /**
+     * Blurs all focusable elements in the component.
+     */
+    blur(): void;
+    /**
+     * The component's overall tab index. If the component is disabled, it is always `-1`. Coercible into a number, defaults to `0`.
+     */
+    readonly tabIndex: import("@angular/core").Signal<number>;
+    readonly _tabIndex: import("@angular/core").InputSignalWithTransform<number, NumberLike>;
+    /**
+     * The event emitter responsible for firing `focus` events.
+     */
+    readonly focusEvent: import("@angular/core").OutputEmitterRef<FocusEvent>;
+    /**
+     * The event emitter responsible for firing `blur` events.
+     */
+    readonly blurEvent: import("@angular/core").OutputEmitterRef<FocusEvent>;
+    /**
+     * Whether the component is currently focused.
+     */
+    readonly isFocused: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * Function to handle when an element is focused. Sets `isFocused` and fires the `focus` event.
+     * @param event The focus event to emit.
+     */
+    onFocus(event: FocusEvent): void;
+    /**
+     * Function to handle when an element is blurred. Sets `isFocused` and fires the `blur` event.
+     * @param event The focus event to emit.
+     */
+    onBlur(event: FocusEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_FocusableComponentBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_FocusableComponentBase, never, never, { "_tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; }, { "focusEvent": "focus"; "blurEvent": "blur"; }, never, never, true, never>;
+}

package/lib/_internal/form-field-component.d.ts

@@ -0,0 +1,22 @@
+import { ControlValueAccessor } from '@angular/forms';
+import { BooleanLike } from '@ardium-ui/devkit';
+import { ArdFormFieldControl } from '../form-field/form-field-child.token';
+import { _NgModelComponentBase, _NgModelComponentDefaults } from './ngmodel-component';
+import * as i0 from "@angular/core";
+export interface _FormFieldComponentDefaults extends _NgModelComponentDefaults {
+    required: boolean | undefined;
+}
+export declare const _formFieldComponentDefaults: _FormFieldComponentDefaults;
+/**
+ * Common code for components which implement the ControlValueAccessor.
+ *
+ * **Warning**: `writeValue` function should be implemented on the child component!
+ */
+export declare abstract class _FormFieldComponentBase extends _NgModelComponentBase implements ControlValueAccessor, ArdFormFieldControl {
+    protected readonly _DEFAULTS: _FormFieldComponentDefaults;
+    readonly _required: import("@angular/core").InputSignalWithTransform<boolean | undefined, any>;
+    readonly required: import("@angular/core").Signal<boolean>;
+    readonly isSuccess: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_FormFieldComponentBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_FormFieldComponentBase, never, never, { "_required": { "alias": "required"; "required": false; "isSignal": true; }; "isSuccess": { "alias": "isSuccess"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/_internal/item-storages/dropdown-item-storage.d.ts

@@ -0,0 +1,79 @@
+import { Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AddCustomFn } from '../../select/select.types';
+import { ArdOption, ArdOptionGroup, CompareWithFn, GroupByFn, SearchFn } from '../../types/item-storage.types';
+import { Nullable } from '../../types/utility.types';
+export interface ItemStorageHost {
+    readonly valueFrom: Signal<string>;
+    readonly labelFrom: Signal<string>;
+    readonly disabledFrom: Signal<string>;
+    readonly invertDisabled: Signal<boolean>;
+    readonly groupLabelFrom: Signal<string | GroupByFn>;
+    readonly groupDisabledFrom: Signal<string>;
+    readonly childrenFrom: Signal<string>;
+    readonly itemsAlreadyGrouped: Signal<Nullable<boolean>>;
+    readonly hideSelected: Signal<boolean>;
+    readonly deferValueWrites: Signal<boolean>;
+    readonly searchCaseSensitive: Signal<boolean>;
+    readonly searchFn: Signal<SearchFn | null>;
+    readonly compareWith: Signal<Nullable<CompareWithFn>>;
+    readonly multiselectable: Signal<boolean>;
+    readonly maxSelectedItems: Signal<Nullable<number>>;
+    readonly addCustom: Signal<boolean | AddCustomFn<any> | AddCustomFn<Promise<any>>>;
+    readonly _componentId: string;
+}
+export declare class ItemStorage {
+    private readonly _ardParentComp;
+    private readonly _items;
+    readonly filteredItems: Signal<ArdOption[]>;
+    readonly selectedItems: Signal<ArdOption[]>;
+    readonly highlightedItems: Signal<ArdOption[]>;
+    private readonly _lastHighlightedItem;
+    private readonly _recentlyHighlightedItem;
+    private readonly _groups;
+    private _updateItems;
+    private _updateItemsFromArray;
+    constructor(_ardParentComp: ItemStorageHost);
+    readonly groups: Signal<ArdOptionGroup[]>;
+    readonly items: Signal<ArdOption[]>;
+    readonly lastSelectedItem: Signal<ArdOption>;
+    readonly value: Signal<any[]>;
+    private _itemsToValue;
+    readonly isNoItemsToSelect: Signal<boolean>;
+    readonly isNoItemsFound: Signal<boolean>;
+    readonly isAnyItemExactMatch: Signal<boolean>;
+    readonly isAnyItemSelected: Signal<boolean>;
+    readonly isAnyItemHighlighted: Signal<boolean>;
+    readonly itemsLeftUntilLimit: Signal<number>;
+    readonly isItemLimitReached: Signal<boolean>;
+    private readonly _highlightableItems;
+    setItems(items: any[]): void;
+    updateItemFromOptionComponent(itemValue: any, updatedItem: Partial<ArdOption>): void;
+    private _addSingleItem;
+    private _primitiveItemsMapFn;
+    private _ungroupAlreadyGroupedItems;
+    private _setItemsMapFn;
+    private _createEmptyGroupMap;
+    private _isWriteValueValid;
+    private _valueToWriteAfterItemsLoad;
+    handleWriteValue(ngModel: any): Promise<void>;
+    findItemByValue(valueToFind: any): ArdOption | undefined;
+    addCustomOption(value: string, fn: AddCustomFn<any> | AddCustomFn<Promise<any>> | AddCustomFn<Observable<any>>): Promise<ArdOption | null>;
+    clearAllSelected(): any[];
+    clearLastSelected(): ArdOption;
+    selectItem(...items: ArdOption[]): [any[], any[], any[]];
+    unselectItem(...items: ArdOption[]): any[];
+    toggleItem(item: ArdOption): void;
+    clearAllHighlights(): void;
+    highlightGroup(group: ArdOptionGroup): ArdOption;
+    highlightSingleItem(item: ArdOption): ArdOption | null;
+    highlightItem(...items: ArdOption[]): ArdOption;
+    unhighlightItem(...items: ArdOption[]): void;
+    highlightFirstItem(): ArdOption | null;
+    highlightLastItem(): ArdOption | null;
+    highlightAllItems(): void;
+    setRecentlyHighlighted(itemToSet: ArdOption): void;
+    highlightNextItem(offset: number, hasShift?: boolean): ArdOption | null;
+    filter(filterTerm: string): void;
+    resetFiltered(): ArdOption[];
+}

package/lib/_internal/item-storages/simple-item-storage.d.ts

@@ -0,0 +1,167 @@
+import { Signal } from '@angular/core';
+import { ArdOptionSimple, CompareWithFn } from '../../types/item-storage.types';
+import { Nullable } from '../../types/utility.types';
+export interface ItemStorageHostDefaults {
+    valueFrom: string;
+    labelFrom: string;
+    disabledFrom: string;
+}
+export interface SimpleItemStorageHost {
+    readonly valueFrom: Signal<Nullable<string>>;
+    readonly labelFrom: Signal<Nullable<string>>;
+    readonly disabledFrom: Signal<Nullable<string>>;
+    readonly invertDisabled: Signal<boolean>;
+    readonly DEFAULTS: ItemStorageHostDefaults;
+    readonly compareWith: Signal<Nullable<CompareWithFn>>;
+    readonly multiselectable: Signal<boolean>;
+    readonly isValueRequired: Signal<boolean>;
+    readonly maxSelectedItems: Signal<Nullable<number>>;
+    readonly _componentId: string;
+    readonly _componentName: string;
+}
+export declare class SimpleItemStorage {
+    private readonly _ardParentComp;
+    private readonly _items;
+    constructor(_ardParentComp: SimpleItemStorageHost);
+    /**
+     * Gets all items.
+     */
+    readonly items: Signal<ArdOptionSimple[]>;
+    /**
+     * Gets all currently selected items.
+     */
+    readonly selectedItems: Signal<ArdOptionSimple[]>;
+    /**
+     * Gets all currently highlighted items.
+     */
+    readonly highlightedItems: Signal<ArdOptionSimple[]>;
+    /**
+     * Gets the values of the currently selected items.
+     */
+    readonly value: Signal<any[]>;
+    /**
+     * Maps an array of items into their values.
+     * @param items The items to convert to value.
+     * @returns An array of item values.
+     */
+    private _itemsToValue;
+    private _updateItems;
+    private _updateItemsFromArray;
+    /**
+     * Returns true if at least one item is highlighted, otherwise false.
+     */
+    readonly isAnyItemHighlighted: Signal<boolean>;
+    /**
+     * Finds all highlightable items. An item is considered highlightable if it is **not** disabled.
+     * @returns An array of all highlightable items.
+     */
+    private readonly _highlightableItems;
+    readonly itemsLeftUntilLimit: Signal<number>;
+    /**
+     * Returns true if the parent component defines the limit of concurrently selectable items and the amount of currently selected items matches that limit. Otherwise returns false.
+     *
+     * **TLDR**: true if `maxSelectedItems` is defined and the number of selected items matches that value.
+     */
+    readonly isItemLimitReached: Signal<boolean>;
+    private _areItemsInitialized;
+    /**
+     * Sets the component's items. Takes into account the values defined by the parent component for `valueFrom`, `labelFrom`, and `disabledFrom`.
+     * @param items An array of items to be set as the component's items.
+     * @returns true if at least one of the items is of primitive type, otherwise false.
+     */
+    setItems(items: unknown[]): void;
+    private _primitiveItemsMapFn;
+    private _setItemsMapFn;
+    private _valueBeforeItemsSet;
+    /**
+     * Writes a new value to the item storage. Selects the correct items based on the provided values, warning the user if the value is not found.
+     * @param ngModel The value of the ngModel to set.
+     */
+    writeValue(ngModel: any): void;
+    private _validateSingleElementType;
+    /**
+     * Validates that all values of the value to be written are able to be accurately compared against the storage items.
+     *
+     * An item from the ngModel array is considered valid if it is a primitive value, or if all of the below points are met:
+     * 1. The parent component defines the `compareWith` property.
+     * 2. The ngModel value item is an object (or array).
+     * 3. The parent component has a defined `valueFrom` property.
+     * @param ngModel The value of ngModel to validate.
+     * @returns true if all items are valid, otherwise false.
+     */
+    private _validateWriteValue;
+    findItemByValue(valueToFind: any): ArdOptionSimple | undefined;
+    /**
+     * Unselects all selected items.
+     *
+     * If the parent component requires at least one value to be selected at all times, the first selected items is left selected.
+     * @returns An array of items cleared, mapped to only their values.
+     */
+    unselectAll(): any[];
+    /**
+     * Unselects all selected items, no matter what the component settings are.
+     * @returns An array of items cleared, mapped to only their values.
+     */
+    private _forceUnselectAll;
+    /**
+     * Selects one or multiple items.
+     *
+     * Accounts for the limit of concurrently selected items defined by the parent component.
+     * @param items A rest operator array of item objects to be selected.
+     * @returns A tuple containing three arrays, all mapped to only their values:
+     * - An array of items selected,
+     * - An array of items unselected,
+     * - An array of items failed to select due to the limit.
+     */
+    selectItem(...items: ArdOptionSimple[]): [any[], any[], any[]];
+    /**
+     *
+     * @param items A rest operator array of item objects to be unselected.
+     * @returns An array of items unselected, mapped to only their values.
+     */
+    unselectItem(...items: ArdOptionSimple[]): any[];
+    /**
+     * Unhighlights all currently highlighted items.
+     */
+    unhighlightAll(): void;
+    /**
+     * Highlights the given item, while unhighlighting all other items. Does nothing when the item is disabled.
+     * @param item The item to be highlighted.
+     * @returns The highlighted item.
+     */
+    highlightSingleItem(item: ArdOptionSimple): ArdOptionSimple | null;
+    /**
+     * Highlights all given items.
+     * @param items A rest operator array of items to be highlighted.
+     * @returns The last highlighted item.
+     */
+    highlightItem(...items: ArdOptionSimple[]): ArdOptionSimple;
+    /**
+     * Unhighlights all given items.
+     * @param items A rest operator array of items to be unhighlighted.
+     */
+    unhighlightItem(...items: ArdOptionSimple[]): void;
+    /**
+     * Highlights the first item out of all items.
+     * @returns The highlighted item.
+     */
+    highlightFirstItem(): ArdOptionSimple | null;
+    /**
+     * Highlights the last item out of all items.
+     * @returns The highlighted item.
+     */
+    highlightLastItem(): ArdOptionSimple | null;
+    /**
+     * Highlights all non-disabled items.
+     */
+    highlightAllItems(): void;
+    /**
+     * Highlights the next non-disabled item defined by the offset amount.
+     *
+     * If `hasShift` is set to true, all originally highlighted items are kept. Otherwise, all original items are unselected.
+     * @param offset The amount of items to offset the highlight by.
+     * @param hasShift Whether the user has the shift key pressed.
+     * @returns The item highlighted.
+     */
+    highlightNextItem(offset: number, hasShift?: boolean): ArdOptionSimple | null;
+}

package/lib/_internal/item-storages/simplest-item-storage.d.ts

@@ -0,0 +1,75 @@
+import { Signal } from '@angular/core';
+import { ArdSimplestStorageItem } from '../../types/item-storage.types';
+import { Nullable } from '../../types/utility.types';
+export interface SimplestItemStorageHostDefaults {
+    suggValueFrom: string;
+    suggLabelFrom: string;
+}
+export interface SimplestItemStorageHost {
+    readonly valueFrom: Signal<Nullable<string>>;
+    readonly labelFrom: Signal<Nullable<string>>;
+    readonly DEFAULTS: SimplestItemStorageHostDefaults;
+}
+export declare class SimplestItemStorage {
+    private readonly _ardParentComp;
+    private readonly _items;
+    private readonly _highlightedItem;
+    constructor(_ardParentComp: SimplestItemStorageHost);
+    /**
+     * Gets all items.
+     */
+    readonly items: import("@ardium-ui/devkit").ArraySignal<ArdSimplestStorageItem>;
+    /**
+     * The currently highlighted item.
+     */
+    readonly highlightedItem: Signal<Nullable<ArdSimplestStorageItem>>;
+    /**
+     * True if at least one item is highlighted, otherwise false.
+     */
+    readonly isAnyItemHighlighted: Signal<boolean>;
+    /**
+     * Sets the component's items. Takes into account the values defined by the parent component for `suggValueFrom` and `suggLabelFrom`.
+     * @param items An array of items to be set as the component's items.
+     * @returns true if at least one of the items is of primitive type, otherwise false.
+     */
+    setItems(items: any[]): void;
+    private _primitiveItemsMapFn;
+    private _setItemsMapFn;
+    /**
+     * Selects the given item.
+     * @param items The item to select.
+     * @returns The value of the selected item.
+     */
+    selectItem(item: ArdSimplestStorageItem): any;
+    selectCurrent(): any;
+    /**
+     * Unhighlights all currently highlighted items.
+     */
+    unhighlightCurrent(): void;
+    /**
+     * Highlights a given item.
+     * @param item The item to be highlighted.
+     */
+    highlightItem(item: ArdSimplestStorageItem): void;
+    /**
+     * Unhighlights a given item.
+     * @param item The item to be unhighlighted.
+     */
+    unhighlightItem(item: ArdSimplestStorageItem): void;
+    /**
+     * Highlights the first item out of all items.
+     * @returns The highlighted item.
+     */
+    highlightFirstItem(): ArdSimplestStorageItem | null;
+    /**
+     * Highlights the last item out of all items.
+     * @returns The highlighted item.
+     */
+    highlightLastItem(): ArdSimplestStorageItem | null;
+    /**
+     * Highlights the next non-disabled item defined by the offset amount.
+     * @param offset The amount of items to offset the highlight by.
+     * @returns The item highlighted.
+     */
+    highlightNextItem(offset: number): ArdSimplestStorageItem | null;
+}

package/lib/_internal/models/pagination.model.d.ts

@@ -0,0 +1,49 @@
+import { ModelSignal, Signal } from '@angular/core';
+export interface PaginationModelHost {
+    readonly componentId: string;
+    readonly totalItems: Signal<number>;
+    readonly options: Signal<number[] | {
+        value: number;
+        label: string;
+    }[]>;
+    readonly itemsPerPage: ModelSignal<number>;
+    readonly page: ModelSignal<number>;
+}
+export interface PaginationCurrentItemsContext {
+    readonly currentItemsFrom: number;
+    readonly currentItemsTo: number;
+    readonly totalItems: number;
+    readonly totalPages: number;
+    readonly page: number;
+}
+export interface PaginationContext extends PaginationCurrentItemsContext {
+    readonly itemsPerPageOptions: number[] | {
+        value: number;
+        label: string;
+    }[];
+    readonly itemsPerPage: number;
+    readonly onItemsPerPageChange: (newValue: number) => void;
+    readonly firstPageDisabled: boolean;
+    readonly prevPageDisabled: boolean;
+    readonly nextPageDisabled: boolean;
+    readonly lastPageDisabled: boolean;
+    readonly onPageChange: (newPage: number) => void;
+}
+export declare class PaginationModel {
+    private readonly _ardHostCmp;
+    constructor(_ardHostCmp: PaginationModelHost);
+    readonly isTotalItemsDefined: Signal<boolean>;
+    readonly lastPageNum: Signal<number | null>;
+    readonly isLastPage: Signal<boolean>;
+    readonly itemsOnCurrentPage: Signal<[number, number] | null>;
+    readonly firstPageDisabled: Signal<boolean>;
+    readonly lastPageDisabled: Signal<boolean>;
+    setPage(v: number): void;
+    getPage(): number;
+    goToFirstPage(): number | null;
+    goToPrevPage(): number | null;
+    goToNextPage(): number | null;
+    goToLastPage(): number | null;
+    readonly getCurrentItemsContext: Signal<PaginationCurrentItemsContext>;
+    readonly getPartialContext: Signal<Omit<PaginationContext, "onItemsPerPageChange" | "onPageChange">>;
+}

package/lib/_internal/models/queue.d.ts

@@ -0,0 +1,21 @@
+interface IQueue {
+    readonly length: number;
+}
+export declare class Queue<T = unknown> implements IQueue {
+    private head?;
+    private tail?;
+    push(item: T): void;
+    pushFront(item: T): void;
+    pop(): T | undefined;
+    peek(): T | undefined;
+    clear(): void;
+    get length(): number;
+    isEmpty(): boolean;
+    toArray(): T[];
+}
+export declare class QueueItem<T> {
+    value: T;
+    next?: QueueItem<T> | undefined;
+    constructor(value: T, next?: QueueItem<T> | undefined);
+}
+export {};

package/lib/_internal/ngmodel-component.d.ts

@@ -0,0 +1,58 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { Nullable } from '../types/utility.types';
+import { _FocusableComponentBase, _FocusableComponentDefaults } from './focusable-component';
+import * as i0 from "@angular/core";
+export interface _NgModelComponentDefaults extends _FocusableComponentDefaults {
+}
+export declare const _ngModelComponentDefaults: _NgModelComponentDefaults;
+/**
+ * Common code for components which implement the ControlValueAccessor.
+ *
+ * **Warning**: `writeValue` function should be implemented on the child component!
+ */
+export declare abstract class _NgModelComponentBase extends _FocusableComponentBase implements ControlValueAccessor, OnInit, OnDestroy {
+    protected readonly _DEFAULTS: _NgModelComponentDefaults;
+    protected _onChangeRegistered: (_: any) => void;
+    protected _onTouchedRegistered: () => void;
+    /**
+     * Registers a function to handle touched state. Required by ControlValueAccessor.
+     * @param fn The function to register.
+     */
+    registerOnTouched(fn: () => void): void;
+    /**
+     * Registers a function to handle value change. Required by ControlValueAccessor.
+     * @param fn The function to register.
+     */
+    registerOnChange(fn: (_: any) => void): void;
+    /**
+     * Sets the component's disabled state. Required by ControlValueAccessor.
+     * @param isDisabled the new disabled state.
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Writes the a new value into the component. Required by ControlValueAccessor.
+     * @abstract
+     * @param v The new value to write.
+     */
+    abstract writeValue(v: any): void;
+    /**
+     * Writes the a new value into the component. Required by ControlValueAccessor.
+     * @abstract
+     * @param v The new value to write.
+     */
+    protected abstract _emitChange(): void;
+    onFocus(event: FocusEvent): void;
+    protected _shouldEmitTouched: boolean;
+    onBlur(event: FocusEvent): void;
+    protected _emitTouched(): void;
+    readonly control: import("@ardium-ui/devkit").TrackedFormControl<any>;
+    ngOnInit(): void;
+    readonly htmlId: import("@angular/core").InputSignal<string>;
+    readonly htmlName: import("@angular/core").InputSignal<Nullable<string>>;
+    readonly _hasError: import("@angular/core").InputSignalWithTransform<boolean | undefined, any>;
+    readonly hasError: import("@angular/core").Signal<boolean>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_NgModelComponentBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_NgModelComponentBase, never, never, { "htmlId": { "alias": "htmlId"; "required": false; "isSignal": true; }; "htmlName": { "alias": "htmlName"; "required": false; "isSignal": true; }; "_hasError": { "alias": "hasError"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/_internal/public-api.d.ts

@@ -0,0 +1,3 @@
+import { _FormFieldComponentBase } from './form-field-component';
+export interface ArdFormFieldComponent extends _FormFieldComponentBase {
+}