import { Provider } from '../provider.js';
export interface Dictionary<T> {
    [key: string]: T;
}
/**
 * Extract a subset from a larger dictionary
 *
 * @param all
 * @param keyList
 * @return subset
 */
export declare function lookup<T>(all: Dictionary<T>, keyList: string[]): Dictionary<T>;
export declare function join<T>(kvList: {
    k: string;
    v: T;
}[]): Dictionary<T>;
export declare function split<T>(dict: Dictionary<T>): {
    k: string;
    v: T;
}[];
/**
 * Convert a dictionary of promises to a promise
 * for a dictionary
 */
export declare function toPromise<T>(dict: Dictionary<Promise<T>>): Promise<Dictionary<T>>;
export declare type ConfigDb = Dictionary<Dictionary<any>>;
/**
 * An entry in the AppContext configuration db - has
 * default dictionary and loaded overrides,
 * can do simple shallow merge with { ...defaults, ...overrides }
 */
export interface ConfigEntry {
    defaults: Dictionary<any>;
    overrides: Dictionary<any>;
}
export interface AppContextConfig {
    configHref: string[];
    loadConfig: (href: string) => Promise<Dictionary<Dictionary<any>>>;
}
export declare type ToolBox = Dictionary<Provider<any>>;
export declare function getTools(tb: ToolBox): Promise<Dictionary<any>>;
export declare type ToolFactory<T> = (toolbox: ToolBox) => Provider<T> | Promise<Provider<T>>;
export interface ProviderInfo {
    key: string;
    toolKeys: Dictionary<string>;
    lambda: ToolFactory<any>;
}
/**
 * Core application context database decoupled
 * from custom element configuration mechanism
 *
 * LifeCycle:
 *    singleton - put config accepted
 *    started   - lookup config accepted, no new puts
 */
export declare class AppContext {
    static build(config: AppContextConfig): Promise<AppContext>;
    static get(): Promise<AppContext>;
    private static singletonBarrier;
    config: AppContextConfig;
    /**
       * Trigger context launch - invoke once
       * from main().
       *
       * @returns a list of tools that
       * are required by registered providers, but
       * unbound.
       */
    start: () => Promise<string[]>;
    private defaultConfigs;
    private overrideConfigs;
    private providerDb;
    private allToolKeys;
    private state;
    private subscriptions;
    private startBarrier;
    /**
       * Constructor takes an immutable configuration
       */
    constructor(config: AppContextConfig);
    /**
       * Register a new provider.
       * A provider's factory specifies the dependencies (toolbox)
       * it wants injected.  A tool dependency must start with
       * driver/, alias/, or config/ - where config/ translates
       * into a call to context.getConfig
       *
       * @param keyIn automatically prepended with "driver/" if not already
       * @param toolKeys map from global key (driver/, alias/, or config/)
       *           to the internal key passed to the tool factory
       * @param lambda
       */
    putProvider(keyIn: string, toolKeys: Dictionary<string>, lambda: ToolFactory<any>): void;
    /**
       * Register a lambda to run at startup
       *
       * @param toolKeys to inject into lambda - alias to rawKey
       * @param lambda
       */
    onStart<T>(toolKeys: Dictionary<string>, lambda: (ToolBox: any) => T | Promise<T>): Promise<T>;
    /**
       * Register a new provider.
       *
       * @param alias automatically prepended with "alias/" if not already
       * @param driverName automatically prepended with "driver/" if not already
       */
    putAlias(alias: string, driverName: string): void;
    /**
       *
       * @param key must start with driver/, alias/, or config/
       */
    getProvider<T>(key: string): Promise<Provider<T>>;
    /**
       * Put a default configuration into the context.
       * Note that config overrides loaded at runtime
       * overwrite a default put into the context.
       * This method is intended for use by modules that
       * want to register default configuration at
       * startup time.  Multiple calls to putDeafultConfig
       * with the same key call Object.assign() to augment
       * the previous value.
       *
       * @param contextIn
       * @param key
       */
    putDefaultConfig(key: string, value: Dictionary<any>): void;
    getConfig(key: string): Promise<ConfigEntry>;
    getState(key: string, part: string): Promise<any>;
    changeState(key: string, handler: (state: any) => Promise<any>): Promise<any>;
    /**
       * Load the remote configuration specified
       * by the constructor injected properties
       */
    private init;
    private fillToolBox;
    private putProviderOrAlias;
}
export default AppContext;