@quadrel-enterprise-ui/framework 19.8.1 → 20.0.0

package/lib/notifications/notification/notification.component.d.ts

@@ -1,499 +0,0 @@
-import { ElementRef } from '@angular/core';
-import { QdNotification, QdNotificationType } from '../interfaces/notifications';
-import { QdNotificationsService } from '../services/notifications-service.service';
-import { QdSnackbarService } from '../services/snackbar.service';
-import * as i0 from "@angular/core";
-/**
- *  **QdNotification** displays a single notification item within a **QdNotifications** container.
- *
- * # Notifications Service
- *
- * The **Notifications Service** can be used to catch errors from the backend. In addition, this service provides several methods to display messages.
- *
- * ## Notification from Backend
- *
- * The **QdUiModule** provides an HTTP interceptor that displays request errors as snackbar notifications. To get the proper notification messages for the corresponding backend errors, please comply with these conventions.
- *
- * ### Example of a response object
- *
- * The backend service response has to contain an errorCode field. This error code will be mapped to get the translation for the notification message.
- *
- * ```json
- * {
- *   "errorCode": "TRANSPORT_COCKPIT_PERSISTENCE_ERROR",
- *   "errorMessage": "TRANSPORT_COCKPIT_PERSISTENCE_ERROR: Could not find Declaration wih id: b78e0734-ae1b-434e-b44d-b48797f5696d"
- * }
- * ```
- *
- * ### Define Error Codes in the QdUiModule
- *
- * The **QdUiModule** expects an enum with error codes as the second parameter. For these given error codes you can define specific notification messages.
- *
- * This is an example configuration of the **QdUiModule** in the **app.module.ts**.
- *
- * ```typescript
- * enum ErrorCodes {
- *   TRANSPORT_COCKPIT_PERSISTENCE_ERROR,
- *   TRANSPORT_COCKPIT_VALIDATION_ERROR
- * }
- * ```
- *
- * ```typescript
- * imports: [
- *   ...
- *   QdUiModule.forRoot(appEnvironment, ErrorCodes),
- *   ...
- * ]
- * ```
- *
- * ### Translations:
- *
- * You can define the specific backend error notification messages for the respective error codes under `"ERROR"` in the translation files.
- *
- * ```json
- * {
- *   ...
- *
- *   "ERROR": {
- *     "TRANSPORT_COCKPIT_PERSISTENCE_ERROR": "In der Datenbank ist ein Fehler aufgetreten",
- *     "TRANSPORT_COCKPIT_VALIDATION_ERROR": "Ungültige Eingabe"
- *   }
- * }
- * ```
- *
- * ### Default error messages
- *
- * A default error message is shown if no error code is given in the backend response or the error code is not defined in the `ErrorCodes` enum that you pass to the **QdUiModule**.
- *
- * To override the default error messages you have to add the corresponding HTTP error code in the `ErrorCodes` enum. Then you can define a custom default error message in the translation files.
- *
- * ```typescript
- * enum ErrorCodes {
- *   ...,
- *   HTTP_BAD_REQUEST,
- *   HTTP_UNAUTHORIZED,
- *   HTTP_FORBIDDEN,
- *   HTTP_NOT_FOUND,
- *   HTTP_SERVER_ERROR,
- *   HTTP_UNKNOWN_ERROR
- * }
- * ```
- *
- * ```json
- * {
- *   ...
- *
- *   "ERROR": {
- *     "HTTP_BAD_REQUEST": "This is a custom error message for a response with the HTTP status code 400.",
- *     "HTTP_UNAUTHORIZED": "This is a custom error message for a response with the HTTP status code 401.",
- *     "HTTP_FORBIDDEN": "This is a custom error message for a response with the HTTP status code 403.",
- *     "HTTP_NOT_FOUND": "This is a custom error message for a response with the HTTP status code 404.",
- *     "HTTP_SERVER_ERROR": "This is a custom error message for a response with some server error (HTTP status code 5xx).",
- *     "HTTP_UNKNOWN_ERROR": "This is a custom error message for all other errors."
- *   }
- * }
- * ```
- *
- * ### Whitelisting HTTP status codes
- *
- * In some cases, you might want to prevent certain HTTP status codes from triggering error notifications. For example, a 304 Not Modified response is not actually an error and should not display an error notification. The **QdUiModule** allows you to whitelist specific HTTP status codes.
- *
- * To whitelist HTTP status codes, pass an array of status codes as the third parameter to the **QdUiModule.forRoot** method:
- *
- * ```typescript
- * import { HttpStatusCode } from '@angular/common/http';
- *
- * imports: [
- *   ...
- *   QdUiModule.forRoot(
- *     appEnvironment,
- *     ErrorCodes,
- *     [HttpStatusCode.NotModified, HttpStatusCode.NoContent] // Whitelist 304 Not Modified and 204 No Content
- *   ),
- *   ...
- * ]
- * ```
- *
- * When a response with a whitelisted status code is received, no error notification will be displayed, even if it would normally be treated as an error by the HTTP client.
- *
- * ### Blacklisting HTTP status codes
- *
- * For critical errors, notifications are always shown, even if the status code is whitelisted. The **QdUiModule** implements a fixed blacklist that takes precedence over the whitelist.
- *
- * The following status codes are permanently blacklisted:
- * - 401 Unauthorized
- * - 402 Payment Required
- * - 403 Forbidden
- * - All 5xx server error codes (500-511)
- *
- * These critical errors will always show notifications, even if they are included in the whitelist.
- *
- * **Important**: The blacklist has higher precedence than the whitelist. If a status code appears in both the whitelist and the blacklist, it will be treated as blacklisted, and an error notification will be shown.
- *
- * ### Component:
- *
- * ```typescript
- * class MyNotificationComponent {
- *   data;
- *
- *   constructor(private http: HttpClient) {}
- *
- *   private setData(data) {
- *     this.data = data;
- *   }
- *
- *   public callApiEndPoint() {
- *     // This way you can display the content in the frontend.
- *     return this.http.get('route/to/endpoint').subscribe({
- *       next: res => this.setData(res),
- *       error: err => this.setData(err)
- *     });
- *   }
- * }
- * ```
- *
- * The errors are rendered into a container, which by default has the attribute `context="qdPanel"`.
- *
- * ```html
- * <!-- Landing pad for notifications -->
- * <qd-notifications></qd-notifications>
- * ```
- *
- * ## Notifications via service
- *
- * ### Interfaces:
- *
- * ```typescript
- * interface QdNotification {
- *   uuid?: string;
- *   context?: string;
- *   type: QdNotificationType;
- *   i18n: QdNotificationTranslation;
- *   title?: QdNotificationTitle;
- *   date?: Date;
- *   lifeTime?: number;
- *   disableClose?: boolean;
- *   onClose?: () => void;
- *   showAsSnackbar?: boolean;
- *   snackbarOptions?: QdSnackbarNotificationOptions;
- *   showAsOsNotification?: boolean;
- *   osNotificationOptions?: QdOsNotificationOptions;
- * }
- *
- * type QdNotificationType = 'info' | 'warning' | 'critical' | 'success';
- *
- * type QdNotificationTranslation = string;
- * type QdNotificationTitle = { i18n: string };
- *
- * type QdNotifications = QdNotification[];
- *
- * interface QdSnackbarNotificationOptions {
- *   lifeTime?: number;
- *   disableClose?: boolean;
- *   onClose?: () => void;
- * }
- *
- * interface QdOsNotificationOptions {
- *   silent?: boolean;
- *   lifeTime?: number;
- *   onClose?: (event) => void;
- *   onClick?: (event) => void;
- * }
- * ```
- *
- * The Notifications Service provides some methods to display them in the frontend.
- *
- * ### Component
- *
- * ```typescript
- * class MyNotificationComponent {
- *   constructor(private notificationsService: QdNotificationsService) {}
- *
- *   public add(context: string, notification: QdNotification): void {
- *     this.notificationsService.add(context, notification);
- *   }
- * }
- * ```
- *
- * ### Type QdNotification (Second param of the add method)
- *
- * ```typescript
- * interface QdNotification {
- *   ...
- *
- *   type: QdNotificationType;
- *   i18n: string;
- *   lifeTime?: number;
- * }
- *
- * type QdNotifications = QdNotification[];
- * ```
- *
- * ### Type QdNotificationType
- *
- * ```typescript
- * type QdNotificationType = 'info' | 'warning' | 'critical' | 'success';
- * ```
- *
- * ### Template
- *
- * ```html
- * <button (click)="add('qdPanel', { type: 'critical', i18n: 'i18n.error.critical' })">Add Notification</button>
- * ```
- *
- * ### Template for displaying notifications - for instance in the Info Panel
- *
- * ```html
- * <qd-notifications></qd-notifications>
- * ```
- *
- * ## Notifications as a snackbar
- *
- * You can also display the notifications as a snack bar. They are then on top of the layout system. What you need to do is to place the directive `qdSnackbarListener` there. Also, just add the `showAsSnackbar` parameter to the method call.
- *
- * ### Example
- *
- * ```html
- * <qd-section qdSnackbarListener> My Container Content </qd-section>
- *
- * <button (click)="addNotification('qdPanel', { type: 'critical', i18n: 'i18n.error.critical', showAsSnackbar: true })">
- *   Add Notification
- * </button>
- * ```
- *
- * All notifications are now displayed by the directive contained in the `qd-section`. Also, all notifications from the backend are displayed there.
- *
- * **Recommendation of the Quadrel Team**: Place the `qdSnackbarListener` directly on top of the layout system - so for example in the **AppComponent**.
- *
- * ### Options
- *
- * You can also pass a configuration object in the `snackbarOptions` parameter to customize the snackbar notification or to set an `onClose` handler.
- * When you close the main notification, the snackbar notification will be closed automatically. The snackbar notification can be closed for itself alone.
- *
- * In the `snackbarOptions` configuration object you can override the properties `disableClose` and `lifeTime`. When the main notification is closed,
- * the snackbar notification will also be closed. So the life time of the snackbar notification only can be shorter.
- *
- * ## OS Notifications
- *
- * To bring a notification to the foreground, even if the application window is not in focus, you can also push the notification as an OS Notification.
- * Then the notification will also be pushed through the Notification browser API and will be displayed on your operating system (e.g. Windows/Linux).
- * In the future, the OS Notifications will also be pushed as smartphone system notifications. Currently, only desktop notifications are supported.
- *
- * ### Example
- *
- * ```html
- * <button (click)="addNotification('qdPanel', { type: 'critical', i18n: 'i18n.error.critical', showAsOsNotification: true })">
- *   Add Notification
- * </button>
- * ```
- *
- * ### Options
- *
- * You can also pass a configuration object in the `osNotificationOptions` parameter to customize the OS notification or to set `onClick` and `onClose` handlers.
- * When you close the main notification, the OS notification will be closed automatically. The OS notification can be closed for itself alone.
- *
- * In the `osNotificationOptions` configuration object you can override the properties `disableClose` and `lifeTime`. When the main notification is closed,
- * the OS notification will also be closed. So the life time of the OS notification only can be shorter.
- *
- * ### Deep links
- *
- * To open a deep link when the OS notification is clicked, use the following code for the click handler:
- *
- * ```typescript
- * event.preventDefault();
- * window.open('https://your/deep/link');
- * ```
- *
- * ## Notifications via service (multiple instances)
- *
- * ### Object of multiple notifications
- *
- * ```typescript
- * const BULK: QdNotifications = [
- *   {
- *     type: 'critical',
- *     i18n: 'i18n.error.1'
- *   },
- *   {
- *     type: 'critical',
- *     i18n: 'i18n.error.2'
- *   }
- * ];
- * ```
- *
- * ### Component
- *
- * ```typescript
- * class MyNotificationComponent {
- *   bulk: QdNotifications = BULK;
- *
- *   constructor(private notificationsService: QdNotificationsService, public modalService: QdModalService) {}
- *
- *   openNotificationModal(mrn) {
- *     // MRN represents a unique context
- *     this.modalService.open(MyNotificationModalComponent, { data: { mrn } });
- *
- *     // Adds the notifications when opening
- *     this.notificationsService.addBulk(mrn, this.bulk);
- *   }
- * }
- * ```
- *
- * ### Template
- *
- * ```html
- * <mat-table [dataSource]="dataSource">
- *   <ng-container matColumnDef="mrn">
- *     <mat-header-cell *matHeaderCellDef class="center">Mrn.</mat-header-cell>
- *     <mat-cell *matCellDef="let element" class="center">
- *       <button mat-button color="primary" (click)="openNotificationModal(element.mrn)">
- *         <!-- MRN represents a unique context -->
- *         {{ element.mrn }}
- *       </button>
- *     </mat-cell>
- *   </ng-container>
- * </mat-table>
- * ```
- *
- * ## Notification Events
- *
- * You can define an `onClose` callback for each notification type. When the main notification is closed, then
- * the corresponding snackbar notification and OS notification will also be closed and all events will be fired.
- *
- * ```typescript
- * class MyNotificationComponent {
- *   constructor(private notificationsService: QdNotificationsService) {}
- *
- *   showNotification(): void {
- *     this.notificationsService.add(
- *       'qdPanel',
- *       {
- *         type: 'critical',
- *         i18n: 'i18n.error.critical',
- *         onClose: () => console.log('Notification closed.'),
- *         showAsSnackbar: true,
- *         snackbarOptions: {
- *           onClose: () => console.log('Snackbar Notification closed.')
- *         }
- *         showAsOsNotification: true,
- *         osNotificationOptions: {
- *           onClose: () => console.log('OS Notification closed.')
- *         }
- *       }
- *     );
- *   }
- * }
- * ```
- *
- * Especially for the OS notification an `onClick` handler can be defined. With the onClick handler it's also possible
- * to define a deep link that will be opened on click with the following code:
- *
- * ```typescript
- * this.notificationsService.add(
- *   'qdPanel',
- *   {
- *     type: 'critical',
- *     i18n: 'i18n.error.critical',
- *     showAsOsNotification: true,
- *     osNotificationOptions: {
- *       onClick: (event) => {
- *         event.preventDefault();
- *         window.open('https://your/deep/link');
- *       }
- *     }
- *   }
- * );
- * ```
- *
- * ## Inline Notifications
- *
- * Notifications can also be inserted directly into the template.
- *
- * ```html
- * <qd-notification [type]="type" [notification]="notification">
- *   <qd-notification-content> test notification content </qd-notification-content>
- * </qd-notification>
- * ```
- *
- * ```typescript
- * // The type can be defined with the type input
- * type = 'critical';
- *
- * // ... or in the notification config
- * notification: QdNotification = {
- *   type: 'critical'
- * }
- * ```
- *
- * The content can also be defined in the config. Then you don't have to put a `qd-notification-content`
- * element into the `qd-notification`.
- *
- * ```html
- * <qd-notification [notification]="notification"></qd-notification>
- * ```
- *
- * ```typescript
- * notification: QdNotification = {
- *   type: 'critical',
- *   i18n: 'i18n.error.critical'
- * }
- * ```
- *
- * ## Multiline Notifications
- *
- * To create a multiline notification you simply can insert `\n` in the i18n translation text. Line breaks (`\n`) are
- * not considered if you use the `<qd-notification-content>` variant. Line breaks only work if you define the
- * i18n key in the notification config.
- *
- * ### Example
- *
- * ```typescript
- * notification: QdNotification = {
- *   type: 'warning',
- *   i18n: 'i18n.ncts.declaration.detailInventoryResult.notification.transitDeadlineExpired'
- * }
- * ```
- *
- * ```json
- * {
- *   ...
- *
- *   "i18n.ncts.declaration.detailInventoryResult.notification.transitDeadlineExpired": "The inventory result must be checked and the control result recorded. \nAttention: The transit period has expired upon arrival at the Authorized Place",
- * }
- * ```
- *
- * ### Notifications Service
- *
- * | Method                       | Params                                                 | description                                      | default |
- * | ---------------------------- | ------------------------------------------------------ | ------------------------------------------------ | ------- |
- * | getNotificationsForContext() | context: string                                        | Returns notification stream for context.         | -       |
- * | add()                        | context: string, notification: QdNotification          | Adds a single notification.                      | -       |
- * | addBulk()                    | context: string, notifications: QdNotifications        | Adds multiple notifications.                     | -       |
- * | remove()                     | context: string, id: string                            | Removes specific notification.                   | -       |
- * | removeAll()                  | context: string                                        | Removes all notifications in context.            | -       |
- * | reset()                      | -                                                      | Clear all notifications.                         | -       |
- */
-export declare class QdNotificationComponent {
-    private readonly notificationService;
-    private readonly snackbarService;
-    private element;
-    /**
-     * Defines the type of this notification.
-     */
-    type: QdNotificationType;
-    /**
-     * Configuration of a notification.
-     */
-    notification: QdNotification;
-    get typeClassName(): string;
-    get closeable(): boolean;
-    constructor(notificationService: QdNotificationsService, snackbarService: QdSnackbarService, element: ElementRef);
-    getType(): QdNotificationType;
-    getIcon(): string;
-    remove(): void;
-    handleLinkClick(): void;
-    private isNotificationInSnackbar;
-    static ɵfac: i0.ɵɵFactoryDeclaration<QdNotificationComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<QdNotificationComponent, "qd-notification", never, { "type": { "alias": "type"; "required": false; }; "notification": { "alias": "notification"; "required": false; }; }, {}, never, ["qd-notification-content"], false, never>;
-}
-//# sourceMappingURL=notification.component.d.ts.map

