/// <reference types="node" />
import { IdentityService } from "./app/service/IdentityService";
import { MembershipService } from "./app/service/MembershipService";
import { PeeringService } from "./app/service/PeeringService";
import { BlockchainService } from "./app/service/BlockchainService";
import { TransactionService } from "./app/service/TransactionsService";
import { ConfDTO } from "./app/lib/dto/ConfDTO";
import { FileDAL } from "./app/lib/dal/fileDAL";
import * as stream from "stream";
import { GlobalFifoPromise } from "./app/service/GlobalFifoPromise";
import { BlockchainContext } from "./app/lib/computation/BlockchainContext";
import { BlockDTO } from "./app/lib/dto/BlockDTO";
import { DBIdentity } from "./app/lib/dal/sqliteDAL/IdentityDAL";
import { CertificationDTO } from "./app/lib/dto/CertificationDTO";
import { MembershipDTO } from "./app/lib/dto/MembershipDTO";
import { RevocationDTO } from "./app/lib/dto/RevocationDTO";
import { TransactionDTO } from "./app/lib/dto/TransactionDTO";
import { PeerDTO } from "./app/lib/dto/PeerDTO";
import { WS2PCluster } from "./app/modules/ws2p/lib/WS2PCluster";
import { DBBlock } from "./app/lib/db/DBBlock";
import { DBPeer } from "./app/lib/db/DBPeer";
import { HttpMilestonePage } from "./app/modules/bma/lib/dtos";
export interface HookableServer {
    generatorGetJoinData: (...args: any[]) => Promise<any>;
    generatorComputeNewCerts: (...args: any[]) => Promise<any>;
    generatorNewCertsToLinks: (...args: any[]) => Promise<any>;
    onPluggedFSHook: (...args: any[]) => Promise<any>;
    resetDataHook: (...args: any[]) => Promise<any>;
    resetConfigHook: (...args: any[]) => Promise<any>;
}
export declare class Server extends stream.Duplex implements HookableServer {
    private memoryOnly;
    private overrideConf;
    private paramsP;
    private endpointsDefinitions;
    private wrongEndpointsFilters;
    startService: () => Promise<void>;
    stopService: () => Promise<void>;
    ws2pCluster: WS2PCluster | undefined;
    conf: ConfDTO;
    dal: FileDAL;
    home: string;
    version: string;
    logger: any;
    rawer: any;
    keyPair: any;
    sign: any;
    blockchain: any;
    MerkleService: (req: any, merkle: any, valueCoroutine: any) => any;
    IdentityService: IdentityService;
    MembershipService: MembershipService;
    PeeringService: PeeringService;
    BlockchainService: BlockchainService;
    TransactionsService: TransactionService;
    private documentFIFO;
    milestoneArray: DBBlock[];
    constructor(home: string, memoryOnly: boolean, overrideConf: any);
    getDocumentsFIFO(): GlobalFifoPromise;
    _read(): void;
    _write(obj: any, enc: any, writeDone: any): Promise<void>;
    /**
     * Facade method to control what is pushed to the stream (we don't want it to be closed)
     * @param obj An object to be pushed to the stream.
     */
    streamPush(obj: any): void;
    getBcContext(): BlockchainContext;
    plugFileSystem(): Promise<void>;
    unplugFileSystem(): Promise<void>;
    reloadConf(): Promise<void>;
    loadConf(useDefaultConf?: any, reuseExisting?: boolean): Promise<ConfDTO>;
    initWithDAL(): Promise<this>;
    writeRawBlock(raw: string): Promise<BlockDTO>;
    writeBlock(obj: any, notify?: boolean, noResolution?: boolean): Promise<BlockDTO>;
    writeRawIdentity(raw: string): Promise<DBIdentity>;
    writeIdentity(obj: any, notify?: boolean): Promise<DBIdentity>;
    writeRawCertification(raw: string): Promise<CertificationDTO>;
    writeCertification(obj: any, notify?: boolean): Promise<CertificationDTO>;
    writeRawMembership(raw: string): Promise<MembershipDTO>;
    writeMembership(obj: any, notify?: boolean): Promise<MembershipDTO>;
    writeRawRevocation(raw: string): Promise<RevocationDTO>;
    writeRevocation(obj: any, notify?: boolean): Promise<RevocationDTO>;
    writeRawTransaction(raw: string): Promise<TransactionDTO>;
    writeTransaction(obj: any, notify?: boolean): Promise<TransactionDTO>;
    writeRawPeer(raw: string): Promise<PeerDTO>;
    writePeer(obj: any, notify?: boolean): Promise<PeerDTO>;
    private emitDocument;
    initDAL(conf?: ConfDTO | null): Promise<void>;
    recomputeSelfPeer(): Promise<DBPeer | null>;
    getCountOfSelfMadePoW(): Promise<number>;
    checkConfig(): Promise<any>;
    resetHome(): Promise<void>;
    resetAll(done?: any): Promise<void>;
    resetData(done?: any): Promise<void>;
    resetConf(done?: any): Promise<void>;
    resetStats(done?: any): Promise<void>;
    resetPeers(): Promise<void>;
    exportAllDataAsZIP(): Promise<any>;
    importAllDataFromZIP(zipFile: string): Promise<void>;
    private resetFiles;
    disconnect(): Promise<void>;
    revert(): Promise<DBBlock>;
    revertHead(): Promise<void>;
    revertTo(number: number): Promise<void>;
    pullingEvent(type: string, number?: any): void;
    reapplyTo(number: number): Promise<void>;
    /*****************
     * DAEMONIZATION
     ****************/
    /**
     * Get the daemon handle. Eventually give arguments to launch a new daemon.
     * @param overrideCommand The new command to launch.
     * @param insteadOfCmd The current command to be replaced by `overrideCommand` command.
     * @returns {*} The daemon handle.
     */
    getDaemon(overrideCommand?: string, insteadOfCmd?: string): any;
    /**
     * Return current script full command arguments except the two firsts (which are node executable + js file).
     * If the two optional `cmd` and `insteadOfCmd` parameters are given, replace `insteadOfCmd`'s value by `cmd` in
     * the script arguments.
     *
     *   Ex:
     *     * process.argv: ['/usr/bin/node', '/opt/duniter/sources/bin/duniter', 'restart', '--mdb', 'g1']
     *
     *     Then `getCommand('direct_start', 'restart') will return:
     *
     *     * ['direct_start', '--mdb', 'g1']
     *
     *     This new array is what will be given to a *fork* of current script, resulting in a new process with:
     *
     *     * process.argv: ['/usr/bin/node', '/opt/duniter/sources/bin/duniter', 'direct_start', '--mdb', 'g1']
     *
     * @param cmd
     * @param insteadOfCmd
     * @returns {*}
     */
    private getCommand;
    /**
     * Retrieve the last linesQuantity lines from the log file.
     * @param linesQuantity
     */
    getLastLogLines(linesQuantity: number): Promise<unknown>;
    addEndpointsDefinitions(definition: () => Promise<string>): void;
    addWrongEndpointFilter(filter: (endpoints: string[]) => Promise<string[]>): void;
    getEndpoints(): Promise<string[]>;
    getWrongEndpoints(endpoints: string[]): Promise<string[]>;
    /*****************
     * MODULES UTILITIES
     ****************/
    requireFile(path: string): any;
    /*****************
     * MODULES PLUGS
     ****************/
    /**
     * Default WoT incoming data for new block. To be overriden by a module.
     */
    generatorGetJoinData(current: DBBlock | null, idtyHash: string, char: string): Promise<any>;
    /**
     * Default WoT incoming certifications for new block, filtering wrong certs. To be overriden by a module.
     */
    generatorComputeNewCerts(...args: any[]): Promise<any>;
    /**
     * Default WoT transforming method for certs => links. To be overriden by a module.
     */
    generatorNewCertsToLinks(...args: any[]): Promise<any>;
    /**
     * Default hook on file system plugging. To be overriden by module system.
     */
    onPluggedFSHook(): Promise<any>;
    /**
     * Default hook on data reset. To be overriden by module system.
     */
    resetDataHook(): Promise<any>;
    /**
     * Default hook on data reset. To be overriden by module system.
     */
    resetConfigHook(): Promise<any>;
    milestones(page?: number): Promise<HttpMilestonePage>;
}