import { BytearrayWrapper } from '../bytearray-wrapper';
export declare class AccumulatorParams extends BytearrayWrapper {
    /**
     *  Generate accumulator parameters. They are needed to generate public key and initialize the accumulator.
     * @param label - Pass to generate parameters deterministically.
     * @returns
     */
    static generate(label?: Uint8Array): AccumulatorParams;
    /**
     * Check if parameters are valid. Before verifying witness or using for proof verification,
     * make sure the params are valid.
     * @returns true if key is valid, false otherwise
     */
    isValid(): boolean;
}
export declare class AccumulatorSecretKey extends BytearrayWrapper {
    /**
     * Generate secret key for the accumulator manager who updates the accumulator and creates witnesses.
     * @param seed - Pass to generate key deterministically.
     * @returns
     */
    static generate(seed?: Uint8Array): AccumulatorSecretKey;
    /**
     * Generate public key from given params and secret key.
     * @param params
     * @returns
     */
    generatePublicKey(params: AccumulatorParams): AccumulatorPublicKey;
}
export declare class AccumulatorPublicKey extends BytearrayWrapper {
    static generate(secretKey: AccumulatorSecretKey, params: AccumulatorParams): AccumulatorPublicKey;
    /**
     * Check if public key is valid. Before verifying witness or using for proof verification,
     * make sure the public key is valid.
     * @returns true if key is valid, false otherwise
     */
    isValid(): boolean;
}
export declare class AccumulatorKeypair {
    sk: AccumulatorSecretKey;
    pk: AccumulatorPublicKey;
    static generate(params: AccumulatorParams, seed?: Uint8Array): AccumulatorKeypair;
    constructor(sk: AccumulatorSecretKey, pk: AccumulatorPublicKey);
    get secretKey(): AccumulatorSecretKey;
    get publicKey(): AccumulatorPublicKey;
}
/**
 * Generate proving key for proving membership in an accumulator in zero knowledge. Proving key is
 * public data that must be known to both the prover and verifier. Any prover and verifier pair can mutually agree
 * on a proving key and the manager does not need to be aware of any proving key.
 * @param label - The bytearray that is hashed to deterministically generate the proving key.
 */
export declare class MembershipProvingKey extends BytearrayWrapper {
    static generate(label?: Uint8Array): MembershipProvingKey;
}
/**
 * Generate proving key for proving non-membership in a universal accumulator in zero knowledge.
 * @param label - The bytearray that is hashed to deterministically generate the proving key.
 */
export declare class NonMembershipProvingKey extends BytearrayWrapper {
    static generate(label?: Uint8Array): NonMembershipProvingKey;
    deriveMembershipProvingKey(): MembershipProvingKey;
}
export declare class AccumulatorParamsForKeyedVerification extends BytearrayWrapper {
    /**
     *  Generate accumulator parameters for keyed-verification.
     * @param label - Pass to generate parameters deterministically.
     * @returns
     */
    static generate(label?: Uint8Array): AccumulatorParamsForKeyedVerification;
}
export declare class AccumulatorPublicKeyForKeyedVerification extends BytearrayWrapper {
    static generate(secretKey: AccumulatorSecretKey, params: AccumulatorParamsForKeyedVerification): AccumulatorPublicKeyForKeyedVerification;
}
//# sourceMappingURL=params-and-keys.d.ts.map