package/lib/notifications/notification/notification.component.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"notification.component.d.ts","sourceRoot":"","sources":["../../../../../libs/qd-ui/src/lib/notifications/notification/notification.component.ts"],"names":[],"mappings":"AACA,OAAO,EAAa,UAAU,EAAsB,MAAM,eAAe,CAAC;AAC1E,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjF,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AACnF,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqdG;AACH,qBAOa,uBAAuB;IAoBhC,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IACpC,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,OAAO;IArBjB;;OAEG;IACM,IAAI,EAAE,kBAAkB,CAAc;IAE/C;;OAEG;IACM,YAAY,EAAE,cAAc,CAAC;IAEtC,IAA+B,aAAa,IAAI,MAAM,CAErD;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;gBAGkB,mBAAmB,EAAE,sBAAsB,EAC3C,eAAe,EAAE,iBAAiB,EAC3C,OAAO,EAAE,UAAU;IAG7B,OAAO,IAAI,kBAAkB;IAI7B,OAAO,IAAI,MAAM;IAajB,MAAM,IAAI,IAAI;IAQd,eAAe,IAAI,IAAI;IAIvB,OAAO,CAAC,wBAAwB;yCAtDrB,uBAAuB;2CAAvB,uBAAuB;CAyDnC"}

package/lib/notifications/notification-content/notification-content.component.d.ts

