import { AccountStore, ContractLoader, Description, Executor, Logger, LoggerOptions, NameResolver, DfsInterface } from '@evan.network/dbcp';
/**
 * verification status from blockchain
 */
export declare enum VerificationsStatus {
    /** issued by a non-issuer parent verification holder, self issued state is 0 */
    Issued = 0,
    /** issued by a non-issuer parent verification holder, self issued state is 0 */
    Confirmed = 1,
    /** verification rejected status */
    Rejected = 2,
}
/**
 * status annotations about verification, depending on defined ``VerificationsQueryOptions``,
 * this may lead to the verification to be invalid or less trustworthy
 */
export declare enum VerificationsStatusFlagsV2 {
    /** parent verification does not allow subverifications */
    disableSubVerifications = "disableSubVerifications",
    /** verification has expired */
    expired = "expired",
    /** signature does not match requirements, this could be because it hasn’t been signed
      * by correct account or underlying checksum does not match subject, topic and data */
    invalid = "invalid",
    /** verification has been issued, but not accepted or rejected by subject */
    issued = "issued",
    /** verification has not been issued */
    missing = "missing",
    /** given subject has no identity */
    noIdentity = "noIdentity",
    /** verification path has a trusted root verification topic, but this verification is not signed
      * by a trusted instance */
    notEnsRootOwner = "notEnsRootOwner",
    /** parent verification is missing in path */
    parentMissing = "parentMissing",
    /** verification path cannot be traced back to a trusted root verification */
    parentUntrusted = "parentUntrusted",
    /** verification has been issued and then rejected by subject */
    rejected = "rejected",
    /** verification issuer is the same account as the subject */
    selfIssued = "selfIssued",
}
/**
 * represents the status of a requested verification topic
 * after applying rules in ``VerificationsQueryOptions``
 */
export declare enum VerificationsStatusV2 {
    /** verification is valid according to ``VerificationsQueryOptions`` */
    Green = "green",
    /** verification may be valid but more checks may be required more for trusting it,
     *  see status flags for details  */
    Yellow = "yellow",
    /** verification is invalid, see status flags for details */
    Red = "red",
}
/**
 * information for submitting a delegated transaction,
 * created with ``signSetVerificationTransaction`` consumed by ``executeVerification``
 */
export interface VerificationsDelegationInfo {
    /** address of identity contract, that issues verification */
    sourceIdentity: string;
    /** address of identity contract, that receives verification */
    targetIdentity: string;
    /** value to transfer, usually 0 */
    value: number;
    /** abi encoded input for transaction */
    input: string;
    /** signed data from transaction */
    signedTransactionInfo: string;
    /** source identity contract execution nonce for this transaction */
    nonce: string;
}
/**
 * options for ``getNestedVerificationsV2``, define how to calculate status of verification
 */
export interface VerificationsQueryOptions {
    /** specification of how to handle status flags of each single verification */
    validationOptions?: VerificationsValidationOptions;
    /** function for setting verification with custom logic */
    statusComputer?: VerificationsStatusComputer;
}
/**
 * result of a verification query
 */
export interface VerificationsResultV2 {
    /** overall status of verification */
    status: VerificationsStatusV2;
    /** list of verifications on same topic and subject */
    verifications?: VerificationsVerificationEntry[];
    /** consolidated information about verification  */
    levelComputed?: {
        /** identity contract address or hash of subject */
        subjectIdentity: string;
        /** type of subject (account/contract) */
        subjectType: string;
        /** topic (name) of verification */
        topic: string;
        /** js timestamp */
        expirationDate?: number;
        /** verifications of parent path, issued for all issuers of verifications on this level */
        parents?: VerificationsResultV2;
        /** subject accountId/contractId (if query was issued with ``isIdentity`` set to ``false``) */
        subject?: string;
    };
}
/**
 * a single verification; usually used in ``VerificationsResultV2``
 */
