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';
import * as i0 from '@angular/core';
import { InjectionToken, ModuleWithProviders, EnvironmentProviders, Provider, ErrorHandler, Injector, 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 { TranslationObject, 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;

declare function getCoreProviders(): Provider[];
declare function getDependencyProviders(): Provider[];
declare function getCoreChildProviders(moduleName: string): Provider[];

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;
    /**
     * 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;
    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: TranslationObject;
    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<TranslationObject>;
    /**
     * 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: TranslationObject;
        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;
    hasSideContainer?: boolean;
    hasBreadcrumb?: boolean;
    hasHeader?: boolean;
    hasHeaderLogo?: boolean;
    hasHeaderEnvironment?: boolean;
    hasToolbar?: boolean;
    hasToolbarMegaMenu?: boolean;
    hasToolbarMenu?: boolean;
    environmentValue?: string;
    isSidebarHidden?: boolean;
    isSidebarFocused?: 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;
    activateSideContainer(): void;
    deactivateSideContainer(): void;
    activateSidebarHeader(): void;
    activateSidebarFooter(): void;
    activateHeader(): void;
    activateBreadcrumb(): void;
    activateTopMessage(height: number): void;
    activateToolbar(): void;
    activateToolbarMegaMenu(): 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;
    /**
     * Checks if a given locale string is valid according to the Intl.Locale API. (based on BCP 47)
     * A valid locale string can be used to create a new Intl.Locale object without throwing an error.
     *
     * @param localeString - The locale string to be validated.
     * @returns {boolean} - Returns true if the locale string is valid, false otherwise.
     */
    private isValidLocale;
    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>>;
}

/**
 * @description
 * Centralized service for managing application-wide `eui-growl` notifications.
 * Provides methods to display success, error, warning, and info messages with configurable behavior.
 * Manages message lifecycle, positioning, and accessibility settings through reactive BehaviorSubjects.
 * Supports both temporary auto-dismissing messages and persistent sticky notifications.
 * Injected at root level, ensuring a single instance across the entire application.
 */
declare class EuiGrowlService {
    readonly growlMessages: BehaviorSubject<EuiGrowlMessage[]>;
    readonly isGrowlSticky: BehaviorSubject<boolean>;
    readonly isCloseAllSticky: BehaviorSubject<boolean>;
    readonly growlLife: BehaviorSubject<number>;
    readonly growlPosition: BehaviorSubject<string>;
    readonly growlCallback: BehaviorSubject<() => void>;
    readonly ariaGrowlLive: BehaviorSubject<"off" | "polite" | "assertive">;
    /**
     * Displays a growl notification message with customizable behavior and appearance.
     * Validates message severity and manages message lifecycle through reactive streams.
     * Danger severity messages default to sticky behavior unless explicitly configured.
     *
     * @param msg - Message object containing severity, summary, and detail properties
     * @param isSticky - When true, message persists until manually dismissed; defaults to false except for danger messages
     * @param isMultiple - When true, appends message to existing queue; when false, clears previous messages
     * @param life - Duration in milliseconds before auto-dismissal; defaults to 3000ms
     * @param position - Screen position for message display (e.g., 'bottom-right', 'top-center')
     * @param callback - Optional function executed when message is clicked
     * @param ariaLive - ARIA live region politeness level for screen reader announcements
     * @throws Error if message severity is not one of: 'info', 'warning', 'success', 'danger'
     */
    growl(msg: EuiGrowlMessage, isSticky?: boolean, isMultiple?: boolean, life?: number, position?: string, callback?: () => void, ariaLive?: 'off' | 'polite' | 'assertive'): void;
    /**
     * Removes all currently displayed growl messages from the notification queue.
     * Clears both sticky and temporary messages immediately.
     */
    clearGrowl(): void;
    /**
     * Displays a success growl notification with predefined styling and behavior.
     * Message is non-sticky and auto-dismisses after the default duration.
     *
     * @param msg - Detail text to display in the notification
     * @param position - Optional screen position override; defaults to service-configured position
     */
    growlSuccess(msg: string, position?: string): void;
    /**
     * Displays an error growl notification with predefined styling and behavior.
     * Message is non-sticky but can be configured to persist based on severity handling.
     *
     * @param msg - Detail text to display in the notification
     * @param position - Optional screen position override; defaults to service-configured position
     */
    growlError(msg: string, position?: string): void;
    /**
     * Displays a warning growl notification with predefined styling and behavior.
     * Message is non-sticky and auto-dismisses after the default duration.
     *
     * @param msg - Detail text to display in the notification
     * @param position - Optional screen position override; defaults to service-configured position
     */
    growlWarning(msg: string, position?: string): void;
    /**
     * Displays an informational growl notification with predefined styling and behavior.
     * Message is non-sticky and auto-dismisses after the default duration.
     *
     * @param msg - Detail text to display in the notification
     * @param position - Optional screen position override; defaults to service-configured position
     */
    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 activateToolbarMegaMenuCssVars: (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 activateSideContainerCssVars: (document: Document, platform: unknown) => void;
    static readonly deactivateSideContainerCssVars: (document: Document, platform: unknown) => void;
    static readonly setSideContainerWidth: (width: number, document: Document) => 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, formatNumber, getCoreChildProviders, getCoreProviders, getDependencyProviders, 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=eui-core.d.ts.map
