@eui/core 19.3.3-snapshot-1754655052849 → 21.0.0-alpha.1

package/lib/services/locale/locale.service.mock.d.ts

@@ -1,16 +0,0 @@
-import { Observable } from 'rxjs';
-import { EuiServiceStatus, LocaleState } from '@eui/base';
-import { LocaleService } from './locale.service';
-import * as i0 from "@angular/core";
-export declare class LocaleServiceMock<T extends LocaleState = LocaleState> extends LocaleService<T> {
-    protected locale_id: string;
-    private DEFAULT_LOCALE;
-    private stateSub;
-    constructor(locale_id: string);
-    getState(): Observable<T>;
-    updateState(state: T): void;
-    init(state?: T): Observable<EuiServiceStatus>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LocaleServiceMock<any>, [{ optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<LocaleServiceMock<any>>;
-}
-//# sourceMappingURL=locale.service.mock.d.ts.map

package/lib/services/locale/locale.service.mock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"locale.service.mock.d.ts","sourceRoot":"","sources":["../../../../src/lib/services/locale/locale.service.mock.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,UAAU,EAAM,MAAM,MAAM,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;;AAKjD,qBACa,iBAAiB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;cAI1B,SAAS,EAAE,MAAM;IAH/E,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,QAAQ,CAAgF;gBAElC,SAAS,EAAE,MAAM;IAItE,QAAQ,IAAI,UAAU,CAAC,CAAC,CAAC;IAIzB,WAAW,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAU3B,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,gBAAgB,CAAC;yCAtB7C,iBAAiB;6CAAjB,iBAAiB;CA0B7B"}

package/lib/services/log/index.d.ts

@@ -1,4 +0,0 @@
-export * from './log.service';
-export * from './log.service.mock';
-export * from './log.module';
-//# sourceMappingURL=index.d.ts.map

package/lib/services/log/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/services/log/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC"}

package/lib/services/log/log.module.d.ts

@@ -1,16 +0,0 @@
-import { ModuleWithProviders } from '@angular/core';
-import { LogConfig } from '@eui/base';
-import * as i0 from "@angular/core";
-/**
- * Log Module
- */
-export declare class LogModule {
-    /** method called in your root module to provide the LogService */
-    static forRoot(config?: LogConfig): ModuleWithProviders<LogModule>;
-    /** method called in your other (non root, lazy loaded) modules to import a different instance of LogService */
-    static forChild(config?: LogConfig): ModuleWithProviders<LogModule>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LogModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<LogModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<LogModule>;
-}
-//# sourceMappingURL=log.module.d.ts.map

package/lib/services/log/log.module.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"log.module.d.ts","sourceRoot":"","sources":["../../../../src/lib/services/log/log.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,mBAAmB,EAAY,MAAM,eAAe,CAAC;AACxF,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;;AAQtC;;GAEG;AACH,qBACa,SAAS;IAClB,kEAAkE;IAClE,MAAM,CAAC,OAAO,CAAC,MAAM,GAAE,SAA8B,GAAG,mBAAmB,CAAC,SAAS,CAAC;IAUtF,+GAA+G;IAC/G,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAE,SAA8B,GAAG,mBAAmB,CAAC,SAAS,CAAC;yCAb9E,SAAS;0CAAT,SAAS;0CAAT,SAAS;CAsBrB"}

package/lib/services/log/log.service.d.ts

@@ -1,28 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { LogAppender, Logger, LogLevel } from '@eui/base';
-import * as i0 from "@angular/core";
-export declare const BASE_LOGGER_NAME_TOKEN: InjectionToken<string>;
-export declare const LOG_LEVEL_TOKEN: InjectionToken<LogLevel>;
-export declare const LOG_APPENDERS_TOKEN: InjectionToken<LogAppender<import("@eui/base").LogAppenderConfig>[]>;
-/**
- * Log service, responsible for getting or creating loggers. It itself acts as a base logger
- */
-export declare class LogService extends Logger {
-    protected name: string;
-    protected level: LogLevel;
-    protected appenders: LogAppender[];
-    /** the list of persistent loggers */
-    protected loggers: {};
-    constructor(name: string, level: LogLevel, appenders: LogAppender[]);
-    /**
-     * Gets a logger by name. If the logger does not exist, it is created
-     *
-     * @param loggerName logger name
-     * @param persist optional parameter. Set it to true if you want to reuse the logger. By default, it is set to false
-     * @returns the logger
-     */
-    getLogger(loggerName: string, persist?: boolean): Logger;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LogService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<LogService>;
-}
-//# sourceMappingURL=log.service.d.ts.map

package/lib/services/log/log.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"log.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/services/log/log.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,cAAc,EAAE,MAAM,eAAe,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;;AAE1D,eAAO,MAAM,sBAAsB,wBAAiD,CAAC;AACrF,eAAO,MAAM,eAAe,0BAA4C,CAAC;AACzE,eAAO,MAAM,mBAAmB,sEAAqD,CAAC;AAEtF;;GAEG;AACH,qBACa,UAAW,SAAQ,MAAM;cAKqB,IAAI,EAAE,MAAM;cACnB,KAAK,EAAE,QAAQ;cACX,SAAS,EAAE,WAAW,EAAE;IAN5E,qCAAqC;IACrC,SAAS,CAAC,OAAO,KAAM;gBAGgC,IAAI,EAAE,MAAM,EACnB,KAAK,EAAE,QAAQ,EACX,SAAS,EAAE,WAAW,EAAE;IAK5E;;;;;;OAMG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,UAAQ,GAAG,MAAM;yCAnB7C,UAAU;6CAAV,UAAU;CA8BtB"}

package/lib/services/log/log.service.mock.d.ts

@@ -1,5 +0,0 @@
-import { LoggerMock } from '@eui/base';
-export declare class LogServiceMock extends LoggerMock {
-    getLogger(): LoggerMock;
-}
-//# sourceMappingURL=log.service.mock.d.ts.map

package/lib/services/log/log.service.mock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"log.service.mock.d.ts","sourceRoot":"","sources":["../../../../src/lib/services/log/log.service.mock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC,qBAAa,cAAe,SAAQ,UAAU;IAC1C,SAAS,IAAI,UAAU;CAG1B"}

package/lib/services/permission/permission.service.d.ts

@@ -1,188 +0,0 @@
-import { EuiService, EuiServiceStatus, EuiUserRight } from '@eui/base';
-import { Observable } from 'rxjs';
-import { LogService } from '../log';
-import { StoreService } from '../store';
-import * as i0 from "@angular/core";
-/**
- * Service for managing user permissions within the application.
- * This class extends `EuiService` and is responsible for handling user rights and permissions.
- * It provides methods to initialize the service with user rights, check specific rights and permissions,
- * and subscribe to changes in the user rights state.
- *
- * @extends {EuiService<EuiUserRight[]>}
- * @see EuiService
- *
- * @example
- * // Example of using the EuiPermissionService in an application
- * const permissionService = new EuiPermissionService();
- * permissionService.init([{ id: 'ADMIN', permissions: ['CREATE', 'READ', 'UPDATE', 'DELETE'] }]);
- * if (permissionService.checkRight('ADMIN')) {
- *   console.log('User has ADMIN rights');
- * }
- */
-export declare class EuiPermissionService extends EuiService<EuiUserRight[]> {
-    private log;
-    protected store: StoreService;
-    private readonly logger;
-    constructor(log: LogService, store: StoreService);
-    /**
-     * Initializes the permission service with a set of user rights.
-     * This method sets up the initial state of the service based on the provided user rights.
-     * It should be called before using other methods of the service to ensure it is properly configured.
-     *
-     * @param {EuiUserRight[]} rights - An array of user rights to initialize the service with.
-     *                                  Each `EuiUserRight` object should contain at least an `id` property,
-     *                                  and optionally a `permissions` property which is an array of strings.
-     *
-     * @returns {Observable<EuiServiceStatus>} An Observable that emits the status of the initialization.
-     *                                         The status object includes a `success` boolean indicating
-     *                                         whether the initialization was successful, and an `error` property
-     *                                         with a message in case of failure.
-     *
-     * @example
-     * // Example of initializing the service with two user rights
-     * const userRights = [
-     *   { id: 'ADMIN', permissions: ['CREATE', 'READ', 'UPDATE', 'DELETE'] },
-     *   { id: 'USER', permissions: ['READ'] }
-     * ];
-     * permissionService.init(userRights).subscribe(status => {
-     *   if (status.success) {
-     *     console.log('Initialization successful');
-     *   } else {
-     *     console.error('Initialization failed:', status.error);
-     *   }
-     * });
-     *
-     * @throws {Error} Throws an error if the `rights` parameter is not an array of `EuiUserRight` objects.
-     */
-    init(rights: EuiUserRight[]): Observable<EuiServiceStatus>;
-    /**
-     * Retrieves the current user rights from the service's state.
-     * This getter provides access to the array of `EuiUserRight` objects that represent the current rights
-     * of the user. It is a protected method, intended for internal use within the service or by subclasses.
-     *
-     * @returns {EuiUserRight[]} An array of `EuiUserRight` objects representing the current user rights.
-     *                           Each `EuiUserRight` object typically contains an `id` property, and may
-     *                           also include a `permissions` property which is an array of strings.
-     *
-     * @example
-     * // Example of accessing user rights within a subclass or within the service
-     * const currentRights = this.userRights;
-     * currentRights.forEach(right => {
-     *   console.log(`Right ID: ${right.id}, Permissions: ${right.permissions.join(', ')}`);
-     * });
-     *
-     * @protected
-     */
-    protected get userRights(): EuiUserRight[];
-    /**
-     * Retrieves the current state of user rights by subscribing to changes.
-     * This method is used to access the current state of user rights in the service. It returns an Observable
-     * that emits the current user rights. The method is generic and can be parameterized to return a specific
-     * type that extends from `EuiUserRight[]`.
-     *
-     * @template K - The type of the user rights state to be returned. Defaults to `EuiUserRight[]` if not specified.
-     *
-     * @returns {Observable<K>} An Observable that emits the current state of user rights.
-     *                          The type of the emitted value is `K`, which is `EuiUserRight[]` by default.
-     *
-     * @example
-     * // Example of subscribing to the user rights state
-     * permissionService.getState().subscribe(currentRights => {
-     *   console.log('Current User Rights:', currentRights);
-     * });
-     *
-     * // Example with a specific type
-     * permissionService.getState<CustomUserRightType[]>().subscribe(customRights => {
-     *   console.log('Custom User Rights:', customRights);
-     * });
-     */
-    getState<K = EuiUserRight[]>(): Observable<K>;
-    /**
-     * Updates the state of the service with a new set of user rights.
-     * This method is used to modify the current user rights in the service. It takes an array of `EuiUserRight`
-     * objects and updates the service's state. This change is then propagated to all subscribers of the state.
-     *
-     * @param {EuiUserRight[]} rights - An array of `EuiUserRight` objects to update the service's state with.
-     *                                  Each `EuiUserRight` object should contain an `id` property,
-     *                                  and optionally a `permissions` property which is an array of strings.
-     *
-     * @example
-     * // Example of updating the service's state with new user rights
-     * const newUserRights = [
-     *   { id: 'USER', permissions: ['READ', 'COMMENT'] },
-     *   { id: 'MODERATOR', permissions: ['READ', 'WRITE', 'DELETE'] }
-     * ];
-     * permissionService.updateState(newUserRights);
-     */
-    updateState(rights: EuiUserRight[]): void;
-    /**
-     * Checks if the user has the specified attribute permission.
-     * This method interprets a string that represents a combination of rights and/or permissions
-     * and determines whether the user has the specified permissions. The string format can be
-     * 'RIGHT.PERMISSION' or just 'RIGHT'. For multiple rights, it can be 'RIGHT1.RIGHT2.PERMISSION'.
-     *
-     * @param {string} rightsAndPermission - A string representing the rights and/or permissions to check.
-     *                                       Format can be 'RIGHT', 'RIGHT.PERMISSION', or 'RIGHT1.RIGHT2.PERMISSION'.
-     *
-     * @returns {boolean} True if the user has the specified attribute permission, false otherwise.
-     *
-     * @example
-     * // Check a single right
-     * const hasRight = permissionService.checkAttributePermission('VIEW');
-     *
-     * // Check a right with a specific permission
-     * const hasRightWithPermission = permissionService.checkAttributePermission('EDIT.APPROVE');
-     *
-     * // Check multiple rights with a specific permission
-     * const hasMultipleRights = permissionService.checkAttributePermission('ADMIN.VIEW.APPROVE');
-     */
-    checkAttributePermission(rightsAndPermission: string): boolean;
-    /**
-     * Checks if the user has a specific right.
-     * This method determines whether the user possesses a particular right identified by its ID.
-     *
-     * @param {string} rightId - The ID of the right to check.
-     *
-     * @returns {boolean} True if the user has the specified right, false otherwise.
-     *
-     * @example
-     * // Check if the user has the 'ADMIN' right
-     * const isAdmin = permissionService.checkRight('ADMIN');
-     */
-    checkRight(rightId: string): boolean;
-    /**
-     * Checks if the user has a specific permission within a right.
-     * This method determines whether the user has a specific permission associated with a given right.
-     *
-     * @param {string} rightId - The ID of the right.
-     * @param {string} permission - The permission to check within the right.
-     *
-     * @returns {boolean} True if the user has the specified permission in the given right, false otherwise.
-     *
-     * @example
-     * // Check if the user has 'APPROVE' permission in the 'EDIT' right
-     * const canApproveEdit = permissionService.checkPermission('EDIT', 'APPROVE');
-     */
-    checkPermission(rightId: string, permission: string): boolean;
-    /**
-     * Checks if the user has all the specified rights.
-     * This private method determines whether the user possesses all the rights provided in the array.
-     * Each right in the array is checked against the user's current rights.
-     *
-     * @param {EuiUserRight[]} rights - An array of rights to check against the user's rights.
-     *
-     * @returns {boolean} True if the user has all the specified rights, false otherwise.
-     *
-     * @example
-     * // Example usage within the service
-     * const requiredRights = [{ id: 'VIEW' }, { id: 'EDIT' }];
-     * const hasAllRequiredRights = this.haveAllRights(requiredRights);
-     *
-     * @private
-     */
-    private haveAllRights;
-    static ɵfac: i0.ɵɵFactoryDeclaration<EuiPermissionService, [{ optional: true; }, null]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<EuiPermissionService>;
-}
-//# sourceMappingURL=permission.service.d.ts.map

package/lib/services/permission/permission.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"permission.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/services/permission/permission.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,YAAY,EAAgC,MAAM,WAAW,CAAC;AACrG,OAAO,EAAE,UAAU,EAAM,MAAM,MAAM,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;;AAIxC;;;;;;;;;;;;;;;;GAgBG;AACH,qBAGa,oBAAqB,SAAQ,UAAU,CAAC,YAAY,EAAE,CAAC;IAIhD,OAAO,CAAC,GAAG;IACvB,SAAS,CAAC,KAAK,EAAE,YAAY;IAJjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAGR,GAAG,EAAE,UAAU,EACzB,KAAK,EAAE,YAAY;IAQjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,IAAI,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,UAAU,CAAC,gBAAgB,CAAC;IAa1D;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,KAAK,UAAU,IAAI,YAAY,EAAE,CAEzC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,CAAC,CAAC,GAAG,YAAY,EAAE,KAAK,UAAU,CAAC,CAAC,CAAC;IAO7C;;;;;;;;;;;;;;;;OAgBG;IACH,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,IAAI;IAIzC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,wBAAwB,CAAC,mBAAmB,EAAE,MAAM,GAAG,OAAO;IAmB9D;;;;;;;;;;;OAWG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIpC;;;;;;;;;;;;OAYG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO;IAO7D;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,aAAa;yCA5NZ,oBAAoB;6CAApB,oBAAoB;CAmOhC"}

