export declare interface IGenericObject {
    [key: string]: any;
}

/**
 * @interface IHashFunctionOptions
 * @desc - Merkletree hashing options.
 * @since 1.0.0
 *
 * @prop {function} sha3_512 - Hashes using SHA3-512.
 */
export declare interface IHashFunctionOptions {
    sha3_512: (a: ArrayBuffer) => ArrayBuffer;
}

/**
 * @interface IMerkletree
 * @desc - Merkletree Proving Structure.
 * @since 1.0.0
 *
 * @prop {getRoot} getRoot
 * @prop {getRootAsHex} getRootAsHex
 * @prop {getSalt} getSalt
 * @prop {generatePollard} generatePollard
 * @prop {generateProof} generateProof
 */
export declare interface IMerkletree {
    /**
     * @method getRoot
     * @desc - Get raw merkletree root node.
     * @returns {ArrayBuffer}
     */
    getRoot(): ArrayBuffer;
    /**
     * @method getRootAsHex
     * @desc - Get merkletree root node as hex encoding.
     * @returns {string}
     */
    getRootAsHex(): string;
    /**
     * @method getSalt
     * @desc - Check if salt was used in creating merkletree.
     * @returns {boolean}
     */
    getSalt(): boolean;
    /**
     * @method generatePollard
     * @desc - Generate IPollard instance from merkletree.
     * @param {number} height - Height to use for creating pollard.
     * @returns {IPollard}
     */
    generatePollard(height: number): IPollard;
    /**
     * @method generateProof
     * @desc - Generate IProof instance from merkletree.
     * @param {ArrayBuffer} data - ArrayBuffer to check for comparison.
     * @param {number} height - Height to use for creating internal pollard.
     * @returns {IProof}
     */
    generateProof(data: ArrayBuffer, height: number): IProof;
}

/**
 * @interface IMerkletreeCompact
 * @desc - Memory efficient Merkletree Hashing Structure.
 * @since 1.1.0
 *
 * @prop {getRoot} getRoot
 * @prop {getRootAsHex} getRootAsHex
 */
export declare interface IMerkletreeCompact {
    /**
     * @method getRoot
     * @desc - Get raw merkletree root node.
     * @returns {ArrayBuffer}
     */
    getRoot(): ArrayBuffer;
    /**
     * @method getRootAsHex
     * @desc - Get merkletree root node as hex encoding.
     * @returns {string}
     */
    getRootAsHex(): string;
}

/**
 * @interface IMerkletreeCompactSource
 * @desc - Memory efficient Merkletree creation parameters.
 * @since 1.1.0
 *
 * @prop {ArrayBuffer} [seed] - Raw ArrayBuffer to use default pre-processing.
 * @prop {Array<ArrayBuffer>} [sapling] - Prepared array of ArrayBuffers.
 * @prop {number} [chunkSize] - Chunk size to use with seed.
 * @prop {string} [hashType] - Tag of hashing type to use, currently only supports SHA3_512.
 */
export declare interface IMerkletreeCompactSource {
    seed?: ArrayBuffer;
    sapling?: Array<ArrayBuffer>;
    chunkSize?: number;
    hashType?: TBranchHashOptionKeys;
}

/**
 * @interface IMerkletreeSource
 * @desc - Merkletree creation parameters.
 * @since 1.0.0
 *
 * @prop {ArrayBuffer} [seed] - Raw ArrayBuffer to use default pre-processing.
 * @prop {Array<ArrayBuffer>} [sapling] - Prepared array of ArrayBuffers.
 * @prop {number} [chunkSize] - Chunk size to use with seed.
 * @prop {string} [hashType] - Tag of hashing type to use, currently only supports SHA3_512.
 * @prop {boolean} [useSalt] - If merkletree should be salted, not yet implemented.
 * @prop {boolean} [sort] - If merkletree should be sorted, not yet implemented.
 * @prop {boolean} [preserve] - If merkletree should preserve full tree or only final root.
 */
export declare interface IMerkletreeSource {
    seed?: ArrayBuffer;
    sapling?: Array<ArrayBuffer>;
    chunkSize?: number;
    hashType?: TBranchHashOptionKeys;
    useSalt?: boolean;
    sort?: boolean;
    preserve?: boolean;
}

export declare interface IMultiProof {
    verify(data: Array<ArrayBuffer>): Promise<boolean>;
}

/**
 * @interface IPollard
 * @desc - Merkletree Pollard.
 * @since 1.0.0
 *
 * @prop {getHashes} getHashes
 * @prop {getHeight} getHeight
 * @prop {getLength} getLength
 * @prop {verify} verify
 */
export declare interface IPollard {
    /**
     * @method getHashes
     * @desc - Get hashes in pollard.
     * @returns {Array<ArrayBuffer>}
     */
    getHashes(): Array<ArrayBuffer>;
    /**
     * @method getHeight
     * @desc - Get height in parent merkletree of this pollard.
     * @returns {number}
     */
    getHeight(): number;
    /**
     * @method getLength
     * @desc - Get number of hashes in pollard.
     * @returns {number}
     */
    getLength(): number;
    /**
     * @method verify
     * @desc - Async check if this is a valid merkletree pollard.
     * @returns {Promise<boolean>}
     */
    verify(): Promise<boolean>;
}