@@ -1,9 +0,0 @@
-import * as i0 from "@angular/core";
-/**
- * **QdNotificationContent**: a container for the content of a single **QdNotification** item.
- */
-export declare class QdNotificationContentComponent {
-    static ɵfac: i0.ɵɵFactoryDeclaration<QdNotificationContentComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<QdNotificationContentComponent, "qd-notification-content", never, {}, {}, never, ["*"], false, never>;
-}
-//# sourceMappingURL=notification-content.component.d.ts.map

package/lib/notifications/notification-content/notification-content.component.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"notification-content.component.d.ts","sourceRoot":"","sources":["../../../../../libs/qd-ui/src/lib/notifications/notification-content/notification-content.component.ts"],"names":[],"mappings":";AAEA;;GAEG;AACH,qBAKa,8BAA8B;yCAA9B,8BAA8B;2CAA9B,8BAA8B;CAAG"}

package/lib/notifications/notifications/notifications.component.d.ts

@@ -1,20 +0,0 @@
-import { OnInit } from '@angular/core';
-import { QdNotifications } from '../interfaces/notifications';
-import { QdNotificationsService } from '../services/notifications-service.service';
-import * as i0 from "@angular/core";
-/**
- * **QdNotifications** creates a container for the single **QdNotification** items.
- */
-export declare class QdNotificationsComponent implements OnInit {
-    private readonly notificationService;
-    notifications: QdNotifications;
-    /**
-     * The context can be assigned to control the positioning of the notifications.
-     */
-    context: string;
-    constructor(notificationService: QdNotificationsService);
-    ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<QdNotificationsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<QdNotificationsComponent, "qd-notifications", never, { "context": { "alias": "context"; "required": false; }; }, {}, never, never, false, never>;
-}
-//# sourceMappingURL=notifications.component.d.ts.map

