@ti-engine/web-framework 1.19.1 → 1.20.1

package/types/components/auth-manager.d.ts

@@ -0,0 +1,125 @@
+export = AuthManager;
+import User = require("#user");
+import type { SettingsAuth } from "#web-server";
+export type TiAuthMethod = string;
+/** @import { SettingsAuth } from "#web-server" */
+/**
+ * Enum for specifying the authentication method.
+ *
+ * @readonly
+ * @enum {string}
+ * @typedef {string} TiAuthMethod
+ */
+declare const authMethodEnum: import("@ti-engine/core/definitions").TiEnumOf<{
+    LOCAL: string[];
+    OPENID_AZURE: string[];
+    OPENID_GOOGLE: string[];
+}>;
+export type TiTokenEndpointAuthMethod = string;
+/**
+ * The AuthManager class is used to manage authentication and authorization.
+ *
+ * @class AuthManager
+ * @public
+ */
+declare class AuthManager {
+    #private;
+    /**
+     * @constructor
+     * @param {SettingsAuth} settings
+     */
+    constructor(settings: SettingsAuth);
+    /**
+     * Used to initialize the authentication manager.
+     *
+     * @method
+     * @returns {Promise}
+     * @public
+     */
+    initialize(): Promise<any>;
+    /**
+     * Used to check whether the specified authentication method is enabled.
+     *
+     * @method
+     * @param {TiAuthMethod} authMethod
+     * @returns {boolean}
+     * @public
+     */
+    isAuthEnabled(authMethod: TiAuthMethod): boolean;
+    /**
+     * Returns the list of currently enabled authentication methods, reflecting any OpenID providers dropped by
+     * {@link AuthManager#initialize} for being enabled but unconfigured. Callers (e.g. the login-page renderer)
+     * use this to present only the methods a user can actually complete.
+     *
+     * @method
+     * @returns {TiAuthMethod[]}
+     * @public
+     */
+    getEnabledMethods(): TiAuthMethod[];
+    /**
+     * Used to authenticate a user via the specified authentication method.
+     *
+     * @method
+     * @param {TiAuthMethod} authMethod
+     * @param {Object} authDetails
+     * @returns {Promise<Object>}
+     * @throws {TiException.E_SEC_UNRECOGNIZED_AUTH_METHOD} If the authentication method is not recognized or enabled.
+     * @throws {TiException.E_GEN_NOT_INITIALIZED} If the auth manager was not properly initialized.
+     * @public
+     */
+    authenticate(authMethod: TiAuthMethod, authDetails: Object): Promise<Object>;
+    /**
+     * Used to set up user authorization according to the specified authentication method.
+     *
+     * @method
+     * @param {TiAuthMethod} authMethod
+     * @param {URL} currentUrl
+     * @param {Object} oidc
+     * @returns {Promise<User>}
+     * @throws {TiException.E_SEC_UNRECOGNIZED_AUTH_METHOD} If the authentication method is not recognized.
+     * @public
+     */
+    authorize(authMethod: TiAuthMethod, currentUrl: URL, oidc: Object): Promise<User>;
+    /**
+     * Used to get the callback URL for the specified OAuth2 authentication method.
+     *
+     * @method
+     * @param {TiAuthMethod} authMethod
+     * @returns {string}
+     * @throws {TiException.E_SEC_UNRECOGNIZED_AUTH_METHOD} If the requested OAuth2 method is not recognized or enabled.
+     * @public
+     */
+    getOAuth2CallbackUrl(authMethod: TiAuthMethod): string;
+    /**
+     * Used to get the local route path of the callback for the specified OAuth2 authentication method.
+     * <br/>
+     * A callback can legitimately be configured either as a path or as the full absolute URL registered with the
+     * identity provider. The absolute form is what the provider expects as the redirect URI, but it is not a usable
+     * Express route pattern, so this reduces whatever is configured to the path the server must actually listen on.
+     *
+     * @method
+     * @param {TiAuthMethod} authMethod
+     * @returns {string|null} The route path, or null if the configured callback yields no usable path.
+     * @throws {TiException.E_SEC_UNRECOGNIZED_AUTH_METHOD} If the requested OAuth2 method is not recognized or enabled.
+     * @public
+     */
+    getOAuth2CallbackPath(authMethod: TiAuthMethod): string | null;
+    /**
+     * Reduces a configured OAuth2 callback value to the local route path it corresponds to. Accepts an absolute URL
+     * ('https://host/login/azure-callback'), a protocol-relative URL, or a path with or without its leading slash,
+     * and strips any query string or fragment. Pure and static; exposed for unit testing.
+     * <br/>
+     * NOTE: This exists because Express 5 parses a route pattern with path-to-regexp v8, where ':' opens a parameter
+     * name — so an absolute URL used verbatim as a route path throws 'Missing parameter name' at startup.
+     *
+     * @method
+     * @static
+     * @param {string} callbackUrl
+     * @returns {string|null} The route path, or null if no usable path can be derived.
+     * @public
+     */
+    static toCallbackPath(callbackUrl: string): string | null;
+}
+declare namespace AuthManager {
+    export { authMethodEnum as authMethod };
+}

