@odx/angular 6.0.0 → 6.1.0

package/components/modal/lib/models/modal-ref.d.ts

@@ -1,20 +1,54 @@
 import { Controller } from '@odx/angular';
 import { ModalOptions } from './modal-options';
+/**
+ * A reference to a dynamically created modal, providing methods to manipulate, close, or update the modal's state
+ * and options.
+ * This class extends the `Controller` base class from `@odx/angular`, adding modal-specific functionalities like
+ * handling closures and dismissals.
+ *
+ * @see {Controller}
+ */
 export declare class ModalRef<Data = unknown, Result = unknown> extends Controller {
     private internalOptions;
     private readonly onClose$$;
     private readonly onDismiss$$;
+    /** An observable that emits when the modal is closed with a result. */
     readonly onClose$: import("rxjs").Observable<Result>;
+    /** An observable that emits when the modal is dismissed without a result. */
     readonly onDismiss$: import("rxjs").Observable<void>;
+    /** An observable that merges the onClose$ and onDismiss$ streams for cases when any kind of teardown is needed. */
     readonly onDestroy$: import("rxjs").Observable<void>;
+    /** A method that returns whether the modal is currently active. */
     readonly isActive: () => boolean;
+    /** Gets the unique identifier for the modal instance. */
     get id(): string;
+    /** Gets the ARIA label ID for the modal title, based on the modal's ID. */
     get modalTitleId(): string;
+    /** Gets the data passed to the modal. This is useful for modal initialization. */
     get data(): Data;
+    /** Gets the current options for the modal. These options include configurations.
+     * @see {ModalOptions}
+     */
     get options(): ModalOptions<Data>;
     constructor(internalOptions: ModalOptions<Data>, isActive: (modalRef: ModalRef<Data, Result>) => boolean);
+    /**
+     * Updates the modal's options.
+     *
+     * @param {Partial<ModalOptions<Data>>} options A partial set of options to update.
+     */
     update(options: Partial<ModalOptions<Data>>): void;
+    /**
+     * Dismisses the modal. This does not result in an output value.
+     *
+     * @param {boolean} [force=false] Whether to force dismissal regardless of the `canDismiss` condition.
+     */
     dismiss(force?: boolean): void;
+    /**
+     * Closes the modal with a result.
+     *
+     * @param {Result} result The result to emit when the modal closes.
+     */
     close(result: Result): void;
+    /** Completes the onClose and onDismiss streams and cleans up resources. */
     destroy(): void;
 }

package/components/navigation-back/lib/navigation-back.component.d.ts

@@ -1,4 +1,7 @@
 import * as i0 from "@angular/core";