package/lib/services/queue/api-queue.service.d.ts

@@ -1,278 +0,0 @@
-import { HttpClient } from '@angular/common/http';
-import { Observable } from 'rxjs';
-import { ApiQueueItem } from '@eui/base';
-import { LogService } from '../log';
-import { StoreService } from '../store';
-import * as i0 from "@angular/core";
-/**
- * Service class for managing and processing a queue of API requests.
- *
- * This service provides functionality to add, remove, process, and manage HTTP requests stored in a queue.
- * It enables sequential or bulk processing of requests, ensuring controlled execution and handling of API calls.
- * The service methods offer features like processing individual items, processing all items in the queue either
- * sequentially or all at once, and removing items from the queue. Each method is designed to handle specific aspects
- * of queue management and processing, with attention to details like order of execution and error handling.
- *
- * Usage of this service is ideal in scenarios where API requests need to be managed in a queue structure, allowing
- * for controlled execution and monitoring of these requests.
- *
- * @example
- * // Adding a new item to the queue
- * apiQueueService.addQueueItem({ id: 'item124', method: 'POST', uri: '/api/data', payload: {...} });
- *
- * // Processing a single item from the queue
- * apiQueueService.processQueueItem('item123').subscribe(result => {
- *   console.log('Processed item 123 with result:', result);
- * });
- *
- * // Processing all items in the queue in sequential order
- * apiQueueService.processAllQueueItemsSequential(false).subscribe(results => {
- *   console.log('Processed all items in descending order of their timestamp:', results);
- * });
- *
- * // Removing an item from the queue
- * apiQueueService.removeQueueItem('item123');
- *
- * // Processing all items in the queue and continuing on error
- * apiQueueService.processAllQueueItems(true).subscribe(results => {
- *   console.log('Processed all items in the queue with continuation on errors:', results);
- * });
- */
-export declare class ApiQueueService {
-    protected store: StoreService;
-    protected http: HttpClient;
-    protected logService: LogService;
-    private readonly logger;
-    private readonly getAppState;
-    private getApiQueue;
-    private getApiQueueItem;
-    constructor(store: StoreService, http: HttpClient, logService: LogService);
-    /**
-     * Adds an item to the queue by dispatching an action to the store.
-     * This function is specifically designed to enqueue API call requests represented by `ApiQueueItem` objects.
-     * Each item is identified by a unique `id`, which is used to manage the queue.
-     *
-     * @param {string} id - The unique identifier for the queue item. It's crucial to ensure that this ID is unique within the queue.
-     *                      If an item with the same ID already exists, the new item will overwrite the existing one.
-     *                      WARNING: Duplicate IDs will lead to overwriting of queue items.
-     *
-     * @param {ApiQueueItem} item - The item to be enqueued. This should be an object of type `ApiQueueItem`.
-     *                              The `method` property of the item must be one of the allowed methods ('post', 'put', 'get').
-     *                              If an unsupported method is provided, the function will throw an error.
-     *
-     * @throws {Error} Throws an error if the `method` property of the `item` is not one of the allowed methods.
-     *                 The error message is: `[ApiQueue] method "${item.method}" is not allowed`.
-     *
-     * @example
-     * // Example of adding an item to the API queue
-     * addQueueItem('12345', { method: 'post', url: '/api/data', payload: {...} });
-     *
-     * @returns {void} This function does not return a value. It adds the item to the queue via a dispatch action.
-     */
-    addQueueItem(id: string, item: ApiQueueItem): void;
-    /**
-     * Retrieves the current state of the API queue and converts it into an array of Observables.
-     *
-     * This method subscribes to the store to access the API queue. It then maps the queue object,
-     * which is an associative array, into a linear array of ApiQueueItem instances. If the queue is empty,
-     * a warning is logged. This method is useful for tracking the state and contents of the API queue
-     * at a given moment.
-     *
-     * Note: This method takes a snapshot of the queue at the time of subscription. It does not provide
-     * a continuous stream of queue updates. To get real-time updates, consider subscribing directly
-     * to the store's observable.
-     *
-     * @returns {Observable<ApiQueueItem[]>} An Observable that emits an array of ApiQueueItem.
-     * The array represents all items currently in the queue. If the queue is empty, it emits an empty array.
-     *
-     * @example
-     * // Example usage
-     * this.getQueue().subscribe(queueItems => {
-     *   console.log('Current queue items:', queueItems);
-     * });
-     */
-    getQueue(): Observable<ApiQueueItem[]>;
-    /**
-     * Retrieves a specific item from the API queue by its ID.
-     *
-     * This method subscribes to the store and selects a single item from the API queue based on the provided ID.
-     * It employs a pipeline to fetch the item: the `getApiQueueItem` selector is used to retrieve the item,
-     * and a `map` operator processes the result. If the item with the specified ID does not exist in the queue,
-     * a warning is logged, and `null` is returned.
-     *
-     * This method is ideal for accessing a specific queue item when its ID is known, allowing for targeted
-     * operations or checks on that particular item.
-     *
-     * @param {string} id - The unique identifier of the item within the queue.
-     * @returns {Observable<ApiQueueItem | null>} An Observable emitting the requested ApiQueueItem.
-     * If no item with the given ID exists in the queue, the Observable emits `null`.
-     *
-     * @example
-     * // Example usage
-     * this.getQueueItem('item123').subscribe(item => {
-     *   if (item) {
-     *     console.log('Found item:', item);
-     *   } else {
-     *     console.log('Item not found in the queue');
-     *   }
-     * });
-     */
-    getQueueItem(id: string): Observable<ApiQueueItem>;
-    /**
-     * Removes a specific item from the API queue using its ID.
-     *
-     * This method dispatches an action to remove an item from the queue, identified by the provided ID.
-     * It is essential for managing the queue by eliminating items that are no longer needed or have been processed.
-     * The function does not return any value, as it primarily triggers an action within the store.
-     *
-     * Note: This method assumes the existence of the item in the queue. It does not perform a check
-     * to confirm the presence of the item before attempting to remove it. Therefore, it's recommended
-     * to verify the item's existence in the queue if uncertainty exists.
-     *
-     * @param {string} id - The unique identifier of the item to be removed from the queue.
-     *
-     * @example
-     * // Example usage
-     * this.removeQueueItem('item123');
-     * // The item with ID 'item123' will be dispatched for removal from the queue.
-     */
-    removeQueueItem(id: string): void;
-    /**
-     * Clears all items from the API queue.
-     *
-     * This method dispatches an action to empty the entire API queue, effectively removing all items that are currently queued.
-     * It is useful for scenarios where a complete reset of the queue is required, such as during initialization or after processing
-     * a batch of items. The function does not return any value, as its primary purpose is to trigger a state change in the store.
-     *
-     * Note: Use this method with caution as it will irreversibly clear all items in the queue. Ensure that this action does not
-     * disrupt any ongoing processes that rely on the queue's contents.
-     *
-     * @example
-     * // Example usage
-     * this.removeAllQueueItem();
-     * // This will dispatch an action to empty the entire API queue.
-     */
-    removeAllQueueItem(): void;
-    /**
-     * Processes an item from the API queue identified by its ID.
-     *
-     * Retrieves the specified item from the queue and applies processing logic as defined in `buildHttpRequest`.
-     * If the item is not found, logs a warning and returns an Observable emitting `null`.
-     *
-     * @param {string} id - The unique identifier of the item within the queue to be processed.
-     * @returns {Observable<any>} An Observable that emits the result of processing the queue item.
-     * If the item does not exist, the Observable emits `null`.
-     *
-     * @example
-     * // Example usage
-     * this.processQueueItem('item123').subscribe(result => {
-     *   if (result) {
-     *     console.log('Processing result:', result);
-     *   } else {
-     *     console.log('Item not found in the queue');
-     *   }
-     * });
-     */
-    processQueueItem<T>(id: string): Observable<T>;
-    /**
-     * Processes all items in the API queue and collects their responses.
-     *
-     * Iterates over each item in the queue and processes them using `buildHttpRequest`. If a request fails,
-     * the method can either continue processing the remaining items or stop, based on the `continueOnError` parameter.
-     * It returns an Observable that emits an array containing the responses or errors from all the processed items.
-     *
-     * The function currently returns `Observable<any[]>` indicating an array of any type. Future improvements
-     * should aim to specify a more accurate return type or utilize generics for increased type safety.
-     *
-     * @param {boolean} [continueOnError=true] - Determines whether to continue with the next item in the queue
-     *                                           after a request failure. Defaults to `true`.
-     * @returns {Observable<any[]>} An Observable emitting an array of either responses or errors from the processed
-     *                              queue items.
-     *
-     * @example
-     * this.processAllQueueItems().subscribe(results => {
-     *   // Handle the array of responses or errors
-     * });
-     */
-    processAllQueueItems<T>(continueOnError?: boolean): Observable<T[]>;
-    /**
-     * Processes all items in the queue sequentially, based on their timestamp ordering.
-     *
-     * This method first orders the items in the API queue by their timestamp, either in ascending or descending
-     * order as specified by the `ascending` parameter. It then processes each item using `buildHttpRequest`, ensuring
-     * that each request is completed before the next begins. This sequential processing is crucial when the order of
-     * execution matters for HTTP requests in the queue. The method returns an Observable that emits the responses
-     * following the same order as the queue items were processed.
-     *
-     * The function currently returns `Observable<any>`, indicating a broad type. Future improvements should focus on
-     * specifying a more accurate return type or utilizing generics for increased type safety.
-     *
-     * @param {boolean} [ascending=true] - Determines whether the queue items are processed in ascending order of their
-     *                                     timestamp. Defaults to `true`.
-     * @returns {Observable<any>} An Observable emitting the responses of the HTTP requests in the order they were processed.
-     *
-     * @example
-     * this.processAllQueueItemsSequential().subscribe(response => {
-     *   // Handle each response in the order of queue processing
-     * });
-     */
-    processAllQueueItemsSequential<T>(ascending?: boolean): Observable<T>;
-    /**
-     * Compares two queue items based on their timestamp and determines their order.
-     *
-     * This protected method is used to sort queue items. It takes two queue items as input, each represented
-     * as a tuple containing an item ID and the `ApiQueueItem` object. The method compares these items based on
-     * the `timestamp` property of the `ApiQueueItem` objects. It returns a number indicating the order in which
-     * these items should be sorted.
-     *
-     * A positive return value indicates that the first item should come after the second, a negative value
-     * indicates the opposite, and zero indicates that they are equal in terms of timestamp.
-     *
-     * @param {[string, ApiQueueItem]} a - The first queue item tuple for comparison.
-     * @param {[string, ApiQueueItem]} b - The second queue item tuple for comparison.
-     * @returns {number} A number indicating the order of the items: negative if `a` is earlier than `b`,
-     *                  positive if `a` is later than `b`, and zero if they are equal.
-     * @beta
-     */
-    protected sortOnTimestamp(a: [string, ApiQueueItem], b: [string, ApiQueueItem]): number;
-    /**
-     * Constructs and executes an HTTP request based on the provided queue item details.
-     *
-     * This private method takes an ID and an `ApiQueueItem` object to build and execute an HTTP request.
-     * It determines the HTTP method (like GET, POST, etc.) from the `method` property of the `ApiQueueItem`,
-     * and uses the `uri` and `payload` properties for the request's URL and body, respectively. After the
-     * request is executed, the corresponding queue item is removed from the queue.
-     *
-     * The method is generic, allowing the caller to specify the expected response type `T`. By default,
-     * it uses `any` type, but specifying a more concrete type enhances type safety and clarity in usage.
-     *
-     * @param {string} id - The ID of the queue item being processed.
-     * @param {ApiQueueItem} item - The queue item containing details for the HTTP request.
-     * @returns {Observable<T>} An Observable of type T, representing the response of the HTTP request.
-     *
-     * @example
-     * // Example usage for a specific response type
-     * this.buildHttpRequest<MyResponseType>('item123', queueItem)
-     *     .subscribe(response => {
-     *         // Handle the response
-     *     });
-     *
-     * @template T - The expected type of the HTTP response. Defaults to `any`.
-     */
-    private buildHttpRequest;
-    /**
-     * A state reducer that adds an item to the API queue.
-     * @param state
-     * @param action
-     */
-    private addApiQueueItem;
-    /**
-     * A state reducer that removes an item from the API queue.
-     * @param state
-     * @param action
-     */
-    private removeApiQueueItem;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ApiQueueService, [null, null, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ApiQueueService>;
-}
-//# sourceMappingURL=api-queue.service.d.ts.map

package/lib/services/queue/api-queue.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-queue.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/services/queue/api-queue.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAsB,MAAM,MAAM,CAAC;AAEtD,OAAO,EAAY,YAAY,EAA+B,MAAM,WAAW,CAAC;AAEhF,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;;AAGxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAGa,eAAe;IAOpB,SAAS,CAAC,KAAK,EAAE,YAAY;IAC7B,SAAS,CAAC,IAAI,EAAE,UAAU;IACd,SAAS,CAAC,UAAU,EAAE,UAAU;IARhD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiC;IAC7D,OAAO,CAAC,WAAW,CAA+B;IAClD,OAAO,CAAC,eAAe,CAAuD;gBAGhE,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,UAAU,EACJ,UAAU,EAAE,UAAU;IAWhD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI;IAUlD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,IAAI,UAAU,CAAC,YAAY,EAAE,CAAC;IActC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,CAAC,YAAY,CAAC;IAalD;;;;;;;;;;;;;;;;;OAiBG;IACH,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIjC;;;;;;;;;;;;;;OAcG;IACH,kBAAkB,IAAI,IAAI;IAI1B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gBAAgB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC;IAc9C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,oBAAoB,CAAC,CAAC,EAAE,eAAe,UAAO,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC;IAqBhE;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,8BAA8B,CAAC,CAAC,EAAE,SAAS,UAAO,GAAG,UAAU,CAAC,CAAC,CAAC;IAWlE;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,MAAM;IAIvF;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;;;OAIG;IACH,OAAO,CAAC,eAAe,CAOrB;IAEF;;;;OAIG;IACH,OAAO,CAAC,kBAAkB,CASxB;yCA9VO,eAAe;6CAAf,eAAe;CA+V3B"}

package/lib/services/queue/api-queue.service.mock.d.ts

@@ -1,14 +0,0 @@
-import { ApiQueueService } from './api-queue.service';
-import { Observable } from 'rxjs';
-import { ApiQueueItem } from '@eui/base';
-export declare class ApiQueueServiceMock extends ApiQueueService {
-    constructor();
-    getQueue(): Observable<ApiQueueItem[]>;
-    getQueueItem(id: string): Observable<ApiQueueItem>;
-    removeAllQueueItem(): void;
-    processAllQueueItems<T>(): Observable<T>;
-    addQueueItem(): void;
-    removeQueueItem(): void;
-    processQueueItem<T>(): Observable<T>;
-}
-//# sourceMappingURL=api-queue.service.mock.d.ts.map

package/lib/services/queue/api-queue.service.mock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-queue.service.mock.d.ts","sourceRoot":"","sources":["../../../../src/lib/services/queue/api-queue.service.mock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAM,MAAM,MAAM,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC,qBAAa,mBAAoB,SAAQ,eAAe;;IAI3C,QAAQ,IAAI,UAAU,CAAC,YAAY,EAAE,CAAC;IAGtC,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,CAAC,YAAY,CAAC;IAGlD,kBAAkB,IAAI,IAAI;IAC1B,oBAAoB,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC;IAGxC,YAAY,IAAI,IAAI;IACpB,eAAe,IAAI,IAAI;IACvB,gBAAgB,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC;CAGhD"}

package/lib/services/queue/index.d.ts

@@ -1,3 +0,0 @@
-export * from './api-queue.service';
-export * from './api-queue.service.mock';
-//# sourceMappingURL=index.d.ts.map

package/lib/services/queue/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/services/queue/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC"}

package/lib/services/storage/async-storage.service.d.ts

@@ -1,45 +0,0 @@
-import { StorageService } from './storage.service';
-import { Observable } from 'rxjs';
-/**
- * Generic asynchronous storage service. Concrete asynchronous storage services must extend this class
- */
-export declare abstract class AsyncStorageService extends StorageService {
-    /**
-     * reflects the readiness of the storage
-     * @returns one time emission Observable<any>
-     */
-    abstract ready(): Observable<any>;
-    /**
-     * retrieve an object from async storage
-     * @param key the associated key
-     * @returns one time emission Observable of value
-     */
-    abstract get(key: string): Observable<any>;
-    abstract get<T>(key: string): Observable<T>;
-    /**
-     * sets an object in async storage
-     * @param key the associated key
-     * @param value the value to set
-     * @returns one time emission Observable
-     */
-    abstract set(key: string, value: any): Observable<any>;
-    abstract set<T>(key: string, value: T): Observable<any>;
-    /**
-     * removes an object from async storage
-     * @param key the associated key
-     * @returns one time emission Observable
-     */
-    abstract remove(key: string): Observable<any>;
-    /**
-     * asynchronous helper for set function
-     * @param key the associated key
-     * @param value the value to set
-     */
-    setAsync(key: string, value: any): void;
-    /**
-     * asynchronous helper for remove function
-     * @param key the associated key
-     */
-    removeAsync(key: string): void;
-}
-//# sourceMappingURL=async-storage.service.d.ts.map

package/lib/services/storage/async-storage.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"async-storage.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/services/storage/async-storage.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAElC;;GAEG;AACH,8BAAsB,mBAAoB,SAAQ,cAAc;IAC5D;;;OAGG;IAGH,QAAQ,CAAC,KAAK,IAAI,UAAU,CAAC,GAAG,CAAC;IAEjC;;;;OAIG;aAGe,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC;aACjC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC;IAEpD;;;;;OAKG;aAGe,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC;aAG7C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC;IAEhE;;;;OAIG;aAGe,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC;IAEtD;;;;OAIG;IAGH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI;IAKvC;;;OAGG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;CAGjC"}