package/types/components/authorization.d.ts

@@ -0,0 +1,54 @@
+declare const _exports: {
+    ADMIN_ROLE: string;
+    isAdminIdentity: typeof isAdminIdentity;
+    applyAdminRole: typeof applyAdminRole;
+    hasAnyRole: typeof hasAnyRole;
+    isAccessAllowed: typeof isAccessAllowed;
+    requireRole: typeof requireRole;
+    requireAdmin: (request: Object, response: Object, next: Function) => void;
+};
+export = _exports;
+/**
+ * Returns `true` if the user matches any entry in the admin allowlist. An entry may match the user's `userID`,
+ * `username`, or `email` (case-insensitive).
+ *
+ * @param {Object} user A session user (`{ userID, username, email, roles, ... }`).
+ * @param {string[]} admins The configured allowlist of admin identifiers.
+ * @returns {boolean}
+ */
+declare function isAdminIdentity(user: Object, admins: string[]): boolean;
+/**
+ * Adds the `admin` role to the session user (additively, no duplicates) when the user is in the allowlist.
+ * Safe to call with an empty/missing allowlist or session — it is then a no-op. Returns the session for chaining.
+ *
+ * @param {Object} session
+ * @param {string[]} [admins]
+ * @returns {Object} The (possibly modified) session.
+ */
+declare function applyAdminRole(session: Object, admins?: string[]): Object;
+/**
+ * @param {Object} session
+ * @param {Array<string|number>} roles
+ * @returns {boolean} `true` if the session user holds any of the given roles.
+ */
+declare function hasAnyRole(session: Object, roles: Array<string | number>): boolean;
+/**
+ * Pure access decision for a resource (e.g. an HTML fragment) that declares a set of required roles. A resource with
+ * no required roles (`null` / `undefined` / empty) is public — any (authenticated) user may access it; otherwise the
+ * user must hold at least one of the required roles. Roles are treated opaquely, so this works equally for numeric
+ * application role codes and the string `admin` role — there is no implicit hierarchy (an `admin`-gated resource is
+ * reachable only by holders of the `admin` role, never by a high numeric role). Backs {@link TiWebAppManager#verifyAccess}.
+ *
+ * @param {Array<string|number>} [requiredRoles] The roles permitted to access the resource; empty/absent = public.
+ * @param {Array<string|number>} [userRoles] The roles held by the current session user.
+ * @returns {boolean}
+ */
+declare function isAccessAllowed(requiredRoles?: Array<string | number>, userRoles?: Array<string | number>): boolean;
+/**
+ * Express middleware factory that admits a request only if its session user holds at least one of the given roles.
+ * Responds `401` when unauthenticated (no session user) and `403` when authenticated but lacking the role.
+ *
+ * @param {...(string|number)} roles
+ * @returns {(request: Object, response: Object, next: Function) => void}
+ */
+declare function requireRole(...roles: (string | number)[]): (request: Object, response: Object, next: Function) => void;

package/types/components/config-change-notifier.d.ts

