import { Tier } from '../core/salter.ts';
import { Serder } from '../core/serder.ts';
import { Verfer } from '../core/verfer.ts';
import { Encrypter } from '../core/encrypter.ts';
import { Decrypter } from '../core/decrypter.ts';
/**
 * Agent is a custodial entity that can be used in conjuntion with a local Client to establish the
 * KERI "signing at the edge" semantic
 */
export declare class Agent {
    pre: string;
    anchor: string;
    verfer: Verfer | null;
    state: any | null;
    sn: number | undefined;
    said: string | undefined;
    constructor(agent: any);
    private parse;
    private event;
}
/**
 * Controller is responsible for managing signing keys for the client and agent.  The client
 * signing key represents the Account for the client on the agent
 */
export declare class Controller {
    private bran;
    /**
     * The stem is the prefix for the stretched input bytes the controller's cryptographic
     * key pairs are derived from.
     */
    stem: string;
    /**
     * The security tier for the identifiers created by this Controller.
     */
    tier: Tier;
    /**
     * The rotation index used during key generation by this Controller.
     */
    ridx: number;
    /**
     * The salter is a cryptographic salt used to derive the controller's cryptographic key pairs
     * and is deterministically derived from the bran and the security tier.
     */
    salter: any;
    /**
     * The current signing key used to sign requests for this controller.
     */
    signer: any;
    /**
     * The next signing key of which a digest is committed to in an establishment event (inception or rotation) to become the
     * signing key after the next rotation.
     * @private
     */
    private nsigner;
    /**
     * Either the current establishment event, inception or rotation, or the interaction event used for delegation approval.
     */
    serder: Serder;
    /**
     * Current public keys formatted in fully-qualified Base64.
     * @private
     */
    private keys;
    /**
     * Digests of the next public keys formatted in fully-qualified Base64.
     */
    ndigs: string[];
    /**
     * Creates a Signify Controller starting at key index 0 that generates keys in
     * memory based on the provided seed, or bran, the tier, and the rotation index.
     *
     * The rotation index is used as follows:
     *
     * @param bran
     * @param tier
     * @param ridx
     * @param state
     */
    constructor(bran: string, tier: Tier, ridx?: number, state?: any | null);
    approveDelegation(_agent: Agent): any[];
    get pre(): string;
    get event(): any[];
    get verfers(): [];
    derive(state: any): Serder;
    rotate(bran: string, aids: Array<any>): {
        rot: import("../core/core.ts").Dict<any>;
        sigs: any[];
        sxlt: any;
        keys: Record<any, any>;
    };
    recrypt(enc: string, decrypter: Decrypter, encrypter: Encrypter): any;
}