@odx/angular 5.7.4 → 6.0.1

package/components/modal/lib/helpers/provide-modal-ref.d.ts

@@ -1,3 +1,12 @@
 import { ValueProvider } from '@angular/core';
 import { ModalRef } from '../models';
+/**
+ * Provides a configuration for the Angular dependency injection system to inject a specific instance of `ModalRef`.
+ * This function is particularly useful when you want to configure a provider for a `ModalRef` within an Angular module or component.
+ *
+ * @template D The data type expected by the modal.
+ * @template R The result type that the modal will produce.
+ * @param {ModalRef<D, R>} modalRef An instance of `ModalRef` to be provided.
+ * @returns {ValueProvider} An Angular value provider that can be used in module or component providers arrays.
+ */
 export declare function provideModalRef<D = unknown, R = unknown>(modalRef: ModalRef<D, R>): ValueProvider;

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

@@ -2,6 +2,10 @@ import { Injector, OnChanges } from '@angular/core';
 import { DynamicContent, DynamicTextContent } from '@odx/angular/cdk/dynamic-view';
 import { NgChanges } from '@odx/angular/utils';
 import * as i0 from "@angular/core";
+/**
+ * A component that represents a modal dialog with dynamic content and customizable animations.
+ * It supports both modal and sidesheet variants with configurable animations for each type.
+ */
 export declare class ModalComponent implements OnChanges {
     protected readonly modalRef: import("@odx/angular/components/modal").ModalRef<unknown, unknown>;
     protected readonly injector: Injector;
@@ -9,9 +13,30 @@ export declare class ModalComponent implements OnChanges {
         $implicit: import("@odx/angular/components/modal").ModalRef<unknown, unknown>;
     };
     readonly element: import("@angular/core").ElementRef<HTMLElement>;
+    /**
+     * Size of the modal as a CSS modifier based on modal options.
+     *
+     * @type {ModalSize}
+     */
     size: import("@odx/angular/components/modal").ModalSize;
+    /**
+     * Variant of the modal as a CSS modifier that influences animation choices.
+     *
+     * @type {ModalVariant}
+     */
     variant: import("@odx/angular/components/modal").ModalVariant;
+    /**
+     * Boolean that indicates if the content is a component type rather than a template.
+     *
+     * @type {boolean}
+     */
     withComponent: boolean;
+    /**
+     * Dynamic content to be loaded into the modal. Excludes simple textual content
+     * to enable complex Angular components or templates.
+     *
+     * @type {Exclude<DynamicContent, DynamicTextContent>}
+     */
     content: Exclude<DynamicContent, DynamicTextContent>;
     constructor();
     ngOnChanges(changes: NgChanges<ModalComponent>): void;

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

@@ -1,3 +1,36 @@
 import { ModalInstanceOptions } from './models';
 export type ModalConfig = Omit<ModalInstanceOptions, 'id' | 'host' | 'data'>;
+/**
+ * Utilizes `createConfigTokens` to create configuration tokens and utility functions for managing modal configurations.
+ * This setup enables easy injection and provision of default global settings for modals throughout the application,
+ * fostering consistency and ease of customization.
+ *
+ * The generated tokens and functions include:
+ * - `ModalDefaultConfig`: The default configuration values for modals.
+ * - `ModalConfig`: An Angular `InjectionToken` for injecting modal configuration into components or services.
+ * - `injectModalConfig`: A utility function for retrieving the current modal configuration, considering any overrides.
+ * - `provideModalConfig`: A function that allows specifying overrides to the default modal configuration.
+ *
+ * @example
+ * ```ts
+ * // Example of providing a custom modal configuration in an Angular module
+ * @NgModule({
+ *   providers: [
+ *     provideModalConfig({
+ *       size: ModalSize.LARGE,
+ *       dismissable: false
+ *     })
+ *   ]
+ * })
+ * class AppModule {}
+ *
+ * // Example of injecting modal configuration in a component
+ * @Component({...})
+ * export class MyComponent {
+ *   constructor(@Inject(ModalConfig) private modalConfig: ModalConfig) {
+ *     console.log(this.modalConfig.size); // Outputs the size from the provided or default configuration
+ *   }
+ * }
+ * ```
+ */
 export declare const ModalDefaultConfig: ModalConfig, ModalConfig: import("@angular/core").InjectionToken<Partial<ModalConfig>>, injectModalConfig: () => ModalConfig, provideModalConfig: <D extends import("@odx/angular/utils").ConfigDependencies<unknown> = import("@odx/angular/utils").ConfigDependencies<Partial<ModalConfig>>>(config: import("@odx/angular/utils").ConfigProvider<Partial<ModalConfig>, D>) => import("@angular/core").ValueProvider | import("@angular/core").FactoryProvider;

package/components/modal/lib/modal.directive.d.ts

@@ -2,16 +2,45 @@ import { EventEmitter, OnChanges, OnDestroy, TemplateRef } from '@angular/core';
 import { NgChanges } from '@odx/angular/utils';
 import { ModalOptions } from './models';
 import * as i0 from "@angular/core";
+/**
+ * A directive that simplifies the creation and management of modals directly from Angular templates.
+ * It allows for declarative modal instantiation with full control over modal options, and supports
+ * capturing modal close and dismiss events.
+ *
+ * Usage:
+ * Apply `odxModal` to an `<ng-template>` element and bind it to modal options.
+ */
 export declare class ModalDirective implements OnChanges, OnDestroy {
     private readonly modalService;
     private modalRef;
     protected readonly template: TemplateRef<any>;
+    /**
+     * Options for the modal directive.
+     *
+     * @type {Partial<ModalOptions> | '' | null}
+     */
     modalOptions?: Partial<ModalOptions> | '' | null;
+    /**
+     * Event emitter for closing the modal.
+     *
+     * @emits {any} The result of the modal close event.
+     */
     modalClose: EventEmitter<any>;
+    /**
+     * Event emitter for dismissing the modal.
+     *
+     * @emits {any} The result of the modal dismiss event.
+     */
     modalDismiss: EventEmitter<any>;
     ngOnChanges(changes: NgChanges<ModalDirective>): void;
     ngOnDestroy(): void;
+    /**
+     * Opens the modal based on the provided template and options. Binds modal result and dismissal outputs to EventEmitter properties.
+     */
     open(): void;
+    /**
+     * Dismisses the currently opened modal.
+     */
     dismiss(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ModalDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ModalDirective, "ng-template[odxModal]", ["odxModal"], { "modalOptions": { "alias": "odxModal"; "required": false; }; }, { "modalClose": "odxModalClose"; "modalDismiss": "odxModalDismiss"; }, never, never, true, never>;

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

@@ -2,18 +2,72 @@ import { Location } from '@angular/common';
 import { TemplateRef } from '@angular/core';
 import { BasicModalOptions, GetModalActionData, ModalOptions, ModalRef, ModalType } from './models';
 import * as i0 from "@angular/core";
+/**
+ * Service for managing modal dialogs within the application. It supports creating, opening,
+ * and dismissing modals dynamically, with comprehensive options for customization and lifecycle management.
+ * Utilizes Angular's dynamic view management to instantiate and render modals as needed.
+ *
+ * @example
+ * ```ts
+ * // Example of using ModalService to open a modal
+ * constructor(private modalService: ModalService) {}
+ *
+ * openModal() {
+ *   const modalRef = this.modalService.open(MyModalContentComponent, {
+ *     data: { someData: 'test' },
+ *     size: ModalSize.SMALL,
+ *   });
+ *
+ *   modalRef.onClose$.subscribe(result => {
+ *     console.log('Modal closed with result:', result);
+ *   });
+ * }
+ * ```
+ */
 export declare class ModalService {
     private readonly config;
     private readonly openModals;
     private readonly injector;
     private readonly dynamicViewService;
+    /**
+     * An observable that emits the current value of the openModals subject.
+     *
+     * @emits {ModalRef[]} openModals$ - The current array of open modals.
+     */
     readonly openModals$: import("rxjs").Observable<(ModalRef<unknown, unknown> & {
         id: string | number;
     })[]>;
     constructor(location: Location);
+    /**
+     * Dismisses all open modals.
+     */
     dismissAll(): void;
+    /**
+     * Retrieves the modal reference by its ID.
+     *
+     * @template Data The type of data passed to the modal.
+     * @template Result The type of result returned by the modal.
+     * @param id The ID of the modal.
+     * @returns The modal reference if found, otherwise null.
+     */
     getModalById<Data = unknown, Result = unknown>(id: ModalOptions['id']): ModalRef<Data, Result> | null;
+    /**
+     * Creates a modal with the specified options.
+     * @param modal - The basic modal options.
+     * @param options - Additional modal options.
+     * @returns The reference to the created modal.
+     */
     create<Data extends BasicModalOptions, Result = GetModalActionData<Data>>(modal: Data, options?: Partial<ModalOptions<Data>>): ModalRef<Data, Result>;
+    /**
+     * Creates and opens a new modal with the specified content and options.
+     *
+     * @template Data - The type of data passed to the modal for use in its content.
+     * @template Result - The type of result expected when the modal is closed.
+     * @template T - The content type of the modal, either a `TemplateRef` or a component.
+     * @param {ModalType<T, Data, Result> | TemplateRef<T>} content - The content of the modal, either as a `TemplateRef` or a component type.
+     * @param {Partial<ModalOptions<Data>>} [options] - Optional configuration options for the modal.
+     * @returns {ModalRef<Data, Result>} A reference to the newly opened modal, allowing interaction with and control over the modal instance.
+     */
     open<Data, Result, T>(content: TemplateRef<T>, options?: Partial<ModalOptions<Data>>): ModalRef<Data, Result>;
     open<Data, Result, T = unknown>(content: ModalType<T, Data, Result>, options?: Partial<ModalOptions<Data>>): ModalRef<Data, Result>;
     private attachModal;

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.