/**
 * Generates an queue ID by concadinating an ensAddress and a dispatcher name
 *
 * @param ensAddress    ens address were the dispatcher lives
 * @param dispatcher    name of the exported function on the ens expose object
 * @param id            specification to start the same queue in seperated instances
 * @param foreReload    use force reload to disable alert when current opened ens address is the same as the currently finished dispatcher
 */
export declare class QueueId {
    ensAddress: string;
    dispatcher: string;
    id: string;
    forceReload: boolean;
    /**
     * use force reload to disable alert when current opened ens address is the
     * same as the currently finished dispatcher
     */
    constructor(ensAddress: string, dispatcher: string, id?: string, forceReload?: boolean);
    /**
     * return the queue id concadinated to a unique string
     *
     * @return     {<type>}  queue id string
     */
    getString(): string;
}
/**
 * Used to handle one step of an dispatcher
 *
 * @param {string} name         Display name for queue (used for QueueDApp)
 * @param {string} description  Description for the queue (used for QueueDApp)
 * @param {Function} run        the function that is called to run the queue
 *                              (gets the within the QueueDispatcher configured service and the data
 *                              that should be handled (Array<any>: one entry for each new added
 *                              QueueEntry))
 *
 * usage:
 *     new QueueSequence(
 *       '_dappdapps.dispatcher.save-bookmarks',
 *       '_dappdapps.dispatcher.save-bookmarks-description',
 *       async (service: BookmarkDispatcherService, data: any) => {
 *         await service.bookmarkService.syncQueueBookmarks();
 *       }
 *     )
 *
 * @class      QueueSequence
 */
export declare class QueueSequence {
    name: string;
    description: string;
    run: Function;
    constructor(name: string, description: string, run: Function);
}
/**
 * Represents one dispatcher using several queueSequences, that will processed
 * one after another, using step caches
 *
 * @param {Array<QueueSequence>} sequence  All sequences that should be runned after another
 * @param {any} i18n                       i18n definitions for the queue
 * @param {string} serviceName             name of the servide that should be applied to the
 *                                         sequence entry
 *
 * usage:
 *  export const BookmarkDispatcher = new QueueDispatcher(
 *    [
 *      sequences...
 *    ],
 *    translations
 *  );
 *
 * @class      QueueDispatcher
 */
export declare class QueueDispatcher {
    sequence: Array<QueueSequence>;
    i18n: any;
    serviceName: any;
    constructor(sequence: Array<QueueSequence>, i18n: any, serviceName?: string);
}