import { Transaction } from 'web3-core';
import { ArianeeConfig } from '../../models/arianeeConfiguration';
import { WatchParameter } from '../../models/watchParameter';
import { ConsolidatedCertificateRequest } from './certificateSummary/certificateSummary';
import { ContractService } from './services/contractService/contractsService';
import { UtilsService } from './services/utilService/utilsService';
import { WalletService } from './services/walletService/walletService';
import { TransactionObject } from '@arianee/arianee-abi/types/types';
import EventEmitter = require('eventemitter3');
export interface ClassicConfiguration {
    account: any;
    mnemonic?: string;
    web3?: any;
}
export declare class ArianeeWallet {
    private container;
    private _account;
    private _mnemonic;
    constructor(configuration: ClassicConfiguration, arianeeConfig: ArianeeConfig);
    private registerSingletons;
    get globalConfiguration(): any;
    /**
     * Function to override the default wallet send method
     * @param send( transaction:Transaction, data:TransactionObject<any>):Promise<any>
     *     transaction: the transaction to send (encoded)
     *     data: the non encoded transaction
     */
    setCustomSendTransaction(send: (transaction: Transaction, data?: any) => Promise<any>): ArianeeWallet;
    setCustomCall(call: (transaction: Transaction, data: TransactionObject<any>) => Promise<any>): ArianeeWallet;
    setCustomSign(sign: (data: string) => Promise<{
        message: string;
        messageHash: string;
        signature: string;
    }>): ArianeeWallet;
    /**
     * @deprecated use address instead
     */
    get publicKey(): string;
    get address(): string;
    get privateKey(): string;
    get mnemnonic(): string;
    get web3(): any;
    get configuration(): ArianeeConfig;
    get methods(): {
        requestAria: () => Promise<any>;
        requestPoa: () => Promise<any>;
        cancelTransactions: (parameters: {
            fromNonce: number;
            toNonce?: number;
            gas?: number;
            gasPrice?: number;
        }) => Promise<void>;
        reserveCertificateId: (certificateId?: number, receiver?: string) => Promise<any>;
        createCertificate: (data: import("../../models/transaction-parameters").hydrateTokenParameters) => Promise<{
            [key: string]: any;
            passphrase: string;
            certificateId: any;
            deepLink: string;
        }>;
        createCertificatesBatch: (datas: import("../../models/transaction-parameters").hydrateTokenParameters[]) => Promise<unknown>;
        createAndStoreCertificate: (data: import("../../models/transaction-parameters").hydrateTokenParameters, urlOfRPCServer?: string) => Promise<{
            [key: string]: any;
            passphrase: string;
            certificateId: any;
            deepLink: string;
        }>;
        getCertificate: <CertificateType = any, IdentityType = any>(certificateId: any, passphrase?: string, query?: ConsolidatedCertificateRequest) => Promise<import("./certificateSummary/certificateSummary").CertificateSummary<CertificateType, IdentityType>>;
        getCertificateFromArianeeAccessToken: (arianeeAccessToken: string, query?: ConsolidatedCertificateRequest) => Promise<import("./certificateSummary/certificateSummary").CertificateSummary<any, any>>;
        destroyCertificate: (certificateId: any) => Promise<any>;
        recoverCertificate: (certificateId: any) => Promise<any>;
        getMyCertificates: (query?: ConsolidatedCertificateRequest, verifyOwnership?: boolean) => Promise<import("./certificateSummary/certificateSummary").CertificateSummary<any, any>[]>;
        getCertificatesId: (verifyOwnership?: boolean) => Promise<any[]>;
        getMyCertificatesGroupByIssuer: (query?: ConsolidatedCertificateRequest) => Promise<{
            [key: string]: import("./certificateSummary/certificateSummary").CertificateSummary<any, any>[];
        }>;
        getIdentity: (address: string, issuerQuery?: import("./certificateSummary/certificateSummary").ConsolidatedIssuerRequest) => Promise<import("../../models").IdentitySummary<any>>;
        getIdentityByShortId: (shortId: string) => Promise<import("../../models").IdentitySummary<any>>;
        createCertificateRequestOwnershipLink: (certificateId: number, passphrase?: string, customDeeplink?: string) => Promise<{
            certificateId: number;
            passphrase: string;
            link: string;
        }>;
        createCertificateProofLink: (certificateId: number, passphrase?: string, customDeeplink?: string) => Promise<{
            certificateId: number;
            passphrase: string;
            link: string;
        }>;
        createActionProofLink: (url: string, certificateId: number, passphrase?: string) => Promise<string>;
        getCertificateFromLink: (arianeeLink: string, query?: ConsolidatedCertificateRequest) => Promise<import("./certificateSummary/certificateSummary").CertificateSummary<any, any>>;
        isCertificateProofValid: (certificateId: number, passphrase?: string, jwt?: string) => Promise<import("../../models/extendedBoolean").ExtendedBoolean<{
            timestamp?: number;
        }>>;
        isCertificateProofValidFromLink: (proofLink: string) => Promise<import("../../models/extendedBoolean").ExtendedBoolean<{
            timestamp?: number;
        }>>;
        isCertificateProofValidFromActionProofLink: (url: string) => Promise<any>;
        isCertificateOwnershipRequestable: (certificateId: any, passphrase: any) => Promise<any>;
        requestCertificateOwnership: (certificateId: number, passphrase: string) => Promise<any>;
        balanceOfAria: (address?: any) => Promise<string>;
        balanceOfRia: (address?: any) => Promise<string>;
        balanceOfPoa: (address?: any) => Promise<string>;
        balanceOfAriaReadable: (address?: any) => Promise<string>;
        getCreditPrice: (creditType: string) => Promise<any>;
        approveStore: () => PromiEvent<T>;
        buyCredits: (creditType: string, quantity: number, receiver?: string) => Promise<any>;
        balanceOfCredit: (creditType: string, address?: any) => Promise<string>;
        ownerOf: (certificateId: any) => Promise<import("../../models").IOwnerOf>;
        transfer: (certificateId: any, toAddress: string) => Promise<PromiEvent<T>>;
        acceptArianeeEvent: (eventId: any) => PromiEvent<T>;
        refuseArianeeEvent: (eventId: any) => PromiEvent<T>;
        setMessageAuthorizationFor: (certificateId: any, senderAddress: string, isAuthorized: boolean) => Promise<any>;
        getMessageSenders: (parameters: {
            certificateId: any;
            query: ConsolidatedCertificateRequest;
        }) => Promise<{
            [key: string]: boolean;
        }>;
        storeContentInRPCServer: (certificateId: any, content: any, arianeePrivacyGatewayURL?: string) => Promise<{
            jsonrpc: number;
            id: string;
            result?: any;
        }>;
        createArianeeEvent: (data: {
            uri?: string;
            contentImprint?: string;
            certificateId: number;
            arianeeEventId?: number;
            content?: {
                [key: string]: any;
                $schema: string;
            };
        }) => Promise<{
            contentImprint: string;
            arianeeEventId: number;
        }>;
        storeArianeeEvent: (certificateId: any, arianeeEventId: number, content: any, url?: string) => Promise<{
            jsonrpc: number;
            id: string;
            result?: any;
        }>;
        createAndStoreArianeeEvent: (data: {
            uri?: string;
            certificateId: number;
            arianeeEventId?: number;
            content?: {
                [key: string]: any;
                $schema: string;
            };
        }, url?: string) => Promise<{
            contentImprint: string;
            arianeeEventId: number;
        }>;
        getMyMessages: (parameters?: {
            query?: ConsolidatedCertificateRequest;
            url?: string;
        }) => Promise<any[]>;
        getAllMyMessageIds: () => Promise<any>;
        getMessage: (parameters: {
            messageId: number;
            query?: ConsolidatedCertificateRequest;
            url?: string;
            forceRefresh?: boolean;
        }) => Promise<import("./certificateSummary/certificateSummary").Message<any, any>>;
        isMessageRead: (messageId?: number) => Promise<boolean>;
        createMessage: (data: {
            contentImprint?: string;
            certificateId: number;
            content?: {
                [key: string]: any;
                $schema: string;
            };
            messageId?: number;
        }) => Promise<{
            contentImprint: string;
            messageId: number;
        }>;
        storeMessage: (messageId: number, content: any, url?: string) => Promise<{
            jsonrpc: number;
            id: string;
            result?: any;
        }>;
        createAndStoreMessage: (data: {
            uri?: string;
            certificateId: number;
            content?: {
                [key: string]: any;
                $schema: string;
            };
            messageId?: number;
        }, url?: string) => Promise<{
            contentImprint: string;
            messageId: number;
        }>;
        markAsRead: (messageId: number) => Promise<any>;
        diagnosis: (diagnosisList: Promise<any>[], rawErrors?: any) => Promise<any[]>;
        createActionArianeeAccessTokenLink: (url: string, certificateId: number) => Promise<any>;
        decodeArianeeAccessToken: (token: any) => {
            header: any;
            payload: import("../../models/JWT/certificate-jwt").CertificateJwt;
            signature: string;
        };
        createCertificateArianeeAccessToken: (certificateId: number) => Promise<string>;
        isCertificateArianeeAccessTokenValid: (token: any) => Promise<boolean>;
        isArianeeAccessTokenValid: (token: any) => Promise<boolean>;
        getArianeeAccessTokenJWT: (token: any) => Promise<{
            header: any;
            payload: any;
            signature: string;
        }>;
        createWalletAccessToken: () => Promise<string>;
        createAuthURL: (data: {
            type: "arianeeAccessToken" | "proof";
            certificateId: any;
            url: string;
        }) => Promise<string>;
        isAuthURL: (url: string) => Promise<any>;
        updateAndStoreCertificate: <T_1 = any>(parameters: {
            certificateId: any;
            content: any;
        }, urlOfRPCServer?: string) => Promise<any>;
        storeUpdateContentInRPCServer: (certificateId: any, content: any, arianeePrivacyGatewayURL?: string) => Promise<{
            jsonrpc: number;
            id: string;
            result?: any;
        }>;
        updateCertificate: <T_2 = any>(parameters: {
            certificateId: any;
            content?: any;
            imprint?: string;
        }) => Promise<any>;
        setMissingStatus: (arianeeId: any) => PromiEvent<T>;
        unsetMissingStatus: (arianeeId: any) => Promise<any>;
        setStolenStatus: (arianeeId: any) => Promise<any>;
        unsetStolenStatus: (arianeeId: any) => Promise<any>;
        isMissing: (arianeeId: any) => Promise<boolean>;
        isStolen: (arianeeId: any) => Promise<boolean>;
        fetchGasPrice: () => Promise<string>;
    };
    get arianeeMethods(): {
        aria: {
            faucet: () => Promise<any>;
            balance: (objParams: {
                address: any;
            }) => Promise<string>;
        };
        poa: {
            balance: () => Promise<any>;
            faucet: (objParams: {
                address: any;
            }) => Promise<string>;
        };
        credit: {
            buy: (objParams: {
                creditType: string;
                quantity: number;
                receiver?: string;
            }) => Promise<any>;
            balance: (objParams: {
                creditType: string;
                address?: string;
            }) => Promise<string>;
            types: () => import("../../models").creditTypeEnum[];
        };
        identity: {
            fetch: (objParams: {
                address: string;
                query?: import("./certificateSummary/certificateSummary").ConsolidatedIssuerRequest;
            }) => Promise<import("../../models").IdentitySummary<any>>;
            getByShortId: (objParams: {
                shortId: string;
            }) => Promise<import("../../models").IdentitySummary<any>>;
        };
        certificate: {
            fetch: {
                one: (objParams: {
                    certificateId: string;
                    passphrase?: string;
                    query?: ConsolidatedCertificateRequest;
                }) => Promise<import("./certificateSummary/certificateSummary").CertificateSummary<any, any>>;
                oneFromLink: (objParams: {
                    link: string;
                    query: ConsolidatedCertificateRequest;
                }) => Promise<import("./certificateSummary/certificateSummary").CertificateSummary<any, any>>;
                oneFromArianeeAccessToken: (objParams: {
                    arianeeAccessToken: string;
                    query: ConsolidatedCertificateRequest;
                }) => Promise<import("./certificateSummary/certificateSummary").CertificateSummary<any, any>>;
                mine: {
                    all: (objParams: {
                        verifyOwnership?: boolean;
                        query?: ConsolidatedCertificateRequest;
                    }) => Promise<import("./certificateSummary/certificateSummary").CertificateSummary<any, any>[]>;
                    groupByIssuer: (objParams: {
                        query?: ConsolidatedCertificateRequest;
                    }) => Promise<{
                        [key: string]: import("./certificateSummary/certificateSummary").CertificateSummary<any, any>[];
                    }>;
                };
            };
            creation: {
                create: (data: import("../../models/transaction-parameters").hydrateTokenParameters) => Promise<{
                    [key: string]: any;
                    passphrase: string;
                    certificateId: any;
                    deepLink: string;
                }>;
                reserveId: (objParams: {
                    certificateId: number;
                }) => Promise<any>;
                createAndStore: (objParams: {
                    data: import("../../models/transaction-parameters").hydrateTokenParameters;
                    urlOfRPCServer: string;
                }) => Promise<{
                    [key: string]: any;
                    passphrase: string;
                    certificateId: any;
                    deepLink: string;
                }>;
                storeContent: (objParams: {
                    certificateId: any;
                    content: any;
                    url?: string;
                }) => Promise<{
                    jsonrpc: number;
                    id: string;
                    result?: any;
                }>;
                batch: (objParams: {
                    datas: import("../../models/transaction-parameters").hydrateTokenParameters[];
                }) => Promise<unknown>;
            };
            arianeeAccessToken: {
                create: (objParams: {
                    url: string;
                    certificateId: number;
                }) => Promise<any>;
                decode: (objParams: {
                    arianeeAccessToken: any;
                }) => {
                    header: any;
                    payload: import("../../models/JWT/certificate-jwt").CertificateJwt;
                    signature: string;
                };
                isArianeeAccessTokenValid: (objParams: {
                    arianeeAccessToken: any;
                }) => Promise<boolean>;
                isCertificateProofValid: (objParams: {
                    certificateId: number;
                    passphrase?: string;
                    arianeeAccessToken?: string;
                }) => Promise<import("../../models/extendedBoolean").ExtendedBoolean<{
                    timestamp?: number;
                }>>;
                isCertificateProofValidFromLink: (objParams: {
                    proofLink: string;
                }) => Promise<import("../../models/extendedBoolean").ExtendedBoolean<{
                    timestamp?: number;
                }>>;
                isCertificateProofValidFromActionProofLink: (objParams: {
                    actionProofLink: string;
                }) => Promise<any>;
            };
            proof: {
                createCertificateProofLink: (objParams: {
                    certificateId: number;
                    passphrase?: string;
                }) => Promise<{
                    certificateId: number;
                    passphrase: string;
                    link: string;
                }>;
                createActionProofLink: (objParams: {
                    url: string;
                    certificateId: number;
                    passphrase?: string;
                }) => Promise<string>;
                isCertificateProofValid: (objParams: {
                    certificateId: number;
                    passphrase?: string;
                    arianeeAccessToken?: string;
                }) => Promise<import("../../models/extendedBoolean").ExtendedBoolean<{
                    timestamp?: number;
                }>>;
                isCertificateProofValidFromLink: (objParams: {
                    proofLink: string;
                }) => Promise<import("../../models/extendedBoolean").ExtendedBoolean<{
                    timestamp?: number;
                }>>;
                isCertificateProofValidFromActionProofLink: (objParams: {
                    actionProofLink: string;
                }) => Promise<any>;
            };
            ownership: {
                destroy: (objParams: {
                    certificateId: any;
                }) => Promise<any>;
                recover: (objParams: {
                    certificateId: any;
                }) => Promise<any>;
                request: (objParams: {
                    certificateId: any;
                    passphrase: string;
                }) => Promise<any>;
                isRequestable: (objParams: {
                    certificateId: any;
                    passphrase: string;
                }) => Promise<any>;
                createRequestLink: (objParams: {
                    certificateId: any;
                    passphrase: string;
                }) => Promise<{
                    certificateId: number;
                    passphrase: string;
                    link: string;
                }>;
            };
        };
        arianeeEvent: {
            accept: (objParams: {
                eventId: string;
            }) => PromiEvent<T>;
            refuse: (objParams: {
                eventId: string;
            }) => PromiEvent<T>;
            setMessageAuthorization: (objParams: {
                certificateId: any;
                senderAddress: string;
                isAuthorized: boolean;
            }) => Promise<any>;
            senders: (parameters: {
                certificateId: any;
                query: ConsolidatedCertificateRequest;
            }) => Promise<{
                [key: string]: boolean;
            }>;
            creation: {
                create: (data: {
                    uri?: string;
                    contentImprint?: string;
                    certificateId: number;
                    arianeeEventId?: number;
                    content?: {
                        [key: string]: any;
                        $schema: string;
                    };
                }) => Promise<{
                    contentImprint: string;
                    arianeeEventId: number;
                }>;
                storeContent: (objParams: {
                    certificateId: any;
                    arianeeEventId: number;
                    content: any;
                    url: string;
                }) => Promise<{
                    jsonrpc: number;
                    id: string;
                    result?: any;
                }>;
                createAndStore: (objParams: {
                    data: {
                        uri?: string;
                        certificateId: number;
                        arianeeEventId?: number;
                        content?: {
                            [key: string]: any;
                            $schema: string;
                        };
                    };
                    urlOfRPC: string;
                }) => Promise<{
                    contentImprint: string;
                    arianeeEventId: number;
                }>;
            };
        };
        store: {
            approve: () => PromiEvent<T>;
        };
        advanced: {
            diagnosis: (diagnosisList: Promise<any>[], rawErrors?: any) => Promise<any[]>;
        };
        dMessage: {
            fetch: {
                mine: (parameters?: {
                    query?: ConsolidatedCertificateRequest;
                    url?: string;
                }) => Promise<any[]>;
                one: (parameters: {
                    messageId: number;
                    query?: ConsolidatedCertificateRequest;
                    url?: string;
                    forceRefresh?: boolean;
                }) => Promise<import("./certificateSummary/certificateSummary").Message<any, any>>;
            };
            creation: {
                send: (objParams: {
                    data: {
                        uri?: string;
                        certificateId: number;
                        content?: {
                            [key: string]: any;
                            $schema: string;
                        };
                        messageId?: number;
                    };
                    url: string;
                }) => Promise<{
                    contentImprint: string;
                    messageId: number;
                }>;
                storeContent: (objParams: {
                    messageId: number;
                    content: any;
                    url: string;
                }) => Promise<{
                    jsonrpc: number;
                    id: string;
                    result?: any;
                }>;
                create: (data: {
                    contentImprint?: string;
                    certificateId: number;
                    content?: {
                        [key: string]: any;
                        $schema: string;
                    };
                    messageId?: number;
                }) => Promise<{
                    contentImprint: string;
                    messageId: number;
                }>;
                createAndStore: (objParams: {
                    data: {
                        uri?: string;
                        certificateId: number;
                        content?: {
                            [key: string]: any;
                            $schema: string;
                        };
                        messageId?: number;
                    };
                    url: string;
                }) => Promise<{
                    contentImprint: string;
                    messageId: number;
                }>;
            };
            markAsRead: (objParams: {
                certificateId: any;
            }) => Promise<any>;
        };
    };
    get utils(): UtilsService;
    get requestPoa(): () => Promise<any>;
    get requestAria(): () => Promise<any>;
    get account(): any;
    get walletservice(): WalletService;
    get contracts(): ContractService;
    customWatch: (watchParameters: WatchParameter) => EventEmitter<string | symbol, any>;
    get watch(): EventEmitter;
    setDefaultQuery(value: ConsolidatedCertificateRequest): this;
}