@@ -0,0 +1,73 @@
+export = ConfigChangeNotifier;
+export type ConfigChangeEvent = {
+    changeSetID: string;
+    /**
+     * The configuration documents affected by the change.
+     */
+    configKeys: string[];
+    /**
+     * Who committed the change.
+     */
+    adminID: string;
+    /**
+     * ISO timestamp.
+     */
+    timestamp: string;
+};
+/**
+ * @typedef {Object} ConfigChangeEvent
+ * @property {string} changeSetID
+ * @property {string[]} configKeys The configuration documents affected by the change.
+ * @property {string} adminID Who committed the change.
+ * @property {string} timestamp ISO timestamp.
+ */
+declare const CONFIG_CHANGED = "config:changed";
+/**
+ * Notifies subscribers that configuration changed, so they can react (e.g. invalidate an in-memory cache, or push a
+ * live update to an admin UI). This is the **in-process** implementation of a deliberately transport-agnostic
+ * contract — `publish(event)` (fire-and-forget) and `subscribe(listener) → unsubscribe`.
+ *
+ * **Designed for an eventual switch to a reusable core pub/sub.** Cross-instance propagation is out of scope for v1
+ * (the store-backed model already makes a committed change visible to every instance via the shared Redis cache;
+ * this emitter exists to invalidate optional *in-memory* caches and drive live UI within a process). When a Redis
+ * (or other) pub/sub primitive lands in `@ti-engine/core`, a drop-in implementation of this same contract can be
+ * provided and injected into {@link ConfigService} — no change to publishers or subscribers. To keep that swap
+ * behavior-safe, **delivery here is already asynchronous** (matching cross-instance transports); subscribers must
+ * not assume synchronous delivery, and the event payload is plain serializable JSON so it survives a wire transport.
+ *
+ * @class ConfigChangeNotifier
+ * @public
+ */
+declare class ConfigChangeNotifier {
+    #private;
+    constructor();
+    /**
+     * Publishes a configuration-change event to all subscribers. Fire-and-forget; delivery is asynchronous.
+     *
+     * @method
+     * @param {ConfigChangeEvent} event
+     * @returns {ConfigChangeEvent} The (frozen) event that will be delivered.
+     * @public
+     */
+    publish(event: ConfigChangeEvent): ConfigChangeEvent;
+    /**
+     * Subscribes a listener to configuration-change events.
+     *
+     * @method
+     * @param {(event: ConfigChangeEvent) => void} listener
+     * @returns {() => void} An unsubscribe function.
+     * @public
+     */
+    subscribe(listener: (event: ConfigChangeEvent) => void): () => void;
+    /**
+     * @method
+     * @returns {number} The current number of subscribers.
+     * @public
+     */
+    subscriberCount(): number;
+}
+declare namespace ConfigChangeNotifier {
+    export { instance };
+    export { CONFIG_CHANGED };
+}
+declare const instance: ConfigChangeNotifier;

package/types/components/config-registry.d.ts

