@o3r/core 14.1.0-prerelease.4 → 14.1.0-prerelease.41

package/index.d.ts

@@ -1,954 +0,0 @@
-import { InputSignal, Signal, EventEmitter } from '@angular/core';
-import { Observable, OperatorFunction } from 'rxjs';
-import { FormControl } from '@angular/forms';
-import * as _ngrx_entity from '@ngrx/entity';
-import { EntityAdapter, EntityState } from '@ngrx/entity';
-import { Action } from '@ngrx/store';
-
-/**
- * Library build time properties
- */
-interface BuildTimeProperties {
-    /**
-     * True if the application in launch in debug mode
-     */
-    DEBUG_MODE: boolean;
-    /**
-     * True if the webStorage option is enabled
-     */
-    ENABLE_WEBSTORAGE: boolean;
-    /**
-     * Name of the current environment
-     */
-    ENVIRONMENT: string;
-    /**
-     * Boolean that can be used to activate API calls mocks for development or mock-up purpose.
-     */
-    USE_MOCKS: boolean;
-    /**
-     * Maximum size of the dev tool history
-     */
-    DEVTOOL_HISTORY_SIZE: number | undefined;
-    /**
-     * path to bundles in published folder
-     */
-    LOCALIZATION_BUNDLES_OUTPUT: string;
-    /**
-     * The name of the bundle generated with the default localization components keys
-     */
-    DEFAULT_LOC_BUNDLE_NAME: string;
-    /**
-     * Indicates the default server prefix to be used in case no dynamic is found
-     */
-    APP_BASE_HREF: string | undefined;
-    /**
-     * Version of the App based on the package.json
-     */
-    APP_VERSION: string;
-    /**
-     * Determine if the ghosting is activated on the app
-     */
-    ENABLE_GHOSTING: boolean;
-}
-/**
- * Library build time default properties
- */
-declare const DEFAULT_BUILD_PROPERTIES: Readonly<BuildTimeProperties>;
-
-interface BootstrapConfig {
-    /**
-     * App environment
-     *
-     */
-    environment: 'prod' | 'dev';
-}
-/** Data set injected to the page from the DGP web-server */
-interface Dataset {
-    /**
-     * Bootstrap configuration
-     * @example
-     * ```typescript
-     * '{ environment: 'prod' }'
-     * ```
-     */
-    bootstrapconfig?: string;
-    /**
-     * Dynamic content path
-     * @example
-     * ```typescript
-     * 'my/dynamic/path'
-     * ```
-     */
-    dynamiccontentpath?: string;
-    /**
-     * Application basehref url
-     * @example
-     * ```typescript
-     * '/my/base/href'
-     * ```
-     */
-    appbasehref?: string;
-}
-
-/**
- * Types available for configuration
- */
-type ConfigurationValueType = string | number | boolean;
-/**
- * Nested configuration allowing one level only
- * Object should only contain primitive types
- */
-interface NestedConfiguration {
-    [key: string]: ConfigurationValueType;
-}
-/**
- * Interface of configuration that is supported by the cms
- */
-interface Configuration {
-    [key: string]: ConfigurationValueType | (string | NestedConfiguration)[];
-}
-/** Configuration model exported by the CMS */
-interface CustomConfig<T extends Partial<Configuration> = Partial<Configuration>> {
-    /** Component name */
-    name: string;
-    /** Component's library name; No library name for global config */
-    library?: string;
-    /** Component configuration as key value pairs */
-    config: T;
-}
-/**
- * Dynamically Configurable item
- */
-interface DynamicConfigurable<T extends Configuration> {
-    /**
-     * Configuration override by Angular input mechanism
-     */
-    config: Partial<T> | undefined;
-    /**
-     * Configuration stream based on the input and the stored configuration
-     */
-    config$: Observable<T>;
-}
-/**
- * Dynamically Configurable item working with signal
- */
-interface DynamicConfigurableWithSignal<T extends Configuration> {
-    /**
-     * Configuration override by Angular input mechanism
-     */
-    config: InputSignal<Partial<T> | undefined>;
-    /**
-     * Configuration signal based on the input and the stored configuration
-     */
-    configSignal: Signal<T>;
-}
-/**
- * Configurable item
- */
-interface Configurable<T extends {}> {
-    /**
-     * Configuration
-     */
-    config: T;
-}
-/**
- * Description of a configuration property extracted to the CMS
- */
-interface CategoryDescription {
-    /** Category name */
-    name: string;
-    /** Category description */
-    label: string;
-}
-/** Types of components config */
-type ConfigType = 'Block' | 'Page' | 'AppRuntimeConfiguration' | 'AppBuildConfiguration' | 'ExposedComponent';
-/**
- * Interface to define widget parameter to be used on CMS side
- */
-interface ConfigPropertyWidgetParameters {
-    [parameterName: string]: string | boolean | number | string[] | boolean[] | number[];
-}
-/**
- * Interface to define the widget to be used on CMS side
- */
-interface ConfigPropertyWidget {
-    /** Type of the CMS widget */
-    type: string;
-    /** Parameters provided to the CMS widget */
-    parameters?: ConfigPropertyWidgetParameters;
-}
-
-/**
- * Application config
- * Application config should implement this to be identified by CMS extractor as a 'runtime' config
- */
-interface AppRuntimeConfiguration extends Configuration {
-}
-/**
- * Application config
- * Application config should implement this to be identified by CMS extractor as a 'build time' config
- */
-interface AppBuildConfiguration extends Configuration {
-}
-
-/**
- * Type expert to extend only public fields of a class
- */
-type InterfaceOf<T> = {
-    [P in keyof T]: T[P];
-};
-
-/**
- * Interface used to define an object of two elements: label & value
- */
-interface LabelValue<T> {
-    label: string;
-    value: T;
-}
-
-/** Interface extending Window with Otter Devtools accessor */
-interface WindowWithDevtools extends Window {
-    /** Otter Devtools accessor */
-    _OTTER_DEVTOOLS_?: Record<string, any>;
-}
-/** Common option used by the different DevKit services */
-interface DevtoolsCommonOptions {
-    /**
-     * Activated on the application bootstrap
-     * @default false
-     */
-    isActivatedOnBootstrap: boolean;
-}
-/** Common option used by the different Contextualization DevKit services */
-interface ContextualizationDevtoolsCommonOptions {
-    /**
-     * Activated on the application bootstrap when integrated in CMS context
-     * @default true
-     */
-    isActivatedOnBootstrapWhenCMSContext: boolean;
-}
-/**
- * Dataset injected on the page when in CMS context
- */
-interface ContextualizationDataset {
-    /** `"true"` when in CMS context */
-    cmscontext?: string;
-}
-/** Interface describing an Otter Devtools service */
-interface DevtoolsServiceInterface {
-    /** Activate the devtools service */
-    activate(): void;
-}
-
-/**
- * Generic translation
- */
-interface Translation {
-    [x: string]: string;
-}
-
-/**
- * Inputs of the component
- */
-interface ContextInput {
-    [key: string]: any;
-}
-/**
- * Base outputs of the components
- */
-interface BaseContextOutput {
-    [key: string]: any;
-}
-/**
- * Type helper to generate the interface of component outputs
- */
-type EventEmitterify<T extends BaseContextOutput> = {
-    [P in keyof T]: EventEmitter<T[P]>;
-};
-/**
- * Context of the component
- */
-type Context<T extends ContextInput = {}, U extends BaseContextOutput = {}> = {
-    [P in keyof T]: T[P];
-} & {
-    [P in keyof U]: EventEmitterify<U>[P];
-};
-/**
- * Type helper to generate the template context outputs
- */
-type Functionify<T extends BaseContextOutput> = {
-    [P in keyof T]: (value: T[P]) => void;
-};
-/**
- * Interface for a context of a child component
- */
-interface TemplateContext<N extends {}, S extends ContextInput = Record<string, unknown>, F extends BaseContextOutput = Record<string, unknown>, W extends Translation = Translation> {
-    /** Component configuration */
-    config?: Partial<N>;
-    /** Component inputs context */
-    inputs: S & {
-        [key: string]: any;
-    };
-    /** Component outputs context */
-    outputs: Functionify<F & {
-        [key: string]: any;
-    }>;
-    /** Component translation */
-    translations?: Partial<W>;
-    /** Parent Component Id */
-    parentId?: string;
-    /** Form control object to be applied to the form */
-    formControl?: FormControl;
-}
-
-/**
- * Unique identifier of an item in the extracted metadata
- */
-interface ItemIdentifier {
-    /**
-     * Name of the library where the item is originally from
-     */
-    library: string;
-    /**
-     * Name of the item
-     */
-    name: string;
-}
-
-/** Type of component */
-type ComponentType = 'Block' | 'Page' | 'ExposedComponent' | 'Component';
-/**
- * Information about an Otter component to provide
- */
-interface OtterComponentInfoToProvide {
-    /** Type of component */
-    componentType: ComponentType;
-}
-/**
- * Information about an Otter component
- */
-interface OtterComponentInfo extends OtterComponentInfoToProvide {
-    /** Configuration ID */
-    configId?: string;
-    /** Translation keys */
-    translations?: Translation;
-    /** Component Name */
-    componentName: string;
-}
-/**
- * Private field where Otter component information are stored
- */
-declare const otterComponentInfoPropertyName = "__otter-info__";
-/**
- * Decorates an Angular component to provide Otter information
- * @param info Information to define the Otter component
- * @returns the component with the information
- */
-declare function O3rComponent(info: OtterComponentInfoToProvide): <T extends new (...args: any[]) => object>(constructor: T) => T;
-
-/**
- * Compute the name of the component with the library's name to generate unique component identifier used in metadata and different modules
- * @param componentName Name of the component to get the configuration
- * @param libraryName Name of the library the component is coming from
- */
-declare function computeItemIdentifier<C extends string, L extends string>(componentName: C, libraryName?: L): `${L extends string ? `${L}#` : ''}${C}`;
-
-/**
- * Represents an output generated by an Extractor
- */
-interface Output {
-    /** Name of the output entity */
-    name: string;
-    /** Filepath of the entity */
-    path: string;
-}
-
-/**
- * Minimum action field
- */
-interface RulesEngineAction<A extends string = string, V = any> {
-    /** Type of the action */
-    actionType: A;
-    /** Generic value of the action */
-    value: V;
-}
-/**
- * Action handler executed by the rules engine
- */
-interface RulesEngineActionHandler<T extends RulesEngineAction = RulesEngineAction> {
-    /**
-     * Execute the actions resulting of the rules engine
-     * @param actions List of actions executed by the rules engine
-     */
-    executeActions(actions: T[]): void | Promise<void>;
-    /**
-     * Actions supported by the handler
-     */
-    supportingActions: readonly T['actionType'][];
-}
-
-/**
- * Logger Client interface.
- */
-interface Logger {
-    /**
-     * Log an error.
-     * @param message Message to log
-     * @param optionalParams Optional parameters to log
-     */
-    error(message?: any, ...optionalParams: any[]): void;
-    /**
-     * Log a warning.
-     * @param message Message to log
-     * @param optionalParams Optional parameters to log
-     */
-    warn(message?: any, ...optionalParams: any[]): void;
-    /**
-     * Log a message.
-     * @param message Message to log
-     * @param optionalParams Optional parameters to log
-     */
-    info?(message?: any, ...optionalParams: any[]): void;
-    /**
-     * Log a message.
-     * @param message Message to log
-     * @param optionalParams Optional parameters to log
-     */
-    log(message?: any, ...optionalParams: any[]): void;
-    /**
-     * Log a debug message.
-     * @param message Message to log
-     * @param optionalParams Optional parameters to log
-     */
-    debug?(message?: any, ...optionalParams: any[]): void;
-}
-
-/** Type of a message exchanged within the Otter Framework */
-declare const otterMessageType = "otter";
-/** Target of a message that should be handled by the application */
-declare const applicationMessageTarget = "app";
-interface OtterMessageContent<DataType extends string = string> {
-    /** Type of data */
-    dataType: DataType;
-}
-interface OtterMessage<Content extends OtterMessageContent = OtterMessageContent, Target extends string | undefined = undefined | string> {
-    /** Type of the message */
-    type: typeof otterMessageType;
-    /** Version of the message (default to the @o3r/core version ) */
-    version?: string;
-    /** Target of the message */
-    to: Target;
-    /** Message content */
-    content: Content;
-}
-/** Type helper to retrieve the data types of a union of MessageContent */
-type MessageDataTypes<T extends OtterMessageContent> = T['dataType'];
-/** Type helper to filter the message that can be received by the application */
-type FilterMessageToApplication<T extends OtterMessage> = T extends {
-    to: infer U;
-} ? U extends (typeof applicationMessageTarget | undefined) ? T : never : never;
-type ContentMessageData<T extends OtterMessageContent> = T extends any ? Omit<T, 'dataType'> : never;
-
-/** Extension connection notification message content */
-interface ConnectContentMessage extends OtterMessageContent<'connect'> {
-}
-/** Script Injection message content */
-interface InjectContentMessage extends OtterMessageContent<'inject'> {
-    /** Path to the extension script to inject to the web application */
-    scriptToInject: string;
-}
-/** Requested messages Message Content */
-interface RequestMessagesContentMessage<AvailableMessageDataTypes extends string = string> extends OtterMessageContent<'requestMessages'> {
-    /** If specified, only the listed messages will be re-emitted */
-    only?: AvailableMessageDataTypes[];
-}
-/** List of common Otter content messages */
-type CommonContentMessages = ConnectContentMessage | InjectContentMessage | RequestMessagesContentMessage;
-
-/**
- * Determine if a message should be handle by the application
- * @param message Message to analyze
- */
-declare const isToAppOtterMessage: <T extends OtterMessage>(message?: T) => message is FilterMessageToApplication<T & {
-    to: "app";
-}>;
-/**
- * Determine if a message is emitted by an Otter tool
- * @param message Message to analyze
- */
-declare const isOtterMessage: <T extends OtterMessageContent>(message: any) => message is OtterMessage<T>;
-/**
- * Send an Otter Message
- * @param dataType Type of the message
- * @param content content of the message
- * @param preStringify determine if the message should JSON.stringify before being send (will use the default mechanism otherwise)
- */
-declare const sendOtterMessage: <T extends OtterMessageContent>(dataType: T["dataType"], content: ContentMessageData<T>, preStringify?: boolean) => void;
-declare function filterMessageContent<T extends Event | MessageEvent>(): (source$: Observable<T>) => Observable<OtterMessageContent<string>>;
-declare function filterMessageContent<T extends Event | MessageEvent, S extends OtterMessageContent>(predicate: (message: any) => message is S): (source$: Observable<T>) => Observable<S>;
-
-/**
- * Object that define how to serialize a specific state
- */
-interface Serializer<T> {
-    serialize?: (obj: T) => any;
-    deserialize?: (data?: any) => T;
-    reviver?: (key: string, value: any) => any;
-    replacer?: (key: string, value: any) => any;
-    initialState?: T;
-}
-declare class StateSerializer<T> implements Serializer<T> {
-    serialize?: (obj: T) => any;
-    deserialize?: (data?: any) => T;
-    replacer?: (key: string, value: any) => any;
-    initialState?: T;
-    constructor(serializer: Serializer<T>);
-    reviver: (_: string, value: any) => any;
-}
-interface LocalStateModel {
-    /**
-     * Temporary ID of the model in the dictionary
-     */
-    tid: string;
-}
-/**
- * Adds an `id` to the given type
- */
-type Idfy<T> = T & {
-    id: string | number;
-};
-/**
- * Payload to update actions
- */
-interface UpdateActionPayload<T> {
-    stateDetails: Partial<T>;
-}
-/**
- * Payload to set actions
- */
-interface SetActionPayload<T> {
-    stateDetails: T;
-}
-/**
- * Payload to set state actions
- */
-interface SetStateActionPayload<T> {
-    state: T;
-}
-/**
- * Payload to fail actions
- */
-interface FailActionPayload<T> {
-    error?: T;
-}
-type Keep<T, K extends keyof T> = Partial<T> & Pick<T, K>;
-/** Payload to update entities actions */
-interface UpdateEntitiesActionPayload<T, K extends keyof T> {
-    entities: Keep<T, K>[];
-}
-/** Payload to update entities actions with a field ID */
-interface UpdateEntitiesActionPayloadWithId<T extends {
-    id: string | number;
-}> {
-    entities: Keep<T, 'id'>[];
-}
-/** Payload to update entities actions */
-interface UpdateEntityActionPayload<T, K extends keyof T> {
-    entity: Keep<T, K>;
-}
-/** Payload to update entities actions with a field ID */
-interface UpdateEntityActionPayloadWithId<T extends {
-    id: string | number;
-}> {
-    entity: Keep<T, 'id'>;
-}
-/** Payload to set entities and upsert entities actions */
-interface SetEntitiesActionPayload<T> {
-    entities: T[];
-}
-/** Payload to set entity and upsert entity actions */
-interface SetEntityActionPayload<T> {
-    entity: T;
-}
-/** Payload to fail entities actions */
-interface FailEntitiesActionPayload<T> extends FailActionPayload<T> {
-    ids?: (string | number)[];
-}
-/**
- * Payload to clear the store in case of failure
- */
-interface ClearOnFailurePayload {
-    /** Clear store on failure */
-    clearOnFailure?: boolean;
-}
-
-type RequestId = string;
-/**
- * Interface representing an asynchronous request
- */
-interface AsyncRequest {
-    /** ID of the request */
-    requestId: RequestId;
-}
-/**
- * Represents a store item that can be manipulated via asynchronous calls
- */
-interface AsyncStoreItem {
-    /**
-     * IDs of the active asynchronous requests for this item.
-     */
-    requestIds: RequestId[];
-    /**
-     * Has a recent call failed.
-     * This is reset back to false the next time a new async process is started and there are no active requests.
-     */
-    isFailure?: boolean;
-    /**
-     * Is an asynchronous process ongoing on that item
-     */
-    isPending?: boolean;
-}
-/**
- * Payload for actions relying on asynchronous requests
- */
-interface FromApiActionPayload<T> extends Partial<AsyncRequest> {
-    /** Promise call from API */
-    call: Promise<T>;
-}
-/**
- * Unwraps the type of a FromApiActionPayload
- */
-type ExtractFromApiActionPayloadType<T extends FromApiActionPayload<any>> = T['call'] extends Promise<infer U> ? U : never;
-/**
- * Payload for actions relying on asynchronous requests
- */
-interface FromApiActionPayloadWithEntityId<T> extends FromApiActionPayload<T> {
-    /** ID of the entity affected by the call */
-    id?: string;
-}
-/** Add an optional request ID to the given object */
-type WithRequestId<T> = T & Partial<AsyncRequest>;
-/** Payload to set entities actions from async */
-interface SetAsyncStoreItemActionPayload<T> extends SetActionPayload<T>, Partial<AsyncRequest> {
-}
-/** Payload to update entities actions from async */
-interface UpdateAsyncStoreItemEntitiesActionPayload<T extends object, K extends keyof T> extends UpdateEntitiesActionPayload<T, K>, Partial<AsyncRequest> {
-}
-/** Payload to update entities actions from async with a field ID */
-interface UpdateAsyncStoreItemEntitiesActionPayloadWithId<T extends {
-    id: string | number;
-}> extends UpdateEntitiesActionPayloadWithId<T>, Partial<AsyncRequest> {
-}
-/** Payload to update entity actions from async */
-interface UpdateAsyncStoreItemEntityActionPayload<T extends object, K extends keyof T> extends UpdateEntityActionPayload<T, K>, Partial<AsyncRequest> {
-}
-/** Payload to update entity actions from async with a field ID */
-interface UpdateAsyncStoreItemEntityActionPayloadWithId<T extends {
-    id: string | number;
-}> extends UpdateEntityActionPayloadWithId<T>, Partial<AsyncRequest> {
-}
-/** Payload to set/upsert entities actions from async */
-interface SetAsyncStoreItemEntitiesActionPayload<T extends object> extends SetEntitiesActionPayload<T>, Partial<AsyncRequest> {
-}
-/** Payload to set/upsert entity actions from async */
-interface SetAsyncStoreItemEntityActionPayload<T extends object> extends SetEntityActionPayload<T>, Partial<AsyncRequest> {
-}
-/** Payload to fail entity actions from async */
-interface FailAsyncStoreItemEntityActionPayload<T extends object> extends FailActionPayload<T>, Partial<AsyncRequest> {
-}
-/** Payload to fail entities actions from async */
-interface FailAsyncStoreItemEntitiesActionPayload<T extends object> extends FailEntitiesActionPayload<T>, Partial<AsyncRequest> {
-}
-/** Status for all the elements inside a cart */
-type EntityStatus<T, U extends keyof T = never> = {
-    [P in keyof Omit<T, 'id' | U>]?: AsyncStoreItem;
-};
-/**
- * Extends an Entity model with a status property that holds async information for each of its sub-resources
- */
-type EntityWithStatus<T> = T & {
-    status: EntityStatus<T>;
-};
-/** Modifies the given type that extends AsyncStoreItem to remove those properties */
-type EntityWithoutAsyncStoreItem<T extends AsyncStoreItem> = Omit<T, keyof AsyncStoreItem>;
-
-/** Adapter for Asynchronous Entity Store */
-interface EntityAsyncRequestAdapter<T extends AsyncStoreItem> extends EntityAdapter<T> {
-    /**
-     * Updates the AsyncStoreItem properties of each entity matching an id from the list of given ids, when a request has failed.
-     * @param state        Actual state
-     * @param ids          Ids of the entity to be updated with AsyncStoreItem properties
-     * @param requestId    Id of request which has failed
-     */
-    failRequestMany<V extends EntityState<T> & AsyncStoreItem>(state: V, ids?: (string | number)[], requestId?: string): V;
-    /**
-     * Adds AsyncStoreItem property to the global store, or the entity if it already exists, when a request is triggered.
-     * @param state       Actual state
-     * @param id          Id of the entity to update
-     * @param requestId   Id of the request which is triggered
-     */
-    addRequestOne<V extends EntityState<T> & AsyncStoreItem>(state: V, id: string | number | null | undefined, requestId: string): V;
-    /**
-     * Adds AsyncStoreItem properties for each entity matching the given ids, when a request is triggered
-     * @param state        Actual state
-     * @param ids          Ids of the entity to be updated with AsyncStoreItem properties
-     * @param requestId    Id of request which is triggered
-     */
-    addRequestMany<V extends EntityState<T>>(state: V, ids: (string | number)[], requestId: string): V;
-    /**
-     * Updates the state with the given entity. Update the global or the current entity's status if it exists.
-     * @param state        Actual state
-     * @param entity       Payload item;
-     * @param requestId    Id of request which has resolved if any
-     */
-    resolveRequestOne<V extends EntityState<T> & AsyncStoreItem>(state: V, entity: EntityWithoutAsyncStoreItem<T> & Record<'id', string | number>, requestId?: string): V;
-    /**
-     * Updates the state with the given entity. Update the global or the current entity's status if it exists.
-     * @param state        Actual state
-     * @param entity       Payload item;
-     * @param requestId    Id of request which has resolved if any
-     * @param idProperty   Property of the entity containing its unique identifier
-     */
-    resolveRequestOne<V extends EntityState<T> & AsyncStoreItem, W extends keyof T>(state: V, entity: EntityWithoutAsyncStoreItem<T> & Record<W, string | number>, requestId?: string, idProperty?: W): V;
-    /**
-     * Updates the state with the given entities. Updates also AsyncStoreItem properties of each entity, when a request is resolved.
-     * @param state        Actual state
-     * @param entities     Payload items;
-     * @param requestId    Id of request which has resolved if any
-     */
-    resolveRequestMany<V extends EntityState<T>>(state: V, entities: (Partial<T> & Record<'id', string | number>)[], requestId?: string): V;
-    /**
-     * Updates the state with the given entities. Updates also AsyncStoreItem properties of each entity, when a request is resolved.
-     * @param state        Actual state
-     * @param entities     Payload items;
-     * @param requestId    Id of request which has resolved if any
-     * @param idProperty   Property of the entity containing its unique identifier
-     */
-    resolveRequestMany<V extends EntityState<T>, W extends keyof T>(state: V, entities: (Partial<T> & Record<W, string | number>)[], requestId?: string, idProperty?: W): V;
-}
-/**
- * Create an Asynchronous Request Entity Adapter
- * @param  adapter  Entity Adapter
- */
-declare function createEntityAsyncRequestAdapter<T extends AsyncStoreItem>(adapter: EntityAdapter<T>): EntityAsyncRequestAdapter<T>;
-
-/**
- * Adapter to help manipulate AsyncStoreItems to register new request and update the status when they fail or resolve.
- */
-interface AsyncStoreItemAdapter {
-    /**
-     * Adds a request to an AsyncStoreItem.
-     * If the item had a failure and no ongoing requests, sets it's failure status back to false
-     * @param item
-     * @param requestId
-     */
-    addRequest<T extends AsyncStoreItem>(item: T, requestId: string): T;
-    /**
-     * Updates an AsyncStoreItem when a request has resolved.
-     * Removes it from its requestIds array.
-     * If no requestId provided, the method returns the current status of the AsyncStoreItem
-     * @param item
-     * @param requestId
-     */
-    resolveRequest<T extends AsyncStoreItem>(item: T, requestId?: string): T;
-    /**
-     * Updates an AsyncStoreItem when a request has failed.
-     * Removes it from its requestIds array and set its failure status.
-     * @param item
-     * @param requestId
-     */
-    failRequest<T extends AsyncStoreItem>(item: T, requestId?: string): T;
-    /**
-     * Add AsyncStoreItem properties (with initial values) to the given entity
-     * @param entityItem
-     * @returns Given item improved with AsyncStoreItem properties
-     */
-    initialize<T extends object>(entityItem: T): T & AsyncStoreItem;
-    /**
-     * Extract only AsyncStoreItem properties from the given entity
-     * @param entityItem   A model containing AsyncStoreItem properties
-     * @returns Object containing only AsyncStoreItem properties
-     */
-    extractAsyncStoreItem<T extends AsyncStoreItem>(entityItem: T): AsyncStoreItem;
-    /**
-     * Clear AsyncStoreItem properties from the given entity
-     * @param entityItem A model containing AsyncStoreItem properties
-     */
-    clearAsyncStoreItem<T extends AsyncStoreItem>(entityItem: T): T;
-    /**
-     * Merges an AsyncStoreItem collection into one item that gives an overall status.
-     * @param items
-     */
-    merge(...items: (AsyncStoreItem | undefined)[]): AsyncStoreItem;
-    /**
-     * Add a request to the given subResource of an EntityStatus object
-     * @param status
-     * @param subResource
-     * @param requestId
-     */
-    entityStatusAddRequest<T extends EntityStatus<T>>(status: T, subResource: keyof T, requestId: string): T;
-    /**
-     * Resolve a request on the given subResource of an EntityStatus object
-     * @param status
-     * @param subResource
-     * @param requestId
-     */
-    entityStatusResolveRequest<T extends EntityStatus<T>>(status: T, subResource: keyof T, requestId?: string): T;
-    /**
-     * Fail a request to the given subResource of an EntityStatus object
-     * @param status
-     * @param subResource
-     * @param requestId
-     */
-    entityStatusFailRequest<T extends EntityStatus<T>>(status: T, subResource: keyof T, requestId?: string): T;
-    /**
-     * Reset the failure status of the given subResource of an EntityStatus object
-     * @param status
-     * @param subResource
-     */
-    entityStatusResetFailure<T extends EntityStatus<T>>(status: T, subResource: keyof T): T;
-    /**
-     * Reset the failure status of the given AsyncStoreItem to false
-     * @param entityItem
-     * @returns AsyncStoreItem with the updated failure status
-     */
-    resetFailureStatus<T extends AsyncStoreItem>(entityItem: T): T;
-    /**
-     * Set the pending status of the given AsyncStoreItem to true
-     * @param entityItem
-     * @returns AsyncStoreItem with the updated pending status
-     */
-    setLoadingStatus<T extends AsyncStoreItem>(entityItem: T): T;
-}
-declare const asyncStoreItemAdapter: AsyncStoreItemAdapter;
-
-/**
- * Determine if the action is an AsyncRequest action
- * @param action Redux Action
- */
-declare function isCallAction<T = any>(action?: any): action is FromApiActionPayload<T>;
-/**
- * Determine if the action is an AsyncRequest action with a Request ID
- * @param action Redux Action
- */
-declare function isIdentifiedCallAction<T = any>(action?: any): action is FromApiActionPayload<T> & AsyncRequest;
-/**
- * Determine if the given item implements the AsyncRequest interface
- * @param item
- */
-declare function isAsyncRequest<T>(item: any): item is T & AsyncRequest;
-
-/**
- * Custom operator to use instead of SwitchMap with effects based on FromApi actions.
- * It makes sure to emit an action when the inner subscription is unsubscribed in order to keep the store up-to-date with pending information.
- * @param successHandler function that returns the action to emit in case the FromApi call is a success
- * @param errorHandler function that returns the action to emit in case the FromApi call fails
- * @param cancelRequestActionFactory function that returns the action to emit in case the FromApi action is 'cancelled' because a new action was received by the switchMap
- */
-declare function fromApiEffectSwitchMap<T extends FromApiActionPayload<any>, S extends ExtractFromApiActionPayloadType<T>, U extends Action, V extends Action, W extends Action>(successHandler: (result: S, action: T) => U | Observable<U> | Promise<U>, errorHandler?: (error: any, action: T) => Observable<V>, cancelRequestActionFactory?: (props: AsyncRequest, action: T) => W): OperatorFunction<T, U | V | W>;
-/**
- * Same as {@link fromApiEffectSwitchMap}, instead one inner subscription is kept by id.
- * @param successHandler
- * @param errorHandler
- * @param cancelRequestActionFactory
- * @param cleanUpTimer
- */
-declare function fromApiEffectSwitchMapById<T extends FromApiActionPayload<any> & {
-    id: string;
-}, S extends ExtractFromApiActionPayloadType<T>, U extends Action, V extends Action, W extends Action>(successHandler: (result: S, action: T) => U | Observable<U> | Promise<U>, errorHandler?: (error: any, action: T) => Observable<V>, cancelRequestActionFactory?: (props: AsyncRequest, action: T) => W, cleanUpTimer?: number): OperatorFunction<T, U | V | W>;
-
-/**
- * Returns a creator that makes sure that requestId is defined in the action's properties by generating one
- * if needed.
- */
-declare const asyncProps: <P extends object>() => (props: P) => P & AsyncRequest;
-
-/**
- * Serializer for asynchronous store.
- * @param state State of an asynchronous store to serialize
- * @returns a plain json object to pass to json.stringify
- */
-declare function asyncSerializer<T extends AsyncStoreItem>(state: T): T;
-/**
- * Serializer for asynchronous entity store.
- * @param state State of an asynchronous entity store to serialize
- * @returns a plain json object to pass to json.stringify
- */
-declare function asyncEntitySerializer<T extends AsyncStoreItem & EntityState<AsyncStoreItem>>(state: T): T & {
-    entities: _ngrx_entity.Dictionary<AsyncStoreItem>;
-};
-/**
- * Serializer for asynchronous entity store with status.
- * @param state State of an asynchronous entity store with status to serialize
- * @returns a plain json object to pass to json.stringify
- */
-declare function asyncEntityWithStatusSerializer<T extends AsyncStoreItem & EntityState<AsyncStoreItem & {
-    status: EntityStatus<T['entities']['status']>;
-}>>(state: T): T & {
-    entities: _ngrx_entity.Dictionary<AsyncStoreItem & {
-        status: EntityStatus<T["entities"]["status"]>;
-    }>;
-};
-
-/**
- * Pad number
- * @param val
- * @param digits
- */
-declare function padNumber(val: number, digits?: number): string;
-/**
- * Returns TRUE if bootstrap config environment is production FALSE otherwise
- * @param dataset
- * @returns TRUE if bootstrap config environment is production FALSE otherwise
- */
-declare function isProductionEnvironment(dataset: Dataset): boolean;
-
-/** Reviver Mapper to detect and create object on deepFill */
-interface PrimitiveReviverMapper<T = any> {
-    /** Condition to fill to be determine as  */
-    condition: (data: any) => boolean;
-    /**
-     * Construct the primitive type if needed
-     * @param data to be constructed
-     * @default {@see defaultConstruct}
-     */
-    construct?: (data: any) => T;
-}
-/**
- * Check if an object is not an array or a date
- * @param obj
- * @param additionalMappers
- */
-declare function isObject(obj: any, additionalMappers?: PrimitiveReviverMapper[]): boolean;
-/**
- * Return a new reference of the given object
- * @param obj
- * @param additionalMappers
- */
-declare function immutablePrimitive(obj: any, additionalMappers?: PrimitiveReviverMapper[]): any;
-/**
- * Deep fill of base object using source
- * It will do a deep merge of the objects, overriding arrays
- * All properties not present in source, but present in base, will remain
- * @param base
- * @param source
- * @param additionalMappers Map of conditions of type mapper
- */
-declare function deepFill<T extends {
-    [x: string]: any;
-}>(base: T, source?: {
-    [x: string]: any;
-}, additionalMappers?: PrimitiveReviverMapper[]): T;
-
-/**
- * Buffers and emits data for lazy/progressive rendering of big lists
- * That could solve issues with long-running tasks when trying to render an array
- * of similar components.
- * @param delayMs Delay between data emits
- * @param concurrency Amount of elements that should be emitted at once
- */
-declare function lazyArray<T>(delayMs?: number, concurrency?: number): (source$: Observable<T[]>) => Observable<T[]>;
-
-export { DEFAULT_BUILD_PROPERTIES, O3rComponent, StateSerializer, applicationMessageTarget, asyncEntitySerializer, asyncEntityWithStatusSerializer, asyncProps, asyncSerializer, asyncStoreItemAdapter, computeItemIdentifier, createEntityAsyncRequestAdapter, deepFill, filterMessageContent, fromApiEffectSwitchMap, fromApiEffectSwitchMapById, immutablePrimitive, isAsyncRequest, isCallAction, isIdentifiedCallAction, isObject, isOtterMessage, isProductionEnvironment, isToAppOtterMessage, lazyArray, otterComponentInfoPropertyName, otterMessageType, padNumber, sendOtterMessage };
-export type { AppBuildConfiguration, AppRuntimeConfiguration, AsyncRequest, AsyncStoreItem, AsyncStoreItemAdapter, BaseContextOutput, BootstrapConfig, BuildTimeProperties, CategoryDescription, ClearOnFailurePayload, CommonContentMessages, ComponentType, ConfigPropertyWidget, ConfigPropertyWidgetParameters, ConfigType, Configurable, Configuration, ConfigurationValueType, ConnectContentMessage, ContentMessageData, Context, ContextInput, ContextualizationDataset, ContextualizationDevtoolsCommonOptions, CustomConfig, Dataset, DevtoolsCommonOptions, DevtoolsServiceInterface, DynamicConfigurable, DynamicConfigurableWithSignal, EntityAsyncRequestAdapter, EntityStatus, EntityWithStatus, EntityWithoutAsyncStoreItem, EventEmitterify, ExtractFromApiActionPayloadType, FailActionPayload, FailAsyncStoreItemEntitiesActionPayload, FailAsyncStoreItemEntityActionPayload, FailEntitiesActionPayload, FilterMessageToApplication, FromApiActionPayload, FromApiActionPayloadWithEntityId, Functionify, Idfy, InjectContentMessage, InterfaceOf, ItemIdentifier, Keep, LabelValue, LocalStateModel, Logger, MessageDataTypes, NestedConfiguration, OtterComponentInfo, OtterComponentInfoToProvide, OtterMessage, OtterMessageContent, Output, PrimitiveReviverMapper, RequestId, RequestMessagesContentMessage, RulesEngineAction, RulesEngineActionHandler, Serializer, SetActionPayload, SetAsyncStoreItemActionPayload, SetAsyncStoreItemEntitiesActionPayload, SetAsyncStoreItemEntityActionPayload, SetEntitiesActionPayload, SetEntityActionPayload, SetStateActionPayload, TemplateContext, Translation, UpdateActionPayload, UpdateAsyncStoreItemEntitiesActionPayload, UpdateAsyncStoreItemEntitiesActionPayloadWithId, UpdateAsyncStoreItemEntityActionPayload, UpdateAsyncStoreItemEntityActionPayloadWithId, UpdateEntitiesActionPayload, UpdateEntitiesActionPayloadWithId, UpdateEntityActionPayload, UpdateEntityActionPayloadWithId, WindowWithDevtools, WithRequestId };
-//# sourceMappingURL=index.d.ts.map