import { Checksum256, PrivateKey, PublicKey, Signature } from '@wharfkit/antelope';
declare enum KeyManagerLevel {
    PASSWORD = "PASSWORD",
    ACTIVE = "ACTIVE",
    PIN = "PIN",
    BIOMETRIC = "BIOMETRIC",
    LOCAL = "LOCAL",
    BROWSER_LOCAL_STORAGE = "BROWSER_LOCAL_STORAGE",
    BROWSER_SESSION_STORAGE = "BROWSER_SESSION_STORAGE"
}
declare namespace KeyManagerLevel {
    function indexFor(value: KeyManagerLevel): number;
    function from(value: number | string): KeyManagerLevel;
    function validate(value: KeyManagerLevel): void;
}
/**
 * @param {KeyManagerLevel} level - The security level of the key
 * @param {PrivateKey} privateKey - The private key to be stored
 * @param {string} [challenge] - A challenge that needs to be presented in order for the key to be used
 */
declare class StoreKeyOptions {
    level: KeyManagerLevel;
    privateKey: PrivateKey;
    challenge?: string;
    static validate(options: StoreKeyOptions): void;
}
/**
 * @param {KeyManagerLevel} level - The security level of the key
 * @param {string | Checksum256} data - The data that will be used to create a digital signature
 * @param {string} [challenge] - A challenge that needs to be presented in order for the key to be used
 * @param {'jwt' | 'transaction'} [outputType] - The type of output to return
 */
declare class SignDataOptions {
    level: KeyManagerLevel;
    data: string | Checksum256;
    challenge?: string;
    outputType?: 'jwt' | 'transaction';
    static validate(options: SignDataOptions): void;
}
/**
 * @param {KeyManagerLevel} level - The security level of the key
 */
declare class GetKeyOptions {
    level: KeyManagerLevel;
    static validate(options: GetKeyOptions): void;
}
/**
 * @param {KeyManagerLevel} level - The security level of the key
 * @param {string} challenge - the challenge to check
 */
declare class CheckKeyOptions {
    level: KeyManagerLevel;
    challenge: string;
    static validate(options: CheckKeyOptions): void;
}
interface KeyManager {
    /**
     * Stores a private key that can be used later for signing.
     *
     * @remarks
     * Once a private key is stored, it may no longer be accessible.
     *
     * @param {StoreKeyOptions} options - Options for storing the key
     * @returns {Promise<PublicKey>} The public key
     */
    storeKey(options: StoreKeyOptions): Promise<PublicKey>;
    /**
     * Signs the hash of data with a stored private key
     *
     * @param {SignDataOptions} options - Options for signing data
     * @returns {Promise<string | Signature>} A digital signature of the SHA256 hashed data
     *
     * @throws if a key does not exist for the level or if the challenge is incorrect
     */
    signData(options: SignDataOptions): Promise<string | Signature>;
    /**
     * Returns the public key for provided a key level
     *
     * @param {GetKeyOptions} options - Options for retrieving the key
     * @returns {Promise<PublicKey>} The public key
     *
     * @throws If a key does not exist for the level
     */
    getKey(options: GetKeyOptions): Promise<PublicKey>;
    /**
     * Checks the key against the provided challenge
     *
     * @param {CheckKeyOptions} options - options for checking the key challenge
     * @returns {Promise<boolean>} - returns matching status
     *
     * @throws if challenge is not provided, or if key is not found
     */
    checkKey(options: CheckKeyOptions): Promise<boolean>;
    /**
     * Removes a key for the provided level
     *
     * @param {GetKeyOptions} options - Options for removing a key
     * @throws if a key does not exist for the level
     */
    removeKey(options: GetKeyOptions): Promise<void>;
}
export { KeyManager, KeyManagerLevel, StoreKeyOptions, SignDataOptions, GetKeyOptions, CheckKeyOptions };
//# sourceMappingURL=keymanager.d.ts.map