package/lib/notifications/notifications/notifications.component.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"notifications.component.d.ts","sourceRoot":"","sources":["../../../../../libs/qd-ui/src/lib/notifications/notifications/notifications.component.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,MAAM,EAAqB,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;;AAEnF;;GAEG;AACH,qBAOa,wBAAyB,YAAW,MAAM;IAQzC,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IAPhD,aAAa,EAAE,eAAe,CAAC;IAE/B;;OAEG;IACM,OAAO,SAAa;gBAEA,mBAAmB,EAAE,sBAAsB;IAExE,QAAQ,IAAI,IAAI;yCAVL,wBAAwB;2CAAxB,wBAAwB;CAepC"}

package/lib/notifications/notifications.module.d.ts

@@ -1,24 +0,0 @@
-import { QdNotificationComponent } from './notification/notification.component';
-import { QdNotificationContentComponent } from './notification-content/notification-content.component';
-import { QdNotificationsComponent } from './notifications/notifications.component';
-import { QdNotificationsHttpInterceptorService } from './services/notifications-http-interceptor.service';
-import { QdNotificationsService } from './services/notifications-service.service';
-import { QdNotificationsSnackbarListenerDirective } from './directives/snackbar-listener.directive';
-import { QdNotification } from './interfaces/notifications';
-import * as i0 from "@angular/core";
-import * as i1 from "./notification/notification.component";
-import * as i2 from "./notification-content/notification-content.component";
-import * as i3 from "./notifications/notifications.component";
-import * as i4 from "./snackbar/snackbar.component";
-import * as i5 from "./directives/snackbar-listener.directive";
-import * as i6 from "@angular/common";
-import * as i7 from "../forms/qd-form.module";
-import * as i8 from "../icon/icon.module";
-import * as i9 from "@ngx-translate/core";
-export { QdNotificationComponent, QdNotificationContentComponent, QdNotificationsComponent, QdNotificationsHttpInterceptorService, QdNotificationsService, QdNotificationsSnackbarListenerDirective, QdNotification };
-export declare class QdNotificationsModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<QdNotificationsModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<QdNotificationsModule, [typeof i1.QdNotificationComponent, typeof i2.QdNotificationContentComponent, typeof i3.QdNotificationsComponent, typeof i4.QdNotificationsSnackbarComponent, typeof i5.QdNotificationsSnackbarListenerDirective], [typeof i6.CommonModule, typeof i7.QdFormModule, typeof i8.QdIconModule, typeof i9.TranslateModule], [typeof i1.QdNotificationComponent, typeof i2.QdNotificationContentComponent, typeof i3.QdNotificationsComponent, typeof i5.QdNotificationsSnackbarListenerDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<QdNotificationsModule>;
-}
-//# sourceMappingURL=notifications.module.d.ts.map

