import { ContractLoader, Executor, Logger, LoggerOptions, NameResolver } from '@evan.network/dbcp';
export declare enum ClaimsStatus {
    /**
     * empty subject
     */
    None = 0,
    /**
     * self issued state is 1, values may match
     */
    Rejected = 1,
    /**
     * issued by both, self issued state is 2, values match
     */
    Confirmed = 2,
    /**
     * issued by a non-issuer parent claim holder, self issued state is 0
     */
    Issued = 3,
    /**
     * value from issuer and subject (self issued) missmatch
     */
    ValueMissmatch = 4,
    /**
     * subject set, but value and/or states do not fall within expected range
     */
    Unknown = 5,
}
export interface ClaimsOptions extends LoggerOptions {
    contractLoader: ContractLoader;
    executor: Executor;
    nameResolver: NameResolver;
    registry?: string;
    resolver?: string;
}
/**
 * Claims helper
 *
 * @class      Sharing (name)
 */
export declare class Claims extends Logger {
    contracts: any;
    options: ClaimsOptions;
    constructor(options: ClaimsOptions);
    /**
     * create a new claims structure; this includes a new registry and a default resolver for it
     *
     * @param      {string}        accountId  account, that execute the transaction and owner of the
     *                                        new registry
     * @return     {Promise<any>}  object with properties 'registry' and 'resolver', that are web3js
     *                             contract instances
     */
    createStructure(accountId: string): Promise<any>;
    /**
     * confirms a claim; this can be done, it a claim has been issued for a subject and the subject
     * wants to confirms it
     *
     * @param      {string}         subject     account, that approves the claim
     * @param      {string}         claimName   name of the claim (full path)
     * @param      {string}         claimValue  bytes32 hash of the claim value; this is the subjects
     *                                          value for the claim and has to be the as the issuers
     *                                          value for the claim
     * @return     {Promise<void>}  resolved when done
     */
    confirmClaim(subject: string, claimName: string, claimValue?: string): Promise<void>;
    /**
     * delete a claim. This requires the issuer to have permissions for the parent claim (if claim
     * name seen as a path, the parent 'folder'). Subjects of a claim may only delete it, if they are
     * the issuer as well. If not, they can only react to it by confirming or rejecting the claim.
     *
     * @param      {string}         issuer     issuer of the claim; only the issuer can delete a claim
     * @param      {string}         claimName  name of the claim (full path)
     * @return     {Promise<void>}  resolved when done
     */
    deleteClaim(issuer: string, claimName: string): Promise<void>;
    /**
     * gets claim information for a claim name
     *
     * @param      {string}        claimName  name (/path) of a claim
     * @return     {Promise<any>}  claim info, contains: issuer, name, selfIssuedState, selfIssuedValue,
     *                             status, subject, value
     */
    getClaim(claimName: string): Promise<any>;
    /**
     * sets or creates a claim; this requires the issuer to have permissions for the parent claim (if
     * claim name seen as a path, the parent 'folder')
     *
     * @param      {string}         issuer      issuer of the claim
     * @param      {string}         subject     subject of the claim and the owner of the claim node
     * @param      {string}         claimName   name of the claim (full path)
     * @param      {string}         claimValue  bytes32 hash of the claim value
     * @return     {Promise<void>}  resolved when done
     */
    setClaim(issuer: string, subject: string, claimName: string, claimValue?: string): Promise<void>;
    /**
     * reject a claim; this can be done, it a claim has been issued for a subject and the subject
     * wants to reject it
     *
     * @param      {string}         subject     account, that approves the claim
     * @param      {string}         claimName   name of the claim (full path)
     * @param      {string}         claimValue  bytes32 hash of the claim value; this is the subjects
     *                                          value for the claim and may differ from the issuers
     *                                          value for the claim
     * @return     {Promise<void>}  resolved when done
     */
    rejectClaim(subject: string, claimName: string, claimValue?: string): Promise<void>;
    private getClaimProperties(claimName);
    private loadContracts(registry, resolver);
    private respondToClaim(subject, claimName, state, claimValue?);
}
