@o3r/configuration/index.d.ts

This module contains configuration-related features such as CMS compatibility, Configuration override, store and debugging. It enables your application runtime configuration and comes with an integrated ng builder to help you generate configurations suppo

import { SetStateActionPayload, Serializer, Configuration, CustomConfig, DevtoolsCommonOptions, ContextualizationDevtoolsCommonOptions, OtterMessageContent, MessageDataTypes, ConnectContentMessage, RequestMessagesContentMessage, DevtoolsServiceInterface } from '@o3r/core';
export { Configurable, Configuration, CustomConfig, DynamicConfigurable, DynamicConfigurableWithSignal } from '@o3r/core';
import { Observable, Observer, Subject } from 'rxjs';
import * as _ngrx_entity from '@ngrx/entity';
import { EntityState, EntityAdapter, Dictionary } from '@ngrx/entity';
import * as i0 from '@angular/core';
import { InjectionToken, ModuleWithProviders, Signal, InputSignal } from '@angular/core';
import * as _ngrx_store from '@ngrx/store';
import { ActionReducer, Action, ReducerTypes, ActionCreator, Store } from '@ngrx/store';
import * as i2 from '@o3r/logger';
import * as _o3r_configuration from '@o3r/configuration';

/**
 * Interface to define the error messages into component configuration
 */
interface ErrorMessages {
    /**
     * Error message map
     */
    errorMessages: {
        [key: string]: string;
    };
}
/**
 * Interface to specify that the component has an ID
 */
interface Identifiable {
    /**
     * Identifier
     */
    id: string;
}
/**
 * Get the component and library's names based on the configuration name
 * @param configurationName Name of the component as found in the store
 * @returns Object containing library and component name.
 */
declare function parseConfigurationName(configurationName: string): {
    library?: string;
    libraryName?: string;
    componentName: string;
} | undefined;
/**
 * Operator to get the configuration from store for a given component and merge it with the global config
 * @param defaultValue Default value of the configuration
 */
declare function getConfiguration<T extends Record<string, unknown>>(defaultValue: T): <C extends Partial<T>>(source: Observable<C | undefined>) => Observable<T>;

/**
 * Property override model
 */
interface PropertyOverride {
    [property: string]: any;
}
/**
 * ConfigOverride store state
 */
interface ConfigOverrideState {
    /** Map of PropertyOverride indexed on component + config name */
    configOverrides: Record<string, PropertyOverride>;
}
/**
 * Name of the ConfigOverride Store
 */
declare const CONFIG_OVERRIDE_STORE_NAME = "configOverride";
/**
 * ConfigOverride Store Interface
 */
interface ConfigOverrideStore {
    /** ConfigOverride state */
    [CONFIG_OVERRIDE_STORE_NAME]: ConfigOverrideState;
}

/**
 * Clear all overrides and fill the store with the payload
 */
declare const setConfigOverride: _ngrx_store.ActionCreator<"[ConfigOverride] set", (props: SetStateActionPayload<ConfigOverrideState>) => SetStateActionPayload<ConfigOverrideState> & _ngrx_store.Action<"[ConfigOverride] set">>;