package/lib/notifications/notifications.module.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"notifications.module.d.ts","sourceRoot":"","sources":["../../../../libs/qd-ui/src/lib/notifications/notifications.module.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,8BAA8B,EAAE,MAAM,uDAAuD,CAAC;AACvG,OAAO,EAAE,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AACnF,OAAO,EAAE,qCAAqC,EAAE,MAAM,mDAAmD,CAAC;AAC1G,OAAO,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAElF,OAAO,EAAE,wCAAwC,EAAE,MAAM,0CAA0C,CAAC;AACpG,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;;;;;;;;;;;AAE5D,OAAO,EACL,uBAAuB,EACvB,8BAA8B,EAC9B,wBAAwB,EACxB,qCAAqC,EACrC,sBAAsB,EACtB,wCAAwC,EACxC,cAAc,EACf,CAAC;AAEF,qBAiBa,qBAAqB;yCAArB,qBAAqB;0CAArB,qBAAqB;0CAArB,qBAAqB;CAAG"}

package/lib/notifications/services/notifications-http-interceptor.service.d.ts

@@ -1,25 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
-import { Observable } from 'rxjs';
-import { QdAppEnvironment } from '../../core/model/app-enviroment.interface';
-import { QdNotificationsService } from './notifications-service.service';
-import * as i0 from "@angular/core";
-export declare const BACKEND_ERROR_CODES: InjectionToken<unknown>;
-export declare const WHITELIST_ERROR_CODES: InjectionToken<number[]>;
-/**
- * The QdNotificationsHttpInterceptorService is an Angular HTTP interceptor that captures error responses from HTTP requests and generates notifications for backend errors. This Service not only intercepts error responses, but it also handles specific error codes and translates them into appropriate error messages for display.
- */
-export declare class QdNotificationsHttpInterceptorService implements HttpInterceptor {
-    private readonly appEnvironment;
-    private readonly backendErrorCodes;
-    private readonly whitelistErrorCodes;
-    readonly notificationService: QdNotificationsService;
-    private readonly blacklistErrorCodes;
-    constructor(appEnvironment: QdAppEnvironment, backendErrorCodes: any, whitelistErrorCodes: number[], notificationService: QdNotificationsService);
-    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
-    private getErrorTranslationKeyForHttpStatus;
-    private getHttpErrorName;
-    static ɵfac: i0.ɵɵFactoryDeclaration<QdNotificationsHttpInterceptorService, [{ optional: true; }, { optional: true; }, { optional: true; }, null]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<QdNotificationsHttpInterceptorService>;
-}
-//# sourceMappingURL=notifications-http-interceptor.service.d.ts.map