export interface VerificationsVerificationEntry {
    /** details about verification */
    details: {
        /** js timestamp of verification creation */
        creationDate: number;
        /** ens address of description for this verification */
        ensAddress: string;
        /** id in verification holder / verifications registry */
        id: string;
        /** account id of verification issuer */
        issuer: string;
        /** issuers identity contract id */
        issuerIdentity: string;
        /** identity (contract or identity hash) of subject */
        subjectIdentity: string;
        /** type of subject (account/contract) */
        subjectType: string;
        /** topic of identity (name) */
        topic: string;
        /** 32B data hash string of identity */
        data?: any;
        /** only if actually set */
        description?: any;
        /** expiration date of verification (js timestamp) */
        expirationDate?: number;
        /** if applicable, reason for verification rejection */
        rejectReason?: string;
        /** status of verification, is optional during result computation and required when done */
        status?: VerificationsStatusV2;
        /** subject accountId/contractId (if query was issued with ``isIdentity`` set to ``false``) */
        subject?: string;
    };
    /** raw data about verification from contract */
    raw?: {
        /** block in which verification was issued */
        creationBlock: string;
        /** unix timestamp is s when verification was issued */
        creationDate: string;
        /** 32B data hash string of identity, bytes32 zero if unset */
        data: string;
        /** true if subverification are not allowed */
        disableSubVerifications: boolean;
        /** signature over verification data */
        signature: string;
        /** status of verification, (issued, accepted, rejected, etc.) */
        status: number;
        /** uint string of verification name (topic), is uint representation of sha3 of name */
        topic: string;
    };
    /** all found flags, those may not have impact on status,
     *  depends on ``VerificationsStatusFlagsV2`` */
    statusFlags?: string[];
}
/**
 * Computes status for a single verification. verification, partialResult
 *
 * @param      {Partial<VerificationsVerificationEntry>} verification   current verification result
 *                                                                      (without status)
 * @param      {Partial<VerificationsResultV2>}          partialResult  options for verifications query
 * @return     {Promise<VerificationsStatusV2>}                   status for this verification
 */
export interface VerificationsVerificationEntryStatusComputer {
    (verification: Partial<VerificationsVerificationEntry>, partialResult: Partial<VerificationsResultV2>): Promise<VerificationsStatusV2>;
}
/**
 * Computes status from overall verifications result.
 * This function is applied after each verification has received an own computed status.
 *
 * @param      {Partial<VerificationsResultV2>} partialResult  current verification result (without status)
 * @param      {VerificationsQueryOptions}      queryOptions   options for verifications query
 * @param      {VerificationsStatusV2}          currentStatus  current status of verification
 * @return     {Promise<VerificationsStatusV2>} updated status, will be used at verification status
 */
export interface VerificationsStatusComputer {
    (partialResult: Partial<VerificationsResultV2>, queryOptions: VerificationsQueryOptions, currentStatus: VerificationsStatusV2): Promise<VerificationsStatusV2>;
}
/**
 * Options for verification status computation. Keys are string representations of
 * ``VerificationsStatusFlagsV2``, values can be ``VerificationsStatusV2`` or functions.
 * If value is ``VerificationsStatusV2``, then finding given status flag sets verification value
 * to given ``VerificationsStatusV2`` (if not already at a higher trust level).
 * If value is function, pass verification to this function and set verification status to
 * return value (if not already at a higher trust level).
 */
export interface VerificationsValidationOptions {
    [id: string]: VerificationsStatusV2 | VerificationsVerificationEntryStatusComputer;
}
/**
 * options for Verification constructor, basically a trimmed runtime
 */
export interface VerificationsOptions extends LoggerOptions {
    accountStore: AccountStore;
    config: any;
    contractLoader: ContractLoader;
    description: Description;
    dfs: DfsInterface;
    executor: Executor;
    nameResolver: NameResolver;
    registry?: string;
    storage?: string;
}
/**
 * Verifications helper
 *
 * @class      Verifications (name)
 */
