/**
 * Simple composable factory typeclass
 */
export interface Provider<T> {
    get(): Promise<T>;
    transform<R>(lambda: (x: T) => R | PromiseLike<R>): Provider<R>;
}
/**
 * Little lazy singleton provider with memory and mutex
 * that self-updates on get() after a ttl
 * expires.
 *
 * - if ttl < 0, then the LazyProvider acts as a LazySingleton
 * - if ttl === 0, then the LazyProvider calls through to the loader
 *             on every call - there is no cache
 * - if ttl > 0, then the provider does lazy refresh
 *             once the ttl expires
 */
export declare class LazyProvider<T> implements Provider<T> {
    private _thing;
    private reload;
    private ttlSecs;
    private _lastLoadTime;
    private loader;
    /**
       * @param loader lambda that loads the thing on demand
       * @param ttlSecs number of seconds to cache the thing before triggering a reload,
       *          default to never reload (-1)
       */
    constructor(loader: () => T | Promise<T>, ttlSecs?: number);
    /**
       * Refresh if ttl expired or force true
       * @param force
       * @return cached this.thing and the promise
       *    that loads the new data when reload is done
       */
    refreshIfNecessary(force?: boolean): {
        current: Promise<T>;
        next: Promise<T>;
    };
    get(): Promise<T>;
    /**
       * Date.now of last load attempt completion -
       * whether it succeeded or not.  Zero until after
       * the first call to .thing
       */
    get lastLoadTime(): number;
    /**
       * Apply a transformation on this thing.
       * Shortcut for new LazyProvider(() => parent.thing.then(...))
       * Note that refresh() on the child thing
       * does not force a refresh on the parent, and
       * vice versa, but the child inherits the ttl from
       * its parent.
       *
       * @param lambda
       */
    transform<R>(lambda: (x: T) => R | PromiseLike<R>): LazyProvider<R>;
}
export declare function singletonProvider<T>(loader: () => T | Promise<T>): Provider<T>;
export declare function passThroughProvider<T>(loader: () => T | Promise<T>): Provider<T>;
export declare function asFactory<T>(provider: LazyProvider<T>): () => Promise<T>;