package/lib/notifications/services/notifications-http-interceptor.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"notifications-http-interceptor.service.d.ts","sourceRoot":"","sources":["../../../../../libs/qd-ui/src/lib/notifications/services/notifications-http-interceptor.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,cAAc,EAAY,MAAM,eAAe,CAAC;AAC7E,OAAO,EAEL,SAAS,EACT,WAAW,EACX,eAAe,EACf,WAAW,EAEZ,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAc,MAAM,MAAM,CAAC;AAM9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAC7E,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;;AAEzE,eAAO,MAAM,mBAAmB,yBAA4C,CAAC;AAC7E,eAAO,MAAM,qBAAqB,0BAAwD,CAAC;AAE3F;;GAEG;AACH,qBAGa,qCAAsC,YAAW,eAAe;IAIpC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC3B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAChC,OAAO,CAAC,QAAQ,CAAC,mBAAmB;aAC/D,mBAAmB,EAAE,sBAAsB;IAN7D,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAW;gBAGS,cAAc,EAAE,gBAAgB,EAC5B,iBAAiB,KAAA,EACf,mBAAmB,EAAE,MAAM,EAAE,EACzE,mBAAmB,EAAE,sBAAsB;IAyB7D,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,WAAW,GAAG,UAAU,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAsBnF,OAAO,CAAC,mCAAmC;IAQ3C,OAAO,CAAC,gBAAgB;yCA9Db,qCAAqC;6CAArC,qCAAqC;CA+EjD"}