export declare class Verifications extends Logger {
    readonly defaultValidationOptions: VerificationsValidationOptions;
    readonly defaultQueryOptions: VerificationsQueryOptions;
    cachedIdentities: any;
    contracts: any;
    encodingEnvelope: string;
    /** cache all the ens owners */
    ensOwners: any;
    options: VerificationsOptions;
    /** check if currently the storage is ensuring, if yes, don't run it twice */
    storageEnsuring: Promise<any>;
    subjectTypes: any;
    /** cache all the verifications using an object of promises, to be sure, that the verification is
     * loaded only once */
    verificationCache: any;
    /** backup already loaded verification descriptions */
    verificationDescriptions: any;
    /**
     * Creates a new Verifications instance.
     *
     * Note, that the option properties ``registry`` and ``resolver`` are optional but should be
     * provided in most cases. As the module allows to create an own ENS structure, that includes an
     * own ENS registry and an own default resolver for it, setting them beforehand is optional.
     *
     * @param    {VerificationsOptions} options
     */
    constructor(options: VerificationsOptions);
    /**
     * Takes an array of verifications and combines all the states for one quick view.
     *
     * {
     *   verifications: verifications,
     *   creationDate: null,
     *   displayName: topic.split('/').pop() || 'evan',
     *   loading: verifications.filter(verification => verification.loading).length > 0,
     *   name: topic,
     *   status: -1,
     *   subjects: [ ],
     *   warnings: [ ], // have a look at getNestedVerifications
     * }
     *
     * @param      {string}      topic          topic of all the verifications
     * @param      {Array<any>}  verifications  all verifications of a specific topic
     * @return     {any}         computed verification including latest creationDate, combined color,
     *                           displayName
     */
    computeVerifications(topic: string, verifications: Array<any>): Promise<any>;
    /**
     * confirms a verification; this can be done, if a verification has been issued for a subject and
     * the subject wants to confirm it
     *
     * @param      {string}   accountId       account, that performs the action
     * @param      {string}   subject         verification subject
     * @param      {string}   verificationId  id of a verification to confirm
     * @param      {boolean}  isIdentity      (optional): ``true`` if given ``subject`` is an
     *                                        identity, defaults to ``false``
     * @return     {Promise<void>}  resolved when done
     */
    confirmVerification(accountId: string, subject: string, verificationId: string, isIdentity?: boolean): Promise<void>;
    /**
     * Creates a new identity for account or contract and registers them on the storage. Returned
     * identity is either a 40B contract address (for account identities) or a 32B identity hash
     * contract identities
     *
     * @param      {string}  accountId          account that runs transaction, receiver of identity
     *                                          when omitting the other arguments
     * @param      {string}  contractId         (optional) contract address to create the identity
     *                                          for, creates account identity for ``accountId`` if
     *                                          omitted
     * @param      {bool}    updateDescription  (optional) update description of contract, defaults to
     *                                          ``true``
     * @param      {bool}    linkContract       link contract address to its identity
     * @return     {Promise<string>}  new identity (40Bytes for accounts, 32Bytes for other)
     */
    createIdentity(accountId: string, contractId?: string, updateDescription?: boolean, linkContract?: boolean): Promise<string>;
    /**
     * Delete a single entry from the verification cache object using subject and topic
     *
     * @param      {string}  subject  the subject that should be removed
     * @param      {string}  topic    the topic that should be removed
     * @return     {void}
     */
    deleteFromVerificationCache(subject: string, topic: string): void;
    /**
     * delete a verification. This requires the accountId to have permissions for the parent
     * verification (if verification name seen as a path, the parent 'folder'). Subjects of a
     * verification may only delete it, if they are the issuer as well. If not, they can only react to
     * it by confirming or rejecting the verification.
     *
     * @param      {string}   accountId       account, that performs the action
     * @param      {string}   subject         the subject of the verification
     * @param      {string}   verificationId  id of a verification to delete
     * @param      {boolean}  isIdentity      (optional): ``true`` if given ``subject`` is an
     *                                        identity, defaults to ``false``
     * @return     {Promise<void>}  resolved when done
     */
    deleteVerification(accountId: string, subject: string, verificationId: string, isIdentity?: boolean): Promise<void>;
    /**
     * Gets and sets the default description for a verification if it does not exist.
     *
     * @param      {any}     verification  the verification that should be checked
     */
    ensureVerificationDescription(verification: any): Promise<void>;
    /**
     * Executes a pre-signed verification transaction with given account.
     * This account will be the origin of the transaction and not of the verification.
     * Second argument is generated with ``signSetVerificationTransaction``.
     *
     * @param      {string}                       accountId  account, that submits the transaction
     * @param      {VerificationsDelegationInfo}  txInfo     information with verification tx data
     * @return     {Promise<string>}  id of new verification
     */
    executeVerification(accountId: string, {sourceIdentity, targetIdentity, value, input, signedTransactionInfo}: VerificationsDelegationInfo): Promise<string>;
    /**
     * Loads a list of verifications for a topic and a subject and combines to a single view for a
     * simple verification status check.
     *
     * @param      {string}   subject     subject, that performs the description loading
     * @param      {string}   topic       topic of all the verifications
     * @param      {boolean}  isIdentity  optional indicates if the subject is already a identity
     * @return     {any}      computed verification including latest creationDate, combined color,
     *                        displayName
     */
    getComputedVerification(subject: string, topic: string, isIdentity?: boolean): Promise<any>;
    /**
     * Gets current execution nonce for an identity or an accounts identity.
     *
     * @param      {string}   issuer      account or identity to get execution nonce for
     * @param      {boolean}  isIdentity  optional, true if given issuer is an identity, defaults to
     *                                    ``false``
     * @return     {Promise<string>}  execution nonce
     */
    getExecutionNonce(issuer: string, isIdentity?: boolean): Promise<string>;
    /**
     * gets the identity contract for a given account id or contract
     *
     * @param      {string}        subject      the subject for the identity contract
     * @param      {boolean}       onlyAddress  should only the identity address
     * @return     {Promise<any>}  the identity contract instance
     */
    getIdentityForAccount(subject: string, onlyAddress?: boolean): Promise<any>;
    /**
     * Get all the verifications for a specific subject.
     *
     * @param      {string}      subject     subject to load the verifications for.
     * @param      {string}      topic       topic to load the verifications for.
     * @param      {boolean}     isIdentity  optional indicates if the subject is already a identity
     * @return     {Promise<Array<any>>}  all the verifications with the following properties.
     *   {
     *     id: '...',
     *     // creator of the verification
     *     issuer: '0x1813587e095cDdfd174DdB595372Cb738AA2753A',
     *     // topic of the verification
     *     name: '/company/b-s-s/employee/swo',
     *     // -1: Not issued => no verification was issued
     *     // 0: Issued => status = 0, warning.length > 0
     *     // 1: Confirmed => issued by both, self issued state is 2, values match
     *     // 2: Rejected => reject by the creator / subject
     *     status: 2,
     *     // verification for account id / contract id
     *     subject: subject,
     *     // ???
     *     value: '',
     *     // ???
     *     uri: '',
     *     // ???
     *     signature: ''
     *     // icon for cards display
     *     icon: 'icon to display',
     *     // if the verification was rejected, a reject reason could be applied
     *     rejectReason: '' || { },
     *     // subject type
     *     subjectType: 'account' || 'contract',
     *     // if it's a contract, it can be an contract
     *     subjectOwner: 'account' || 'contract',
     *     // warnings
     *     [
     *       // parent verification does not allow subverifications
     *       'disableSubVerifications',
     *       // verification has expired
     *       'expired',
     *       // signature does not match requirements, this could be because it hasn't been signed by
     *       // correct account or underlying checksum does not match
     *       // ``subject``, ``topic`` and ``data``
     *       'invalid',
     *       // verification has been issued, but not accepted or rejected by subject
     *       'issued',
     *       // verification has not been issued
     *       'missing',
     *       // given subject has no identity
     *       'noIdentity',
     *       // verification path has a trusted root verification topic, but this verification is not
     *       // signed by a trusted instance
     *       'notEnsRootOwner',
     *       // parent verification is missing in path
     *       'parentMissing',
     *       // verification path cannot be traced back to a trusted root verification
     *       'parentUntrusted',
     *       // verification has been issued and then rejected by subject
     *       'rejected',
     *       // verification issuer is the same account as the subject
     *       'selfIssued',
     *     ],
     *     parents: [ ... ],
     *     parentComputed: [ ... ]
     *   }
     */
    getNestedVerifications(subject: string, topic: string, isIdentity?: boolean): Promise<any>;
    /**
     * Get verifications and their parent paths for a specific subject, then format it to updated
     * result format.
     *
     * @param      {string}                     subject       subject (account/contract or identity)
     * @param      {string}                     topic         topic (verification name) to check
     * @param      {boolean}                    isIdentity    true if subject is identity
     * @param      {VerificationsQueryOptions}  queryOptions  options for query and status computation
     * @return     {Promise<VerificationsResultV2>}  verification result object with status,
     *                                               verification data and tree
     */
    getNestedVerificationsV2(subject: string, topic: string, isIdentity?: boolean, queryOptions?: VerificationsQueryOptions): Promise<VerificationsResultV2>;
    /**
     * Map the topic of a verification to it's default ens domain
     *
     * @param      {string}  topic   the verification name / topic
     * @return     {string}  The verification ens address
     */
    getVerificationEnsAddress(topic: string): string;
    /**
     * gets verification information for a verification name from a given account; results has the
     * following properties: creationBlock, creationDate, data, description, expired, expirationDate,
     * id, issuer, name, signature, status, subject, topic, uri, valid
     *
     * @param      {string}          subject     subject of the verifications
     * @param      {string}          topic       name (/path) of a verification
     * @param      {boolean}         isIdentity  (optional) indicates if the subject is already an
     *                                           identity
     * @return     {Promise<any[]>}  verification info array
     */
    getVerifications(subject: string, topic: string, isIdentity?: boolean): Promise<any[]>;
    /**
     * checks if a account has already a identity contract
     *
     * @param      {string}            subject  the target subject
     * @return     {Promise<boolean>}  true if identity exists, otherwise false
     */
    identityAvailable(subject: string): Promise<any>;
    /**
     * reject a Verification. This verification will be marked as rejected but not deleted. This is
     * important for tracking reasons. You can also optionally add a reject reason as JSON object to
     * track additional informations about the rejection. Issuer and Subject can reject a special
     * verification.
     *
     * @param      {string}         accountId       account, that performs the action
     * @param      {string}         subject         account, that rejects the verification
     * @param      {string}         verificationId  id of a verification to reject
     * @param      {any}            rejectReason    (optional) rejectReason object
     * @return     {Promise<void>}  resolved when done
     */
    rejectVerification(accountId: string, subject: string, verificationId: string, rejectReason?: any, isIdentity?: boolean): Promise<void>;
    /**
     * Sets or creates a verification; this requires the issuer to have permissions for the parent
     * verification (if verification name seen as a path, the parent 'folder').
     *
     * @param      {string}           issuer                   issuer of the verification
     * @param      {string}           subject                  subject of the verification and the
     *                                                         owner of the verification node
     * @param      {string}           topic                    name of the verification (full path)
     * @param      {number}           expirationDate           expiration date, for the verification,
     *                                                         defaults to `0` (≈does not expire)
     * @param      {any}              verificationValue        json object which will be stored in the
     *                                                         verification
     * @param      {string}           descriptionDomain        domain of the verification, this is a
     *                                                         subdomain under 'verifications.evan',
     *                                                         so passing 'example' will link
     *                                                         verifications description to
     *                                                         'example.verifications.evan'
     * @param      {boolean}          disabelSubVerifications  if true, verifications created under
     *                                                         this path are invalid
     * @return     {Promise<string>}  verificationId
     */
    setVerification(issuer: string, subject: string, topic: string, expirationDate?: number, verificationValue?: any, descriptionDomain?: string, disabelSubVerifications?: boolean, isIdentity?: boolean): Promise<string>;
    /**
     * set description for a verification under a domain owned by given account
     *
     * @param      {string}  accountId    accountId, that performs the description update
     * @param      {string}  topic        name of the verification (full path) to set description
     * @param      {string}  domain       domain of the verification, this is a subdomain under
     *                                    'verifications.evan', so passing `example` will link
     *                                    verifications description to 'example.verifications.evan'
     * @param      {any}     description  description of the verification; can be an Envelope but only
     *                                    public properties are used
     * @return     {Promise<void>}  resolved when done
     */
    setVerificationDescription(accountId: string, topic: string, domain: string, description: any): Promise<void>;
    /**
     * Signs a verification (off-chain) and returns data, that can be used to submit it later on.
     * Return value can be passed to ``executeVerification``.
     *
     * Note that, when creating multiple signed verification transactions, the ``nonce`` argument
     * **has to be specified and incremented between calls**, as the nonce is included in transaction
     * data and restricts the order of transactions, that can be made.
     *
     * @param      {string}   issuer                   issuer of the verification
     * @param      {string}   subject                  subject of the verification and the owner of
     *                                                 the verification node
     * @param      {string}   topic                    name of the verification (full path)
     * @param      {number}   expirationDate           expiration date, for the verification, defaults
     *                                                 to `0` (≈does not expire)
     * @param      {any}      verificationValue        json object which will be stored in the
     *                                                 verification
     * @param      {string}   descriptionDomain        domain of the verification, this is a subdomain
     *                                                 under 'verifications.evan', so passing
     *                                                 'example' will link verifications description
     *                                                 to 'example.verifications.evan'
     * @param      {boolean}  disabelSubVerifications  if true, verifications created under this path
     *                                                 are invalid
     * @param      {boolean}  isIdentity               (optional) true if given subject is an identity, defaults to ``false``
     *                                                 are invalid
     * @param      {number} nonce                      issuer identities execution nonce, will be
     *                                                 automatically retrieved if if omitted or set to
     *                                                 -1, if set to -1 will automatically retrieve
     *                                                 latest nonce from chain
     * @return     {Promise<VerificationsDelegationInfo>}  information for executing transaction with
     *                                                     another account
     */
    signSetVerificationTransaction(issuer: string, subject: string, topic: string, expirationDate?: number, verificationValue?: any, descriptionDomain?: string, disabelSubVerifications?: boolean, isIdentity?: boolean, executionNonce?: string | number): Promise<VerificationsDelegationInfo>;
    /**
     * Trim ``VerificationsResultV2`` result down to statusFlags and status values for analysis
     * purposes and debugging.
     *
     * @param      {VerificationsResultV2}  inputResult  result to trim down
     * @return     {any}                    trimmed down tree
     */
    trimToStatusTree(inputResult: VerificationsResultV2): any;
    /**
     * validates a given verificationId in case of integrity
     *
     * @param      {string}   subject         the subject of the verification
     * @param      {string}   verificationId  verification identifier
     * @param      {boolean}  isIdentity      optional indicates if the subject is already an identity
     * @return     {Promise<boolean>}  resolves with true if the verification is valid, otherwise false
     */
    validateVerification(subject: string, verificationId: string, isIdentity?: boolean): Promise<boolean>;
    /**
     * execute contract call on identity, checks if account or contract identity is used and if given
     * subject is already an identity
     *
     * @param      {string}        subject     account/contract with identity or an identity of it
     * @param      {boolean}       isIdentity  true if given subject is an identity
     * @param      {string}        fun         function to call
     * @param      {any[]}         args        arguments for function (excluding the identity (for
     *                                         VerificationsRegistry functions))
     * @return     {Promise<any>}  result of called function
     */
    private callOnIdentity(subject, isIdentity, fun, ...args);
    /**
     * Compute status for given (partial) result.
     *
     * @param      {Partial<VerificationsResultV2>}  partialResult  current to be calculated result
     * @param      {VerificationsQueryOptions}       queryOptions   options for query and
     *                                                              status computation
     */
    private computeStatus(partialResult, queryOptions);
    /**
     * Checks if a storage was initialized before, if not, load the default one.
     *
     * @return     {Promise<void>}  resolved when storage exists or storage was loaded
     */
    private ensureStorage();
    /**
     * run given data (serialized contract tx) with given users identity
     *
     * @param      {string}        accountId        account execute given tx on own identity
     * @param      {string}        data             serialized function data
     * @param      {any}           eventInfo        (optional) object with properties: 'eventName' and
     *                                              'contract' (web3 contract instance, that triggers
     *                                              event)
     * @param      {Function}      getEventResults  (optional) function with arguments event and
     *                                              eventArges, that returns result of
     *                                              `executeAndHandleEventResult` call
     * @return     {Promise<any>}  if `eventInfo` and `getEventResults`, result of `getEventResults`,
     *                             otherwise void
     */
    private executeAndHandleEventResult(accountId, data, eventInfo?, getEventResults?);
    /**
     * execute contract transaction on identity, checks if account or contract identity is used and if
     * given subject is already an identity
     *
     * @param      {string}        subject  account/contract with identity or an identity of it
     * @param      {string}        fun      function to call
     * @param      {any}           options  options for transaction
     * @param      {any[]}         args     arguments for function (excluding the identity (for
     *                                      VerificationsRegistry functions))
     * @return     {Promise<any>}  result of called function
     */
    private executeOnIdentity(subject, isIdentity, fun, options, ...args);
    /**
     * Format given result to V2 data format.
     *
     * @param      {any}                        nestedVerificationsInput  verifications array
     * @param      {VerificationsQueryOptions}  queryOptions              options for result
     *                                                                    status computation
     */
    private formatToV2(nestedVerificationsInput, queryOptions);
    /**
     * returns full domain for description
     *
     * @param      {string}  topic              verification topic
     * @param      {string}  descriptionDomain  domain of description
     * @return     {string}  full domain
     */
    private getFullDescriptionDomainWithHash(topic, descriptionDomain);
    /**
     * Generates input for functions ``setVerification`` and ``signSetVerificationTransaction``.
     *
     * @param      {string}   issuer                   issuer of the verification
     * @param      {string}   subject                  subject of the verification and the owner of
     *                                                 the verification node
     * @param      {string}   topic                    name of the verification (full path)
     * @param      {number}   expirationDate           expiration date, for the verification, defaults
     *                                                 to `0` (≈does not expire)
     * @param      {any}      verificationValue        json object which will be stored in the
     *                                                 verification
     * @param      {string}   descriptionDomain        domain of the verification, this is a subdomain
     *                                                 under 'verifications.evan', so passing
     *                                                 'example' will link verifications description
     *                                                 to 'example.verifications.evan'
     * @param      {boolean}  disabelSubVerifications  if true, verifications created under this path
     *                                                 are invalid
     * @return     {any}      data for setting verifications
     */
    private getSetVerificationData(issuer, subject, topic, expirationDate?, verificationValue?, descriptionDomain?, disabelSubVerifications?, isIdentity?);
    /**
     * checks if given given subject belongs to an account to a contract
     *
     * @param      {string}           subject     verification subject
     * @param      {boolean}          isIdentity  true if given subject is an identity
     * @return     {Promise<string>}  resolves to 'account' or 'contract'
     */
    private getSubjectType(subject, isIdentity?);
    /**
     * Tightly pack given arguments (excluding first argument of course), hash result and sign this
     * with private key of account.
     * This function will remove leading '0x' from resulting hash before signing it.
     *
     * @param      {string}  accountId  account, that is used to sign data
     * @param      {any[]}   toSign     arguments, that will be packed, hashed, signed
     * @return     {any}     object with signed data
     */
    private signPackedHash(accountId, toSign);
}
