import { SQLiteDriver } from "./drivers/SQLiteDriver";
import { ConfDTO } from "../dto/ConfDTO";
import { BlockDTO } from "../dto/BlockDTO";
import { DBHead } from "../db/DBHead";
import { DBIdentity, IdentityDAL } from "./sqliteDAL/IdentityDAL";
import { CindexEntry, FullIindexEntry, IindexEntry, IndexEntry, MindexEntry, SimpleTxInput, SimpleUdEntryForWallet, SindexEntry } from "../indexer";
import { TransactionDTO } from "../dto/TransactionDTO";
import { CertDAL, DBCert } from "./sqliteDAL/CertDAL";
import { DBBlock } from "../db/DBBlock";
import { DBMembership, MembershipDAL } from "./sqliteDAL/MembershipDAL";
import { MerkleDTO } from "../dto/MerkleDTO";
import { PowDAL } from "./fileDALs/PowDAL";
import { Initiable } from "./sqliteDAL/Initiable";
import { MetaDAL } from "./sqliteDAL/MetaDAL";
import { BasicRevocableIdentity } from "../dto/IdentityDTO";
import { FileSystem } from "../system/directory";
import { Wot } from "../../../neon/lib";
import { IIndexDAO } from "./indexDAL/abstract/IIndexDAO";
import { BIndexDAO } from "./indexDAL/abstract/BIndexDAO";
import { MIndexDAO } from "./indexDAL/abstract/MIndexDAO";
import { SIndexDAO } from "./indexDAL/abstract/SIndexDAO";
import { CIndexDAO } from "./indexDAL/abstract/CIndexDAO";
import { IdentityForRequirements } from "../../service/BlockchainService";
import { BlockchainDAO } from "./indexDAL/abstract/BlockchainDAO";
import { TxsDAO } from "./indexDAL/abstract/TxsDAO";
import { WalletDAO } from "./indexDAL/abstract/WalletDAO";
import { PeerDAO } from "./indexDAL/abstract/PeerDAO";
import { DBTx } from "../db/DBTx";
import { DBWallet } from "../db/DBWallet";
import { Tristamp } from "../common/Tristamp";
import { CFSCore } from "./fileDALs/CFSCore";
import { DBPeer } from "../db/DBPeer";
import { DividendDAO } from "./indexDAL/abstract/DividendDAO";
import { HttpSource, HttpUD } from "../../modules/bma/lib/dtos";
import { LevelUp } from "levelup";
import { ConfDAO } from "./indexDAL/abstract/ConfDAO";
import { ServerDAO } from "./server-dao";
export interface FileDALParams {
    home: string;
    fs: FileSystem;
    dbf: () => SQLiteDriver;
    wotbf: () => Wot;
}
export interface IndexBatch {
    mindex: MindexEntry[];
    iindex: IindexEntry[];
    sindex: SindexEntry[];
    cindex: CindexEntry[];
}
export declare class FileDAL implements ServerDAO {
    private params;
    getSqliteDB: (dbName: string) => Promise<SQLiteDriver>;
    getLevelDB: (dbName: string) => Promise<LevelUp>;
    rootPath: string;
    fs: FileSystem;
    sqliteDriver: SQLiteDriver;
    wotb: Wot;
    profile: string;
    powDAL: PowDAL;
    coreFS: CFSCore;
    confDAL: ConfDAO;
    metaDAL: MetaDAL;
    idtyDAL: IdentityDAL;
    certDAL: CertDAL;
    msDAL: MembershipDAL;
    blockDAL: BlockchainDAO;
    txsDAL: TxsDAO;
    peerDAL: PeerDAO;
    walletDAL: WalletDAO;
    bindexDAL: BIndexDAO;
    mindexDAL: MIndexDAO;
    iindexDAL: IIndexDAO;
    sindexDAL: SIndexDAO;
    cindexDAL: CIndexDAO;
    dividendDAL: DividendDAO;
    newDals: {
        [k: string]: Initiable;
    };
    private dals;
    loadConfHook: (conf: ConfDTO) => Promise<void>;
    saveConfHook: (conf: ConfDTO) => Promise<ConfDTO>;
    constructor(params: FileDALParams, getSqliteDB: (dbName: string) => Promise<SQLiteDriver>, getLevelDB: (dbName: string) => Promise<LevelUp>);
    init(conf: ConfDTO): Promise<void>;
    getDBVersion(): Promise<number>;
    writeFileOfBlock(block: DBBlock): Promise<DBBlock>;
    writeSideFileOfBlock(block: DBBlock): Promise<DBBlock>;
    listAllPeers(): Promise<DBPeer[]>;
    getPeer(pubkey: string): Promise<DBPeer>;
    getWS2Peers(): Promise<DBPeer[]>;
    getAbsoluteBlockInForkWindowByBlockstamp(blockstamp: string): Promise<DBBlock | null>;
    getAbsoluteValidBlockInForkWindowByBlockstamp(blockstamp: string): Promise<DBBlock | null>;
    getBlockWeHaveItForSure(number: number): Promise<DBBlock>;
    getBlock(number: number): Promise<DBBlock | null>;
    getFullBlockOf(number: number): Promise<DBBlock | null>;
    getBlockstampOf(number: number): Promise<string | null>;
    getTristampOf(number: number): Promise<Tristamp | null>;
    existsAbsoluteBlockInForkWindow(number: number, hash: string): Promise<boolean>;
    getAbsoluteBlockInForkWindow(number: number, hash: string): Promise<DBBlock | null>;
    getAbsoluteValidBlockInForkWindow(number: number, hash: string): Promise<DBBlock | null>;
    getAbsoluteBlockByNumberAndHash(number: number, hash: string, forceNumberAndHashFinding?: boolean): Promise<DBBlock | null>;
    getAbsoluteBlockByBlockstamp(blockstamp: string): Promise<DBBlock | null>;
    existsNonChainableLink(from: string, vHEAD_1: DBHead, sigStock: number): Promise<boolean>;
    getCurrentBlockOrNull(): Promise<DBBlock | null>;
    getPromoted(number: number): Promise<DBBlock | null>;
    getPotentialRootBlocks(): Promise<DBBlock[]>;
    lastBlockOfIssuer(issuer: string): Promise<DBBlock | null>;
    getCountOfPoW(issuer: string): Promise<number>;
    /**
     * Find all the blocks in the blockchain whose number is between [start ; end]
     * @param start Lower number bound (included).
     * @param end Higher number bound (included).
     */
    getBlocksBetween(start: number, end: number): Promise<DBBlock[]>;
    getForkBlocksFollowing(current: DBBlock): Promise<DBBlock[]>;
    getPotentialForkBlocks(numberStart: number, medianTimeStart: number, maxNumber: number): Promise<DBBlock[]>;
    getBlockCurrent(): Promise<DBBlock>;
    getValidLinksTo(to: string): Promise<CindexEntry[]>;
    getAvailableSourcesByPubkey(pubkey: string): Promise<HttpSource[]>;
    findByIdentifierPosAmountBase(identifier: string, pos: number, amount: number, base: number, isDividend: boolean): Promise<SimpleTxInput[]>;
    getGlobalIdentityByHashForExistence(hash: string): Promise<boolean>;
    getGlobalIdentityByHashForHashingAndSig(hash: string): Promise<{
        pubkey: string;
        uid: string;
        buid: string;
        sig: string;
    } | null>;
    getGlobalIdentityByHashForLookup(hash: string): Promise<{
        pubkey: string;
        uid: string;
        buid: string;
        sig: string;
        member: boolean;
        wasMember: boolean;
    } | null>;
    getGlobalIdentityByHashForJoining(hash: string): Promise<{
        pubkey: string;
        uid: string;
        buid: string;
        sig: string;
        member: boolean;
        wasMember: boolean;
        revoked: boolean;
    } | null>;
    getGlobalIdentityByHashForIsMember(hash: string): Promise<{
        pub: string;
        member: boolean;
    } | null>;
    getGlobalIdentityByHashForRevocation(hash: string): Promise<{
        pub: string;
        uid: string;
        created_on: string;
        sig: string;
        member: boolean;
        wasMember: boolean;
        revoked: boolean;
        revocation_sig: string | null;
        expires_on: number;
    } | null>;
    getMembers(): Promise<{
        pubkey: string;
        uid: string | null;
    }[]>;
    getWrittenIdtyByPubkeyForHash(pubkey: string): Promise<{
        hash: string;
    }>;
    getWrittenIdtyByPubkeyForHashing(pubkey: string): Promise<{
        uid: string;
        created_on: string;
        pub: string;
    }>;
    getWrittenIdtyByPubkeyForWotbID(pubkey: string): Promise<{
        wotb_id: number;
    }>;
    getWrittenIdtyByPubkeyForUidAndPubkey(pubkey: string): Promise<{
        pub: string;
        uid: string;
    }>;
    getWrittenIdtyByPubkeyForIsMember(pubkey: string): Promise<{
        member: boolean;
    } | null>;
    getWrittenIdtyByPubkeyForUidAndIsMemberAndWasMember(pubkey: string): Promise<{
        uid: string;
        member: boolean;
        wasMember: boolean;
    } | null>;
    getWrittenIdtyByPubkeyOrUidForIsMemberAndPubkey(search: string): Promise<{
        pub: string;
        member: boolean;
    } | null>;
    getWrittenIdtyByPubkeyOrUIdForHashingAndIsMember(search: string): Promise<{
        uid: string;
        created_on: string;
        pub: string;
        member: boolean;
    } | null>;
    getWrittenIdtyByPubkeyForRevocationCheck(pubkey: string): Promise<{
        pub: string;
        uid: string;
        created_on: string;
        sig: string;
        revoked_on: string | null;
    } | null>;
    getWrittenIdtyByPubkeyForCertificationCheck(pubkey: string): Promise<{
        pub: string;
        uid: string;
        created_on: string;
        sig: string;
    } | null>;
    getWrittenIdtyByPubkeyForUidAndMemberAndCreatedOn(pubkey: string): Promise<{
        uid: string;
        member: boolean;
        created_on: string;
    } | null>;
    private getWrittenForSureIdtyByPubkey;
    private getWrittenForSureIdtyByUid;
    getWrittenIdtyByPubkey(pub: string): Promise<FullIindexEntry | null>;
    getWrittenIdtyByPubkeyForExistence(uid: string): Promise<boolean>;
    getWrittenIdtyByUIDForExistence(uid: string): Promise<boolean>;
    getWrittenIdtyByUidForHashing(uid: string): Promise<{
        uid: string;
        created_on: string;
        pub: string;
    }>;
    getWrittenIdtyByUIDForWotbId(uid: string): Promise<{
        wotb_id: number;
    }>;
    findPeersWhoseHashIsIn(hashes: string[]): Promise<DBPeer[]>;
    getTxByHash(hash: string): Promise<DBTx>;
    removeTxByHash(hash: string): Promise<void>;
    getTransactionsPending(versionMin?: number): Promise<DBTx[]>;
    getNonWritten(pubkey: string): Promise<DBIdentity[]>;
    getRevocatingMembers(): Promise<DBIdentity[]>;
    getToBeKickedPubkeys(): Promise<string[]>;
    getRevokedPubkeys(): Promise<string[]>;
    searchJustIdentities(search: string): Promise<DBIdentity[]>;
    certsToTarget(pub: string, hash: string): Promise<DBCert[]>;
    certsFrom(pubkey: string): Promise<DBCert[]>;
    cindexEntry2DBCert(entry: CindexEntry): Promise<DBCert>;
    isSentry(pubkey: string, conf: ConfDTO): Promise<boolean>;
    certsFindNew(): Promise<DBCert[]>;
    certsNotLinkedToTarget(hash: string): Promise<DBCert[]>;
    getMostRecentMembershipNumberForIssuer(issuer: string): Promise<number>;
    lastJoinOfIdentity(target: string): Promise<any>;
    findNewcomers(blockMedianTime?: number): Promise<DBMembership[]>;
    findLeavers(blockMedianTime?: number): Promise<DBMembership[]>;
    existsNonReplayableLink(from: string, to: string, medianTime: number, version: number): Promise<boolean>;
    getSource(identifier: string, pos: number, isDividend: boolean): Promise<SimpleTxInput | null>;
    isMember(pubkey: string): Promise<boolean>;
    isMemberAndNonLeaver(pubkey: string): Promise<boolean>;
    isLeaving(pubkey: string): Promise<boolean>;
    existsCert(cert: DBCert, current: DBBlock | null): Promise<boolean | DBCert>;
    deleteCert(cert: any): Promise<void>;
    deleteMS(ms: any): Promise<void>;
    setRevoked(pubkey: string): Promise<DBIdentity[]>;
    setRevocating: (idty: BasicRevocableIdentity, revocation_sig: string) => Promise<void>;
    getPeerOrNull(pubkey: string): Promise<DBPeer | null>;
    removePeerByPubkey(pubkey: string): Promise<void>;
    findAllPeersBut(pubkeys: string[]): Promise<DBPeer[]>;
    listAllPeersWithStatusNewUP(): Promise<DBPeer[]>;
    listAllPeersWithStatusNewUPWithtout(pub: string): Promise<DBPeer[]>;
    findPeers(pubkey: string): Promise<DBPeer[]>;
    getRandomlyUPsWithout(pubkeys: string[]): Promise<DBPeer[]>;
    setPeerUP(pubkey: string): Promise<DBPeer | null>;
    setPeerDown(pubkey: string): Promise<void>;
    saveBlock(dbb: DBBlock): Promise<void>;
    generateIndexes(block: BlockDTO, conf: ConfDTO, index: IndexEntry[], aHEAD: DBHead | null): Promise<{
        HEAD: DBHead;
        mindex: any;
        iindex: any;
        sindex: any;
        cindex: any;
        dividends: any;
    }>;
    updateWotbLinks(cindex: CindexEntry[], instance?: Wot): Promise<void>;
    trimIndexes(maxNumber: number): Promise<void>;
    trimSandboxes(block: {
        medianTime: number;
    }): Promise<boolean>;
    savePendingMembership(ms: DBMembership): Promise<void>;
    saveBlockInFile(block: DBBlock): Promise<void>;
    saveSideBlockInFile(block: DBBlock): Promise<DBBlock>;
    saveTxsInFiles(txs: TransactionDTO[], block_number: number, medianTime: number): Promise<DBTx[]>;
    merkleForPeers(): Promise<MerkleDTO>;
    savePendingIdentity(idty: DBIdentity): Promise<void>;
    revokeIdentity(pubkey: string): Promise<void>;
    removeUnWrittenWithPubkey(pubkey: string): Promise<void>;
    removeUnWrittenWithUID(pubkey: string): Promise<void>;
    registerNewCertification(cert: DBCert): Promise<void>;
    saveTransaction(tx: DBTx): Promise<DBTx>;
    getTransactionsHistory(pubkey: string): Promise<{
        sent: DBTx[];
        received: DBTx[];
        sending: DBTx[];
        receiving: DBTx[];
        pending: DBTx[];
    }>;
    getUDHistory(pubkey: string): Promise<{
        history: HttpUD[];
    }>;
    savePeer(peer: DBPeer): Promise<DBPeer>;
    getUniqueIssuersBetween(start: number, end: number): Promise<string[]>;
    /**
     * Gets a range of entries for the last `start`th to the last `end`th HEAD entry.
     * @param start The starting entry number (min. 1)
     * @param end The ending entry (max. BINDEX length)
     * @param property If provided, transforms the range of entries into an array of the asked property.
     */
    range(start: number, end: number, property: string): Promise<any[]>;
    /**
     * Get the last `n`th entry from the BINDEX.
     * @param n The entry number (min. 1).
     */
    head(n: number): Promise<DBHead>;
    /***********************
     *    CONFIGURATION
     **********************/
    getParameters(): Promise<import("../dto/ConfDTO").CurrencyConfDTO>;
    loadConf(overrideConf: ConfDTO, defaultConf?: boolean): Promise<any>;
    saveConf(confToSave: ConfDTO): Promise<void>;
    /***********************
     *     WALLETS
     **********************/
    getWallet(conditions: string): Promise<DBWallet>;
    saveWallet(wallet: DBWallet): Promise<DBWallet>;
    /***********************
     *     STATISTICS
     **********************/
    getStat(name: StatName): Promise<number[]>;
    cleanCaches(): Promise<void>;
    close(): Promise<void>;
    resetPeers(): Promise<void>;
    getLogContent(linesQuantity: number): Promise<unknown>;
    findReceiversAbove(minsig: number): Promise<IdentityForRequirements[]>;
    flushIndexes(indexes: IndexBatch): Promise<void>;
    updateDividend(blockNumber: number, dividend: number | null, unitbase: number, local_iindex: IindexEntry[]): Promise<SimpleUdEntryForWallet[]>;
}
export declare type StatName = "newcomers" | "certs" | "joiners" | "actives" | "leavers" | "revoked" | "excluded" | "ud" | "tx";