package/lib/notifications/services/notifications-service.service.d.ts

@@ -1,33 +0,0 @@
-import { Observable } from 'rxjs';
-import { QdNotification, QdNotifications } from '../interfaces/notifications';
-import { QdSnackbarService } from './snackbar.service';
-import { QdOsNotificationsService } from './os-notifications/os-notifications.service';
-import * as i0 from "@angular/core";
-export declare class QdNotificationsService {
-    private snackbarService;
-    private osNotificationsService;
-    private readonly notificationLifeTimeDefault;
-    private readonly _notificationsSubject;
-    private readonly notifications$;
-    private notifications;
-    constructor(snackbarService: QdSnackbarService, osNotificationsService: QdOsNotificationsService);
-    getNotificationsForContext(context: string): Observable<QdNotification[]>;
-    add(context: string, notification: QdNotification): void;
-    private addSnackbarNotification;
-    private addOsNotification;
-    addBulk(context: string, notifications: QdNotifications): void;
-    remove(context: string, id: string): void;
-    removeAll(context: string): void;
-    reset(): void;
-    private updateSubject;
-    private removeNotificationAfterTimeOut;
-    private getNotificationLifeTime;
-    private removeSnackbarNotificationAfterTimeOutIfOverriden;
-    private removeOsNotificationAfterTimeOutIfOverriden;
-    private zeroToInfinity;
-    private subscribeToTriggerOnCloseHandlers;
-    private getClosedNotifications;
-    static ɵfac: i0.ɵɵFactoryDeclaration<QdNotificationsService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<QdNotificationsService>;
-}
-//# sourceMappingURL=notifications-service.service.d.ts.map