@@ -0,0 +1,149 @@
+export = ConfigRegistry;
+export type ConfigValidationIssue = {
+    /**
+     * A JSON pointer / data path to the offending value (e.g. ".competencies.E1-1.name"), or "".
+     */
+    path: string;
+    /**
+     * Human-readable problem description.
+     */
+    message: string;
+    /**
+     * "schema" for JSON-Schema failures, or a validator-supplied code (default "semantic").
+     */
+    code: string;
+    /**
+     * Optional structured details (e.g. ajv params).
+     */
+    params?: Object;
+};
+export type ValidatorContext = {
+    /**
+     * Resolves the *pending* value of `key` when it is part of the
+     * current edit batch, otherwise its current committed value. Lets a validator check a sibling document's
+     * post-edit state — but calling this for the document being validated itself just returns the same incoming
+     * value already passed as the validator's first argument, not its prior state.
+     */
+    getConfig: (key: string) => Promise<any>;
+    /**
+     * Always resolves the current committed value of `key`,
+     * even when `key` is the document currently under validation. Use this to compare a document against its own
+     * previous state (e.g. detecting an edit that should have bumped a version marker).
+     */
+    getStoredConfig: (key: string) => Promise<any>;
+};
+export type SemanticValidator = (value: Object, context: ValidatorContext) => ConfigValidationIssue[] | Promise<ConfigValidationIssue[]>;
+/**
+ * @typedef {Object} ConfigValidationIssue
+ * @property {string} path A JSON pointer / data path to the offending value (e.g. ".competencies.E1-1.name"), or "".
+ * @property {string} message Human-readable problem description.
+ * @property {string} code "schema" for JSON-Schema failures, or a validator-supplied code (default "semantic").
+ * @property {Object} [params] Optional structured details (e.g. ajv params).
+ */
+/**
+ * The cross-document read context passed to every {@link SemanticValidator}, built fresh for each
+ * {@link ConfigService#applyEdits} call.
+ *
+ * @typedef {Object} ValidatorContext
+ * @property {(key: string) => Promise<*>} getConfig Resolves the *pending* value of `key` when it is part of the
+ *      current edit batch, otherwise its current committed value. Lets a validator check a sibling document's
+ *      post-edit state — but calling this for the document being validated itself just returns the same incoming
+ *      value already passed as the validator's first argument, not its prior state.
+ * @property {(key: string) => Promise<*>} getStoredConfig Always resolves the current committed value of `key`,
+ *      even when `key` is the document currently under validation. Use this to compare a document against its own
+ *      previous state (e.g. detecting an edit that should have bumped a version marker).
+ */
+/**
+ * @typedef {(value: Object, context: ValidatorContext) => ConfigValidationIssue[]|Promise<ConfigValidationIssue[]>} SemanticValidator
+ * A semantic validator receives the candidate value and a {@link ValidatorContext} and returns the issues it found
+ * (empty array = OK). May be async.
+ */
+/**
+ * Registry of editable configuration *documents* and the gate that validates a candidate value against a
+ * document's JSON Schema (ajv) plus its semantic validators. The framework stays domain-agnostic: an application
+ * registers its config documents (schemas, validators, defaults, editor metadata) at startup; this component knows
+ * only "validated, versioned JSON documents". Validation must pass *before* {@link ConfigStore#saveChangeSet}.
+ *
+ * @class ConfigRegistry
+ * @public
+ */
+declare class ConfigRegistry {
+    #private;
+    constructor();
+    /**
+     * Registers an editable configuration document.
+     *
+     * @method
+     * @param {string} configKey Stable identifier for the document (also the ConfigStore key).
+     * @param {Object} definition
+     * @param {Object} definition.schema A JSON Schema for the document.
+     * @param {SemanticValidator[]} [definition.validators] Cross-cutting/semantic checks beyond the schema.
+     * @param {Object} [definition.defaultValue] The bootstrap default (seeds an empty store).
+     * @param {Object} [definition.metadata] Editor metadata (label, editor type, group, risk class, …).
+     * @returns {ConfigRegistry} this (chainable)
+     * @throws {TiException.E_WEB_INVALID_REQUEST_PARAMETERS} On missing key/schema.
+     * @public
+     */
+    register(configKey: string, definition: {
+        schema: Object;
+        validators?: SemanticValidator[];
+        defaultValue?: Object;
+        metadata?: Object;
+    }): ConfigRegistry;
+    /**
+     * Adds a schema that is referenced (via `$ref`/`$id`) by document schemas but is not itself a document.
+     *
+     * @method
+     * @param {Object} schema
+     * @returns {ConfigRegistry} this (chainable)
+     * @public
+     */
+    addSchema(schema: Object): ConfigRegistry;
+    /**
+     * @method
+     * @param {string} configKey
+     * @returns {boolean}
+     * @public
+     */
+    has(configKey: string): boolean;
+    /**
+     * @method
+     * @returns {string[]} All registered configuration keys.
+     * @public
+     */
+    list(): string[];
+    /**
+     * @method
+     * @param {string} configKey
+     * @returns {Object|undefined} The editor metadata registered for the document.
+     * @public
+     */
+    metadataFor(configKey: string): Object | undefined;
+    /**
+     * @method
+     * @param {string} configKey
+     * @returns {Object|undefined} The bootstrap default value registered for the document.
+     * @public
+     */
+    getDefault(configKey: string): Object | undefined;
+    /**
+     * Validates a candidate value for a registered document: JSON Schema first, then the semantic validators.
+     * Resolves with `{ valid, errors }` (errors is an array of {@link ConfigValidationIssue}).
+     *
+     * @method
+     * @param {string} configKey
+     * @param {Object} value
+     * @param {ValidatorContext} [context] Passed to each semantic validator.
+     * @returns {Promise<{valid: boolean, errors: ConfigValidationIssue[]}>}
+     * @throws {TiException.E_WEB_INVALID_REQUEST_PARAMETERS} If the document is not registered.
+     * @public
+     */
+    validate(configKey: string, value: Object, context?: ValidatorContext): Promise<{
+        valid: boolean;
+        errors: ConfigValidationIssue[];
+    }>;
+}
+declare namespace ConfigRegistry {
+    export { instance };
+}
+declare const instance: ConfigRegistry;

package/types/components/config-service.d.ts

