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

package/index.d.ts

@@ -1,6 +1,2471 @@
+import * as _eui_base from '@eui/base';
+import { EuiEnvConfig, EuiAppJsonConfig, EuiConfig, ModuleConfig, EuiAppConfig, GlobalConfig, LogConfig, HttpErrorHandlerConfig, ConnectionStatus, EuiAppHandlersConfig, Logger, LogLevel, LogAppender, LoggerMock, HttpErrorRouteConfig, ApiQueueItem, I18nState, UserState, UserDetails, UserPreferences, EuiUserRight, LocaleState, AppState, CoreState, NotificationsState, DeepPartial, I18nLoaderConfig, EuiLazyService, I18nServiceConfig, EuiServiceStatus, EuiService, EuiMenuItem, EuiLanguage, LocaleServiceConfig, EuiGrowlMessage, ErrorMappingHandler } from '@eui/base';
 export * from '@eui/base';
-export * from './lib/eui-core.module';
-export * from './lib/services/index';
-export * from './lib/interceptors/index';
-export * from './lib/helpers/index';
-//# sourceMappingURL=index.d.ts.map
+import * as i0 from '@angular/core';
+import { InjectionToken, ModuleWithProviders, EnvironmentProviders, Injector, ErrorHandler, OnDestroy, Signal, ElementRef, DebugElement, Type } from '@angular/core';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpErrorResponse, HttpClient, HttpResponseBase } from '@angular/common/http';
+import { Router, ActivatedRoute } from '@angular/router';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { TranslateLoader, TranslateService } from '@ngx-translate/core';
+import { ComponentType, DomPortalOutlet } from '@angular/cdk/portal';
+import { ComponentFixture } from '@angular/core/testing';
+import { AbstractControl, FormGroup, FormArray, FormControl } from '@angular/forms';
+
+declare const CORE_ROOT_GUARD: InjectionToken<void>;
+declare class CoreModule {
+    /**
+     * No more providing config from forRoot, you have to use EUI_CONFIG_TOKEN to pass config via providers.
+     */
+    static forRoot(): ModuleWithProviders<CoreModule>;
+    static forChild(moduleName: string): ModuleWithProviders<CoreModule>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CoreModule>;
+}
+declare const createEuiCoreRootGuard: (core: any) => string;
+declare class EuiCoreRootGuardClass {
+    constructor();
+}
+declare const euiCoreRootGuardClass: () => EuiCoreRootGuardClass;
+
+/**
+ * Function to be used before the AppModule is bootstrapped. It is currently used to load dynamic configurations.
+ * It needs to be added in your application main.ts file.
+ * @param envConfig the current environment configuration
+ * @returns the updated environment configuration, as a promise
+ */
+declare function preInitApp(envConfig: EuiEnvConfig): Promise<EuiEnvConfig>;
+/**
+ * Function to load asynchronously a dynamic configuration (from a local path or a web service)
+ *
+ * @param url the path to the configuration
+ * @param timeout possible timeout
+ * @returns EuiAppJsonConfig promise
+ */
+declare function loadEuiDynamicEnvironmentConfig(url: string, timeout?: number): Promise<EuiAppJsonConfig>;
+
+/**
+ * Initializes the app with the necessary configurations. Use this in combination with `provideAppInitializer(euiInitApp_Env)`
+ */
+declare function provideEuiInitializer(): EnvironmentProviders;
+/**
+ * Initializes the app with the necessary configurations
+ * @param injector
+ * @deprecated Use `provideEuiInitializer()` instead. Beware that this should be declared as Environment providers.
+ */
+declare const euiInitApp: (injector: Injector) => () => Promise<null>;
+
+declare const EUI_CONFIG_TOKEN: InjectionToken<EuiConfig>;
+declare const MODULE_NAME_TOKEN: InjectionToken<string>;
+declare const MODULE_CONFIG_TOKEN: InjectionToken<ModuleConfig<any>>;
+declare const CONFIG_TOKEN: InjectionToken<EuiAppConfig>;
+declare const GLOBAL_CONFIG_TOKEN: InjectionToken<GlobalConfig<any>>;
+declare const BASE_NAME_TOKEN: InjectionToken<string>;
+declare const ROOT_LOG_CONFIG_TOKEN: InjectionToken<LogConfig>;
+declare const SHOW_CONNECTION_STATUS_TOKEN: InjectionToken<boolean>;
+declare const HTTP_ERROR_HANDLER_CONFIG_TOKEN: InjectionToken<HttpErrorHandlerConfig>;
+declare function getGlobalConfig(appConfig: EuiAppConfig): GlobalConfig;
+declare function getShowConnectionStatus(globalConfig: GlobalConfig): ConnectionStatus;
+declare function getModuleConfig(appConfig: EuiAppConfig, moduleName: string): ModuleConfig;
+declare function getHttpErrorHandlingConfig(appConfig: EuiAppConfig): HttpErrorHandlerConfig;
+declare function getRootLogConfig(appConfig: EuiAppConfig): LogConfig;
+declare function prepareEuiAppConfigToken(euiConfig: EuiConfig): EuiAppConfig;
+declare function mergeAppHandlerConfigToAppConfig(euiAppConfig: EuiAppConfig, envAppHandler: EuiAppHandlersConfig): EuiAppConfig;
+declare function mergeAppJsonConfigToAppConfig(euiAppConfig: EuiAppConfig, envAppJsonConfig: EuiAppJsonConfig, merge: Array<string>, isDeepMerge: boolean): EuiAppConfig;
+
+declare const errorCodes: {
+    ERR_GENERIC: string;
+};
+declare class ErrorSubClass {
+    code?: string;
+    message: string;
+    stack: string;
+    name: string;
+    constructor(code?: string, msg?: string, args?: any);
+}
+declare class EuiError extends ErrorSubClass {
+    constructor(code?: string, msg?: string, args?: any);
+}
+
+declare const BASE_LOGGER_NAME_TOKEN: InjectionToken<string>;
+declare const LOG_LEVEL_TOKEN: InjectionToken<LogLevel>;
+declare const LOG_APPENDERS_TOKEN: InjectionToken<LogAppender<_eui_base.LogAppenderConfig>[]>;
+/**
+ * Log service, responsible for getting or creating loggers. It itself acts as a base logger
+ */
+declare class LogService extends Logger {
+    protected name: string;
+    protected level: LogLevel;
+    protected appenders: LogAppender[];
+    /** the list of persistent loggers */
+    protected loggers: {};
+    constructor();
+    /**
+     * 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>;
+}
+
+declare class LogServiceMock extends LoggerMock {
+    getLogger(): LoggerMock;
+}
+
+/**
+ * Log Module
+ */
+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>;
+}
+
+declare class GlobalErrorHandler extends ErrorHandler {
+    protected logService: LogService;
+    handleError(error: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalErrorHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalErrorHandler>;
+}
+
+declare class HttpErrorHandlerInterceptor implements HttpInterceptor {
+    protected config: HttpErrorHandlerConfig;
+    protected injector: Injector;
+    protected router: Router;
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    /**
+     * Search in the configuration for the first matching route
+     *
+     * @param error http error response
+     * @returns HttpErrorRouteConfig or null
+     */
+    protected getRouteConfig(error: HttpErrorResponse): HttpErrorRouteConfig | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpErrorHandlerInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpErrorHandlerInterceptor>;
+}
+
+declare function AlertHttpErrorCallbackFn(error: HttpErrorResponse): void;
+declare function ConsoleHttpErrorCallbackFn(error: HttpErrorResponse): void;
+declare function LogHttpErrorCallbackFn(error: HttpErrorResponse, injector: Injector): void;
+declare function GrowlHttpErrorCallbackFn(error: HttpErrorResponse, injector: Injector): void;
+
+/**
+ * A function that takes an `Action` and a `State`, and returns a `State`.
+ * See `createReducer`.
+ */
+interface ActionReducer<T, V extends Action = Action> {
+    (state: T | undefined, action: V): T;
+}
+type ActionReducerMap<T, V extends Action = Action> = {
+    [p in keyof T]: ActionReducer<T[p], V>;
+};
+interface Action<Type extends string = string> {
+    type: Type;
+}
+
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare enum CoreAppActionTypes {
+    INIT_STORE = "[App] Init store",
+    UPDATE_APP_VERSION = "[App] Update version",
+    UPDATE_APP_CONNECTION = "[App] Update connection",
+    ADD_APP_LOADED_CONFIG_MODULES = "[App] Update app loaded config modules",
+    UPDATE_APP_STATUS = "[App] Update status",
+    UPDATE_CURRENT_MODULE = "[App] Update current module",
+    ACTIVATED_ROUTE = "[App] Activated route",
+    ADD_API_QUEUE_ITEM = "[App] Add API queue item",
+    REMOVE_API_QUEUE_ITEM = "[App] Remove API queue item",
+    EMPTY_API_QUEUE = "[App] empty API queue"
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class InitStoreAction implements Action {
+    payload: {
+        version?: string;
+    };
+    type: CoreAppActionTypes;
+    constructor(payload: {
+        version?: string;
+    });
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class UpdateAppVersionAction implements Action {
+    payload: string;
+    type: CoreAppActionTypes;
+    constructor(payload: string);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class UpdateAppConnectionAction implements Action {
+    payload: boolean;
+    type: CoreAppActionTypes;
+    constructor(payload: boolean);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class AddAppLoadedConfigModulesAction implements Action {
+    payload: {
+        moduleName: string;
+        moduleConfig: ModuleConfig;
+    };
+    type: CoreAppActionTypes;
+    constructor(payload: {
+        moduleName: string;
+        moduleConfig: ModuleConfig;
+    });
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class UpdateAppStatusAction implements Action {
+    payload: string;
+    type: CoreAppActionTypes;
+    constructor(payload: string);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class UpdateCurrentModuleAction implements Action {
+    payload: string;
+    type: CoreAppActionTypes;
+    constructor(payload: string);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class ActivatedRouteAction implements Action {
+    payload: ActivatedRoute;
+    type: CoreAppActionTypes;
+    constructor(payload: ActivatedRoute);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class AddApiQueueItemAction implements Action {
+    payload: {
+        id: string;
+        item: ApiQueueItem;
+    };
+    type: CoreAppActionTypes;
+    constructor(payload: {
+        id: string;
+        item: ApiQueueItem;
+    });
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class RemoveApiQueueItemAction implements Action {
+    payload: string;
+    type: CoreAppActionTypes;
+    constructor(payload: string);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class EmptyApiQueueAction implements Action {
+    payload: any;
+    type: CoreAppActionTypes;
+    constructor(payload: any);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+type CoreAppActions = InitStoreAction | UpdateAppVersionAction | UpdateAppConnectionAction | AddAppLoadedConfigModulesAction | UpdateAppStatusAction | UpdateCurrentModuleAction | ActivatedRouteAction | AddApiQueueItemAction | RemoveApiQueueItemAction;
+
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare enum CoreI18nActionTypes {
+    UPDATE_I18N_STATE = "[I18n] Update I18n State"
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class UpdateI18nStateAction implements Action {
+    payload: I18nState;
+    type: CoreI18nActionTypes;
+    constructor(payload: I18nState);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+type CoreI18nActions = UpdateI18nStateAction;
+
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare enum CoreUserActionTypes {
+    UPDATE_USER_STATE = "[User] Update User state",
+    UPDATE_USER_DETAILS = "[User] Update details",
+    UPDATE_USER_PREFERENCES = "[User] Update preferences",
+    UPDATE_USER_RIGHTS = "[User] Update rights",
+    UPDATE_USER_DASHBOARD = "[User] Update dashboard"
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class UpdateUserStateAction implements Action {
+    payload: UserState;
+    type: CoreUserActionTypes;
+    constructor(payload: UserState);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class UpdateUserDetailsAction implements Action {
+    payload: UserDetails;
+    type: CoreUserActionTypes;
+    constructor(payload: UserDetails);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class UpdateUserPreferencesAction implements Action {
+    payload: UserPreferences;
+    type: CoreUserActionTypes;
+    constructor(payload: UserPreferences);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class UpdateUserRightsAction implements Action {
+    payload: EuiUserRight[];
+    type: CoreUserActionTypes;
+    constructor(payload: EuiUserRight[]);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class UpdateUserDashboardAction implements Action {
+    payload: unknown;
+    type: CoreUserActionTypes;
+    constructor(payload: unknown);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+type CoreUserActions = UpdateUserDetailsAction | UpdateUserPreferencesAction | UpdateUserRightsAction | UpdateUserDashboardAction;
+
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare enum CoreNotificationsActionTypes {
+    UPDATE_NOTIFICATIONS_LIST = "[Notif] Update list"
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class UpdateNotificationsListAction implements Action {
+    payload: any[];
+    type: CoreNotificationsActionTypes;
+    constructor(payload: any[]);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+type CoreNotificationsActions = UpdateNotificationsListAction;
+
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare enum CoreLocaleActionTypes {
+    UPDATE_LOCALE_STATE = "[Locale] Update Locale State"
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare class UpdateLocaleStateAction implements Action {
+    payload: LocaleState;
+    type: CoreLocaleActionTypes;
+    constructor(payload: LocaleState);
+}
+/**
+ * @deprecated it will be removed in the next major version
+ */
+type CoreLocaleActions = UpdateLocaleStateAction;
+
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare const coreAppReducers: (state: AppState, action: Action) => AppState;
+
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare const coreReducers: ActionReducerMap<CoreState, any>;
+
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare const corI18nReducers: (state: I18nState, action: Action) => I18nState;
+
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare const coreUserReducers: (state: UserState, action: Action) => UserState;
+
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare const coreNotificationsReducers: (state: NotificationsState, action: Action) => NotificationsState;
+
+/**
+ * Utility meta-reducer to load the state from the local storage
+ * @param platformId the platformId based on PLATFORM_ID token of Angular
+ * @deprecated it will be removed in the next major version
+ */
+declare function localStorageSync<S extends CoreState>(platformId: unknown): ((reducer: ActionReducer<S>) => (state: S, action: Action) => S);
+/**
+ * Utility meta-reducer to load the state from the local storage
+ * @param reducer the action reducer
+ */
+declare function localStorageSync<S extends CoreState>(reducer: ActionReducer<S>): (state: S, action: Action) => S;
+/**
+ * Utility meta-reducer to load the state from the session storage
+ * @param platformId the platformId based on PLATFORM_ID token of Angular
+ * @deprecated it will be removed in the next major version
+ */
+declare function sessionStorageSync<S extends CoreState>(platformId: unknown): ((reducer: ActionReducer<S>) => (state: S, action: Action) => S);
+/**
+ * Utility meta-reducer to load the state from the session storage
+ * @param reducer the action reducer
+ * @deprecated it will be removed in the next major version
+ */
+declare function sessionStorageSync<S extends CoreState>(reducer: ActionReducer<S>): (state: S, action: Action) => S;
+/**
+ *
+ * @param storage Type of storage to load the state from
+ * @deprecated it will be removed in the next major version
+ */
+declare const loadState: <S extends CoreState>(storage?: Storage | null) => S;
+
+/**
+ * @deprecated it will be removed in the next major version
+ */
+declare const coreLocaleReducers: (state: LocaleState, action: Action) => LocaleState;
+
+declare enum BrowserStorageType {
+    local = 0,
+    session = 1
+}
+type Handler<T> = (state: T[keyof T]) => Partial<T[keyof T]>;
+declare class StoreService<T = any> {
+    protected logService: LogService;
+    private platformId;
+    /**
+     * autoSave handlers to call before saving in local Storage
+     */
+    protected _autoSaveHandlers: {
+        [key: string]: Handler<T>;
+    };
+    /** storage instance e.g. localStorage, sessionStorage */
+    private _storage;
+    private state;
+    private isHandlingAutoSave;
+    constructor();
+    init(version?: string, storageType?: BrowserStorageType): void;
+    /**
+     * Add an autoSave handler for a specific state slice
+     * @param stateSlice
+     * @param handler
+     * @deprecated it will be removed in the next major version
+     */
+    addAutoSaveHandler(stateSlice: string, handler: Handler<T>): void;
+    handleAutoSave(): void;
+    /**
+     * Proxy to NGRX store.dispatch()
+     * that allows to intercept if the store is present
+     *
+     * @deprecated it will be removed in the next version support of NGRX will cease
+     */
+    dispatch(action: unknown): void;
+    /**
+     * This method is used to update the state of the service with a new state.
+     *
+     * @param state
+     */
+    updateState(state: DeepPartial<T>): void;
+    /**
+     * @deprecated it will be removed in next version. Use updateState(partialState: DeepPartial<T>) instead
+     * @param slice
+     * @param reducer
+     */
+    updateState(slice: DeepPartial<T>, reducer: (state: T, action: DeepPartial<T>) => T): void;
+    select(key?: any): Observable<T[any]>;
+    /**
+     * filters and save the state with the Browser storage
+     * @param state type of CoreState
+     */
+    protected saveState(state: CoreState): void;
+    /**
+     * deep merge two objects
+     * @param target the object that will be merged into
+     * @param source the object that will be merged from
+     */
+    private deepMerge;
+    /**
+     * checks if the given item is an object
+     * @param item the item that will be checked
+     */
+    private isObject;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StoreService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StoreService<any>>;
+}
+
+declare const PLATFORM_BROWSER_ID = "browser";
+declare class StoreServiceMock extends StoreService {
+    constructor();
+    init(): void;
+    addAutoSaveHandler(): void;
+    handleAutoSave(): void;
+    dispatch(): void;
+    select(): Observable<object>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StoreServiceMock, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StoreServiceMock>;
+}
+
+/**
+ * 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);
+ * });
+ */
+declare class ApiQueueService {
+    protected store: StoreService<any>;
+    protected http: HttpClient;
+    protected logService: LogService;
+    private readonly logger;
+    private readonly getAppState;
+    private getApiQueue;
+    private getApiQueueItem;
+    constructor();
+    /**
+     * 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, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiQueueService>;
+}
+
+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>;
+}
+
+declare class I18nResourceImpl {
+    protected prefix: string;
+    protected suffix: string;
+    protected compileTranslationsFn: (translations: unknown, lang: string) => unknown;
+    /**
+     * Resource constructor
+     *
+     * @param prefix the prefix of the resource
+     * @param suffix the suffix of the resource, optional parameter
+     * @param compileTranslationsFn compiler function, optional parameter
+     */
+    constructor(prefix: string, suffix?: string, compileTranslationsFn?: (translations: unknown, lang: string) => unknown);
+    /**
+     * Translations pre-processor
+     *
+     * @param translations the object to be pre-processed
+     * @param lang the translations language
+     * @returns the pre-processed translations
+     */
+    compileTranslations(translations: unknown, lang: string): unknown;
+    /**
+     * Indicates whether other object is equal-to this one.
+     *
+     * @param obj the reference object with which to compare
+     * @returns true if this object is the same as obj, false otherwise
+     */
+    equals(obj: I18nResourceImpl): boolean;
+    /**
+     * The path to the resource
+     *
+     * @param lang the resource language
+     * @returns the path
+     */
+    getPath(lang: string): string;
+}
+
+interface ResourceError {
+    isError: boolean;
+    error?: string;
+    resource?: I18nResourceImpl;
+}
+interface LoadedResources {
+    translations: object;
+    hasError: boolean;
+    errors?: Array<LoadedResourcesError>;
+}
+interface LoadedResourcesError {
+    resource: I18nResourceImpl;
+    error: string;
+}
+interface TranslationKeys {
+    [key: string]: string;
+}
+declare class I18nLoader implements TranslateLoader {
+    protected http: HttpClient;
+    protected logService: LogService;
+    protected euiAppConfig: EuiAppConfig;
+    protected resources: I18nResourceImpl[];
+    protected failedResources: Array<LoadedResourcesError>;
+    private logger;
+    constructor();
+    /**
+     * Gets the translations from the server
+     *
+     * @param lang
+     * @returns Observable<object>
+     */
+    getTranslation(lang: string): Observable<object>;
+    /**
+     * Adds resources
+     *
+     * @param config loader configuration
+     * @returns Observable<any> | false
+     */
+    addResources(config: I18nLoaderConfig): I18nResourceImpl[];
+    /**
+     * Removes resources from the loader instance
+     */
+    removeResources(removedResources: I18nResourceImpl[]): void;
+    /**
+     * Loads an array of resources, by language
+     *
+     * @param resources the definition of the resources
+     * @param lang the resource language to load
+     * @returns Observable<any>
+     */
+    loadResources(resources: I18nResourceImpl[], lang: string): Observable<{
+        hasError: boolean;
+        translations: object;
+        errors?: LoadedResourcesError[];
+    }>;
+    /**
+     * Returns resources that failed
+     */
+    getFailedResources(): Array<LoadedResourcesError>;
+    /**
+     * Create resources from a config file
+     *
+     * @param config loader configuration
+     * @returns I18nResourceImpl[] resources
+     */
+    protected createResources(config: I18nLoaderConfig): I18nResourceImpl[];
+    /**
+     * Loads a resource, by language
+     *
+     * @param resource the definition of the resource
+     * @param lang the resource language to load
+     * @returns Observable<any>
+     */
+    protected loadResource(resource: I18nResourceImpl, lang: string): Observable<TranslationKeys | ResourceError>;
+    private getResourceCompileFunction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<I18nLoader, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<I18nLoader>;
+}
+declare const translateConfig: {
+    loader: {
+        provide: typeof TranslateLoader;
+        useClass: typeof I18nLoader;
+    };
+};
+
+interface ModuleLoadEvent {
+    ready: boolean;
+    name: string;
+    error?: any;
+}
+declare class I18nService<T extends I18nState = I18nState> extends EuiLazyService<T | I18nState> implements OnDestroy {
+    protected config: I18nServiceConfig;
+    protected onModuleLoad: BehaviorSubject<ModuleLoadEvent>;
+    protected baseGlobalConfig: GlobalConfig<any>;
+    protected translateService: TranslateService;
+    protected logService: LogService;
+    protected store: StoreService<T>;
+    private static readonly DEFAULT_STATE;
+    private document;
+    /**
+     * a single signal holding the state - initial state is null
+     */
+    private state;
+    /**
+     * a BehaviorSubject holding the state - initial state is null
+     * This is the main source of truth for the state
+     */
+    private stateSubject;
+    private subNotifier;
+    constructor();
+    ngOnDestroy(): void;
+    getState(): Observable<T>;
+    /**
+     * @deprecated this will be removed in a future version
+     * @param mapFn
+     */
+    getState<K = T>(mapFn?: (state: T) => K): Observable<K>;
+    getState<a extends keyof DeepPartial<T>>(key?: a): Observable<DeepPartial<a>>;
+    updateState(state: DeepPartial<T>): void;
+    /**
+     * @deprecated it will be removed in next version. Use updateState(partialState: DeepPartial<T>) instead
+     * @param slice
+     * @param reducer
+     */
+    updateState(slice: DeepPartial<T>, reducer: (state: T, action: DeepPartial<T>) => T): void;
+    /**
+     * This method is used to get the state as readonly signal.
+     */
+    getSignal(): Signal<T>;
+    init(langState?: T): Observable<EuiServiceStatus>;
+    /**
+     * A pipe function that could serve as a wrapper of another observable
+     * e.g. ngx-translate i18n.onReady('my_module').pipe(switchMap(()=>translate.get('eui.KEY')));
+     * WARNING: onReady will emit only once for a loaded Module, going to another and then going back will not result
+     * into another emission.
+     *
+     * @param moduleName the name of the module that has been given through the eUI globalConfig. In case non provided
+     * fetch module name from the state.
+     */
+    onReady(moduleName?: string): Observable<ModuleLoadEvent>;
+    lazyLoad(config: I18nLoaderConfig): Observable<EuiServiceStatus>;
+    lazyLoadInit(moduleConfig: ModuleConfig, moduleName?: string): Observable<EuiServiceStatus>;
+    /**
+     * Add resources based of a config loader
+     *
+     * @param config I18nLoaderConfig
+     * @param moduleName
+     * @return Promise<EuiServiceStatus> an EuiServiceStatus when translation has fully loaded
+     */
+    addResources(config: I18nLoaderConfig, moduleName?: string): Observable<EuiServiceStatus>;
+    /**
+     * Prepares the default language
+     */
+    private preparedDefaultLanguage;
+    /**
+     * @param initLanguage if given default language to override default language coming from the
+     * configuration token.
+     */
+    private setup;
+    private bindActiveLangStateToTranslateService;
+    private bindTranslateServiceLangChangeToState;
+    private setDefaultLanguage;
+    /**
+     * change the currently used language
+     *
+     * @param lang is the language code based on the convention you used e.g. (en or en-EN)
+     * @returns Observable that returns an object contain the object translation for given language after language
+     * fully loaded.
+     */
+    private use;
+    /**
+     * updates the HTML element lang attribute
+     *
+     * @private
+     */
+    private updateHTMLDOMLang;
+    static ɵfac: i0.ɵɵFactoryDeclaration<I18nService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<I18nService<any>>;
+}
+
+/**
+ * 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');
+ * }
+ */
+declare class EuiPermissionService extends EuiService<EuiUserRight[]> {
+    private log;
+    protected store: StoreService<any>;
+    private readonly logger;
+    constructor();
+    /**
+     * 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, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EuiPermissionService>;
+}
+
+declare class EuiDynamicMenuService {
+    menuLinks: Array<EuiMenuItem>;
+    private euiPermission;
+    private store;
+    constructor();
+    getMenuLinks(): EuiMenuItem[];
+    filterEuiMenuItemsWithRights(links: Array<EuiMenuItem>): Array<EuiMenuItem>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EuiDynamicMenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EuiDynamicMenuService>;
+}
+
+declare const DYNAMIC_COMPONENT_CONFIG: InjectionToken<object>;
+declare class EuiDynamicComponentService {
+    private injector;
+    private appRef;
+    private portalHost;
+    private portal;
+    private portalComponentInstance;
+    /**
+     * Adds a component to portal host dynamically
+     * @param component The component to be injected
+     * @param el The element reference for the component to be injected
+     * @param config The data to be passed (config) for the DYNAMIC_COMPONENT_CONFIG token
+     */
+    add<T>(component: ComponentType<T>, el?: ElementRef, config?: any): any;
+    /**
+     * detaches a portalHost
+     * @param portalHostRef reference of portal host to be detached
+     */
+    remove(portalHostRef: DomPortalOutlet): void;
+    /**
+     * creates a custom injector to be used when providing custom injection tokens to components inside a portal
+     * @param data to be used by DYNAMIC_COMPONENT_CONFIG token
+     */
+    private createInjector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EuiDynamicComponentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EuiDynamicComponentService>;
+}
+
+interface UIState<BP = any, DI = any, AMD = any, BPV = any> {
+    appName?: string;
+    appShortName?: string;
+    appSubTitle?: string;
+    appBaseFontSize?: string;
+    isSidebarOpen?: boolean;
+    isSidebarActive?: boolean;
+    hasSidebar?: boolean;
+    hasBreadcrumb?: boolean;
+    hasHeader?: boolean;
+    hasHeaderLogo?: boolean;
+    hasHeaderEnvironment?: boolean;
+    hasToolbar?: boolean;
+    hasToolbarMenu?: boolean;
+    environmentValue?: string;
+    isSidebarHidden?: boolean;
+    hasSidebarCollapsedVariant?: boolean;
+    hasTopMessage?: boolean;
+    windowWidth?: number;
+    windowHeight?: number;
+    mainContentHeight?: number;
+    pageHeaderHeight?: number;
+    breakpoint?: string;
+    wrapperClasses?: string;
+    breakpoints?: BP;
+    breakpointValues?: BPV;
+    menuLinks?: EuiMenuItem[];
+    sidebarLinks?: EuiMenuItem[];
+    combinedLinks?: EuiMenuItem[];
+    isBlockDocumentActive?: boolean;
+    deviceInfo: DI;
+    activeLanguage: string;
+    languages: (string | EuiLanguage)[];
+    appMetadata: AMD;
+    hasModalActive?: boolean;
+    isDimmerActive?: boolean;
+}
+declare class EuiAppShellService {
+    navigationStartCustomHandler: () => void;
+    navigationEndCustomHandler: () => void;
+    protected config: GlobalConfig<any>;
+    private http;
+    private platformId;
+    private document;
+    private router;
+    private storeService;
+    private i18nService;
+    get state$(): Observable<UIState>;
+    get breakpoint$(): Observable<string>;
+    get breakpoints$(): Observable<any>;
+    get state(): UIState;
+    set isSidebarOpen(isOpen: boolean);
+    get isSidebarOpen(): boolean;
+    set isSidebarActive(isActive: boolean);
+    set sidebarLinks(links: EuiMenuItem[]);
+    set hasSidebarCollapsedVariant(isActive: boolean);
+    set menuLinks(links: EuiMenuItem[]);
+    set isBlockDocumentActive(isActive: boolean);
+    get hasHeader(): boolean;
+    get isDimmerActive(): boolean;
+    set isDimmerActive(isActive: boolean);
+    private _state$;
+    private _breakpoint$;
+    private _breakpoints$;
+    constructor();
+    setState(nextState: UIState, updateI18?: boolean): void;
+    /**
+     * Emits a slice from the state whether that changes
+     *
+     * @param key can be 'key' or 'key.sub.sub'
+     */
+    getState<T = any>(key?: string): Observable<T>;
+    sidebarToggle(): void;
+    dimmerActiveToggle(): void;
+    setDimmerActiveState(activeState: boolean): void;
+    fetchAppMetadata(metadataFilePath?: string): void;
+    activateSidebar(): void;
+    activateSidebarHeader(): void;
+    activateSidebarFooter(): void;
+    activateHeader(): void;
+    activateBreadcrumb(): void;
+    activateTopMessage(height: number): void;
+    activateToolbar(): void;
+    activateToolbarMenu(): void;
+    /**
+     * Returns the current value of --eui-f-size-base CSS variable
+     */
+    getBaseFontSize(): string;
+    /**
+     * Updates the current value of --eui-f-size-base CSS variable and the UIState appBaseFontSize
+     */
+    setBaseFontSize(newsize: string): void;
+    private getWrapperClasses;
+    private getBreakpoint;
+    private getBreakpoints;
+    private getJson;
+    private extractData;
+    private handleError;
+    private bindActiveLanguageToAppShellState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EuiAppShellService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EuiAppShellService>;
+}
+
+declare const EUI_COUNTRIES: {
+    AF: string;
+    AX: string;
+    AL: string;
+    DZ: string;
+    AS: string;
+    AD: string;
+    AO: string;
+    AI: string;
+    AQ: string;
+    AG: string;
+    AR: string;
+    AM: string;
+    AW: string;
+    AU: string;
+    AT: string;
+    AZ: string;
+    BS: string;
+    BH: string;
+    BD: string;
+    BB: string;
+    BY: string;
+    BE: string;
+    BZ: string;
+    BJ: string;
+    BM: string;
+    BT: string;
+    BO: string;
+    BA: string;
+    BW: string;
+    BV: string;
+    BR: string;
+    VG: string;
+    IO: string;
+    BN: string;
+    BG: string;
+    BF: string;
+    BI: string;
+    KH: string;
+    CM: string;
+    CA: string;
+    CV: string;
+    KY: string;
+    CF: string;
+    TD: string;
+    CL: string;
+    CN: string;
+    HK: string;
+    MO: string;
+    CX: string;
+    CC: string;
+    CO: string;
+    KM: string;
+    CG: string;
+    CD: string;
+    CK: string;
+    CR: string;
+    CI: string;
+    HR: string;
+    CU: string;
+    CY: string;
+    CZ: string;
+    DK: string;
+    DJ: string;
+    DM: string;
+    DO: string;
+    EC: string;
+    EG: string;
+    SV: string;
+    GQ: string;
+    ER: string;
+    EE: string;
+    ET: string;
+    FK: string;
+    FO: string;
+    FJ: string;
+    FI: string;
+    FR: string;
+    GF: string;
+    PF: string;
+    TF: string;
+    GA: string;
+    GM: string;
+    GE: string;
+    DE: string;
+    GH: string;
+    GI: string;
+    GR: string;
+    GL: string;
+    GD: string;
+    GP: string;
+    GU: string;
+    GT: string;
+    GG: string;
+    GN: string;
+    GW: string;
+    GY: string;
+    HT: string;
+    HM: string;
+    VA: string;
+    HN: string;
+    HU: string;
+    IS: string;
+    IN: string;
+    ID: string;
+    IR: string;
+    IQ: string;
+    IE: string;
+    IM: string;
+    IL: string;
+    IT: string;
+    JM: string;
+    JP: string;
+    JE: string;
+    JO: string;
+    KZ: string;
+    KE: string;
+    KI: string;
+    KP: string;
+    KR: string;
+    KW: string;
+    KG: string;
+    LA: string;
+    LV: string;
+    LB: string;
+    LS: string;
+    LR: string;
+    LY: string;
+    LI: string;
+    LT: string;
+    LU: string;
+    MK: string;
+    MG: string;
+    MW: string;
+    MY: string;
+    MV: string;
+    ML: string;
+    MT: string;
+    MH: string;
+    MQ: string;
+    MR: string;
+    MU: string;
+    YT: string;
+    MX: string;
+    FM: string;
+    MD: string;
+    MC: string;
+    MN: string;
+    ME: string;
+    MS: string;
+    MA: string;
+    MZ: string;
+    MM: string;
+    NA: string;
+    NR: string;
+    NP: string;
+    NL: string;
+    AN: string;
+    NC: string;
+    NZ: string;
+    NI: string;
+    NE: string;
+    NG: string;
+    NU: string;
+    NF: string;
+    MP: string;
+    NO: string;
+    OM: string;
+    PK: string;
+    PW: string;
+    PS: string;
+    PA: string;
+    PG: string;
+    PY: string;
+    PE: string;
+    PH: string;
+    PN: string;
+    PL: string;
+    PT: string;
+    PR: string;
+    QA: string;
+    RE: string;
+    RO: string;
+    RU: string;
+    RW: string;
+    BL: string;
+    SH: string;
+    KN: string;
+    LC: string;
+    MF: string;
+    PM: string;
+    VC: string;
+    WS: string;
+    SM: string;
+    ST: string;
+    SA: string;
+    SN: string;
+    RS: string;
+    SC: string;
+    SL: string;
+    SG: string;
+    SK: string;
+    SI: string;
+    SB: string;
+    SO: string;
+    ZA: string;
+    GS: string;
+    SS: string;
+    ES: string;
+    LK: string;
+    SD: string;
+    SR: string;
+    SJ: string;
+    SZ: string;
+    SE: string;
+    CH: string;
+    SY: string;
+    TW: string;
+    TJ: string;
+    TZ: string;
+    TH: string;
+    TL: string;
+    TG: string;
+    TK: string;
+    TO: string;
+    TT: string;
+    TN: string;
+    TR: string;
+    TM: string;
+    TC: string;
+    TV: string;
+    UG: string;
+    UA: string;
+    AE: string;
+    GB: string;
+    US: string;
+    UM: string;
+    UY: string;
+    UZ: string;
+    VU: string;
+    VE: string;
+    VN: string;
+    VI: string;
+    WF: string;
+    EH: string;
+    YE: string;
+    ZM: string;
+    ZW: string;
+};
+interface EuiTimeZone {
+    name: string;
+    desc: string;
+}
+declare const EUI_TIMEZONES: EuiTimeZone[];
+declare class EuiTimezoneService {
+    /**
+     * Convert country ISO code to country name (in english)
+     */
+    iso2country(iso: string): string;
+    /**
+     * Gets the list of ISO-codes for all countries
+     */
+    getCountries(): string[];
+    getTimezones(): EuiTimeZone[];
+    getTimezone(tz: string): EuiTimeZone;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EuiTimezoneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EuiTimezoneService>;
+}
+
+declare enum EuiTheme {
+    DEFAULT = "default",
+    ECL_EC = "ecl-ec",
+    ECL_EC_RTL = "ecl-ec-rtl",
+    ECL_EU = "ecl-eu",
+    ECL_EU_RTL = "ecl-eu-rtl",
+    EUI_LEGACY = "eui-legacy",
+    EUI_LEGACY_HC = "eui-legacy-high-contrast",
+    DARK = "dark",
+    COMPACT = "compact",
+    DS2025 = "ds2025"
+}
+interface IEuiTheme {
+    name: EuiTheme;
+    isActive: boolean;
+    styleSheet: string;
+    cssClass: string;
+}
+interface ThemeState {
+    themes: IEuiTheme[];
+    theme: any;
+}
+declare class EuiThemeService {
+    private document;
+    protected config: GlobalConfig<any>;
+    private asService;
+    private _state$;
+    constructor();
+    get state$(): Observable<ThemeState>;
+    get state(): ThemeState;
+    isDefault(): boolean;
+    isEclEc(): boolean;
+    isEclEcRtl(): boolean;
+    isEclEu(): boolean;
+    isEclEuRtl(): boolean;
+    isEuiLegacy(): boolean;
+    isEuiLegacyHc(): boolean;
+    isDark(): boolean;
+    isCompact(): boolean;
+    isDs2025(): boolean;
+    setActiveTheme(theme: EuiTheme, isActive: boolean): void;
+    private _renderTheme;
+    private _renderThemeCss;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EuiThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EuiThemeService>;
+}
+
+/**
+ * Generic storage service. Concrete storage services must extend this class
+ */
+declare abstract class StorageService {
+    /**
+     * utility function, to determine the storage implementation
+     */
+    abstract name(): string;
+    /**
+     * retrieve an object from storage
+     * @param key the associated key
+     * @returns the value or undefined, if case of error
+     */
+    abstract get(key: string): any;
+    abstract get<T>(key: string): T;
+    /**
+     * sets an object in storage
+     * @param key the associated key
+     * @param value the value to set
+     */
+    abstract set(key: string, value: any): void;
+    abstract set<T>(key: string, value: T): void;
+    /**
+     * removes an object from storage
+     * @param key the associated key
+     */
+    abstract remove(key: string): void;
+}
+
+declare class StorageServiceMock extends StorageService {
+    name(): string;
+    get(): null;
+    set(): void;
+    remove(): void;
+}
+
+/**
+ * Generic asynchronous storage service. Concrete asynchronous storage services must extend this class
+ */
+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;
+}
+
+declare class AsyncStorageServiceMock extends AsyncStorageService {
+    ready(): Observable<any>;
+    name(): string;
+    get(): Observable<any>;
+    set(): Observable<any>;
+    remove(): Observable<any>;
+    setAsync(): void;
+    removeAsync(): void;
+}
+
+/**
+ * localStorage service
+ */
+declare class LocalStorageService extends StorageService {
+    static NAME: string;
+    protected log: LogService;
+    private platformId;
+    /**
+     * the name of the storage service
+     */
+    name(): string;
+    /**
+     * retrieve an object from local storage
+     * @param key the associated key
+     * @returns the value or undefined, if case of error
+     */
+    get(key: string): any;
+    /**
+     * sets an object in local storage
+     * @param key the associated key
+     * @param value the value to set
+     */
+    set(key: string, value: any): void;
+    /**
+     * removes an object from local storage
+     * @param key the associated key
+     */
+    remove(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageService>;
+}
+
+/**
+ * sessionStorage service
+ */
+declare class SessionStorageService extends StorageService {
+    protected log: LogService;
+    static NAME: string;
+    /**
+     * the name of the storage service
+     */
+    name(): string;
+    /**
+     * retrieve an object from session storage
+     * @param key the associated key
+     * @returns the value or undefined, if case of error
+     */
+    get(key: string): any;
+    /**
+     * sets an object in session storage
+     * @param key the associated key
+     * @param value the value to set
+     */
+    set(key: string, value: any): void;
+    /**
+     * removes an object from session storage
+     * @param key the associated key
+     */
+    remove(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SessionStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SessionStorageService>;
+}
+
+/** @internal */
+declare const localForage: any;
+declare const LOCAL_FORAGE_SERVICE_CONFIG_TOKEN: InjectionToken<any>;
+/**
+ * localforage service, using the localForage javascript library
+ * https://localforage.github.io/localForage
+ */
+declare class LocalForageService extends AsyncStorageService {
+    protected config: any;
+    protected log: LogService;
+    static NAME: string;
+    constructor();
+    /**
+     * the name of the storage service
+     */
+    name(): string;
+    /**
+     * reflects the readiness of the storage
+     * @returns one time emission Observable<void>
+     */
+    ready(): Observable<any>;
+    /**
+     * retrieve an object from localforage
+     * @param key the associated key
+     * @returns one time emission Observable of value
+     */
+    get(key: string): Observable<any>;
+    /**
+     * sets an object in localforage
+     * @param key the associated key
+     * @param value the value to set
+     * @returns one time emission Observable
+     */
+    set(key: string, value: any): Observable<any>;
+    /**
+     * removes an object from localforage
+     * @param key the associated key
+     * @returns one time emission Observable
+     */
+    remove(key: string): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalForageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalForageService>;
+}
+
+type LocaleMapper = (locale: string) => string;
+declare const LOCALE_ID_MAPPER: InjectionToken<LocaleMapper>;
+/**
+ * LocaleService is responsible for managing locale states and configurations in an Angular application.
+ * It utilizes the CLDR library to load and construct the locale for each region. This service allows
+ * for dynamic loading of locales upon request and updates the state of the EUI app accordingly.
+ *
+ * Key functionalities include:
+ *  - Binding to a translation service for locale changes.
+ *  - Updating the Angular LOCALE_ID token.
+ *
+ * @template T - Extends LocaleState, representing the state structure for locales.
+ * @template L - The type of the locale data.
+ * @extends EuiService<T | LocaleState>
+ */
+declare class LocaleService<T extends LocaleState = LocaleState> extends EuiService<T | LocaleState> implements OnDestroy {
+    protected store: StoreService<any>;
+    protected baseGlobalConfig: GlobalConfig<any>;
+    protected locale_id: string;
+    private static readonly DEFAULT_STATE;
+    private localeMapper;
+    private i18n;
+    private log;
+    private readonly logger;
+    private subNotifier;
+    protected config: LocaleServiceConfig;
+    /**
+     * a single signal holding the state - initial state is null
+     */
+    private state;
+    /**
+     * a BehaviorSubject holding the state - initial state is null
+     * This is the main source of truth for the state
+     */
+    private stateSubject;
+    constructor();
+    ngOnDestroy(): void;
+    getState(): Observable<T>;
+    /**
+     * Retrieves the state of the locale service. This method is overloaded to allow different ways of accessing the state.
+     *
+     * @template K - The type of the value to be returned. Defaults to the type of the locale state (T).
+     *
+     * @param {((state: T) => K)} [mapFn] - A function that maps the state to a specific form.
+     *                                      Takes the current state as an argument and returns the transformed state.
+     * @returns {Observable<K>} - An observable that emits the transformed state.
+     */
+    getState<K = T>(mapFn?: (state: T) => K): Observable<K>;
+    /**
+     * @template a - A key that extends the keys of the state type T.
+     * @param {a} [key] - A specific key to access a part of the state.
+     *                    The key should be a property name of the state object.
+     * @returns {Observable<Partial<a>>} - An observable that emits the value of the specified key in the state.
+     * @param key
+     */
+    getState<a extends keyof DeepPartial<T>>(key?: a): Observable<DeepPartial<a>>;
+    /**
+     * Initializes the LocaleService with necessary configurations and state.
+     * Binds language changes to the state and dynamically loads the appropriate locales.
+     *
+     * @param {LocaleState} [state] - Optional initial state for the locale service.
+     * @returns {Observable<EuiServiceStatus>} - Observable emitting the status of the initialization.
+     */
+    init(state?: LocaleState): Observable<EuiServiceStatus>;
+    /**
+     * This method is used to update the state of the service with a new state.
+     *
+     * @param state
+     */
+    updateState(state: DeepPartial<T>): void;
+    /**
+     * This method is used to get the state as readonly signal.
+     */
+    getSignal(): Signal<T>;
+    /**
+     * Retrieves the previous locale used in the application.
+     *
+     * @returns {string} - The previous locale identifier.
+     */
+    get previousLocale(): string;
+    /**
+     * Retrieves the current locale used in the application.
+     *
+     * @returns {string} - The current locale identifier.
+     */
+    get currentLocale(): string;
+    /**
+     * Listens for language changes and dynamically sets the locale accordingly.
+     *
+     * @private
+     */
+    private bindTranslateServiceLangChangeToState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocaleService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocaleService<any>>;
+}
+
+declare class LocaleServiceMock<T extends LocaleState = LocaleState> extends LocaleService<T> {
+    protected locale_id: string;
+    private DEFAULT_LOCALE;
+    private stateSub;
+    constructor();
+    getState(): Observable<T>;
+    updateState(state: T): void;
+    init(state?: T): Observable<EuiServiceStatus>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocaleServiceMock<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocaleServiceMock<any>>;
+}
+
+/**
+ * The status of a library
+ * @enum Status
+ * @property {string} LOADING - the library is loading
+ * @property {string} LOADED - the library is loaded
+ * @property {string} ERROR - the library failed to load
+ */
+declare enum Status {
+    LOADING = "loading",
+    LOADED = "loaded",
+    ERROR = "error"
+}
+/**
+ * A library is a set of script and style dependencies
+ * that can be loaded dynamically
+ * @interface Library
+ * @property {string} name - global variable object name that the script will give to the library
+ * @property {Dependency[]} dependencies - a set of script and style dependencies
+ * @property {Status} status - the status of the library e.g. LOADED
+ * @example
+ *
+ * const library: Library = {
+ *    name: 'Quill',
+ *    dependencies: [
+ *    {
+ *      name: 'quill',
+ *      url: 'https://cdn.quilljs.com/1.3.6/quill.js',
+ *      type: 'js',
+ *      requires: [],
+ *      loaded: false,
+ *      error: false,
+ *    },
+ *    {
+ *      name: 'quill',
+ *      url: 'https://cdn.quilljs.com/1.3.6/quill.snow.css',
+ *      type: 'css',
+ *      requires: [],
+ *      loaded: false,
+ *      error: false,
+ *     },
+ *     ],
+ *     status: Status.LOADING,
+ * };
+ */
+interface Library {
+    /** global variable object name that the script will give to the library */
+    name: string;
+    /** a set of script and style dependencies */
+    dependencies: Dependency[];
+    /** the status of the library e.g. LOADED */
+    status: Status;
+}
+/**
+ * A dependency is a script or style that can be loaded dynamically
+ */
+interface Dependency {
+    /** an identifier for the dependency */
+    name: string;
+    /**
+     * the url of the dependency
+     * @example
+     * https://cdn.quilljs.com/1.3.6/quill.js
+     */
+    url: string;
+    /** the type of the dependency. Is it a style or script? */
+    type: 'js' | 'css';
+    /**
+     * an array of dependencies corresponds to the Dependency.name
+     * that must be loaded before this dependency
+     * @example
+     * ['quill-better-table']
+     * where 'quill-better-table' is the name of the dependency
+     * const betterTable: Dependency = {
+     *   name: 'quill-better-table',
+     *   url: 'https://cdn.quilljs.com/1.3.6/quill.js',
+     *   type: 'js',
+     *   requires: ['quill-better-table'],
+     * }
+     */
+    requires: string[];
+    /** the status of the dependency */
+    status?: Status;
+    /** the number of times the dependency has been loaded */
+    retries?: number;
+}
+/**
+ * Configuration for different policies
+ */
+interface Policy {
+    /** Maximum number of retry attempts */
+    maxAttempts: number;
+    /** Time between retries in milliseconds */
+    retryInterval: number;
+    /** Time in milliseconds before considering a load attempt as failed */
+    timeout: number;
+}
+
+/**
+ *  A service for loading external dependencies dynamically to the DOM and keeping track of their status. Dependencies
+ *  can be loaded in any order and can have prerequisites. The service will load the prerequisites first and then load
+ *  the dependency. If a dependency fails to load, the service will retry loading it according to the retry policy.
+ *  The service will emit the status of the dependency when it changes. This is useful for showing a loading indicator
+ *  while the dependency is loading. In scenarios where the dependency is not required for the application to function,
+ *  the service will not block the application from loading if the dependency fails to load. The service will also
+ *  remove the dependency from the DOM if it is removed from the list. This is useful for scenarios where the dependency
+ *  is only required for a specific component, might be removed from the list when the component is destroyed, and it
+ *  will not affect the bundle size.
+ *
+ *  @example
+ *  // Add a dependency
+ *  loader.addDependency('Quill', 'https://cdn.quilljs.com/1.3.6/quill.js', 'js');
+ *  // Get the status of a dependency
+ *  loader.getDependencyStatus('Quill');
+ *  // Listen for status changes
+ *  loader.statusChanges('Quill').subscribe((status: Status) => {
+ *    console.log(status);
+ *  });
+ *  // Remove a dependency
+ *  loader.removeDependency('Quill');
+ *  // Set the retry policy
+ *  loader.setRetryPolicy(3, 1000);
+ *  // Set the timeout policy
+ *  loader.setTimeoutPolicy(5000);
+ *  // Load a dependency with prerequisites
+ *  loader.addDependency('Quill', 'https://cdn.quilljs.com/1.3.6/quill.js', 'js', ['QuillStyle']);
+ *  loader.addDependency('QuillStyle', 'https://cdn.quilljs.com/1.3.6/quill.snow.css', 'css');
+ *  // Load a dependency with prerequisites and retry logic
+ *  loader.setRetryPolicy(3, 1000);
+ *  loader.setTimeoutPolicy(5000);
+ *  loader.addDependency('Quill', 'https://cdn.quilljs.com/1.3.6/quill.js', 'js', ['QuillStyle']);
+ *  loader.addDependency('QuillStyle', 'https://cdn.quilljs.com/1.3.6/quill.snow.css', 'css');
+ */
+declare class EuiLoaderService {
+    /**
+     * Stores the status and details of each dependency
+     */
+    private dependencies;
+    /** Observable that emits the name of the dependency when its status changes */
+    private onStatusChange;
+    /**
+     * Configuration for policies such as Retry and timeout for failed loads
+     */
+    private policy;
+    /**
+     * Add a dependency with its type (JS or CSS) and dependencies
+     *
+     * @param name The name of the dependency
+     * @param url The URL of the dependency
+     * @param type The type of the dependency (JS or CSS)
+     * @param requires The dependencies that must be loaded before this one (optional)
+     */
+    addDependency(name: string, url: string, type: 'js' | 'css', requires?: string[]): void;
+    /**
+     * Remove a dependency from the DOM
+     *
+     * @param name The name of the dependency
+     */
+    removeDependency(name: string): void;
+    /**
+     * Allow users to configure the retry policy
+     *
+     * @param maxAttempts The maximum number of retry attempts
+     * @param retryInterval The time between retries in milliseconds
+     */
+    setRetryPolicy(maxAttempts: number, retryInterval: number): void;
+    /**
+     * Allow users to configure the timeout policy
+     *
+     * @param time The time in milliseconds before considering a load attempt as failed
+     * @see setRetryPolicy
+     * @see statusChanges
+     */
+    setTimeoutPolicy(time: number): void;
+    /**
+     * Get the status of a dependency
+     *
+     * @param name The name of the dependency
+     * @returns The status of the dependency
+     * @deprecated Prefer using statusChanges instead
+     * @see statusChanges
+     */
+    getDependencyStatus(name: string): Status | null;
+    /**
+     * Get the status of a dependency as an observable
+     *
+     * @param name The name of the dependency
+     */
+    statusChanges(name: string): Observable<Status>;
+    /**
+     * Load a dependency and its prerequisites
+     *
+     * @param name The name of the dependency
+     * @see loadDependency
+     */
+    private loadDependency;
+    /**
+     * Load a JS script and append it to the root of the DOM
+     * @param dependency
+     */
+    private loadScript;
+    /**
+     * Load a CSS style and append it to the head of the document
+     * @param dependency
+     */
+    private loadStyle;
+    /**
+     * Error handling for a failed load
+     * @param name
+     * @param error
+     */
+    private handleError;
+    /**
+     * Get the script element from the DOM
+     *
+     * @param url
+     * @private
+     */
+    private getScript;
+    /**
+     * Get the style element from the DOM
+     *
+     * @param url
+     * @private
+     */
+    private getStyle;
+    /**
+     * Reload a dependency which can be either a script or a style. First remove
+     * the element from the DOM and then load it again.
+     *
+     * @param dependency
+     * @private
+     */
+    private reloadDependency;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EuiLoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EuiLoaderService>;
+}
+
+declare class UserService<T extends UserState = UserState> extends EuiService<T | UserState> {
+    protected store: StoreService<any>;
+    private static readonly DEFAULT_STATE;
+    /**
+     * a single signal holding the state - initial state is null
+     */
+    private state;
+    /**
+     * a BehaviorSubject holding the state - initial state is null
+     * This is the main source of truth for the state
+     */
+    private stateSubject;
+    constructor();
+    init(state: T): Observable<EuiServiceStatus>;
+    getState(): Observable<T>;
+    /**
+     * @deprecated this will be removed in a future version
+     * @param mapFn
+     */
+    getState<K = T>(mapFn?: (state: T) => K): Observable<K>;
+    getState<a extends keyof DeepPartial<T>>(key?: a): Observable<DeepPartial<a>>;
+    /**
+     * This method is used to update the state of the service with a new state.
+     *
+     * @param state
+     */
+    updateState(state: DeepPartial<T>): void;
+    /**
+     * @deprecated it will be removed in next version. Use updateState(partialState: DeepPartial<T>) instead
+     * @param slice
+     * @param reducer
+     */
+    updateState(slice: DeepPartial<T>, reducer: (state: T, action: DeepPartial<T>) => T): void;
+    /**
+     * This method is used to get the signal of the service.
+     */
+    getSignal(): Signal<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserService<any>>;
+}
+
+declare class UserServiceMock<T> extends UserService {
+    constructor();
+    init(userState: UserState): Observable<EuiServiceStatus>;
+    getState<K = T>(mapFn?: (state: T) => K): Observable<K>;
+    getState<a extends keyof T>(key?: a): Observable<T[a]>;
+    updateState(userState: UserState): void;
+    updateState<a extends keyof T>(slice: T[a], reducer: (state: any, action: T[a]) => any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserServiceMock<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserServiceMock<any>>;
+}
+
+declare class EuiGrowlService {
+    growlMessages: any[];
+    isGrowlSticky: boolean;
+    isCloseAllSticky: boolean;
+    growlLife: number;
+    growlPosition: string;
+    growlCallback: any;
+    ariaGrowlLive: 'off' | 'polite' | 'assertive';
+    /**
+     * displays a growl UxMessage item, isSticky
+     */
+    growl(msg: EuiGrowlMessage, isSticky?: boolean, isMultiple?: boolean, life?: number, position?: string, callback?: () => void, ariaLive?: 'off' | 'polite' | 'assertive'): void;
+    clearGrowl(): void;
+    growlSuccess(msg: string, position?: string): void;
+    growlError(msg: string, position?: string): void;
+    growlWarning(msg: string, position?: string): void;
+    growlInfo(msg: string, position?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EuiGrowlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EuiGrowlService>;
+}
+
+declare const LANG_PARAM_KEY = "X-Lang-Param";
+/**
+ * Interceptor for adding the current language as parameter
+ * Add the header (LANG_PARAM_KEY, <language parameter>) to your request http headers
+ */
+declare class AddLangParamInterceptor implements HttpInterceptor {
+    protected translateService: TranslateService;
+    intercept<T>(req: HttpRequest<T>, next: HttpHandler): Observable<HttpEvent<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AddLangParamInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AddLangParamInterceptor>;
+}
+
+declare class CachePreventionInterceptor implements HttpInterceptor {
+    intercept<T>(req: HttpRequest<T>, next: HttpHandler): Observable<HttpEvent<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CachePreventionInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CachePreventionInterceptor>;
+}
+
+declare class CorsSecurityInterceptor implements HttpInterceptor {
+    intercept<T>(request: HttpRequest<T>, next: HttpHandler): Observable<HttpEvent<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CorsSecurityInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CorsSecurityInterceptor>;
+}
+
+declare class CsrfPreventionInterceptor implements HttpInterceptor {
+    intercept<T>(request: HttpRequest<T>, next: HttpHandler): Observable<HttpEvent<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CsrfPreventionInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CsrfPreventionInterceptor>;
+}
+
+interface body {
+    success: boolean;
+    status: string;
+    code: number;
+    message: string;
+}
+declare class EuLoginSessionTimeoutHandlingInterceptor implements HttpInterceptor {
+    intercept<T extends body>(request: HttpRequest<T>, next: HttpHandler): Observable<HttpEvent<T>>;
+    protected checkRequestSuccessForEULoginSessionTimeout<T extends body, E>(request: HttpRequest<T>, event: HttpEvent<E>): void;
+    protected checkRequestErrorForEULoginSessionTimeout<T = unknown>(request: HttpRequest<T>, response: HttpResponseBase): void;
+    protected isSsoResponse(body: string | body): boolean;
+    protected reauthenticate(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EuLoginSessionTimeoutHandlingInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EuLoginSessionTimeoutHandlingInterceptor>;
+}
+
+declare const UX_ERROR_MAPPING_HANDLER_TOKEN: InjectionToken<ErrorMappingHandler>;
+declare class UxRequestErrorModelInterceptor implements HttpInterceptor {
+    private errorMappingHandler;
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UxRequestErrorModelInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UxRequestErrorModelInterceptor>;
+}
+
+declare const diffDays: (dateStart: Date, dateEnd: Date) => number;
+declare const diffDaysFromToday: (date: Date) => number;
+
+/**
+ * Provides read-only equivalent of jQuery's position function:
+ * http://api.jquery.com/position/
+ */
+declare const position: (nativeEl: HTMLElement) => {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+};
+/**
+ * Provides read-only equivalent of jQuery's offset function:
+ * http://api.jquery.com/offset/
+ */
+declare const offset: (nativeEl: HTMLElement) => {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+};
+/**
+ * returns the closest, non-statically positioned parentOffset of a given element
+ * @param nativeEl
+ */
+declare const parentOffsetEl: (nativeEl: HTMLElement) => Element | Document;
+declare const getViewElement: <F>(fixture: ComponentFixture<F>, componentClass: string, klass?: string) => {
+    de: DebugElement;
+    el: HTMLElement;
+    domElement: HTMLElement;
+};
+declare const closestMatchingParent: (target: HTMLElement, className: string) => HTMLElement | null;
+
+declare const consumeEvent: (event: Event) => boolean;
+
+declare const markFormGroupTouched: (FormControls: {
+    [key: string]: AbstractControl;
+} | AbstractControl[]) => void;
+declare const markControlsTouched: (group: FormGroup | FormArray) => void;
+declare const validateEmail: (c: FormControl) => {
+    validateEmail: {
+        valid: boolean;
+    };
+};
+
+/**
+ * returns a random string with radix=36
+ */
+declare const uniqueId: () => string;
+/**
+ * Its job is to parse number and format it based on given input.
+ * @param value can be a number or a string number
+ * @param fractionSize size of fraction of a number e.g. 1000.88 fraction is 2 (88)  default is 2
+ * @param inDecimalSeparator separator for decimal part of the number default is ','
+ * @param inThousandSeparator separator for the whole part of the number default is ''
+ */
+declare const formatNumber: (value: number | string, fractionSize?: number, inDecimalSeparator?: string, inThousandSeparator?: string) => string;
+
+/**
+ * @deprecated it will be removed in the future. Consult the angular documentation for a replacement.
+ * @param error
+ */
+declare const handleError: (error: HttpErrorResponse) => Observable<never>;
+
+/**
+ * check if a value is null or undefined. If it's not both returns true otherwise false
+ *
+ * @param value
+ */
+declare const isDefined: <T>(value: T | undefined | null) => value is T;
+
+declare abstract class CssUtils {
+    static readonly setHtmlClass: (inputClass: string, document: Document) => void;
+    /**
+     * Get the value of a CSS variable. Using getComputedStyle to get the value of the CSS variable (Browser Specific API)
+     * @param inputProperty
+     * @param document
+     * @param platform
+     */
+    static readonly getCssVarValue: (inputProperty: string, document: Document, platform: unknown) => string;
+    static readonly setCssVarValue: (propertyName: string, propertyValue: string, document: Document) => void;
+    static readonly setCssVar: (inputProperty: string, outputProperty: string, document: Document, platform: unknown) => void;
+    static readonly initCssVars: (document: Document, platform: unknown) => void;
+    static readonly getBreakpointValues: (document: Document, platform: unknown) => any;
+    static readonly activateEditModeCssVars: (isActive: boolean, document: Document) => void;
+    static readonly activateHeaderCssVars: (document: Document, platform: unknown) => void;
+    static readonly activateBreadcrumbCssVars: (document: Document, platform: unknown) => void;
+    static readonly activateTopMessageCssVars: (height: number, document: Document) => void;
+    static readonly activateToolbarCssVars: (document: Document, platform: unknown) => void;
+    static readonly activateFooterCssVars: (document: Document, platform: unknown) => void;
+    static readonly setHeaderShrinkCssVar: (active: boolean, document: Document, platform: unknown) => void;
+    static readonly activateSidebarCssVars: (document: Document, platform: unknown, hasSidebarCollapsedVariant?: boolean) => void;
+    static readonly removeSidebarCssVars: (document: Document) => void;
+    static readonly activateSidebarHeaderCssVars: (document: Document, platform: unknown) => void;
+    static readonly activateSidebarFooterCssVars: (document: Document, platform: unknown) => void;
+    /**
+     * Gets the viewport height and width and multiply it by 1% to get a value for a vh/vw unit
+     * Sets the value in the --eui-app-vh custom property to the root of the document
+     * Sets the value in the --eui-app-vw custom property to the root of the document
+     * Example for 100% height: calc(var(--eui-app-vh, 1vh) * 100);
+     * Example for 50% height: calc(var(--eui-app-vh, 1vh) * 50);
+     * Example for 50% width: calc(var(--eui-app-vw, 1vw) * 50);
+     */
+    static setAppViewportCssVars(platform: unknown): void;
+}
+
+/**
+ * Safely resolves a service from the injector only when needed.
+ * Avoids instantiation errors that can occur with `inject(..., { optional: true })`.
+ *
+ * @param token The service token to inject
+ * @param injector The injector to use (defaults to the current injector)
+ * @returns The service instance or null if unavailable
+ */
+declare function injectOptional<T>(token: Type<T> | InjectionToken<T>, injector?: Injector): T | null;
+
+export { ActivatedRouteAction, AddApiQueueItemAction, AddAppLoadedConfigModulesAction, AddLangParamInterceptor, AlertHttpErrorCallbackFn, ApiQueueService, ApiQueueServiceMock, AsyncStorageService, AsyncStorageServiceMock, BASE_LOGGER_NAME_TOKEN, BASE_NAME_TOKEN, BrowserStorageType, CONFIG_TOKEN, CORE_ROOT_GUARD, CachePreventionInterceptor, ConsoleHttpErrorCallbackFn, CoreAppActionTypes, CoreI18nActionTypes, CoreLocaleActionTypes, CoreModule, CoreNotificationsActionTypes, CoreUserActionTypes, CorsSecurityInterceptor, CsrfPreventionInterceptor, CssUtils, DYNAMIC_COMPONENT_CONFIG, EUI_CONFIG_TOKEN, EUI_COUNTRIES, EUI_TIMEZONES, EmptyApiQueueAction, ErrorSubClass, EuLoginSessionTimeoutHandlingInterceptor, EuiAppShellService, EuiCoreRootGuardClass, EuiDynamicComponentService, EuiDynamicMenuService, EuiError, EuiGrowlService, EuiLoaderService, EuiPermissionService, EuiTheme, EuiThemeService, EuiTimezoneService, GLOBAL_CONFIG_TOKEN, GlobalErrorHandler, GrowlHttpErrorCallbackFn, HTTP_ERROR_HANDLER_CONFIG_TOKEN, HttpErrorHandlerInterceptor, I18nLoader, I18nResourceImpl, I18nService, InitStoreAction, LANG_PARAM_KEY, LOCALE_ID_MAPPER, LOCAL_FORAGE_SERVICE_CONFIG_TOKEN, LOG_APPENDERS_TOKEN, LOG_LEVEL_TOKEN, LocalForageService, LocalStorageService, LocaleService, LocaleServiceMock, LogHttpErrorCallbackFn, LogModule, LogService, LogServiceMock, MODULE_CONFIG_TOKEN, MODULE_NAME_TOKEN, PLATFORM_BROWSER_ID, ROOT_LOG_CONFIG_TOKEN, RemoveApiQueueItemAction, SHOW_CONNECTION_STATUS_TOKEN, SessionStorageService, Status, StorageService, StorageServiceMock, StoreService, StoreServiceMock, UX_ERROR_MAPPING_HANDLER_TOKEN, UpdateAppConnectionAction, UpdateAppStatusAction, UpdateAppVersionAction, UpdateCurrentModuleAction, UpdateI18nStateAction, UpdateLocaleStateAction, UpdateNotificationsListAction, UpdateUserDashboardAction, UpdateUserDetailsAction, UpdateUserPreferencesAction, UpdateUserRightsAction, UpdateUserStateAction, UserService, UserServiceMock, UxRequestErrorModelInterceptor, closestMatchingParent, consumeEvent, corI18nReducers, coreAppReducers, coreLocaleReducers, coreNotificationsReducers, coreUserReducers, createEuiCoreRootGuard, diffDays, diffDaysFromToday, errorCodes, euiCoreRootGuardClass, euiInitApp, formatNumber, getGlobalConfig, getHttpErrorHandlingConfig, getModuleConfig, getRootLogConfig, getShowConnectionStatus, getViewElement, handleError, injectOptional, isDefined, loadEuiDynamicEnvironmentConfig, loadState, localForage, localStorageSync, markControlsTouched, markFormGroupTouched, mergeAppHandlerConfigToAppConfig, mergeAppJsonConfigToAppConfig, offset, parentOffsetEl, position, preInitApp, prepareEuiAppConfigToken, provideEuiInitializer, coreReducers as reducers, sessionStorageSync, translateConfig, uniqueId, validateEmail };
+export type { CoreAppActions, CoreI18nActions, CoreLocaleActions, CoreNotificationsActions, CoreUserActions, Dependency, EuiTimeZone, Handler, Library, LoadedResources, LoadedResourcesError, LocaleMapper, ModuleLoadEvent, Policy, ThemeState, TranslationKeys, UIState };
+//# sourceMappingURL=index.d.ts.map