import { SetStateActionPayload, Serializer, Configuration, CustomConfig, OtterMessageContent, ConnectContentMessage, RequestMessagesContentMessage, MessageDataTypes, DevtoolsCommonOptions, ContextualizationDevtoolsCommonOptions, 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 _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], 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=o3r-configuration.d.ts.map