/** Token of the ConfigOverride reducer */
declare const CONFIG_OVERRIDE_REDUCER_TOKEN: InjectionToken<ActionReducer<ConfigOverrideState, Action<string>>>;
/** Provide default reducer for ConfigOverride store */
declare function getDefaultConfigOverrideReducer(): ActionReducer<ConfigOverrideState, Action<string>>;
declare class ConfigOverrideStoreModule {
    static forRoot<T extends ConfigOverrideState>(reducerFactory: () => ActionReducer<T, Action>): ModuleWithProviders<ConfigOverrideStoreModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigOverrideStoreModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfigOverrideStoreModule, never, [typeof _ngrx_store.StoreFeatureModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ConfigOverrideStoreModule>;
}

/**
 * ConfigOverride Store initial value
 */
declare const configOverrideInitialState: ConfigOverrideState;
/**
 *  List of basic actions for ConfigOverride Store
 */
declare const configOverrideReducerFeatures: ReducerTypes<ConfigOverrideState, ActionCreator[]>[];
/**
 * ConfigOverride Store reducer
 */
declare const configOverrideReducer: _ngrx_store.ActionReducer<ConfigOverrideState, _ngrx_store.Action<string>>;

/** Select ConfigOverride State */
declare const selectConfigOverrideState: _ngrx_store.MemoizedSelector<object, ConfigOverrideState, _ngrx_store.DefaultProjectorFn<ConfigOverrideState>>;
/** Select the array of ConfigOverride */
declare const selectConfigOverride: _ngrx_store.MemoizedSelector<object, Record<string, _o3r_configuration.PropertyOverride>, (s1: ConfigOverrideState) => Record<string, _o3r_configuration.PropertyOverride>>;
/**
 * Get the override for given component identifier
 * @param componentId
 */
declare const selectComponentOverrideConfig: (componentId: string) => _ngrx_store.MemoizedSelector<object, _o3r_configuration.PropertyOverride, (s1: Record<string, _o3r_configuration.PropertyOverride>) => _o3r_configuration.PropertyOverride>;

/**
 * Deserializer
 * @param rawObject
 */
declare const configOverrideStorageDeserializer: (rawObject: any) => any;
declare const configOverrideStorageSync: Serializer<ConfigOverrideState>;

interface SetConfigurationEntitiesPayload {
    /** Map of configurations to update/insert, this is now Partial due the change of Configuration interface */
    entities: {
        [id: string]: Partial<Configuration>;
    };
}
interface UpsertConfigurationEntityPayload {
    /** ID of the item */
    id: string;
    /** Updated/New configuration object */
    configuration: Partial<Configuration>;
}
interface UpdateConfigurationEntityPayload {
    /** ID of the item */
    id: string;
    /** Updated/New configuration partial object */
    configuration: Partial<Configuration>;
}
/**
 * Upsert one configuration entity
 */
declare const upsertConfigurationEntity: _ngrx_store.ActionCreator<"[Configuration] set configuration entity", (props: UpsertConfigurationEntityPayload) => UpsertConfigurationEntityPayload & _ngrx_store.Action<"[Configuration] set configuration entity">>;
/**
 * Update one configuration entity
 */
declare const updateConfigurationEntity: _ngrx_store.ActionCreator<"[Configuration] update configuration entity", (props: UpdateConfigurationEntityPayload) => UpdateConfigurationEntityPayload & _ngrx_store.Action<"[Configuration] update configuration entity">>;
/**
 * Clear all configuration and fill the store with the payload
 */
declare const setConfigurationEntities: _ngrx_store.ActionCreator<"[Configuration] set entities", (props: SetConfigurationEntitiesPayload) => SetConfigurationEntitiesPayload & _ngrx_store.Action<"[Configuration] set entities">>;
/**
 * Update configuration with known IDs, ignore the new ones
 */
declare const updateConfigurationEntities: _ngrx_store.ActionCreator<"[Configuration] update entities", (props: SetConfigurationEntitiesPayload) => SetConfigurationEntitiesPayload & _ngrx_store.Action<"[Configuration] update entities">>;
/**
 * Update configuration with known IDs, insert the new ones
 */
declare const upsertConfigurationEntities: _ngrx_store.ActionCreator<"[Configuration] upsert entities", (props: SetConfigurationEntitiesPayload) => SetConfigurationEntitiesPayload & _ngrx_store.Action<"[Configuration] upsert entities">>;
/**
 * Clear only the entities, keeps the other attributes in the state
 */
declare const clearConfigurationEntities: _ngrx_store.ActionCreator<"[Configuration] clear entities", () => _ngrx_store.Action<"[Configuration] clear entities">>;

/**
 * compute the configuration into SetEntitiesPayload
 * @param customConfigObject array of configurations
 */
declare function computeConfiguration<T extends Configuration>(customConfigObject: CustomConfig<T>[]): SetConfigurationEntitiesPayload;

/**
 * Configuration model
 */
interface ConfigurationModel extends Configuration {
    id: string;
}
/**
 * Configuration store state
 */
interface ConfigurationState extends EntityState<ConfigurationModel> {
}
/**
 * Name of the Configuration Store
 */
declare const CONFIGURATION_STORE_NAME = "configuration";
/**
 * Configuration Store Interface
 */
interface ConfigurationStore {
    /** Configuration state */
    [CONFIGURATION_STORE_NAME]: ConfigurationState;
}
/**
 * ID of the global configuration
 */
declare const globalConfigurationId = "global";

/** Token of the Configuration reducer */
declare const CONFIGURATION_REDUCER_TOKEN: InjectionToken<ActionReducer<ConfigurationState, Action<string>>>;
/** Provide default reducer for Configuration store */
declare function getDefaultConfigurationReducer(): ActionReducer<ConfigurationState, Action<string>>;
declare class ConfigurationStoreModule {
    static forRoot<T extends ConfigurationState>(reducerFactory: () => ActionReducer<T, Action>): ModuleWithProviders<ConfigurationStoreModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationStoreModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfigurationStoreModule, never, [typeof _ngrx_store.StoreFeatureModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ConfigurationStoreModule>;
}

/**
 * Configuration Store adapter
 */
declare const configurationAdapter: EntityAdapter<ConfigurationModel>;
/**
 * Configuration Store initial value
 */
declare const configurationInitialState: ConfigurationState;
/**
 *  List of basic actions for Configuration Store
 */
declare const configurationReducerFeatures: ReducerTypes<ConfigurationState, ActionCreator[]>[];
/**
 * Configuration Store reducer
 */
declare const configurationReducer: _ngrx_store.ActionReducer<ConfigurationState, _ngrx_store.Action<string>>;

/**
 * Select Configuration State
 * Note: the usage of createSelector is to avoid warning printing because of potentially undefined feature store
 */
declare const selectConfigurationState: _ngrx_store.MemoizedSelector<{
    configuration: ConfigurationState;
}, ConfigurationState | undefined, (state: ConfigurationState | undefined) => ConfigurationState | undefined>;
/** Select the array of Configuration ids */
declare const selectConfigurationIds: _ngrx_store.MemoizedSelector<{
    configuration: ConfigurationState;
}, string[] | number[], (s1: ConfigurationState | undefined) => string[] | number[]>;
/** Select the array of Configuration */
declare const selectAllConfiguration: _ngrx_store.MemoizedSelector<{
    configuration: ConfigurationState;
}, _o3r_configuration.ConfigurationModel[], (s1: ConfigurationState | undefined) => _o3r_configuration.ConfigurationModel[]>;
/** Select the dictionary of Configuration entities */
declare const selectConfigurationEntities: _ngrx_store.MemoizedSelector<{
    configuration: ConfigurationState;
}, _ngrx_entity.Dictionary<_o3r_configuration.ConfigurationModel>, (s1: ConfigurationState | undefined) => _ngrx_entity.Dictionary<_o3r_configuration.ConfigurationModel>>;
/** Select the total Configuration count */
declare const selectConfigurationTotal: _ngrx_store.MemoizedSelector<{
    configuration: ConfigurationState;
}, number, (s1: ConfigurationState | undefined) => number>;
/**
 * Select the configuration for component with id
 * @param props property of the selector
 * @param props.id id of the component
 */
declare const selectConfigurationForComponent: <T extends Configuration>(props: {
    id: string;
}) => _ngrx_store.MemoizedSelector<{
    configuration: ConfigurationState;
}, T, (s1: _ngrx_entity.Dictionary<_o3r_configuration.ConfigurationModel>) => T>;
/**
 * Select the global configuration
 */
declare const selectGlobalConfiguration: _ngrx_store.MemoizedSelector<{
    configuration: ConfigurationState;
}, Configuration, (s1: Configuration) => Configuration>;

declare const configurationStorageSync: {
    deserialize: (rawObject: any) => ConfigurationState;
};

/** Option for Configuration devtools service */
interface ConfigurationDevtoolsServiceOptions extends DevtoolsCommonOptions, ContextualizationDevtoolsCommonOptions {
    /**
     * Default library name to use if not specified in the function call
     * @default `@o3r/components`
     */
    defaultLibraryName: string;
    /**
     * Default JSON file name if not specified in the function
     * @default partial-static-config.json
     */
    defaultJsonFilename: string;
}
interface ConfigurationsMessage extends OtterMessageContent<'configurations'> {
    /** Configurations */
    configurations: Dictionary<ConfigurationModel>;
}
interface UpdateConfigMessage extends OtterMessageContent<'updateConfig'> {
    /** Configuration ID */
    id: string;
    /** Configuration value */
    configValue: any;
}
type ConfigurationMessageContents = ConfigurationsMessage | UpdateConfigMessage;
/** List of possible DataTypes for Configuration messages */
type ConfigurationMessageDataTypes = MessageDataTypes<ConfigurationMessageContents>;
/** List of all messages for configuration purpose */
type AvailableConfigurationMessageContents = ConfigurationMessageContents | ConnectContentMessage | RequestMessagesContentMessage<ConfigurationMessageDataTypes>;
/**
 * Determine if the given message is a Configuration message
 * @param message message to check
 */
declare const isConfigurationMessage: (message: any) => message is AvailableConfigurationMessageContents;
/**
 * Contextualization devtools exposed for configuration in CMS integration
 */
interface ConfigurationContextualizationDevtools {
    /**
     * Replace N configurations in one shot
     * @param configs array of configurations to update
     */
    updateConfigurations: (configurations: CustomConfig<Configuration>[]) => void;
}

declare class ConfigurationDevtoolsConsoleService implements DevtoolsServiceInterface, ConfigurationContextualizationDevtools {
    /** Name of the Window property to access to the devtools */
    static readonly windowModuleName = "configuration";
    private readonly configurationDevtools;
    private readonly options;
    constructor();
    private downloadJSON;
    private copyElementToClipboard;
    /**
     * Set a specified value of a component configuration
     * @param selector Selector for a component configuration
     * @param configProperty Name of the configuration property to set
     * @param configValue Value of the configuration property to set
     */
    setDynamicConfig(selector: string | {
        library?: string;
        componentName: string;
    }, configProperty: string, configValue: any): void;
    /** @inheritDoc */
    activate(): void;
    /**
     * Display the list of configurations loaded in the store and the library they originate from
     * @returns array with the configurations and libraries for example: ["LibComponentsCommonRuntimeConfig from @my-lib/shared-common"]
     */
    displayComponentsWithConfiguration(): Promise<void>;
    /**
     * Display the configuration for a specific component
     * @param selector Selector for a component configuration. It can be a string in the form library#configurationName (i.e: '@my-lib/shared-components#HeaderContConfig')
     * or an object with the configuration and library names (i.e: {library:"@my-lib/shared-components", componentName:'HeaderContConfig'}).
     * Note the object input componentName expects a configuration name not a component name.
     * @returns Configuration object (i.e: {airlineLogoPath: "img/airlines/icon-BH.svg", displayLanguageSelector: false})
     */
    displayCurrentConfigurationFor(selector: string | {
        library?: string;
        componentName: string;
    }): Promise<void>;
    /**
     * Download the JSON file of the whole configuration
     * @param fileName Name of the file to download
     */
    saveConfiguration(fileName?: string): Promise<void>;
    /**
     * Display the whole configuration of the application
     */
    displayConfiguration(): Promise<void>;
    /**
     * Display a bookmark to generate the current configuration
     */
    displayConfigurationBookmark(): Promise<void>;
    /**
     * Copy the whole configuration to the clipboard
     */
    copyConfigurationToClipboard(): Promise<void>;
    /**
     * Replace N configurations in one shot
     * @param configurations array of configurations to update
     */
    updateConfigurations(configurations: string | CustomConfig<Configuration>[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationDevtoolsConsoleService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationDevtoolsConsoleService>;
}

declare class ConfigurationDevtoolsMessageService implements DevtoolsServiceInterface {
    private readonly store;
    private readonly logger;
    private readonly configurationDevtools;
    private readonly options;
    private readonly sendMessage;
    private readonly destroyRef;
    constructor();
    private sendCurrentConfigurationState;
    /**
     * Function to trigger a re-send a requested messages to the Otter Chrome DevTools extension
     * @param only restricted list of messages to re-send
     */
    private handleReEmitRequest;
    /**
     * Function to handle the incoming messages from Otter Chrome DevTools extension
     * @param message message coming from the Otter Chrome DevTools extension
     */
    private handleEvents;
    /**
     * Function to connect the plugin to the Otter DevTools extension
     */
    private connectPlugin;
    /** @inheritDoc */
    activate(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationDevtoolsMessageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationDevtoolsMessageService>;
}

declare class ConfigurationDevtoolsModule {
    /**
     * Initialize Otter Devtools
     * @param options
     */
    static instrument(options: Partial<ConfigurationDevtoolsServiceOptions>): ModuleWithProviders<ConfigurationDevtoolsModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationDevtoolsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfigurationDevtoolsModule, never, [typeof _ngrx_store.StoreModule, typeof ConfigurationStoreModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ConfigurationDevtoolsModule>;
}

declare class OtterConfigurationDevtools {
    protected store: Store<ConfigurationStore>;
    private readonly appRef;
    private readonly options;
    /** Stream of configurations */
    readonly configurationEntities$: Observable<CustomConfig[]>;
    constructor();
    /**
     * Get configuration name based on input information
     * @param selector Selector for a component configuration. It can be a string in the form library#componentName (i.e: @my-lib/shared-components#HeaderContComponent)
     * or an object with the component and library names (i.e: {library:"@my-lib/shared-components", componentName:'HeaderContComponent'})
     * @param isFallbackName Determine if the name requested is a fallback name
     * @returns string in the format library#componentName (i.e: "@my-lib/shared-components#HeaderContComponent")
     */
    getComponentConfigName(selector: string | {
        library?: string;
        componentName: string;
    }, isFallbackName?: boolean): string;
    /**
     * Get the list of components which have a configuration loaded in the store
     */
    getComponentsWithConfiguration(): Promise<string[]>;
    /**
     * Set a specified value of a component configuration
     * @param selector Selector for a component configuration
     * @param configProperty Name of the configuration property to set
     * @param configValue Value of the configuration property to set
     */
    setDynamicConfig(selector: string | {
        library?: string;
        componentName: string;
    }, configProperty: string, configValue: any): void;
    /**
     * Get the configuration for a specific component
     * @param selector Selector for a component configuration. It can be a string in the form library#configurationName (i.e: @my-lib/shared-components#HeaderPresConfig)
     * or an object with the configuration and library names (i.e: {library:"@my-lib/shared-components", componentName:'HeaderPresConfig'})
     */
    getCurrentConfigurationFor(selector: string | {
        library?: string;
        componentName: string;
    }): Promise<Configuration>;
    /**
     * Get the whole configuration of the application
     */
    getConfiguration(): Promise<CustomConfig<Partial<Configuration>>[]>;
    /**
     * Load a json configuration
     * @param configurations configurations to load
     */
    loadConfiguration(configurations: string | CustomConfig<Configuration>[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OtterConfigurationDevtools, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OtterConfigurationDevtools>;
}

declare const OTTER_CONFIGURATION_DEVTOOLS_DEFAULT_OPTIONS: Readonly<ConfigurationDevtoolsServiceOptions>;
declare const OTTER_CONFIGURATION_DEVTOOLS_OPTIONS: InjectionToken<ConfigurationDevtoolsServiceOptions>;

declare class ConfigurationBaseServiceModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationBaseServiceModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfigurationBaseServiceModule, never, [typeof ConfigurationStoreModule, typeof i2.LoggerModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ConfigurationBaseServiceModule>;
}

/**
 * Configuration service
 */
declare class ConfigurationBaseService {
    private readonly store;
    private readonly extendedConfiguration;
    /**
     * Update a specific component config or add it to the store if does not exist
     * @param configuration to edit/add
     * @param configurationId Configuration ID
     */
    upsertConfiguration<T extends Configuration>(configuration: T, configurationId?: string): void;
    /**
     * Update a specific component config
     * @param configuration Partial config to edit
     * @param configurationId Configuration ID
     */
    updateConfiguration<T extends Partial<Configuration>>(configuration: T, configurationId?: string): void;
    /**
     * This function will get the configuration stored in the data attribute of the html's body tag
     * @param configTagName Value used to identify the data attribute where the config is pushed in the index.html
     */
    getConfigFromBodyTag<T extends Configuration>(configTagName?: string): void;
    /**
     * Transform the custom configuration in store configuration model
     * @param customConfigObject Configuration object (extracted from body tag for static config or downloaded in case of dynamic config)
     */
    computeConfiguration<T extends Configuration>(customConfigObject: CustomConfig<T>[]): void;
    /**
     * Complete a stored configuration by adding the missing fields
     * @param extension Configuration extension to be included in the store
     * @param configurationId Configuration ID to extend
     * @param forceUpdate Force update the configuration in the store
     */
    extendConfiguration<T extends Configuration>(extension: T, configurationId?: string, forceUpdate?: boolean): void;
    /**
     * Operator to get the configuration from store for a given component and merge it with the global config
     * @param id Id of the component
     * @param defaultValue Default value of the configuration
     */
    getComponentConfig<T extends Configuration>(id: string, defaultValue: T): (source: Observable<Partial<T> | undefined>) => Observable<T>;
    /**
     * Get an observable of the configuration from store for a given component and merge it with the global config + the config overrides from the rules engine
     * @param id Id of the component
     */
    getConfig<T extends Configuration>(id: string): Observable<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationBaseService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationBaseService>;
}

/**
 * Decorator to identify the component's configuration
 */
declare function O3rConfig(): (target: any, key: string) => void;

declare class ConfigurationObserver<T extends Configuration> implements Observer<Partial<T> | undefined>, Pick<Subject<T>, 'asObservable'> {
    /** Configuration ID */
    configId: string;
    /** Inner observable */
    private readonly observable;
    /** Inner subscriber */
    private readonly subscriber;
    /** @inheritdoc */
    closed?: boolean;
    constructor(
    /** Configuration ID */
    configId: string, defaultConfig: T, configurationService?: ConfigurationBaseService);
    /** @inheritdoc */
    next(value?: Partial<T>): void;
    /** @inheritdoc */
    error(err: any): void;
    /** @inheritdoc */
    complete(): void;
    /**
     * @inheritdoc
     */
    asObservable(): Observable<T>;
}

/** Configuration signal */
type ConfigurationSignal<T> = Signal<T> & {
    configId: string;
};
/**
 * Get a configuration signal
 * @param configInput
 * @param configId
 * @param defaultConfig
 */
declare function configSignal<T extends Configuration>(configInput: InputSignal<Partial<T> | undefined>, configId: string, defaultConfig: T): ConfigurationSignal<T>;

export { CONFIGURATION_REDUCER_TOKEN, CONFIGURATION_STORE_NAME, CONFIG_OVERRIDE_REDUCER_TOKEN, CONFIG_OVERRIDE_STORE_NAME, ConfigOverrideStoreModule, ConfigurationBaseService, ConfigurationBaseServiceModule, ConfigurationDevtoolsConsoleService, ConfigurationDevtoolsMessageService, ConfigurationDevtoolsModule, ConfigurationObserver, ConfigurationStoreModule, O3rConfig, OTTER_CONFIGURATION_DEVTOOLS_DEFAULT_OPTIONS, OTTER_CONFIGURATION_DEVTOOLS_OPTIONS, OtterConfigurationDevtools, clearConfigurationEntities, computeConfiguration, configOverrideInitialState, configOverrideReducer, configOverrideReducerFeatures, configOverrideStorageDeserializer, configOverrideStorageSync, configSignal, configurationAdapter, configurationInitialState, configurationReducer, configurationReducerFeatures, configurationStorageSync, getConfiguration, getDefaultConfigOverrideReducer, getDefaultConfigurationReducer, globalConfigurationId, isConfigurationMessage, parseConfigurationName, selectAllConfiguration, selectComponentOverrideConfig, selectConfigOverride, selectConfigOverrideState, selectConfigurationEntities, selectConfigurationForComponent, selectConfigurationIds, selectConfigurationState, selectConfigurationTotal, selectGlobalConfiguration, setConfigOverride, setConfigurationEntities, updateConfigurationEntities, updateConfigurationEntity, upsertConfigurationEntities, upsertConfigurationEntity };
export type { AvailableConfigurationMessageContents, ConfigOverrideState, ConfigOverrideStore, ConfigurationContextualizationDevtools, ConfigurationDevtoolsServiceOptions, ConfigurationMessageDataTypes, ConfigurationModel, ConfigurationSignal, ConfigurationState, ConfigurationStore, ConfigurationsMessage, ErrorMessages, Identifiable, PropertyOverride, SetConfigurationEntitiesPayload, UpdateConfigMessage, UpdateConfigurationEntityPayload, UpsertConfigurationEntityPayload };
//# sourceMappingURL=index.d.ts.map