/**
 * @interface IProof
 * @desc - Merkletree Proof.
 * @since 1.0.0
 *
 * @prop {verify} verify
 */
export declare interface IProof {
    /**
     * @method verify
     * @desc - Async check if ArrayBuffer is present in merkletree.
     * @param {ArrayBuffer} data - ArrayBuffer to check for comparison.
     * @returns {Promise<boolean>}
     */
    verify(data: ArrayBuffer): Promise<boolean>;
}

/**
 * @class Merkletree
 * @desc - Merkletree instance.
 * @see {IMerkletree}
 */
export declare class Merkletree implements IMerkletree {
    protected readonly root: ArrayBuffer;
    protected readonly source: Array<ArrayBuffer>;
    protected readonly nodes: Array<ArrayBuffer>;
    protected readonly hash: TBranchHashOptionKeys;
    protected readonly salted: boolean;
    protected readonly sorted: boolean;
    /**
     * @constructor Merkletree
     * @protected
     */
    protected constructor(r: ArrayBuffer, p: boolean, sap: Array<ArrayBuffer>, n: Array<ArrayBuffer>, h: TBranchHashOptionKeys, u: boolean, s: boolean);
    /**
     * @constructor Merkletree
     * @param {IMerkletreeSource} input - Merkletree creation parameters.
     * @returns {Promise<IMerkletree>}
     */
    static grow(input: IMerkletreeSource): Promise<IMerkletree>;
    getRoot(): ArrayBuffer;
    getRootAsHex(): string;
    getSalt(): boolean;
    generatePollard(height: number): IPollard;
    generateProof(data: ArrayBuffer, height: number): IProof;
}

/**
 * @class MerkletreeCompact
 * @desc - Merkletree Compact instance.
 * @see {IMerkletreeCompact}
 */
export declare class MerkletreeCompact implements IMerkletreeCompact {
    protected readonly root: ArrayBuffer;
    /**
     * @constructor MerkletreeCompact
     * @protected
     */
    protected constructor(r: ArrayBuffer);
    /**
     * @constructor MerkletreeCompact
     * @param {IMerkletreeCompactSource} input - Merkletree Compact creation parameters.
     * @returns {Promise<IMerkletreeCompact>}
     */
    static grow(input: IMerkletreeCompactSource): Promise<IMerkletreeCompact>;
    getRoot(): ArrayBuffer;
    getRootAsHex(): string;
}

export declare class MultiProof implements IMultiProof {
    constructor();
    verify(data: Array<ArrayBuffer>): Promise<boolean>;
}

export declare type OneOf<T, V extends any[], NK extends keyof V = Exclude<keyof V, keyof any[]>> = {
    [K in NK]: T extends V[K] ? V[K] : never;
}[NK];

/**
 * @class Pollard
 * @desc - Merkletree Pollard.
 * @see {IPollard}
 */
export declare class Pollard implements IPollard {
    protected readonly hashes: Array<ArrayBuffer>;
    protected readonly hashType: TBranchHashOptionKeys;
    protected readonly height: number;
    /**
     * @constructor Pollard
     * @param {Array<ArrayBuffer>} hashes - Merkletree hashes.
     * @param {TBranchHashOptionKeys} hashType - Merkletree hash type used.
     * @param {number} height - Height in Merkletree.
     */
    constructor(hashes: Array<ArrayBuffer>, hashType: TBranchHashOptionKeys, height: number);
    getHashes(): Array<ArrayBuffer>;
    getHeight(): number;
    getLength(): number;
    verify(): Promise<boolean>;
}

/**
 * @class Proof
 * @desc - Merkletree Proof.
 * @see {IProof}
 */
export declare class Proof implements IProof {
    protected readonly hashes: Array<ArrayBuffer>;
    protected readonly index: number;
    protected readonly hashType: TBranchHashOptionKeys;
    protected readonly salted: boolean;
    protected readonly pollard: IPollard;
    /**
     * @constructor Proof
     * @param {Array<ArrayBuffer>} hashes - Merkletree hashes.
     * @param {number} index - Merkletree index.
     * @param {TBranchHashOptionKeys} hashType - Merkletree hash type used.
     * @param {boolean} salted - If merkletree was salted.
     * @param {IPollard} pollard - Pollard instance to use as source.
     */
    constructor(hashes: Array<ArrayBuffer>, index: number, hashType: TBranchHashOptionKeys, salted: boolean, pollard: IPollard);
    verify(data: ArrayBuffer): Promise<boolean>;
}

export declare type TBranchHashOptionKeys = 'sha3_512';

export declare type TTypedArrays = Uint8Array | Uint16Array | Uint32Array;

export { }