@@ -0,0 +1,218 @@
+export = ConfigService;
+import type ConfigChangeNotifier from "#config-change-notifier";
+import type ConfigRegistry from "#config-registry";
+import type ConfigStore from "#config-store";
+/** @import ConfigChangeNotifier from "#config-change-notifier" */
+/** @import ConfigRegistry from "#config-registry" */
+/** @import ConfigStore from "#config-store" */
+/**
+ * Orchestrates validated, versioned configuration edits on top of {@link ConfigStore} and {@link ConfigRegistry}.
+ *
+ * Two layers:
+ *  - **Document level** — {@link ConfigService#applyEdits}: validate every affected document (schema + semantic,
+ *    with a cross-document {@link ValidatorContext} whose `getConfig` sees the *pending* values of the same edit —
+ *    letting a validator check a sibling document's post-edit state — while `getStoredConfig` always returns the
+ *    committed value, even for the document currently under validation) and, only if all pass, commit them as one
+ *    change-set. Validation failures return `{ ok:false, errors }` and write nothing; a version conflict from the
+ *    store surfaces as a rejection.
+ *  - **Entity level** — composite editors registered with `compose(docs)→view` / `decompose(edited, docs)→{key:value}`,
+ *    so the UI edits a domain entity (e.g. a "competency") that is projected from, and scattered back into, several
+ *    documents. {@link ConfigService#saveEditorEdit} decomposes the edit and routes it through `applyEdits`.
+ *
+ * @class ConfigService
+ * @public
+ */
+declare class ConfigService {
+    #private;
+    /**
+     * @constructor
+     * @param {Object} [options]
+     * @param {ConfigStore} [options.store] Defaults to the ConfigStore singleton.
+     * @param {ConfigRegistry} [options.registry] Defaults to the ConfigRegistry singleton.
+     * @param {ConfigChangeNotifier} [options.notifier] Defaults to the ConfigChangeNotifier singleton.
+     */
+    constructor(options?: {
+        store?: ConfigStore;
+        registry?: ConfigRegistry;
+        notifier?: ConfigChangeNotifier;
+    });
+    /**
+     * Validates and commits a set of document edits atomically. Each edit: `{ configKey, value, expectedVersion }`.
+     *
+     * @method
+     * @param {Array<{configKey: string, value: Object, expectedVersion: number}>} edits
+     * @param {Object} meta
+     * @param {string} meta.adminID
+     * @param {string} [meta.note]
+     * @returns {Promise<{ok: true, changeSetID: string, versions: Object<string, number>} | {ok: false, errors: Object<string, Array>}>}
+     * @public
+     */
+    applyEdits(edits: Array<{
+        configKey: string;
+        value: Object;
+        expectedVersion: number;
+    }>, meta: {
+        adminID: string;
+        note?: string;
+    }): Promise<{
+        ok: true;
+        changeSetID: string;
+        versions: Record<string, number>;
+    } | {
+        ok: false;
+        errors: Record<string, any[]>;
+    }>;
+    /**
+     * Registers a composite editor over one or more documents.
+     *
+     * @method
+     * @param {string} editorKey
+     * @param {Object} definition
+     * @param {string[]} definition.documents The configKeys this editor spans.
+     * @param {(configs: Object) => *} definition.compose Maps `{ [configKey]: value }` → a view for the UI.
+     * @param {(editedView: *, currentDocs: Object) => Object.<string, Object>} definition.decompose Maps `(editedView, currentDocs)` → the
+     *        full new values for the documents that changed (`{ [configKey]: newValue }`).
+     * @param {Object} [definition.metadata]
+     * @returns {ConfigService} this (chainable)
+     * @throws {TiException.E_WEB_INVALID_REQUEST_PARAMETERS}
+     * @public
+     */
+    registerEditor(editorKey: string, definition: {
+        documents: string[];
+        compose: (configs: Object) => any;
+        decompose: (editedView: any, currentDocs: Object) => Record<string, Object>;
+        metadata?: Object;
+    }): ConfigService;
+    /**
+     * @method
+     * @param {string} editorKey
+     * @returns {boolean}
+     * @public
+     */
+    hasEditor(editorKey: string): boolean;
+    /**
+     * @method
+     * @returns {string[]}
+     * @public
+     */
+    listEditors(): string[];
+    /**
+     * Loads the editor's documents and composes them into a view. Returns the view plus the current per-document
+     * versions, which the client must echo back on save for optimistic locking.
+     *
+     * @method
+     * @param {string} editorKey
+     * @returns {Promise<{rows: *, versions: Object<string, number>}>}
+     * @public
+     */
+    composeView(editorKey: string): Promise<{
+        rows: any;
+        versions: Record<string, number>;
+    }>;
+    /**
+     * Applies an edit made against a composite editor: decompose the edited view into per-document new values, then
+     * route through {@link ConfigService#applyEdits} (validate-all → atomic change-set). `expectedVersions` should be
+     * the versions returned by {@link ConfigService#composeView} when the edit started.
+     *
+     * @method
+     * @param {string} editorKey
+     * @param {*} editedView
+     * @param {Object} meta
+     * @param {Object<string, number>} [expectedVersions]
+     * @returns {Promise<Object>} The {@link ConfigService#applyEdits} result (or `{ ok:true, changeSetID:null }` if nothing changed).
+     * @public
+     */
+    saveEditorEdit(editorKey: string, editedView: any, meta: Object, expectedVersions?: Record<string, number>): Promise<Object>;
+    /**
+     * Restores a prior change-set through the validated path: rebuild edits from the change-set's historic snapshots
+     * and route them through {@link ConfigService#applyEdits} — so the restore is **re-validated against the current
+     * schemas/validators** (a snapshot valid when written may be invalid now) and emits `config:changed`. Returns the
+     * `applyEdits` result (`{ ok:false, errors }` if a snapshot no longer validates; nothing is written then).
+     *
+     * @method
+     * @param {string} changeSetID
+     * @param {Object} meta
+     * @param {string} meta.adminID
+     * @param {string} [meta.note]
+     * @returns {Promise<Object>}
+     * @public
+     */
+    restoreChangeSet(changeSetID: string, meta: {
+        adminID: string;
+        note?: string;
+    }): Promise<Object>;
+    /**
+     * @method
+     * @param {string} configKey
+     * @returns {Promise<Object|null>} The current envelope for a configuration document.
+     * @public
+     */
+    getCurrent(configKey: string): Promise<Object | null>;
+    /**
+     * @method
+     * @param {string} configKey
+     * @returns {Promise<Array<Object>>} The document's version history (ascending), each a full snapshot entry.
+     * @public
+     */
+    getHistory(configKey: string): Promise<Array<Object>>;
+    /**
+     * @method
+     * @param {string} changeSetID
+     * @returns {Promise<Object|null>} A single change-set record.
+     * @public
+     */
+    getChange(changeSetID: string): Promise<Object | null>;
+    /**
+     * @method
+     * @returns {Promise<Array<Object>>} The cross-document audit feed (change-sets, most-recent first).
+     * @public
+     */
+    listChanges(): Promise<Array<Object>>;
+    /**
+     * Builds a downloadable snapshot of the current live configuration — for every registered document, its repo file
+     * `path` (from registration metadata, if provided), current `version`, and `value`. This is the one-way export
+     * *out* of the store; an admin downloads it and commits the files to git. The store remains the live truth.
+     *
+     * @method
+     * @param {Object} [meta]
+     * @param {string} [meta.adminID]
+     * @returns {Promise<{exportedAt: string, exportedBy: (string|null), documents: Array<{configKey: string, path: (string|null), version: number, value: Object}>}>}
+     * @public
+     */
+    exportBundle(meta?: {
+        adminID?: string;
+    }): Promise<{
+        exportedAt: string;
+        exportedBy: (string | null);
+        documents: Array<{
+            configKey: string;
+            path: (string | null);
+            version: number;
+            value: Object;
+        }>;
+    }>;
+    /**
+     * Seeds a document's default value into the store only if it has never been written (idempotent bootstrap).
+     * Used by an application to bring its file defaults into the store at startup before serving live config.
+     *
+     * @method
+     * @param {string} configKey
+     * @param {Object} defaultValue
+     * @returns {Promise<Object>} The current envelope.
+     * @public
+     */
+    seedDefault(configKey: string, defaultValue: Object): Promise<Object>;
+    /**
+     * Subscribes a listener to `config:changed` events (delegates to the change notifier). Returns an unsubscribe fn.
+     *
+     * @method
+     * @param {(configs: Object) => void} listener
+     * @returns {() => void}
+     * @public
+     */
+    onConfigChanged(listener: (configs: Object) => void): () => void;
+}
+declare namespace ConfigService {
+    export { instance };
+}
+declare const instance: ConfigService;