@finsemble/finsemble-ui 10.0.0-iocd.9 → 10.0.3-beta.2

package/clients/configClient.d.ts

@@ -1,639 +1,639 @@
-/*!
- * Copyright 2017 - 2020 by ChartIQ, Inc.
- * All rights reserved.
- */
-/**
- * This client provides run-time access to Finsemble's configuration.
- * The Config Client functions similar to a global store created with the Distributed Store Client and offers many of the same methods.
- * Values modified at runtime are not persisted.
- *
- *
- * See the [Configuration tutorial](/docs/customize/customize-with-SDK/configuration) for a configuration overview.
- *
- * @module ConfigClient
- */
-/**
-This is how we want our API to work going forward, the way the world does it: import { processAndSet } from "configClient"
-```
-export const processAndSet = () => { ... }
-```
-
-This module's single exported object gives us backward compatibility when our core code does this: import { ConfigClient } from "configClient"
-and provides the object that is attached to FSBL.Clients. This export should be kept as clean and simple as possible.
-```
-export const ConfigClient = {
-   processAndSet
-}
-```
-
-The default export gives us backward compatibility where our core code does this: import ConfigClient from "configClient"
-This can be eliminated when our core core is converted to normal imports as in the first example.
-```
-export default ConfigClient;
-```
-*/
-import { QueryResponse } from "./routerClient";
-import { StandardErrorCallback, StandardPromise, StandardError, Manifest, FieldPathArrayAndValue, FieldOnlyParam, FieldAndValueParam, FieldAndValueParams, PathArray, ListenerFunction, ListenerParam, RemoveListenersType, PathArrayListenerParam } from "../types";
-export { PathArray, ListenerFunction, ListenerParam, PathArrayListenerParam, FieldOnlyParam, RemoveListenersType, FieldPathArrayAndValue, FieldAndValueParam, FieldAndValueParams, };
-export { FieldPathArray } from "../types";
-export declare type ProcessAndSetCallback = StandardErrorCallback<QueryResponse<Manifest>>;
-/**
- * @language javascript, dotnet
- * Retrieves the entire manifest
- *
- * ```javascript
- * FSBL.Clients.ConfigClient.getManifest(function(err, value){ });
- * const {err, data} = await FSBL.Clients.ConfigClient.getManifest();
- * ```
- */
-export declare const getManifest: (cb?: StandardErrorCallback<Manifest>) => StandardPromise<Manifest>;
-/**
- * @language javascript, java, dotnet
- * Get a value from the config.
- *
- * If a field does not exists in the configuration, `data` will be undefined and `err` will
- * be null.
- *
- * If you pass path as null or an empty path the entire config is returned.
- *
- * ```javascript
- * FSBL.Clients.ConfigClient.get(
- *   ['field1', 'property1'], // field1.property1
- *   function(err,value){ }
- * );
- *
- * const {err, data} = await FSBL.Clients.ConfigClient.get(
- *   ['field1', 'property1'] // field1.property1
- * );
- * ```
- *
- * :::note
- * In Java, this method is named `getValue`.
- * :::
- * @param {Function} cb Will return the value if found.
- */
-export declare const get: <T = any>(path: PathArray | null, cb?: StandardErrorCallback<T> | undefined) => StandardPromise<T>;
-/**
- * @language javascript, java, dotnet
- *
- * Get multiple values from the config.
- *
- * If a field does not exists in the configuration, `data` will be undefined and `err` will
- * be null.
- *
- * ```javascript
- * FSBL.Clients.ConfigClient.getMultiple(
- *  [
- *    // field1.property1.subproperty1
- *    ["field1", "property1", "subproperty1"],
- *
- *    // field1.property2
- *    ["field1", "property2"]
- *  ], (err, values) => {
- *    if(!err){
- *      console.log("Values: ", values);
- *   }
- * });
- *
- * const {err, data} = await FSBL.Clients.ConfigClient.getMultiple([
- *   // field1.property1.subproperty1
- *   ["field1", "property1", "subproperty1"],
- *
- *   // field1.property2
- *   ["field1", "property2"]                  // field1.property2
- * ]);
- * if(!err){
- *   console.log("Values: ", data);
- * }
- * ```
- * @param {Function} cb Will return the value if found.
- */
-export declare const getMultiple: <T = any>(paths: PathArray[], cb?: StandardErrorCallback<T> | undefined) => StandardPromise<T>;
-/**
- * @language javascript, java, dotnet
- * @deprecated - Use [ `FSBL.Clients.ConfigClient.get()`](#get) instead.
- *
- * Get a value from the config.
- *
- * ```javascript
- * FSBL.Clients.ConfigClient.getValue({ field:'field1' }, function(err,value){ });
- * FSBL.Clients.ConfigClient.getValue('field1', function(err,value){ });
- * const {err, data} = await FSBL.Clients.ConfigClient.getValue({ field:'field1' });
- * const {err, data} = await FSBL.Clients.ConfigClient.getValue('field1');
- * ```
- * @param {Function} cb Will return the value if found.
- *
- */
-export declare const getValue: <T = any>(params: FieldOnlyParam | string, cb?: StandardErrorCallback<T> | undefined) => StandardPromise<T>;
-/**
- * @language javascript, java, dotnet
- * @deprecated - Use [`FSBL.Clients.ConfigClient.getMultiple()`](#getmultiple) instead.
- *
- * Get multiple values from the config.
- *
- * :::caution
- * **Deprecated functionality**: If there are no fields provided, the complete configuration manifest
- * is returned (use [getManifest()](#getmanifest)).
- * :::
- *
- * ```javascript
- * FSBL.Clients.ConfigClient.getValues(['field1','field2'], function(err,values){ });
- * FSBL.Clients.ConfigClient.getValues(null, callback); // returns the complete manifest containing the finsemble property
- * const {err, data} = await FSBL.Clients.ConfigClient.getValues(['field1', 'field2']);
- * ```
- * @param {fieldOnlyParam[] | string[]} fields An array of objects containing a field property or an array of string field names.
- * @param {Function} cb Will return the value if found.
- */
-export declare const getValues: <T = any>(fields?: FieldOnlyParam[] | string[] | null, cb?: StandardErrorCallback<Record<string, T>> | undefined) => StandardPromise<Record<string, T>>;
-/**
- * @language javascript, java, dotnet
- * Sets a value in the config.
- *
- * Setting a value will trigger events that you can listen to using [`addListener()`](#addlistener).
- *
- * ```javascript
- * // Set field1.property1 = "foo"
- * FSBL.Clients.ConfigClient.set(
- *   ['field1', 'property1'],
- *   "foo",
- *   function(err,value){ }
- * );
- *
- * // Set field1.property1 = "foo"
- * const {err, data} = await FSBL.Clients.ConfigClient.set(['field1', 'property1'], "foo");
- * ```
- * :::note
- * In Java, this method is named `setValue`.
- * :::
- * @param {Function} cb Optional callback.
- */
-export declare const set: <T = any>(path: PathArray, value: any, cb?: StandardErrorCallback<T> | undefined) => StandardPromise<T>;
-/**
- * @language javascript, java, dotnet
- * Sets multiple values in the config.
- *
- * Setting a value will trigger events that you can listen to using <a href="#addlistener">`addListener()`</a>.
- *
- * ```javascript
- * // Set both field1.property1 = "foo" AND field2.property2 = "bar"
- * FSBL.Clients.ConfigClient.setMultiple(
- *   [
- * 		{field: ['field1', 'property1'], value: "foo"},
- * 		{field: ['field2', 'property2'], value: "bar"}
- *   ],
- *   function(err,value){ }
- * );
- *
- * // Set both field1.property1 = "foo" AND field2.property2 = "bar"
- * const {err, data} = await FSBL.Clients.ConfigClient.setMultiple([
- *   {field: ['field1', 'property1'], value: "foo"},
- *   {field: ['field2', 'property2'], value: "bar"}
- * ]);
- * ```
- *
- *
- * :::note
- * In Java, this method is named `setValues`.
- * :::
- * @param {Function} cb Optional callback.
- */
-export declare const setMultiple: <T = any>(pathsAndValues: FieldPathArrayAndValue[], cb?: StandardErrorCallback<T> | undefined) => StandardPromise<T>;
-/**
- * @language javascript, java, dotnet
- * @deprecated - Use [`FSBL.Clients.ConfigClient.set()`](#set) instead.
- *
- * Set a value in the config. Setting a value will trigger events that you can listen to using <a href="#addlistener">`addListener()`</a>.
- *
- * ```javascript
- * FSBL.Clients.ConfigClient.setValue({ field:'field1', value:"new value" }, function(err){ });
- * const {err} = await FSBL.Clients.ConfigClient.setValue({ field:'field1', value:'new value' })
- * ```
- * @param {function} cb Optional callback
- */
-export declare const setValue: (params: FieldAndValueParam, cb?: StandardErrorCallback<void>) => Promise<{
-    err: string | null | undefined;
-}>;
-/**
- * @language javascript, java, dotnet
- * @deprecated - Use [FSBL.Clients.ConfigClient.setMultiple()](#setmultiple) instead.
- *
- * Set multiple values in the config.
- *
- * ```javascript
- * FSBL.Clients.ConfigClient.setValues([{ field:'field1', value: "new value" }]);
- * const {err} = await FSBL.Clients.ConfigClient.setValues([{ field:'field1', value: "new value" }]);
- * ```
- * @param {function} cb Optional callback
- */
-export declare const setValues: (fields: FieldAndValueParams, cb?: StandardErrorCallback<void>) => Promise<{
-    err: string | null | undefined;
-}>;
-/**
- * @language javascript, java, dotnet
- * Remove a value (and its key) from the config.
- *
- * Removing a value will trigger events that you can listen to using <a href="#addlistener">`addListener()`</a>.
- *
- * ```javascript
- * FSBL.Clients.ConfigClient.remove(
-    ['field1', 'property1'],  // field1.property1
-    function(err,value){ }
-   );
- *
- * const {err, data} = await FSBL.Clients.ConfigClient.remove(
-    ['field1', 'property1']); // field1.property1
- * ```
- *
- * :::note
- * In Java, this method is named `removeValue`.
- * :::
- * @param {Function} cb Optional callback.
- */
-export declare const remove: <T = any>(path: PathArray, cb?: StandardErrorCallback<T> | undefined) => StandardPromise<T>;
-/**
- * @language javascript, java, dotnet
- * Remove multiple values (and their keys) from the config.
- *
- * Removing a value will trigger events that you can listen to using <a href="#addlistener">`addListener()`</a>.
- *
- * ```javascript
- * // Remove field1.property1 AND field2.property2
- * FSBL.Clients.ConfigClient.removeMultiple(
- *   [
- * 		['field1', 'property1'],
- * 		['field2', 'property2']
- *   ],
- *   function(err,value){ }
- * );
- *
- * // Remove field1.property1 AND field2.property2
- * const {err, data} = await FSBL.Clients.ConfigClient.removeMultiple([
- *   ['field1', 'property1'],
- *   ['field2', 'property2']
- * ]);
- * ```
- *
- * :::note
- * In Java, this method is named `removeValues`.
- * :::
- * @param {Function} cb Optional callback.
- */
-export declare const removeMultiple: <T = any>(paths: PathArray[], cb?: StandardErrorCallback<T> | undefined) => StandardPromise<T>;
-/**
- * @language javascript, java, dotnet
- * @deprecated - Use [`FSBL.Clients.ConfigClient.remove()`](#remove) instead.
- *
- * Remove a value from the config.
- *
- * ```javascript
- * FSBL.Clients.ConfigClient.removeValue({ field:'field1' }, function(err){ });
- * FSBL.Clients.ConfigClient.removeValue('field1', function(err){ });
- *
- * const {err} = await FSBL.Clients.ConfigClient.removeValue({ field:'field1' });
- * const {err} = await FSBL.Clients.ConfigClient.removeValue('field1');
- * ```
- * @param {String} field - Name of field to remove
- * @param {Function} cb -  Returns an error if there is one
- */
-export declare const removeValue: <T = any>(params: FieldOnlyParam | string, cb?: StandardErrorCallback<T> | undefined) => StandardPromise<T>;
-/**
- * @language javascript, java, dotnet
- * @deprecated - Use [`FSBL.Clients.ConfigClient.removeMultiple()`](#removemultiple) instead.
- *
- * Removes multiple values from the config.
- *
- * ```javascript
- * FSBL.Clients.ConfigClient.removeValues(['field1'], function(err){ });
- * const {err} = await FSBL.Clients.ConfigClient.removeValues(['field1'])
- * ```
- * @param {FieldOnlyParam[] | string[]} fields - An array of objects containing a field property or an array of string field names.
- * @param {Function} cb -  Returns an error if there is one.
- */
-export declare const removeValues: (fields: FieldOnlyParam[] | string[], cb?: StandardErrorCallback<void>) => Promise<{
-    err: string | null | undefined;
-}>;
-/**
- * @language javascript, java, dotnet
- * Add a listener to the config at either the root config level or field level.
- * If no field is given, the root config level is used. You can also listen for changes to config fields any number of levels deep -- finsemble.configitem.deeperconfigitem.evendeeperconfigitem
- *
- * ```javascript
- * const myFunction = function(err,data){ };
- *
- * FSBL.Clients.ConfigClient.addListener({ field:'field1' }, myFunction, cb);
- * FSBL.Clients.ConfigClient.addListener(['field1', 'property1'], myFunction, cb); // field1.property1
- * ```
- * @param {{ field: string | null } | PathArray} params The piece of data that you want to listen on. If this is empty it listens to all changes of the store.
- * @param {ListenerFunction} fn The function to be called when the observed piece of config is modified.
- * @param {Function} cb Callback to be invoked after the listener is added.
- */
-export declare const addListener: <T = any>(params: {
-    field: string | null;
-} | PathArray, fn: ListenerFunction<T>, cb?: () => void) => Promise<void>;
-/**
- * @language javascript, java, dotnet
- * Add an array of listeners as objects, strings or path arrays.
- * If using strings, you must provide a function callback as the second parameter.
- *
- * ```javascript
- * const myFunction = function(err,data){}
- * FSBL.Clients.ConfigClient.addListeners(
- * 	[
- * 		{ field: "field1", listener: myFunction },
- * 		{ field: "field2", listener: myFunction }
- * 	],
- * 	null,
- * 	cb
- * );
- *
- * FSBL.Clients.ConfigClient.addListeners(
- * [{ field: "field1" }, { field: "field2", listener: myFunction }],
- * myFunction,
- * cb
- * );
- *
- * FSBL.Clients.ConfigClient.addListeners(["field1", "field2"], myFunction, cb);
- * ```
- * @param {listenerParam[] | string[] | PathArrayListenerParam[]} params.field The piece of data that you want listen on. If this is empty it listen to all config changes.
- * @param {ListenerFunction} params.listener The function to call when the piece of data is modified. If this is empty, fn is used.
- * @param {function} fn The function to be called when the observed piece of config is modified.
- * @param {function} cb Callback to be invoked after the listeners are added.
-
- */
-export declare const addListeners: <T = any>(params: ListenerParam[] | string[] | PathArrayListenerParam[], fn: ListenerFunction<T>, cb?: () => void) => Promise<void> | undefined;
-/**
- * @language javascript, java, dotnet
- * Remove a listener from config. If no field is given, we look for a config root listener
- *
- * ```javascript
- * let myFunction = function(err,data){ }
- *
- * FSBL.Clients.ConfigClient.removeListener({field:'field1'}, myFunction, function(err, bool){ });
- * FSBL.Clients.ConfigClient.removeListener(myFunction, function(err, bool){ });
- * FSBL.Clients.ConfigClient.removeListener(['field1'], myFunction, function(err, bool){ });
- * ```
- * @param {function} fn The listener to remove.
- * @param {function} cb Returns true if it was successful in removing the listener.
- *
- */
-export declare const removeListener: (params: {
-    field: string | null;
-} | PathArray, fn: ListenerFunction<any>, cb?: Function) => void;
-/**
- * @language javascript, java, dotnet
- * Remove an array of listeners from the config
- *
- * ```javascript
- * let myFunction = function(err,data){ };
- * FSBL.Clients.ConfigClient.removeListeners(
- *   {
- * 	    field: 'field1'
- *   },
- *   MyFunction,
- *   function(bool){ }
- * );
- *
- * FSBL.Clients.ConfigClient.removeListeners(
- *   [{ field:'field1', listener: MyFunction }],
- *   function(bool){ }
- * );
- *
- * FSBL.Clients.ConfigClient.removeListeners(
- *   ['field1'],
- *   MyFunction,
- *   function(bool) { }
- * );
- * ```
- * @param {removeListenersType} params
- * @param {function} fn The listener to remove
- * @param {function} cb Returns true if it was successful in removing the listener.
- *
- */
-export declare const removeListeners: (params: RemoveListenersType, fn?: ListenerFunction<any>, cb?: StandardErrorCallback<boolean>) => void;
-/**
- * @language javascript, java, dotnet
- * Dynamically set config values within the Finsemble configuration. You can set new config properties
- * or modify existing ones. Note that configuration changes will not necessarily dynamically modify
- * the components or services that use the corresponding configuration -- it depends if the component
- * or service handles the corresponding change notifications (either though PubSub or the config's
- * DataStore). Also, these changes do not persist in any config files.
- *
- * Only services and components that reside on the same domain as Finsemble can use `proessAndSet`.
- * If you want to use it from a domain other than Finsemble, you can't do so directly. Instead,
- * you need to set up a proxy service that is hosted on the same domain as Finsemble.
- * Because this proxy server is on the same domain as Finsemble, it can use `processAndSet`.
- * Now, you can have an externally hosted service or app communicate with this proxy service.
- *
- * Here is an example:
- * 1. Create a proxy app service on the Finsemble domain and make it subscribe to a channel
- * (for example, "customerName.app.config").
- * 2. The cross domain app publishes the new config on that same channel ("customerName.app.config").
- * 3. When the proxy app service receives this request, it invokes `ConfigClient.processAndSet(...)` using
- * the payload from the router message.
- *
- * :::note
- * Any time you set config by using this API, the newConfig along with the updated manifest will by
- * published to the PubSub topic "Config.changeNotification". To get these notifications any
- * component or service you can subscribe to the topic. See an example below.
- * :::
- *
- * :::note
- * Anytime you set config by using this API, the dataStore underlying configuration
- * 'Finsemble-Configuration-Store' will also be updated. To get these dataStore events, you can set
- * a listener as shown in the example below. However, any config modifications made directly though
- * the DataStore will not result in corresponding PubSub notifications.
- * :::
- *
- * :::caution
- * During dynamic configuration, Finsemble can overwrite components already in the configuration when
- * `ConfigClient.processAndSet` is called. To prevent this from happening, set
- * `manifest.component.category = "system"` in the config of the component. For example, use this setting
- * to prevent system UI components from being dropped out of the config.
- * :::
- *
- * ```javascript
- * // Examples using processAndSet()
- * FSBL.Clients.ConfigClient.processAndSet({ newConfig: { myNewConfigField: 12345 }, overwrite: false });
- * FSBL.Clients.ConfigClient.processAndSet(
- * {
- *	newConfig: {
- *		"myNewConfigField": 12345,
- *		"myNewConfigObject": {
- *			A: "this is a test",
- *			B: "more test"
- *		},
- *		"importConfig": [
- *			"$applicationRoot/configs/application/test.json",
- *		]
- *	},
- *	overwrite: true,
- *  replace: false,
- * },
- *	function (err, finsemble) {
- *		if (err) {
- *			console.error("ConfigClient.set", err);
- *		} else {
- *			console.log("new finsemble config", finsemble);
- *		}
- *	}
- * );
- *
- *  // example subscribing to PubSub to get notifications of dynamic updates
- * RouterClient.subscribe("Config.changeNotification", function (err, notify) {
- *		console.log("set notification", notify.data.newConfig, notify.data.finsemble);
- *	});
- *
- *  // example using DataStore to get notifications of dynamic updates
- * DistributedStoreClient.getStore({ store: 'Finsemble-Configuration-Store', global: true }, function (err, configStore) {
- *		configStore.addListener({ field: "finsemble" }, function (err, newFinsembleConfig) {
- *			console.log("new manifest.finsemble configuration", newFinsembleConfig);
- *		});
- * });
- * ```
- *
- * @param {object} params
- * @param {object} params.newConfig Provides the configuration properties to add into the existing configuration under manifest.finsemble. This config must match the Finsemble config requirements as described in the [Configuration tutorial](/docs/customize/customize-with-SDK/configuration). It can include importConfig references to dynamically fetch additional configuration files.
- * @param {boolean} params.overwrite If true then overwrite any preexisting config with new config (can only set to true when running from same origin, not cross-domain); if false then newConfig must not match properties of existing config, including service and component configuration.
- * @param {boolean} params.replace True specifies any component, app, or service definitions in the new config will place all existing non-system component and service configuration
- * @param {StandardErrorCallback} callback Callback to be invoked upon task completion.
- *
- */
-export declare const processAndSet: (params: {
-    newConfig: Record<string, any>;
-    overwrite: boolean;
-    replace: boolean;
-}, cb?: ProcessAndSetCallback) => StandardPromise<Manifest>;
-/**
- * @language javascript, java, dotnet
- * Sets a value on the configStore and persists that value to storage. On application restart, this value will overwrite any application defaults.
- *
- * ```javascript
- * FSBL.Clients.ConfigClient.setPreference({
- * 	field: "finsemble.initialWorkspace",
- * 	value: "Workspace 2"
- * }, (err, response) => {
- * 		// preference has been set
- * });
- *
- * const {err, data} = await FSBL.Clients.ConfigClient.setPreference({
- *   field: "finsemble.initialWorkspace",
- *   value: "Workspace 2"
- * });
- * ```
- * @param {fieldAndValueParam} params
- * @param {StandardErrorCallback} callback Callback to be invoked when preferences have been retrieved from the service or on error.
- */
-export declare const setPreference: (params: FieldAndValueParam, cb?: StandardErrorCallback<void>) => StandardPromise<void>;
-/**
- * @language javascript, java, dotnet
- * Retrieves all of the preferences set for the application.
- *
- * ```javascript
- * FSBL.Clients.ConfigClient.getPreferences((err, preferences)=> {
- * 		 if (!err) {
- * 		 	console.log(preferences); // an object containing the entire user preferences.
- * 		 }
- * });
- * const {err, data} = await FSBL.Clients.ConfigClient.getPreferences();
- * ```
- *
- * @param {StandardErrorCallback} callback Callback to be invoked when preferences have been retrieved from the service.
- */
-export declare const getPreferences: (cb?: StandardErrorCallback<Record<string, any> | null>) => StandardPromise<Record<string, any> | null>;
-/**
- * @language javascript, dotnet
- * Reset a user preference value to default. On application restart, the application default value will be used instead of the preference.
- *
- * ```javascript
- * FSBL.Clients.ConfigClient.unsetPreference({
- * 	field: "finsemble.initialWorkspace",
- * }, (err, response) => {
- * 		//preference has been unset
- * });
- * const {err, data} = await FSBL.Clients.ConfigClient.unsetPreference({
- *   field: "finsemble.initialWorkspace"
- * });
- * ```
- * @param params The preference field to unset.
- * @param callback The callback to be invoked after the preference is removed or on error.
- */
-export declare const unsetPreference: (params: FieldOnlyParam, cb?: StandardErrorCallback<void>) => StandardPromise<void>;
-/**
- * @ignore
- */
-export declare const ConfigClient: {
-    /**
-     * For backward compatibility
-     * @private
-     * @deprecated
-     */
-    initialize(): void;
-    /**
-     * For backward compatibility
-     * @private
-     * @deprecated
-     */
-    onReady: (cb?: any) => void;
-    /**
-     * @private
-     * @deprecated
-     */
-    triggerListeners(listenerKey: string, data: any): void;
-    /**
-     * @private
-     * @deprecated
-     */
-    handleChanges(err: StandardError, response: {
-        data: {
-            store: string;
-            storeData: any;
-            field: string | null;
-            value: any;
-        };
-    }): void;
-    /**
-     * @private
-     * @deprecated
-     */
-    changeSub(change: string): Promise<void>;
-    addListener: <T = any>(params: {
-        field: string | null;
-    } | PathArray, fn: ListenerFunction<T>, cb?: () => void) => Promise<void>;
-    addListeners: <T_1 = any>(params: ListenerParam[] | string[] | PathArrayListenerParam[], fn: ListenerFunction<T_1>, cb?: () => void) => Promise<void> | undefined;
-    getManifest: (cb?: StandardErrorCallback<Manifest>) => StandardPromise<Manifest>;
-    getPreferences: (cb?: StandardErrorCallback<Record<string, any> | null>) => StandardPromise<Record<string, any> | null>;
-    getValue: <T_2 = any>(params: FieldOnlyParam | string, cb?: StandardErrorCallback<T_2> | undefined) => StandardPromise<T_2>;
-    getValues: <T_3 = any>(fields?: FieldOnlyParam[] | string[] | null, cb?: StandardErrorCallback<Record<string, T_3>> | undefined) => StandardPromise<Record<string, T_3>>;
-    processAndSet: (params: {
-        newConfig: Record<string, any>;
-        overwrite: boolean;
-        replace: boolean;
-    }, cb?: ProcessAndSetCallback) => StandardPromise<Manifest>;
-    removeListener: (params: {
-        field: string | null;
-    } | PathArray, fn: ListenerFunction<any>, cb?: Function) => void;
-    removeListeners: (params: RemoveListenersType, fn?: ListenerFunction<any>, cb?: StandardErrorCallback<boolean>) => void;
-    removeValue: <T_4 = any>(params: FieldOnlyParam | string, cb?: StandardErrorCallback<T_4> | undefined) => StandardPromise<T_4>;
-    removeValues: (fields: FieldOnlyParam[] | string[], cb?: StandardErrorCallback<void>) => Promise<{
-        err: string | null | undefined;
-    }>;
-    setPreference: (params: FieldAndValueParam, cb?: StandardErrorCallback<void>) => StandardPromise<void>;
-    setValue: (params: FieldAndValueParam, cb?: StandardErrorCallback<void>) => Promise<{
-        err: string | null | undefined;
-    }>;
-    setValues: (fields: FieldAndValueParams, cb?: StandardErrorCallback<void>) => Promise<{
-        err: string | null | undefined;
-    }>;
-    unsetPreference: (params: FieldOnlyParam, cb?: StandardErrorCallback<void>) => StandardPromise<void>;
-    get: <T_5 = any>(path: PathArray | null, cb?: StandardErrorCallback<T_5> | undefined) => StandardPromise<T_5>;
-    getMultiple: <T_6 = any>(paths: PathArray[], cb?: StandardErrorCallback<T_6> | undefined) => StandardPromise<T_6>;
-    set: <T_7 = any>(path: PathArray, value: any, cb?: StandardErrorCallback<T_7> | undefined) => StandardPromise<T_7>;
-    setMultiple: <T_8 = any>(pathsAndValues: FieldPathArrayAndValue[], cb?: StandardErrorCallback<T_8> | undefined) => StandardPromise<T_8>;
-    remove: <T_9 = any>(path: PathArray, cb?: StandardErrorCallback<T_9> | undefined) => StandardPromise<T_9>;
-    removeMultiple: <T_10 = any>(paths: PathArray[], cb?: StandardErrorCallback<T_10> | undefined) => StandardPromise<T_10>;
-};
-/**
- * @ignore
- */
-export default ConfigClient;
+/*!
+ * Copyright 2017 - 2020 by ChartIQ, Inc.
+ * All rights reserved.
+ */
+/**
+ * This client provides run-time access to Finsemble's configuration.
+ * The Config Client functions similar to a global store created with the Distributed Store Client and offers many of the same methods.
+ * Values modified at runtime are not persisted.
+ *
+ *
+ * See the [Configuration tutorial](/docs/customize/customize-with-SDK/configuration) for a configuration overview.
+ *
+ * @module ConfigClient
+ */
+/**
+This is how we want our API to work going forward, the way the world does it: import { processAndSet } from "configClient"
+```
+export const processAndSet = () => { ... }
+```
+
+This module's single exported object gives us backward compatibility when our core code does this: import { ConfigClient } from "configClient"
+and provides the object that is attached to FSBL.Clients. This export should be kept as clean and simple as possible.
+```
+export const ConfigClient = {
+   processAndSet
+}
+```
+
+The default export gives us backward compatibility where our core code does this: import ConfigClient from "configClient"
+This can be eliminated when our core core is converted to normal imports as in the first example.
+```
+export default ConfigClient;
+```
+*/
+import { QueryResponse } from "./routerClient";
+import { StandardErrorCallback, StandardPromise, StandardError, Manifest, FieldPathArrayAndValue, FieldOnlyParam, FieldAndValueParam, FieldAndValueParams, PathArray, ListenerFunction, ListenerParam, RemoveListenersType, PathArrayListenerParam } from "../types";
+export { PathArray, ListenerFunction, ListenerParam, PathArrayListenerParam, FieldOnlyParam, RemoveListenersType, FieldPathArrayAndValue, FieldAndValueParam, FieldAndValueParams, };
+export { FieldPathArray } from "../types";
+export type ProcessAndSetCallback = StandardErrorCallback<QueryResponse<Manifest>>;
+/**
+ * @language javascript, dotnet
+ * Retrieves the entire manifest
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.getManifest(function(err, value){ });
+ * const {err, data} = await FSBL.Clients.ConfigClient.getManifest();
+ * ```
+ */
+export declare const getManifest: (cb?: StandardErrorCallback<Manifest>) => StandardPromise<Manifest>;
+/**
+ * @language javascript, java, dotnet
+ * Get a value from the config.
+ *
+ * If a field does not exists in the configuration, `data` will be undefined and `err` will
+ * be null.
+ *
+ * If you pass path as null or an empty path the entire config is returned.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.get(
+ *   ['field1', 'property1'], // field1.property1
+ *   function(err,value){ }
+ * );
+ *
+ * const {err, data} = await FSBL.Clients.ConfigClient.get(
+ *   ['field1', 'property1'] // field1.property1
+ * );
+ * ```
+ *
+ * :::note
+ * In Java, this method is named `getValue`.
+ * :::
+ * @param {Function} cb Will return the value if found.
+ */
+export declare const get: <T = any>(path: PathArray | null, cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+/**
+ * @language javascript, java, dotnet
+ *
+ * Get multiple values from the config.
+ *
+ * If a field does not exists in the configuration, `data` will be undefined and `err` will
+ * be null.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.getMultiple(
+ *  [
+ *    // field1.property1.subproperty1
+ *    ["field1", "property1", "subproperty1"],
+ *
+ *    // field1.property2
+ *    ["field1", "property2"]
+ *  ], (err, values) => {
+ *    if(!err){
+ *      console.log("Values: ", values);
+ *   }
+ * });
+ *
+ * const {err, data} = await FSBL.Clients.ConfigClient.getMultiple([
+ *   // field1.property1.subproperty1
+ *   ["field1", "property1", "subproperty1"],
+ *
+ *   // field1.property2
+ *   ["field1", "property2"]                  // field1.property2
+ * ]);
+ * if(!err){
+ *   console.log("Values: ", data);
+ * }
+ * ```
+ * @param {Function} cb Will return the value if found.
+ */
+export declare const getMultiple: <T = any>(paths: PathArray[], cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+/**
+ * @language javascript, java, dotnet
+ * @deprecated - Use [ `FSBL.Clients.ConfigClient.get()`](#get) instead.
+ *
+ * Get a value from the config.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.getValue({ field:'field1' }, function(err,value){ });
+ * FSBL.Clients.ConfigClient.getValue('field1', function(err,value){ });
+ * const {err, data} = await FSBL.Clients.ConfigClient.getValue({ field:'field1' });
+ * const {err, data} = await FSBL.Clients.ConfigClient.getValue('field1');
+ * ```
+ * @param {Function} cb Will return the value if found.
+ *
+ */
+export declare const getValue: <T = any>(params: FieldOnlyParam | string, cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+/**
+ * @language javascript, java, dotnet
+ * @deprecated - Use [`FSBL.Clients.ConfigClient.getMultiple()`](#getmultiple) instead.
+ *
+ * Get multiple values from the config.
+ *
+ * :::caution
+ * **Deprecated functionality**: If there are no fields provided, the complete configuration manifest
+ * is returned (use [getManifest()](#getmanifest)).
+ * :::
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.getValues(['field1','field2'], function(err,values){ });
+ * FSBL.Clients.ConfigClient.getValues(null, callback); // returns the complete manifest containing the finsemble property
+ * const {err, data} = await FSBL.Clients.ConfigClient.getValues(['field1', 'field2']);
+ * ```
+ * @param {fieldOnlyParam[] | string[]} fields An array of objects containing a field property or an array of string field names.
+ * @param {Function} cb Will return the value if found.
+ */
+export declare const getValues: <T = any>(fields?: FieldOnlyParam[] | string[] | null, cb?: StandardErrorCallback<Record<string, T>>) => StandardPromise<Record<string, T>>;
+/**
+ * @language javascript, java, dotnet
+ * Sets a value in the config.
+ *
+ * Setting a value will trigger events that you can listen to using [`addListener()`](#addlistener).
+ *
+ * ```javascript
+ * // Set field1.property1 = "foo"
+ * FSBL.Clients.ConfigClient.set(
+ *   ['field1', 'property1'],
+ *   "foo",
+ *   function(err,value){ }
+ * );
+ *
+ * // Set field1.property1 = "foo"
+ * const {err, data} = await FSBL.Clients.ConfigClient.set(['field1', 'property1'], "foo");
+ * ```
+ * :::note
+ * In Java, this method is named `setValue`.
+ * :::
+ * @param {Function} cb Optional callback.
+ */
+export declare const set: <T = any>(path: PathArray, value: any, cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+/**
+ * @language javascript, java, dotnet
+ * Sets multiple values in the config.
+ *
+ * Setting a value will trigger events that you can listen to using <a href="#addlistener">`addListener()`</a>.
+ *
+ * ```javascript
+ * // Set both field1.property1 = "foo" AND field2.property2 = "bar"
+ * FSBL.Clients.ConfigClient.setMultiple(
+ *   [
+ * 		{field: ['field1', 'property1'], value: "foo"},
+ * 		{field: ['field2', 'property2'], value: "bar"}
+ *   ],
+ *   function(err,value){ }
+ * );
+ *
+ * // Set both field1.property1 = "foo" AND field2.property2 = "bar"
+ * const {err, data} = await FSBL.Clients.ConfigClient.setMultiple([
+ *   {field: ['field1', 'property1'], value: "foo"},
+ *   {field: ['field2', 'property2'], value: "bar"}
+ * ]);
+ * ```
+ *
+ *
+ * :::note
+ * In Java, this method is named `setValues`.
+ * :::
+ * @param {Function} cb Optional callback.
+ */
+export declare const setMultiple: <T = any>(pathsAndValues: FieldPathArrayAndValue[], cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+/**
+ * @language javascript, java, dotnet
+ * @deprecated - Use [`FSBL.Clients.ConfigClient.set()`](#set) instead.
+ *
+ * Set a value in the config. Setting a value will trigger events that you can listen to using <a href="#addlistener">`addListener()`</a>.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.setValue({ field:'field1', value:"new value" }, function(err){ });
+ * const {err} = await FSBL.Clients.ConfigClient.setValue({ field:'field1', value:'new value' })
+ * ```
+ * @param {function} cb Optional callback
+ */
+export declare const setValue: (params: FieldAndValueParam, cb?: StandardErrorCallback<void>) => Promise<{
+    err: string | null | undefined;
+}>;
+/**
+ * @language javascript, java, dotnet
+ * @deprecated - Use [FSBL.Clients.ConfigClient.setMultiple()](#setmultiple) instead.
+ *
+ * Set multiple values in the config.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.setValues([{ field:'field1', value: "new value" }]);
+ * const {err} = await FSBL.Clients.ConfigClient.setValues([{ field:'field1', value: "new value" }]);
+ * ```
+ * @param {function} cb Optional callback
+ */
+export declare const setValues: (fields: FieldAndValueParams, cb?: StandardErrorCallback<void>) => Promise<{
+    err: string | null | undefined;
+}>;
+/**
+ * @language javascript, java, dotnet
+ * Remove a value (and its key) from the config.
+ *
+ * Removing a value will trigger events that you can listen to using <a href="#addlistener">`addListener()`</a>.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.remove(
+    ['field1', 'property1'],  // field1.property1
+    function(err,value){ }
+   );
+ *
+ * const {err, data} = await FSBL.Clients.ConfigClient.remove(
+    ['field1', 'property1']); // field1.property1
+ * ```
+ *
+ * :::note
+ * In Java, this method is named `removeValue`.
+ * :::
+ * @param {Function} cb Optional callback.
+ */
+export declare const remove: <T = any>(path: PathArray, cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+/**
+ * @language javascript, java, dotnet
+ * Remove multiple values (and their keys) from the config.
+ *
+ * Removing a value will trigger events that you can listen to using <a href="#addlistener">`addListener()`</a>.
+ *
+ * ```javascript
+ * // Remove field1.property1 AND field2.property2
+ * FSBL.Clients.ConfigClient.removeMultiple(
+ *   [
+ * 		['field1', 'property1'],
+ * 		['field2', 'property2']
+ *   ],
+ *   function(err,value){ }
+ * );
+ *
+ * // Remove field1.property1 AND field2.property2
+ * const {err, data} = await FSBL.Clients.ConfigClient.removeMultiple([
+ *   ['field1', 'property1'],
+ *   ['field2', 'property2']
+ * ]);
+ * ```
+ *
+ * :::note
+ * In Java, this method is named `removeValues`.
+ * :::
+ * @param {Function} cb Optional callback.
+ */
+export declare const removeMultiple: <T = any>(paths: PathArray[], cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+/**
+ * @language javascript, java, dotnet
+ * @deprecated - Use [`FSBL.Clients.ConfigClient.remove()`](#remove) instead.
+ *
+ * Remove a value from the config.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.removeValue({ field:'field1' }, function(err){ });
+ * FSBL.Clients.ConfigClient.removeValue('field1', function(err){ });
+ *
+ * const {err} = await FSBL.Clients.ConfigClient.removeValue({ field:'field1' });
+ * const {err} = await FSBL.Clients.ConfigClient.removeValue('field1');
+ * ```
+ * @param {String} field - Name of field to remove
+ * @param {Function} cb -  Returns an error if there is one
+ */
+export declare const removeValue: <T = any>(params: FieldOnlyParam | string, cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+/**
+ * @language javascript, java, dotnet
+ * @deprecated - Use [`FSBL.Clients.ConfigClient.removeMultiple()`](#removemultiple) instead.
+ *
+ * Removes multiple values from the config.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.removeValues(['field1'], function(err){ });
+ * const {err} = await FSBL.Clients.ConfigClient.removeValues(['field1'])
+ * ```
+ * @param {FieldOnlyParam[] | string[]} fields - An array of objects containing a field property or an array of string field names.
+ * @param {Function} cb -  Returns an error if there is one.
+ */
+export declare const removeValues: (fields: FieldOnlyParam[] | string[], cb?: StandardErrorCallback<void>) => Promise<{
+    err: string | null | undefined;
+}>;
+/**
+ * @language javascript, java, dotnet
+ * Add a listener to the config at either the root config level or field level.
+ * If no field is given, the root config level is used. You can also listen for changes to config fields any number of levels deep -- finsemble.configitem.deeperconfigitem.evendeeperconfigitem
+ *
+ * ```javascript
+ * const myFunction = function(err,data){ };
+ *
+ * FSBL.Clients.ConfigClient.addListener({ field:'field1' }, myFunction, cb);
+ * FSBL.Clients.ConfigClient.addListener(['field1', 'property1'], myFunction, cb); // field1.property1
+ * ```
+ * @param {{ field: string | null } | PathArray} params The piece of data that you want to listen on. If this is empty it listens to all changes of the store.
+ * @param {ListenerFunction} fn The function to be called when the observed piece of config is modified.
+ * @param {Function} cb Callback to be invoked after the listener is added.
+ */
+export declare const addListener: <T = any>(params: {
+    field: string | null;
+} | PathArray, fn: ListenerFunction<T>, cb?: () => void) => Promise<void>;
+/**
+ * @language javascript, java, dotnet
+ * Add an array of listeners as objects, strings or path arrays.
+ * If using strings, you must provide a function callback as the second parameter.
+ *
+ * ```javascript
+ * const myFunction = function(err,data){}
+ * FSBL.Clients.ConfigClient.addListeners(
+ * 	[
+ * 		{ field: "field1", listener: myFunction },
+ * 		{ field: "field2", listener: myFunction }
+ * 	],
+ * 	null,
+ * 	cb
+ * );
+ *
+ * FSBL.Clients.ConfigClient.addListeners(
+ * [{ field: "field1" }, { field: "field2", listener: myFunction }],
+ * myFunction,
+ * cb
+ * );
+ *
+ * FSBL.Clients.ConfigClient.addListeners(["field1", "field2"], myFunction, cb);
+ * ```
+ * @param {listenerParam[] | string[] | PathArrayListenerParam[]} params.field The piece of data that you want listen on. If this is empty it listen to all config changes.
+ * @param {ListenerFunction} params.listener The function to call when the piece of data is modified. If this is empty, fn is used.
+ * @param {function} fn The function to be called when the observed piece of config is modified.
+ * @param {function} cb Callback to be invoked after the listeners are added.
+
+ */
+export declare const addListeners: <T = any>(params: ListenerParam[] | string[] | PathArrayListenerParam[], fn: ListenerFunction<T>, cb?: () => void) => Promise<void> | undefined;
+/**
+ * @language javascript, java, dotnet
+ * Remove a listener from config. If no field is given, we look for a config root listener
+ *
+ * ```javascript
+ * let myFunction = function(err,data){ }
+ *
+ * FSBL.Clients.ConfigClient.removeListener({field:'field1'}, myFunction, function(err, bool){ });
+ * FSBL.Clients.ConfigClient.removeListener(myFunction, function(err, bool){ });
+ * FSBL.Clients.ConfigClient.removeListener(['field1'], myFunction, function(err, bool){ });
+ * ```
+ * @param {function} fn The listener to remove.
+ * @param {function} cb Returns true if it was successful in removing the listener.
+ *
+ */
+export declare const removeListener: (params: {
+    field: string | null;
+} | PathArray, fn: ListenerFunction<any>, cb?: Function) => void;
+/**
+ * @language javascript, java, dotnet
+ * Remove an array of listeners from the config
+ *
+ * ```javascript
+ * let myFunction = function(err,data){ };
+ * FSBL.Clients.ConfigClient.removeListeners(
+ *   {
+ * 	    field: 'field1'
+ *   },
+ *   MyFunction,
+ *   function(bool){ }
+ * );
+ *
+ * FSBL.Clients.ConfigClient.removeListeners(
+ *   [{ field:'field1', listener: MyFunction }],
+ *   function(bool){ }
+ * );
+ *
+ * FSBL.Clients.ConfigClient.removeListeners(
+ *   ['field1'],
+ *   MyFunction,
+ *   function(bool) { }
+ * );
+ * ```
+ * @param {removeListenersType} params
+ * @param {function} fn The listener to remove
+ * @param {function} cb Returns true if it was successful in removing the listener.
+ *
+ */
+export declare const removeListeners: (params: RemoveListenersType, fn?: ListenerFunction<any>, cb?: StandardErrorCallback<boolean>) => void;
+/**
+ * @language javascript, java, dotnet
+ * Dynamically set config values within the Finsemble configuration. You can set new config properties
+ * or modify existing ones. Note that configuration changes will not necessarily dynamically modify
+ * the components or services that use the corresponding configuration -- it depends if the component
+ * or service handles the corresponding change notifications (either though PubSub or the config's
+ * DataStore). Also, these changes do not persist in any config files.
+ *
+ * Only services and components that reside on the same domain as Finsemble can use `proessAndSet`.
+ * If you want to use it from a domain other than Finsemble, you can't do so directly. Instead,
+ * you need to set up a proxy service that is hosted on the same domain as Finsemble.
+ * Because this proxy server is on the same domain as Finsemble, it can use `processAndSet`.
+ * Now, you can have an externally hosted service or app communicate with this proxy service.
+ *
+ * Here is an example:
+ * 1. Create a proxy app service on the Finsemble domain and make it subscribe to a channel
+ * (for example, "customerName.app.config").
+ * 2. The cross domain app publishes the new config on that same channel ("customerName.app.config").
+ * 3. When the proxy app service receives this request, it invokes `ConfigClient.processAndSet(...)` using
+ * the payload from the router message.
+ *
+ * :::note
+ * Any time you set config by using this API, the newConfig along with the updated manifest will by
+ * published to the PubSub topic "Config.changeNotification". To get these notifications any
+ * component or service you can subscribe to the topic. See an example below.
+ * :::
+ *
+ * :::note
+ * Anytime you set config by using this API, the dataStore underlying configuration
+ * 'Finsemble-Configuration-Store' will also be updated. To get these dataStore events, you can set
+ * a listener as shown in the example below. However, any config modifications made directly though
+ * the DataStore will not result in corresponding PubSub notifications.
+ * :::
+ *
+ * :::caution
+ * During dynamic configuration, Finsemble can overwrite components already in the configuration when
+ * `ConfigClient.processAndSet` is called. To prevent this from happening, set
+ * `manifest.component.category = "system"` in the config of the component. For example, use this setting
+ * to prevent system UI components from being dropped out of the config.
+ * :::
+ *
+ * ```javascript
+ * // Examples using processAndSet()
+ * FSBL.Clients.ConfigClient.processAndSet({ newConfig: { myNewConfigField: 12345 }, overwrite: false });
+ * FSBL.Clients.ConfigClient.processAndSet(
+ * {
+ *	newConfig: {
+ *		"myNewConfigField": 12345,
+ *		"myNewConfigObject": {
+ *			A: "this is a test",
+ *			B: "more test"
+ *		},
+ *		"importConfig": [
+ *			"$applicationRoot/configs/application/test.json",
+ *		]
+ *	},
+ *	overwrite: true,
+ *  replace: false,
+ * },
+ *	function (err, finsemble) {
+ *		if (err) {
+ *			console.error("ConfigClient.set", err);
+ *		} else {
+ *			console.log("new finsemble config", finsemble);
+ *		}
+ *	}
+ * );
+ *
+ *  // example subscribing to PubSub to get notifications of dynamic updates
+ * RouterClient.subscribe("Config.changeNotification", function (err, notify) {
+ *		console.log("set notification", notify.data.newConfig, notify.data.finsemble);
+ *	});
+ *
+ *  // example using DataStore to get notifications of dynamic updates
+ * DistributedStoreClient.getStore({ store: 'Finsemble-Configuration-Store', global: true }, function (err, configStore) {
+ *		configStore.addListener({ field: "finsemble" }, function (err, newFinsembleConfig) {
+ *			console.log("new manifest.finsemble configuration", newFinsembleConfig);
+ *		});
+ * });
+ * ```
+ *
+ * @param {object} params
+ * @param {object} params.newConfig Provides the configuration properties to add into the existing configuration under manifest.finsemble. This config must match the Finsemble config requirements as described in the [Configuration tutorial](/docs/customize/customize-with-SDK/configuration). It can include importConfig references to dynamically fetch additional configuration files.
+ * @param {boolean} params.overwrite If true then overwrite any preexisting config with new config (can only set to true when running from same origin, not cross-domain); if false then newConfig must not match properties of existing config, including service and component configuration.
+ * @param {boolean} params.replace True specifies any component, app, or service definitions in the new config will place all existing non-system component and service configuration
+ * @param {StandardErrorCallback} callback Callback to be invoked upon task completion.
+ *
+ */
+export declare const processAndSet: (params: {
+    newConfig: Record<string, any>;
+    overwrite: boolean;
+    replace: boolean;
+}, cb?: ProcessAndSetCallback) => StandardPromise<Manifest>;
+/**
+ * @language javascript, java, dotnet
+ * Sets a value on the configStore and persists that value to storage. On application restart, this value will overwrite any application defaults.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.setPreference({
+ * 	field: "finsemble.initialWorkspace",
+ * 	value: "Workspace 2"
+ * }, (err, response) => {
+ * 		// preference has been set
+ * });
+ *
+ * const {err, data} = await FSBL.Clients.ConfigClient.setPreference({
+ *   field: "finsemble.initialWorkspace",
+ *   value: "Workspace 2"
+ * });
+ * ```
+ * @param {fieldAndValueParam} params
+ * @param {StandardErrorCallback} callback Callback to be invoked when preferences have been retrieved from the service or on error.
+ */
+export declare const setPreference: (params: FieldAndValueParam, cb?: StandardErrorCallback<void>) => StandardPromise<void>;
+/**
+ * @language javascript, java, dotnet
+ * Retrieves all of the preferences set for the application.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.getPreferences((err, preferences)=> {
+ * 		 if (!err) {
+ * 		 	console.log(preferences); // an object containing the entire user preferences.
+ * 		 }
+ * });
+ * const {err, data} = await FSBL.Clients.ConfigClient.getPreferences();
+ * ```
+ *
+ * @param {StandardErrorCallback} callback Callback to be invoked when preferences have been retrieved from the service.
+ */
+export declare const getPreferences: (cb?: StandardErrorCallback<Record<string, any> | null>) => StandardPromise<Record<string, any> | null>;
+/**
+ * @language javascript, dotnet
+ * Reset a user preference value to default. On application restart, the application default value will be used instead of the preference.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.unsetPreference({
+ * 	field: "finsemble.initialWorkspace",
+ * }, (err, response) => {
+ * 		//preference has been unset
+ * });
+ * const {err, data} = await FSBL.Clients.ConfigClient.unsetPreference({
+ *   field: "finsemble.initialWorkspace"
+ * });
+ * ```
+ * @param params The preference field to unset.
+ * @param callback The callback to be invoked after the preference is removed or on error.
+ */
+export declare const unsetPreference: (params: FieldOnlyParam, cb?: StandardErrorCallback<void>) => StandardPromise<void>;
+/**
+ * @ignore
+ */
+export declare const ConfigClient: {
+    /**
+     * For backward compatibility
+     * @private
+     * @deprecated
+     */
+    initialize(): void;
+    /**
+     * For backward compatibility
+     * @private
+     * @deprecated
+     */
+    onReady: (cb?: any) => void;
+    /**
+     * @private
+     * @deprecated
+     */
+    triggerListeners(listenerKey: string, data: any): void;
+    /**
+     * @private
+     * @deprecated
+     */
+    handleChanges(err: StandardError, response: {
+        data: {
+            store: string;
+            storeData: any;
+            field: string | null;
+            value: any;
+        };
+    }): void;
+    /**
+     * @private
+     * @deprecated
+     */
+    changeSub(change: string): Promise<void>;
+    addListener: <T = any>(params: {
+        field: string | null;
+    } | PathArray, fn: ListenerFunction<T>, cb?: () => void) => Promise<void>;
+    addListeners: <T = any>(params: ListenerParam[] | string[] | PathArrayListenerParam[], fn: ListenerFunction<T>, cb?: () => void) => Promise<void> | undefined;
+    getManifest: (cb?: StandardErrorCallback<Manifest>) => StandardPromise<Manifest>;
+    getPreferences: (cb?: StandardErrorCallback<Record<string, any> | null>) => StandardPromise<Record<string, any> | null>;
+    getValue: <T = any>(params: FieldOnlyParam | string, cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+    getValues: <T = any>(fields?: FieldOnlyParam[] | string[] | null, cb?: StandardErrorCallback<Record<string, T>>) => StandardPromise<Record<string, T>>;
+    processAndSet: (params: {
+        newConfig: Record<string, any>;
+        overwrite: boolean;
+        replace: boolean;
+    }, cb?: ProcessAndSetCallback) => StandardPromise<Manifest>;
+    removeListener: (params: {
+        field: string | null;
+    } | PathArray, fn: ListenerFunction<any>, cb?: Function) => void;
+    removeListeners: (params: RemoveListenersType, fn?: ListenerFunction<any>, cb?: StandardErrorCallback<boolean>) => void;
+    removeValue: <T = any>(params: FieldOnlyParam | string, cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+    removeValues: (fields: FieldOnlyParam[] | string[], cb?: StandardErrorCallback<void>) => Promise<{
+        err: string | null | undefined;
+    }>;
+    setPreference: (params: FieldAndValueParam, cb?: StandardErrorCallback<void>) => StandardPromise<void>;
+    setValue: (params: FieldAndValueParam, cb?: StandardErrorCallback<void>) => Promise<{
+        err: string | null | undefined;
+    }>;
+    setValues: (fields: FieldAndValueParams, cb?: StandardErrorCallback<void>) => Promise<{
+        err: string | null | undefined;
+    }>;
+    unsetPreference: (params: FieldOnlyParam, cb?: StandardErrorCallback<void>) => StandardPromise<void>;
+    get: <T = any>(path: PathArray | null, cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+    getMultiple: <T = any>(paths: PathArray[], cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+    set: <T = any>(path: PathArray, value: any, cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+    setMultiple: <T = any>(pathsAndValues: FieldPathArrayAndValue[], cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+    remove: <T = any>(path: PathArray, cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+    removeMultiple: <T = any>(paths: PathArray[], cb?: StandardErrorCallback<T>) => StandardPromise<T>;
+};
+/**
+ * @ignore
+ */
+export default ConfigClient;
 //# sourceMappingURL=configClient.d.ts.map