package/lib/notifications/services/notifications-service.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"notifications-service.service.d.ts","sourceRoot":"","sources":["../../../../../libs/qd-ui/src/lib/notifications/services/notifications-service.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,UAAU,EAAY,MAAM,MAAM,CAAC;AAG7D,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,wBAAwB,EAAE,MAAM,6CAA6C,CAAC;;AAEvF,qBAGa,sBAAsB;IAMrB,OAAO,CAAC,eAAe;IAAqB,OAAO,CAAC,sBAAsB;IALtF,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAAK;IACjD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAA6C;IACnF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;IAC5E,OAAO,CAAC,aAAa,CAAwB;gBAEzB,eAAe,EAAE,iBAAiB,EAAU,sBAAsB,EAAE,wBAAwB;IAIhH,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC,cAAc,EAAE,CAAC;IAMzE,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,cAAc,GAAG,IAAI;IAcxD,OAAO,CAAC,uBAAuB;IAI/B,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,eAAe,GAAG,IAAI;IAI9D,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAOzC,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAOhC,KAAK,IAAI,IAAI;IAOb,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,8BAA8B;IActC,OAAO,CAAC,uBAAuB;IAI/B,OAAO,CAAC,iDAAiD;IAiBzD,OAAO,CAAC,2CAA2C;IAYnD,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,iCAAiC;IAQzC,OAAO,CAAC,sBAAsB;yCA9HnB,sBAAsB;6CAAtB,sBAAsB;CAoIlC"}

package/lib/notifications/services/os-notifications/desktop-notifications.service.d.ts

@@ -1,20 +0,0 @@
-import { Injector } from '@angular/core';
-import { QdNotification } from '../../interfaces/notifications';
-import * as i0 from "@angular/core";
-export declare class QdDesktopNotificationsService {
-    private injector;
-    private desktopNotifications;
-    private translateService;
-    constructor(injector: Injector);
-    open(notification: QdNotification): Notification;
-    close(id: string): void;
-    closeAll(context?: string): void;
-    private openDesktopNotificationIfPermitted;
-    private openDesktopNotification;
-    private getDesktopNotificationOptions;
-    private addDesktopNotificationEventListeners;
-    private closeByIndex;
-    static ɵfac: i0.ɵɵFactoryDeclaration<QdDesktopNotificationsService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<QdDesktopNotificationsService>;
-}
-//# sourceMappingURL=desktop-notifications.service.d.ts.map

package/lib/notifications/services/os-notifications/desktop-notifications.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"desktop-notifications.service.d.ts","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/notifications/services/os-notifications/desktop-notifications.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,QAAQ,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;;AAGhE,qBAGa,6BAA6B;IAI5B,OAAO,CAAC,QAAQ;IAH5B,OAAO,CAAC,oBAAoB,CAA6E;IACzG,OAAO,CAAC,gBAAgB,CAAmB;gBAEvB,QAAQ,EAAE,QAAQ;IAItC,IAAI,CAAC,YAAY,EAAE,cAAc,GAAG,YAAY;IAQhD,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAehC,OAAO,CAAC,kCAAkC;IAc1C,OAAO,CAAC,uBAAuB;IAe/B,OAAO,CAAC,6BAA6B;IAOrC,OAAO,CAAC,oCAAoC;IAO5C,OAAO,CAAC,YAAY;yCA9ET,6BAA6B;6CAA7B,6BAA6B;CAoFzC"}