+/**
+ * Represents a navigation back component.
+ */
 export declare class NavigationBackComponent {
     readonly element: import("@angular/core").ElementRef<HTMLButtonElement | HTMLLinkElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NavigationBackComponent, never>;

package/components/notification/lib/components/notification-center/notification-center.component.d.ts

@@ -5,8 +5,6 @@ import { NotificationCenterService } from '../../services';
 import * as i0 from "@angular/core";
 /**
  * A component for displaying and managing a list of notifications. It integrates various sub-components and directives to provide a rich user interface for notification interaction. Supports animations for notification transitions and leverages Angular's change detection strategies for performance.
- *
- * @CSSComponent 'notification-center' - Specifies the CSS class for styling the notification center component.
  */
 export declare class NotificationCenterComponent implements OnDestroy {
     protected readonly notificationCenterService: NotificationCenterService;

package/components/notification/lib/directives/notification-center.directive.d.ts

@@ -8,6 +8,10 @@ import * as i2 from "@odx/angular/components/dropdown";
 /**
  * A directive that provides an interface for managing notifications.
  * It allows configuring a notification center with dynamic content, sorting, and badge display functionalities.
+ * The directive has hosted directives `BadgeDirective` and `DropdownDirective` for badge and dropdown functionality.
+ *
+ * @see {BadgeDirective}
+ * @see {DropdownDirective}
  */
 export declare class NotificationCenterDirective implements OnInit, AfterViewInit {
     private readonly badgeDirective;
@@ -32,31 +36,41 @@ export declare class NotificationCenterDirective implements OnInit, AfterViewIni
      * @param value A function that compares two notifications and returns the sort order.
      *
      * @example
+     * ```ts
      *  sortFfn = (a: NotificationRef, b: NotificationRef) => {
-          if (a.createdAt < b.createdAt) return -1;
-          if (a.createdAt > b.createdAt) return 1;
-          return 0;
-        };
+     *     if (a.createdAt < b.createdAt) return -1;
+     *     if (a.createdAt > b.createdAt) return 1;
+     *     return 0;
+     *  };
+     * ```
      */
     set sortFn(value: NotificationSortFn);
     /**
      * An event that is emitted when a new notification is added.
      * Listeners can use this event to react to new notifications being added to the notification center.
+     *
+     * @emits {NotificationRef} notificationAdd - The notification that was added to the notification center.
      */
     notificationAdd: Observable<import("../models").NotificationRef>;
     /**
      * An event that is emitted when a notification is updated.
      * This can be used to react to changes in notifications, such as their read status or content updates.
+     *
+     * @emits {NotificationRef} notificationUpdate - The notification that was updated in the notification center.
      */
     notificationUpdate: Observable<import("../models").NotificationRef>;
     /**
      * An event that is emitted when a notification is removed from the notification center.
      * Use this event to handle the removal of notifications, such as cleaning up resources or updating UI elements.
+     *
+     * @emits {NotificationRef} notificationRemove - The notification that was removed from the notification center.
      */
     notificationRemove: Observable<import("../models").NotificationRef>;
     /**
      * An event that is emitted when a notification is marked as seen.
      * This event can be used to perform actions when the user acknowledges a notification.
+     *
+     * @emits {NotificationRef} notificationSeen - The notification that was marked as seen in the notification center.
      */
     notificationSeen: Observable<import("../models").NotificationRef>;
     ngOnInit(): void;

package/components/notification/lib/helpers/get-notifications-by-tag.d.ts

@@ -1,2 +1,3 @@
 import { NotificationQuery } from '../models';
+/** @internal */
 export declare function getNotificationsByTags(...tags: Array<string | null | undefined>): NotificationQuery;

package/components/notification/lib/helpers/sort-notifications.d.ts

@@ -1,3 +1,4 @@
 import { MonoTypeOperatorFunction } from 'rxjs';
 import { NotificationRef, NotificationSortFn } from '../models';
+/** @internal */
 export declare function sortNotifications(sortFn?: NotificationSortFn): MonoTypeOperatorFunction<NotificationRef[]>;

package/components/notification/lib/helpers/to-notification-collection.d.ts

@@ -1,3 +1,4 @@
 import { OperatorFunction } from 'rxjs';
 import { NotificationCollection, NotificationRef } from '../models';
+/** @internal */
 export declare function toNotificationCollection(): OperatorFunction<NotificationRef[], NotificationCollection>;

package/components/notification/lib/models/notification-feature.d.ts

@@ -2,4 +2,19 @@ import { EnvironmentProviders, Provider } from '@angular/core';
 export type NotificationFeature = EnvironmentProviders & {
     ɵodxBrand: '@odx/angular/components/notification::NotificationFeature';
 };
+/**
+ * Creates a `NotificationFeature` instance from a given provider or a set of environment providers.
+ * This function is a utility to encapsulate providers into a feature for the notification system, enhancing its configurability.
+ *
+ * @param {(Provider | NotificationFeature)[] | EnvironmentProviders} provider - A single provider, an array of providers, or an environment providers object.
+ * @returns {NotificationFeature} A new `NotificationFeature` encapsulating the provided values.
+ *
+ * @example
+ * ```ts
+ * // Creating a notification feature:
+ * const feature = makeNotificationFeature([
+ *   { provide: SomeService, useClass: SomeServiceImpl }
+ * ]);
+ * ```
+ */
 export declare function makeNotificationFeature(provider: (Provider | NotificationFeature)[] | EnvironmentProviders): NotificationFeature;

package/components/notification/lib/notification.config.d.ts

@@ -1,5 +1,15 @@
 import { EnvironmentProviders } from '@angular/core';
 import { NotificationAction, NotificationFeature, NotificationOptions, NotificationSortFn } from './models';
+/**
+ * Represents the configuration options for notifications within the application.
+ * This interface allows customization of various aspects of notification behavior.
+ *
+ * @property {string} defaultIdPrefix - Prefix used for generating unique notification IDs.
+ * @property {NotificationOptions} options - Default global options for all notifications.
+ * @property {NotificationSortFn} sortFn - Function to sort notifications, aiding in prioritization or ordering.
+ * @property {Record<string, string>} [tagToIconMap] - Maps notification tags to specific icons for visual differentiation.
+ * @property {Record<string, NotificationAction>} [actionMap] - Maps action types to their respective handler functions, enabling custom actions.
+ */
 export interface NotificationConfig {
     defaultIdPrefix: string;
     options: NotificationOptions;
@@ -7,5 +17,49 @@ export interface NotificationConfig {
     tagToIconMap?: Record<string, string>;
     actionMap?: Record<string, NotificationAction>;
 }
+/**
+ * Generates and exports configuration tokens for notifications, utilizing Angular's dependency injection.
+ * This function provides a structured approach to configuring and providing notification settings across
+ * an application.
+ *
+ * @example
+ * ```ts
+ * // In module providers:
+ * providers: [
+ *   provideNotificationConfig({
+ *      defaultIdPrefix: 'your-prefix-notifications', // will be used as id prefix for notification items
+ *      options: NotificationOptions, // { icon: 'core::globe', tags: [], dismissable: true } by default
+ *      sortFn: (a: NotificationRef, b: NotificationRef) => b.createdAt.localeCompare(a.createdAt), // default sort function
+ *      tagToIconMap: { message: 'core::mail' }, // custom icon for message tag (default is core::globe)
+ *      actionMap: { view: (notification) => { console.log(notification); } } // custom action handler
+ *  })
+ * ]
+ *
+ * // In component or service:
+ * constructor(@Inject(NotificationConfig) private notificationConfig: NotificationConfig) {...}
+ * ```
+ */
 export declare const NotificationConfig: import("@angular/core").InjectionToken<Partial<NotificationConfig>>, NotificationDefaultConfig: NotificationConfig, injectNotificationConfig: () => NotificationConfig, provideNotificationConfig: <D extends import("@odx/angular/utils").ConfigDependencies<unknown> = import("@odx/angular/utils").ConfigDependencies<Partial<NotificationConfig>>>(config: import("@odx/angular/utils").ConfigProvider<Partial<NotificationConfig>, D>) => import("@angular/core").ValueProvider | import("@angular/core").FactoryProvider;
+/**
+ * Constructs and provides Angular environment providers for notifications based on provided configurations and features.
+ * Ideal for setting up notifications at the application's top level, ensuring global availability and configurability.
+ *
+ * @param {Partial<NotificationConfig>} [config] - Optional configuration overrides.
+ * @param {...NotificationFeature[]} features - Features to enhance the notification system.
+ * @returns {EnvironmentProviders} Configured providers ready for integration into Angular's environment.
+ *
+ * @example
+ * ```ts
+ * // In module providers:
+ * providers: [
+ *   provideNotifications({
+ *      config, // NotificationConfig
+ *   },
+ *   {
+ *      withBrowserNotifications({...}), // NotificationFeature
+ *   },
+ *  )
+ * ]
+ * ```
+ */
 export declare function provideNotifications(config?: Partial<NotificationConfig>, ...features: NotificationFeature[]): EnvironmentProviders;

package/components/notification/lib/notification.logger.d.ts

@@ -1,3 +1,4 @@
 import { Logger } from '@odx/angular/internal';
+/** @internal */
 declare const _default: Logger;
 export default _default;

package/components/notification/lib/notification.service.d.ts

@@ -1,16 +1,53 @@
 import { Observable } from 'rxjs';
 import { Notification, NotificationCollection, NotificationOptions, NotificationQuery, NotificationRef, NotificationSortFn } from './models';
 import * as i0 from "@angular/core";
+/**
+ * The `NotificationService` class provides methods for managing notifications.
+ * It allows you to create, load, dismiss, mark as seen, and execute actions on notifications.
+ * You can also fetch notifications based on specific queries and sort them using custom sort functions.
+ */
 export declare class NotificationService {
     private readonly config;
     private readonly localizationService;
     private readonly queue;
     private readonly injector;
+    /**
+     * An observable stream of all notifications in the queue, sorted by the configured sort function.
+     *
+     * @emits {NotificationCollection} A collection of notifications.
+     */
     readonly notifications$: Observable<NotificationCollection>;
+    /**
+     * An observable stream of all unseen notifications in the queue.
+     * Unseen notifications are those that have not been marked as seen.
+     *
+     * @emits {NotificationCollection} A collection of unseen notifications.
+     */
     readonly unseenNotifications$: Observable<NotificationCollection>;
+    /**
+     * An observable stream of all seen notifications in the queue.
+     * Seen notifications are those that have been marked as seen.
+     *
+     * @emits {NotificationCollection} A collection of seen notifications.
+     */
     readonly onNotificationAdd$: Observable<NotificationRef>;
+    /**
+     * An observable stream of notifications that have been removed from the queue.
+     *
+     * @emits {NotificationCollection} A collection of removed notifications.
+     */
     readonly onNotificationRemove$: Observable<NotificationRef>;
+    /**
+     * An observable stream of notifications that have been updated in the queue.
+     *
+     * @emits {NotificationCollection} A collection of updated notifications.
+     */
     readonly onNotificationUpdate$: Observable<NotificationRef>;
+    /**
+     * An observable stream of notifications that have been marked as seen.
+     *
+     * @emits {NotificationCollection} A collection of seen notifications.
+     */
     readonly onNotificationSeen$: Observable<NotificationRef>;
     /**
      * Fetches notifications filtered by a specified query and optionally sorted by a custom sort function.
@@ -19,11 +56,13 @@ export declare class NotificationService {
      * @param {NotificationSortFn} [sortFn] - An optional sorting function to order the filtered notifications.
      * @returns {Observable<NotificationCollection>} An observable stream of the filtered (and optionally sorted) notification collection.
      * @example
+     * ```ts
      * // Fetch notifications with a specific tag, sorted by creation date
      * const sortedNotifications$ = notificationService.getNotificationsBy$(
      *   notification => notification.tags.includes('important'),
      *   (a, b) => b.createdAt - a.createdAt
      * );
+     * ```
      */
     getNotificationsBy$(query: NotificationQuery, sortFn?: NotificationSortFn): Observable<NotificationCollection>;
     /**
@@ -31,11 +70,13 @@ export declare class NotificationService {
      *
      * @param {NotificationRef[]} refs - An array of notification references to be loaded.
      * @example
+     * ```ts
      * // Load multiple notifications at once
      * notificationService.load([
      *   { id: '1', item: { title: 'Notification 1' }, options: {dismissable: true, icon: 'plus', tags: ['important']}, hasBeenSeen: false, createdAt: Date.now() },
      *   { id: '2', item: { title: 'Notification 2' }, options: {dismissable: true, icon: 'plus', tags: ['important']}, hasBeenSeen: false, createdAt: Date.now() }
      * ]);
+     * ```
      */
     load(refs: NotificationRef[]): void;
     /**
@@ -44,11 +85,13 @@ export declare class NotificationService {
      * @param {Notification} item - The notification to create.
      * @param {Partial<NotificationOptions>} [options] - Optional settings for the notification.
      * @example
+     * ```ts
      * // Create a new notification with custom options
      * notificationService.create(
      *   { title: 'New Notification' },
      *   { dismissable: true, icon: 'plus', tags: ['important'] }
      * );
+     * ```
      */
     create(item: Notification, options?: Partial<NotificationOptions>): void;
     /**
@@ -56,8 +99,10 @@ export declare class NotificationService {
      *
      * @param {NotificationRef} notificationRef - The reference to the notification to mark as seen.
      * @example
+     * ```ts
      * // Mark a notification as seen by its reference
      * notificationService.markAsSeen(notificationRef);
+     * ```
      */
     markAsSeen(notificationRef: NotificationRef): void;
     /**
@@ -65,8 +110,10 @@ export declare class NotificationService {
      *
      * @param {NotificationQuery} query - The query to match notifications to mark as seen.
      * @example
+     * ```ts
      * // Mark all notifications with a specific tag as seen
      * notificationService.markAsSeenBy(notification => notification.tags.includes('important'));
+     * ```
      */
     markAsSeenBy(query: NotificationQuery): void;
     /**
@@ -74,8 +121,10 @@ export declare class NotificationService {
      *
      * @param {NotificationRef} notificationRef - The reference to the notification to dismiss.
      * @example
+     * ```ts
      * // Dismiss a notification by its reference
      * notificationService.dismiss(notificationRef);
+     * ```
      */
     dismiss(notificationRef: NotificationRef): void;
     /**
@@ -83,16 +132,20 @@ export declare class NotificationService {
      *
      * @param {NotificationQuery} query - The query to match notifications to dismiss.
      * @example
+     * ```ts
      * // Dismiss all notifications with a specific tag
      * notificationService.dismissBy(notification => notification.tags.includes('expired'));
+     * ```
      */
     dismissBy(query: NotificationQuery): void;
     /**
      * Dismisses all notifications.
      *
      * @example
+     * ```ts
      * // Dismiss all notifications
      * notificationService.dismissAll();
+     * ```
      */
     dismissAll(): void;
     /**
@@ -100,8 +153,10 @@ export declare class NotificationService {
      *
      * @param {NotificationRef} notificationRef - The reference to the notification whose action to execute.
      * @example
+     * ```ts
      * // Execute action for a notification
      * notificationService.executeAction(notificationRef);
+     * ```
      */
     executeAction(notificationRef: NotificationRef): void;
     private resolveOptions;

package/components/notification/lib/notification.tokens.d.ts

@@ -1,4 +1,7 @@
 import { InjectionToken } from '@angular/core';
 import { Queue } from '@odx/angular/utils';
 import { NotificationRef } from './models';
+/**
+ * Represents the injection token for the notification queue.
+ */
 export declare const ODX_NOTIFICATION_QUEUE: InjectionToken<Queue<NotificationRef>>;

package/components/notification/lib/services/notification-center.service.d.ts

@@ -5,6 +5,8 @@ import * as i0 from "@angular/core";
 /**
  * A service for managing the notification center. This service provides functionalities
  * to filter, sort, and manage actions on notifications.
+ *
+ * @internal
  */
 export declare class NotificationCenterService {
     private readonly currentTag;
@@ -12,12 +14,19 @@ export declare class NotificationCenterService {
     private readonly notificationService;
     private readonly notificationQuery;
     private readonly title;
+    /** @internal */
     readonly title$: Observable<string | null>;
+    /** @internal */
     readonly notifications$: Observable<import("../models").NotificationCollection>;
+    /** @internal */
     readonly unseenNotifications$: Observable<import("../models").NotificationCollection>;
+    /** @internal */
     onNotificationAdd$: Observable<NotificationRef>;
+    /** @internal */
     onNotificationUpdate$: Observable<NotificationRef>;
+    /** @internal */
     onNotificationRemove$: Observable<NotificationRef>;
+    /** @internal */
     onNotificationSeen$: Observable<NotificationRef>;
     /**
      * Sets the title for the notification center. The title can be static text or an observable for dynamic content.

package/components/paginator/lib/paginator.component.d.ts

@@ -3,6 +3,11 @@ import { DynamicTextContent } from '@odx/angular/cdk/dynamic-view';
 import { PageChangeEvent } from './interfaces';
 import { GetRangeContentFn, GetSummaryContentFn } from './models';
 import * as i0 from "@angular/core";
+/**
+ * Paginator component for navigating between pages of content in a dataset.
+ * It provides configurable options for page size, total content length, and navigational controls,
+ * and emits an event when the page is changed.
+ */
 export declare class PaginatorComponent {
     private readonly disabledController;
     private readonly config;
@@ -11,33 +16,117 @@ export declare class PaginatorComponent {
     private _length;
     protected buttonSize: "small";
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Function to generate summary content for display, such as "Items 1-10 of 100".
+     */
     getSummaryContentFn?: GetSummaryContentFn | null;
+    /**
+     * Function to generate range content for display, such as "Page 1 of 10".
+     */
     getRangeContentFn?: GetRangeContentFn | null;
+    /**
+     * Determines whether the summary content is displayed.
+     */
     showSummary: boolean;
+    /**
+     * Determines whether buttons for navigating to the first and last pages are displayed.
+     */
     showFirstLastButtons: boolean;
+    /**
+     * The current page index. Setter ensures the page index is non-negative.
+     */
     set pageIndex(value: number);
+    /**
+     * Gets the current page index, returns -1 if length is zero.
+     */
     get pageIndex(): number;
+    /**
+     * The number of items per page. Setter ensures the page size is positive.
+     */
     set pageSize(value: number);
+    /**
+     * Gets the number of items per page.
+     */
     get pageSize(): number;
+    /**
+     * The total number of items. Setter ensures the length is non-negative.
+     */
     set length(value: number);
+    /**
+     * Gets the total number of items.
+     */
     get length(): number;
+    /**
+     * Event emitted when the page index changes, providing details of the new page context.
+     */
     pageChanged: EventEmitter<PageChangeEvent>;
+    /**
+     * Determines whether pagination controls are disabled.
+     */
     get isDisabled(): boolean;
+    /**
+     * Default function to generate summary content if no function is provided.
+     */
     get defaultGetSummaryContentFn(): GetSummaryContentFn;
+    /**
+     * Default function to generate range content if no function is provided.
+     */
     get defaultGetRangeContentFn(): GetRangeContentFn;
+    /**
+     * Computes and returns the dynamic summary content.
+     */
     get summaryContent(): DynamicTextContent;
+    /**
+     * Computes and returns the dynamic range content.
+     */
     get rangeContent(): DynamicTextContent;
+    /**
+     * Navigates to the first page.
+     */
     firstPage(): void;
+    /**
+     * Navigates to the previous page.
+     */
     previousPage(): void;
+    /**
+     * Navigates to the next page.
+     */
     nextPage(): void;
+    /**
+     * Navigates to the last page.
+     */
     lastPage(): void;
+    /**
+     * Determines whether the current page is the first page.
+     */
     get isFirstPage(): boolean;
+    /**
+     * Determines whether the current page is the last page.
+     */
     get isLastPage(): boolean;
+    /**
+     * Determines whether the previous button is disabled.
+     */
     get isPreviousDisabled(): boolean;
+    /**
+     * Determines whether the next button is disabled.
+     */
     get isNextDisabled(): boolean;
+    /**
+     * Gets the total number of pages.
+     */
     get totalPages(): number;
+    /**
+     * Gets the index of the first item on the current page.
+     */
     get startItemIndex(): number;
+    /**
+     * Gets the index of the last item on the current page.
+     */
     get endItemIndex(): number;
+    /**
+     * Navigates to the specified page index.
+     */
     pageChange(pageIndex: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<PaginatorComponent, "odx-paginator", never, { "getSummaryContentFn": { "alias": "getSummaryContentFn"; "required": false; }; "getRangeContentFn": { "alias": "getRangeContentFn"; "required": false; }; "showSummary": { "alias": "showSummary"; "required": false; }; "showFirstLastButtons": { "alias": "showFirstLastButtons"; "required": false; }; "pageIndex": { "alias": "pageIndex"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "length": { "alias": "length"; "required": false; }; }, { "pageChanged": "pageChanged"; }, never, never, true, never>;

package/components/paginator/lib/paginator.config.d.ts

@@ -1,11 +1,18 @@
 import { GetRangeContentFn, GetSummaryContentFn } from './models';
 export interface PaginatorConfig {
     /**
-     * @param {GetSummaryContentFn} - Content is responsible for paginator summary
+     * Function to generate summary content for paginator, displaying indices and total length.
+     * @param startItemIndex The starting index of the current page.
+     * @param endItemIndex The ending index of the current page.
+     * @param length Total number of items in the dataset.
+     * @returns DynamicTextContent for summary display.
      */
     getSummaryContent: GetSummaryContentFn;
     /**
-     * @param {GetRangeContentFn} - Content is responsible for paginator range
+     * Function to generate range content for paginator, displaying the current page index and total pages.
+     * @param pageIndex The index of the current page.
+     * @param totalPages Total number of pages.
+     * @returns DynamicTextContent for range display.
      */
     getRangeContent: GetRangeContentFn;
     /**
@@ -14,6 +21,21 @@ export interface PaginatorConfig {
      */
     pageSize: number;
 }
+/**
+ * Utility for creating and retrieving configuration tokens for the Paginator.
+ * This facilitates dependency injection of configuration in Angular applications.
+ *
+ * @example
+ * ```ts
+ * // In module providers:
+ * providers: [
+ *  providePaginatorConfig({
+ *   pageSize: 20,
+ *   getSummaryContent: (startItemIndex: number, endItemIndex: number, length: number) => `...`
+ *  }),
+ * ]
+ * ```
+ */
 export declare const PaginatorConfig: import("@angular/core").InjectionToken<Partial<{
     getSummaryContent: GetSummaryContentFn;
     getRangeContent: GetRangeContentFn;

package/components/progress/lib/progress.component.d.ts

@@ -1,11 +1,26 @@
 import * as i0 from "@angular/core";
+/**
+ * Progress component for visually indicating the completion level of a task or process.
+ * The component can display definite progress or operate in an indeterminate mode to indicate ongoing activity.
+ */
 export declare class ProgressComponent {
     private _value;
     protected get ariaValueNow(): null | number;
     protected get progressValue(): number;
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Indicates if the progress bar is in indeterminate state, which is typically used for loading processes
+     * where the completion percentage is unknown.
+     */
     indeterminate: boolean;
+    /**
+     * Sets the current value of the progress bar. Accepts a number between 0 and 100 or -1 for indeterminate.
+     * @param value The new value of the progress bar. -1 sets the bar to indeterminate.
+     */
     set value(value: number);
+    /**
+     * Gets the current value of the progress bar.
+     */
     get value(): number;
     static ɵfac: i0.ɵɵFactoryDeclaration<ProgressComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ProgressComponent, "odx-progress", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;