import { IRouter } from 'express';
import { Container } from 'inversify';
import { GlobalLoggerConfig } from "../../../logger/src";
import { JobHandlers } from "../../../scheduler/src";
import { LedgerHandle } from "../../../types/src";
import { IAnchorsLookupHandler } from '../anchor/interfaces/anchors-lookup-resolver.interface';
import { IAnchorsResolver } from '../anchor/interfaces/anchors-resolver.interface';
import { AnchorsLookupHandlerClass, AnchorsResolverClass } from '../anchor/interfaces/types';
import { DataSourceOptions } from '../database/data-source';
import { IDomainsResolver } from '../domain/interfaces/domains-resolver.interface';
import { DomainsResolverClass } from '../domain/interfaces/types';
import { EventHandler } from '../event/event-handler';
import { EventHandlersMap } from '../event/module';
import { EventHandlerClass } from '../event/types';
import { IIntentUpdatedHandler } from '../intent/interfaces/intent-updated-handler.interface';
import { IntentUpdatedHandlerClass } from '../intent/interfaces/types';
import { LedgerClientOptions } from '../ledger/ledger.client';
import { SchedulerConfigurationData } from '../scheduler/types';
import { ServerService } from './server.service';
import type { SetOptional } from 'type-fest';
export declare class ServerBuilder {
    protected dataSourceOptions: DataSourceOptions;
    protected ledgerClientOptions: LedgerClientOptions;
    protected loggerOptions: GlobalLoggerConfig;
    protected customRouters: IRouter[];
    protected anchorsResolver: IAnchorsResolver | AnchorsResolverClass;
    protected anchorsLookupHandler: IAnchorsLookupHandler | AnchorsLookupHandlerClass;
    protected domainsResolver: IDomainsResolver | DomainsResolverClass;
    protected eventHandlersMap: EventHandlersMap;
    protected intentUpdatedHandler: IIntentUpdatedHandler | IntentUpdatedHandlerClass;
    protected registrator: (container: Container) => void;
    protected schedulerOptions: SchedulerConfigurationData;
    static init(): ServerBuilder;
    useDataSource(dataSourceOptions: DataSourceOptions): this;
    useLedger(ledgerClientOptions: LedgerClientOptions): this;
    useLogger(loggerOptions: GlobalLoggerConfig): this;
    useCustomRouter(router: IRouter): this;
    useAnchorsResolver(adapter: IAnchorsResolver): ServerBuilder;
    useAnchorsResolverClass(resolverClass: AnchorsResolverClass): ServerBuilder;
    useAnchorsLookupHandler(handler: IAnchorsLookupHandler): ServerBuilder;
    useAnchorsLookupHandlerClass(handlerClass: AnchorsLookupHandlerClass): ServerBuilder;
    useDomainsResolver(resolver: IDomainsResolver): ServerBuilder;
    useDomainsResolverClass(resolverClass: DomainsResolverClass): ServerBuilder;
    useEventHandler(adapter: EventHandler, handle: LedgerHandle): ServerBuilder;
    useEventHandlerClass(adapterClass: EventHandlerClass, handle: LedgerHandle): ServerBuilder;
    useIntentUpdatedHandler(handler: IIntentUpdatedHandler): ServerBuilder;
    useIntentUpdatedHandlerClass(handlerClass: IntentUpdatedHandlerClass): ServerBuilder;
    useRegistrator(registrator: (container: Container) => void): this;
    /**
     * Registers functions that can act as job handlers for specific types of scheduler jobs.
     * Some types are used internally by bridge-sdk and will therefore not be allowed to be set.
     * The resulting scheduler job handlers will be a union of the internal ones and ones registered by a service using bridge-sdk.
     * @param handlers
     * @returns
     */
    useSchedulerJobHandlers(handlers: JobHandlers): this;
    /**
     * Registers options that will be used by @minka/scheduler. By default, you should not need to call this.
     * However, if you call this, these settings will be used instead of the default ones, which can also affect the workings of bridge-sdk.
     * @param options Scheduler config options, with no data source since the data source should be passed via `useDataSource`
     * @returns
     */
    useSchedulerOptions(options: SetOptional<SchedulerConfigurationData, 'postgresDataSource'>): this;
    build(container?: Container): ServerService;
}