import { crypto_borromean_signature_t, crypto_bulletproof_plus_t, crypto_bulletproof_t, crypto_clsag_signature_t, crypto_entropy_t, crypto_triptych_signature_t, key_pair_t } from './types';
import { Buffer } from 'buffer';
export * from './types';
/**
 * @ignore
 */
export declare abstract class CryptoModule {
    protected static runtime_configuration: CryptoModule.Settings;
    /**
     * We cannot create a new instance using this method as we need to await the
     * loading of an underlying module, hence, we need to await the static
     * init() method on this class to receive an instance of the class
     *
     * @protected
     */
    protected constructor();
    private static _external_library;
    /**
     * Gets the external library calls that replace our cryptographic method calls
     */
    static get external_library(): Partial<CryptoModule.Interface>;
    /**
     * Sets external library calls that replace our cryptographic method calls
     *
     * @param config
     */
    static set external_library(config: Partial<CryptoModule.Interface>);
    /**
     * Sets external library calls that replace our cryptographic method calls
     *
     * @param config
     */
    set external_library(config: Partial<CryptoModule.Interface>);
    /**
     * Returns the underlying cryptographic library name
     */
    static get library_name(): string;
    /**
     * Returns the underlying cryptographic library type
     */
    static get library_type(): CryptoModule.Type;
    /**
     * Returns if the underlying cryptographic library is of the
     * Node.js C++ Addon type
     */
    static get is_native(): boolean;
    /**
     * Gets the external library calls that replace our cryptographic method calls
     */
    get external_library(): Partial<CryptoModule.Interface>;
    /**
     * Returns the underlying cryptographic library name
     */
    get library_name(): string;
    /**
     * Returns the underlying cryptographic library type
     */
    get library_type(): CryptoModule.Type;
    /**
     * Returns if the underlying cryptographic library is of the
     * Node.js C++ Addon type
     */
    get is_native(): boolean;
    /**
     * Tests if the supplied string is of hexadecimal form
     *
     * @param value
     * @ignore
     */
    static is_hex(value: string): boolean;
    /**
     * Constructs a Module Result
     *
     * Note: This is typically only used by external cryptographic library calls
     * so that it mimics our underlying library call results
     *
     * The string returned should always be a raw type, whether it be
     * a string, a number, or an object as expected by the module.
     *
     * If you are using external libraries for the underlying cryptographic library,
     * it is highly recommended that you read the source code of this module
     * to make sure that you are returning a result of the proper structure.
     *
     * This method will `JSON.stringify()` whatever result you supply so that our
     * module understands it within it's private `execute()` method
     *
     * @param error
     * @param result
     * @param error_message
     */
    static make_module_result<ResultType = string>(error: boolean, result: ResultType, error_message?: string): string;
    /**
     * Returns the common lanague name for the specified language
     *
     * @param language
     */
    static languageToString(language: CryptoModule.Language): string;
    /**
     * Returns the library name from the specified library type
     *
     * @param type
     * @protected
     */
    protected static typeToString(type: CryptoModule.Type): string;
    /**
     * Encodes an address into Base58
     *
     * @param prefix
     * @param public_spend
     * @param public_view
     */
    base58_address_encode(prefix: number, public_spend: string, public_view?: string): Promise<string>;
    /**
     * Encodes an address into CryptoNote Base58
     *
     * @param prefix
     * @param public_spend
     * @param public_view
     */
    cn_base58_address_encode(prefix: number, public_spend: string, public_view?: string): Promise<string>;
    /**
     * Decodes an address from Base58
     *
     * @param base58
     */
    base58_address_decode(base58: string): Promise<{
        prefix: number;
        public_spend: string;
        public_view?: string;
    }>;
    /**
     * Decodes an address from CryptoNote Base58
     *
     * @param base58
     */
    cn_base58_address_decode(base58: string): Promise<{
        prefix: number;
        public_spend: string;
        public_view?: string;
    }>;
    /**
     * Generates a random entropy value
     *
     * @param entropy
     * @param bits
     * @param encode_timestamp
     */
    random_entropy(entropy?: string, bits?: 128 | 256, encode_timestamp?: boolean): Promise<crypto_entropy_t>;
    /**
     * Generates a random hash value
     */
    random_hash(): Promise<string>;
    /**
     * Generates a list of random hashes
     *
     * @param count
     */
    random_hashes(count?: number): Promise<string[]>;
    /**
     * Generates a random ED25519 scalar value
     */
    random_scalar(): Promise<string>;
    /**
     * Generates a list of random ED25519 scalars
     *
     * @param count
     */
    random_scalars(count?: number): Promise<string[]>;
    /**
     * Generates a random ED25519 point value
     */
    random_point(): Promise<string>;
    /**
     * Generates a list of random ED25519 points
     *
     * @param count
     */
    random_points(count?: number): Promise<string[]>;
    /**
     * Hashes the input data using sha256 and returns the resulting hash value
     *
     * @param input
     */
    sha256(input: any): Promise<string>;
    /**
     * Hashes the input data using sha384 and returns the resulting hash value
     *
     * @param input
     */
    sha384(input: any): Promise<string>;
    /**
     * Hashes the input data using sha512 and returns the resulting hash value
     *
     * @param input
     */
    sha512(input: any): Promise<string>;
    /**
     * Hashes the input data using sha3 and returns the resulting hash value
     *
     * @param input
     */
    sha3(input: any): Promise<string>;
    /**
     * Hashes the input data using a simple SHA3 KDF function and returns
     * the resulting hash value
     *
     * @param input
     * @param iterations
     */
    sha3_slow(input: string, iterations?: number): Promise<string>;
    /**
     * Hashes the input data using Blake2b and returns the resulting
     * hash value
     *
     * @param input
     */
    blake2b(input: any): Promise<string>;
    /**
     * Hashes the input data using Argon2i and returns the resulting hash value
     *
     * @param input
     * @param iterations
     * @param memory
     * @param threads
     */
    argon2i(input: any, iterations?: number, memory?: number, threads?: number): Promise<string>;
    /**
     * Hashes the input data using Argon2d and returns the resulting hash value
     *
     * @param input
     * @param iterations
     * @param memory
     * @param threads
     */
    argon2d(input: any, iterations?: number, memory?: number, threads?: number): Promise<string>;
    /**
     * Hashes the input data using Argon2id and returns the resulting hash value
     *
     * @param input
     * @param iterations
     * @param memory
     * @param threads
     */
    argon2id(input: any, iterations?: number, memory?: number, threads?: number): Promise<string>;
    /**
     * Recovers entropy from a mnemonic phrase or a list of mnemonic phrase words
     *
     * @param mnenomic_phrase
     * @param language
     */
    entropy_recover(mnenomic_phrase: string | string[], language?: CryptoModule.Language): Promise<crypto_entropy_t>;
    /**
     * Generates a key derivation
     *
     * Note: D = (a * B) mod l
     *
     * @param public_key
     * @param secret_key
     */
    generate_derivation(public_key: string, secret_key: string): Promise<string>;
    /**
     * Generates a key derivation scalar value
     *
     * Note: Ds = H(D || output_index) mod l
     *
     * @param derivation
     * @param output_index
     */
    generate_derivation_scalar(derivation: string, output_index?: number): Promise<string>;
    /**
     * Derives a public ephemeral from a derivation scalar and a public key
     *
     * Note: P = [(Ds * G) + B] mod l
     *
     * @param derivation_scalar
     * @param public_key
     */
    derive_public_key(derivation_scalar: string, public_key: string): Promise<string>;
    /**
     * Derives a secret ephemeral from a derivation scalar and a secret key
     *
     * Note: p = (Ds + b) mod l
     *
     * @param derivation_scalar
     * @param secret_key
     */
    derive_secret_key(derivation_scalar: string, secret_key: string): Promise<string>;
    /**
     * Generates a key image from the public and secret ephemeral
     *
     * @param public_ephemeral
     * @param secret_ephemeral
     */
    generate_key_image(public_ephemeral: string, secret_ephemeral: string): Promise<string>;
    /**
     * Generates a V2 key image from the secret ephemeral
     *
     * @param secret_ephemeral
     */
    generate_key_image_v2(secret_ephemeral: string): Promise<string>;
    /**
     * Generates a secret & public key pair
     */
    generate_keys(): Promise<key_pair_t>;
    /**
     * Generates a list pf secret & public keys
     *
     * @param count
     */
    generate_keys_m(count?: number): Promise<{
        public_keys: string[];
        secret_keys: string[];
    }>;
    /**
     * Much like derive_public_key() but calculates the public_key used from the public ephemeral
     *
     * Note: B = P - [H(D || output_index) mod l]
     *
     * @param derivation
     * @param public_ephemeral
     * @param output_index
     */
    underive_public_key(derivation: string, public_ephemeral: string, output_index?: number): Promise<string>;
    /**
     * Calculates the public key of the given secret key
     *
     * @param secret_key
     */
    secret_key_to_public_key(secret_key: string): Promise<string>;
    /**
     * Calculates the secret scalar and public key for the provided ED25519 private key (aka seed)
     *
     * @param private_key
     */
    private_key_to_keys(private_key: string): Promise<key_pair_t>;
    /**
     * Generates an ED25519 point by hashing the provided data and turning
     * it into a point on the ED25519 curve
     *
     * @param input
     */
    hash_to_point(input: any): Promise<string>;
    /**
     * Generates an ED25519 scalar by hashing the provided data and
     * reducing it to an ED25519 scalar value
     *
     * @param input
     */
    hash_to_scalar(input: any): Promise<string>;
    /**
     * Reduces the input value to an ED25519 scalar value
     *
     * @param input
     */
    scalar_reduce(input: string | Buffer): Promise<string>;
    /**
     * Calculates the depth of the Merkle tree based upon how many hashes
     * the tree contains
     *
     * @param value
     */
    tree_depth(value: number): Promise<number>;
    /**
     * Generates the root Merkle tree hash using the list of hashes
     *
     * @param hashes
     */
    root_hash(hashes: string[]): Promise<string>;
    /**
     * Generates a Merkle tree root hash value from the supplied input values
     *
     * @param branches
     * @param leaf
     * @param depth
     * @param path
     */
    root_hash_from_branch(branches: string[], leaf: string, depth?: number, path?: 0 | 1): Promise<string>;
    /**
     * Generates Merkle tree branch from the list of hashes
     *
     * @param hashes
     */
    tree_branch(hashes: string[]): Promise<string[]>;
    /**
     * Generates an ED25519 RFC8032 signature for the message using
     * the secret key specified
     * @param message
     * @param secret_key
     */
    generate_rfc8032_signature(message: string, secret_key: string): Promise<string>;
    /**
     * Checks an ED25519 RFC8032 signature to verify that it was created
     * with the secret key of the public key specified
     * @param message
     * @param public_key
     * @param signature
     */
    check_rfc8032_signature(message: string, public_key: string, signature: string): Promise<boolean>;
    /**
     * Generates a simple ED25519 signature for the message digest using
     * the secret key specified
     *
     * @param message_digest
     * @param secret_key
     */
    generate_signature(message_digest: string, secret_key: string): Promise<string>;
    /**
     * Prepares a signature for the message digest such that it
     * can be completed in later stages of the signature construction
     *
     * @param message_digest
     * @param public_key
     */
    prepare_signature(message_digest: string, public_key: string): Promise<string>;
    /**
     * Completes a previously prepared signature
     *
     * @param secret_key
     * @param signature
     */
    complete_signature(secret_key: string, signature: string): Promise<string>;
    /**
     * Checks a simple ED25519 signature to verify that it was created
     * with the secret key of the public key specified
     *
     * @param message_digest
     * @param public_key
     * @param signature
     */
    check_signature(message_digest: string, public_key: string, signature: string): Promise<boolean>;
    /**
     * Generates a borromean ring signature for the message digest using
     * the secret key specified and the list of all possible public key
     * signing candidates
     *
     * @param message_digest
     * @param secret_ephemeral
     * @param public_keys
     */
    generate_borromean_signature(message_digest: string, secret_ephemeral: string, public_keys: string[]): Promise<crypto_borromean_signature_t>;
    /**
     * Prepares a borromean ring signature for the message digest such
     * that it can be completed in later stages of signature construction
     *
     * @param message_digest
     * @param key_image
     * @param public_keys
     * @param real_output_index
     */
    prepare_borromean_signature(message_digest: string, key_image: string, public_keys: string[], real_output_index: number): Promise<crypto_borromean_signature_t>;
    /**
     * Completes a previously prepared borromean ring signature
     *
     * @param secret_ephemeral
     * @param real_output_index
     * @param signature
     */
    complete_borromean_signature(secret_ephemeral: string, real_output_index: number, signature: crypto_borromean_signature_t): Promise<crypto_borromean_signature_t>;
    /**
     * Checks a borromean ring signature to verify that it was created
     * by one of the candidate public keys
     *
     * @param message_digest
     * @param key_image
     * @param public_keys
     * @param signature
     */
    check_borromean_signature(message_digest: string, key_image: string, public_keys: string[], signature: crypto_borromean_signature_t): Promise<boolean>;
    /**
     * Generates a CLSAG ring signature for the message digest using
     * the secret key specified and the list of all possible public
     * key signing candidates.
     *
     * Optionally, we also include proof that we have the real values
     * of the values hidden within pedersen commitments
     *
     * @param message_digest
     * @param secret_ephemeral
     * @param public_keys
     * @param input_blinding_factor
     * @param public_commitments
     * @param pseudo_blinding_factor
     * @param pseudo_commitment
     */
    generate_clsag_signature(message_digest: string, secret_ephemeral: string, public_keys: string[], input_blinding_factor?: string, public_commitments?: string[], pseudo_blinding_factor?: string, pseudo_commitment?: string): Promise<crypto_clsag_signature_t>;
    /**
     * Prepares a CLSAG ring signature for the message digest such
     * that it can be completed in later stages of signature
     * construction
     *
     * @param message_digest
     * @param key_image
     * @param public_keys
     * @param real_output_index
     * @param input_blinding_factor
     * @param public_commitments
     * @param pseudo_blinding_factor
     * @param pseudo_commitment
     */
    prepare_clsag_signature(message_digest: string, key_image: string, public_keys: string[], real_output_index: number, input_blinding_factor?: string, public_commitments?: string[], pseudo_blinding_factor?: string, pseudo_commitment?: string): Promise<{
        signature: crypto_clsag_signature_t;
        h: string[];
        mu_P: string;
    }>;
    /**
     * Completes a previously prepared CLSAG ring signature
     *
     * @param secret_ephemeral
     * @param real_output_index
     * @param signature
     * @param h
     * @param mu_P
     */
    complete_clsag_signature(secret_ephemeral: string, real_output_index: number, signature: crypto_clsag_signature_t, h: string[], mu_P: string): Promise<crypto_clsag_signature_t>;
    /**
     * Checks a CLSAG ring signature to verify that it was created
     * by one of the candidate public keys.
     *
     * @param message_digest
     * @param key_image
     * @param public_keys
     * @param signature
     * @param commitments
     */
    check_clsag_signature(message_digest: string, key_image: string, public_keys: string[], signature: crypto_clsag_signature_t, commitments?: string[]): Promise<boolean>;
    /**
     * Generates a Triptych ring signature for the message digest using
     * the secret key specified and the list of all possible public
     * key signing candidates.
     *
     * Optionally, we also include proof that we have the real values
     * of the values hidden within pedersen commitments
     *
     * @param message_digest
     * @param secret_ephemeral
     * @param public_keys
     * @param input_blinding_factor
     * @param public_commitments
     * @param pseudo_blinding_factor
     * @param pseudo_commitment
     */
    generate_triptych_signature(message_digest: string, secret_ephemeral: string, public_keys: string[], input_blinding_factor: string, public_commitments: string[], pseudo_blinding_factor: string, pseudo_commitment: string): Promise<crypto_triptych_signature_t>;
    /**
     * Prepares a Triptych ring signature for the message digest such
     * that it can be completed in later stages of signature
     * construction
     *
     * @param message_digest
     * @param key_image
     * @param public_keys
     * @param real_output_index
     * @param input_blinding_factor
     * @param public_commitments
     * @param pseudo_blinding_factor
     * @param pseudo_commitment
     */
    prepare_triptych_signature(message_digest: string, key_image: string, public_keys: string[], real_output_index: number, input_blinding_factor: string, public_commitments: string[], pseudo_blinding_factor: string, pseudo_commitment: string): Promise<{
        signature: crypto_triptych_signature_t;
        xpow: string;
    }>;
    /**
     * Completes a previously prepared Triptych ring signature
     *
     * @param secret_ephemeral
     * @param signature
     * @param xpow
     */
    complete_triptych_signature(secret_ephemeral: string, signature: crypto_triptych_signature_t, xpow: string): Promise<crypto_triptych_signature_t>;
    /**
     * Checks a Triptych ring signature to verify that it was created
     * by one of the candidate public keys.
     *
     * @param message_digest
     * @param key_image
     * @param public_keys
     * @param signature
     * @param commitments
     */
    check_triptych_signature(message_digest: string, key_image: string, public_keys: string[], signature: crypto_triptych_signature_t, commitments: string[]): Promise<boolean>;
    /**
     * Generates a Bulletproof Zero-Knowledge proof of the amount(s) specified
     *
     * @param amounts
     * @param blinding_factors
     * @param N
     */
    generate_bulletproof(amounts: number[], blinding_factors: string[], N?: number): Promise<{
        proof: crypto_bulletproof_t;
        commitments: string[];
    }>;
    /**
     * Checks that a Bulletproof proof is valid
     *
     * @param proof
     * @param commitments
     * @param N
     */
    check_bulletproof(proof: crypto_bulletproof_t | crypto_bulletproof_t[], commitments: string[] | string[][], N?: number): Promise<boolean>;
    /**
     * Generates a Bulletproof+ Zero-Knowledge proof of the amount(s) specified
     *
     * @param amounts
     * @param blinding_factors
     * @param N
     */
    generate_bulletproof_plus(amounts: number[], blinding_factors: string[], N?: number): Promise<{
        proof: crypto_bulletproof_plus_t;
        commitments: string[];
    }>;
    /**
     * Checks that a Bulletproof+ proof is valid
     *
     * @param proof
     * @param commitments
     * @param N
     */
    check_bulletproof_plus(proof: crypto_bulletproof_plus_t | crypto_bulletproof_plus_t[], commitments: string[] | string[][], N?: number): Promise<boolean>;
    /**
     * Verifies that the sum of output pedersen commitments plus a pedersen
     * commitment of the transaction fee are equal to the sum of pseudo
     * pedersen commitments
     *
     * @param pseudo_commitments
     * @param output_commitments
     * @param transaction_fee
     */
    check_commitments_parity(pseudo_commitments: string[], output_commitments: string[], transaction_fee: number): Promise<boolean>;
    /**
     * Generates the amount mask for the given deriviation scalar
     *
     * @param derivation_scalar
     */
    generate_amount_mask(derivation_scalar: string): Promise<string>;
    /**
     * Generates the commitment blinding factor for the given derivation scalar
     *
     * @param derivation_scalar
     */
    generate_commitment_blinding_factor(derivation_scalar: string): Promise<string>;
    /**
     * Generates a pedersen commitment for the supplied blinding factor and amount
     *
     * Note: C = (y * G) + (a * H) mod l
     *
     * @param blinding_factor
     * @param amount
     */
    generate_pedersen_commitment(blinding_factor: string, amount: number): Promise<string>;
    /**
     * Generates a list of random blinding factors and pseudo output commitments from
     * the list of input amounts and the output commitments while proving them to a zero-sum
     *
     * @param amounts
     * @param output_blinding_factors
     */
    generate_pseudo_commitments(amounts: number[], output_blinding_factors: string[]): Promise<{
        blinding_factors: string[];
        commitments: string[];
    }>;
    /**
     * Toggles an amount from unmasked/masked to the inverse state of masked/unmasked using the
     * provided amount mask
     *
     * @param amount_mask
     * @param amount
     */
    toggle_masked_amount(amount_mask: string, amount: string | number | bigint): Promise<bigint>;
    /**
     * Generates proof of having the secret ephemerals specified by generating the
     * relevant public keys, key_images, and signature for each and encoding the
     * necessary information into a Base58 encoded string that can be provided
     * to a verified that already has the public ephemerals
     *
     * @param secret_ephemerals
     */
    generate_outputs_proof(secret_ephemerals: string[]): Promise<string>;
    /**
     * Verifies the proof provides using the public ephemerals by decoding the Base58 proof,
     * extracting the key images, the signatures, and then verifying if those signatures
     * are all valid, in which case, the key images are returned
     *
     * @param public_ephemerals
     * @param proof
     */
    check_outputs_proof(public_ephemerals: string[], proof: string): Promise<string[]>;
    /**
     * Encodes the value specified into Base58
     *
     * @param value
     */
    base58_encode(value: string | Buffer): Promise<string>;
    /**
     * Encodes the value specified into Base58 and appends a checksum to the result
     *
     * @param value
     */
    base58_encode_check(value: string | Buffer): Promise<string>;
    /**
     * Decodes a Base58 encoded string
     *
     * @param base58
     */
    base58_decode(base58: string): Promise<Buffer>;
    /**
     * Decodes a Base58 encoded string after verifying the checksum value included
     *
     * @param base58
     */
    base58_decode_check(base58: string): Promise<Buffer>;
    /**
     * Encodes the specified value into CryptoNote Base58
     * @param value
     */
    cn_base58_encode(value: string | Buffer): Promise<string>;
    /**
     * Encodes the value specified into CryptoNote Base58 and appends a checksum to the result
     *
     * @param value
     */
    cn_base58_encode_check(value: string | Buffer): Promise<string>;
    /**
     * Decodes a CryptoNote Base58 string
     *
     * @param base58
     */
    cn_base58_decode(base58: string): Promise<Buffer>;
    /**
     * Decodes a CryptoNote Base58 encoded string after verifying the checkvalue value included
     *
     * @param base58
     */
    cn_base58_decode_check(base58: string): Promise<Buffer>;
    /**
     * Generates a pedersen commitment for a transaction fee
     *
     * @param amount
     */
    generate_transaction_fee_commitment(amount: number): Promise<string>;
    /**
     * Checks if the value provided is a valid ED25519 scalar
     *
     * @param value
     */
    check_scalar(value: string): Promise<boolean>;
    /**
     * Checks if the value provided is a valid ED25519 point
     * @param value
     */
    check_point(value: string): Promise<boolean>;
    /**
     * Encodes the supplied seed into a list of mnemonic words
     *
     * @param entropy
     * @param language
     */
    mnemonics_encode(entropy: string, language?: CryptoModule.Language): Promise<string[]>;
    /**
     * Decodes a mnemonic phrase or list of mnenomic words into as seed value
     *
     * @param mnemonic
     * @param language
     */
    mnemonics_decode(mnemonic: string | string[], language?: CryptoModule.Language): Promise<crypto_entropy_t>;
    /**
     * Returns the index number of the specified mnemonic word
     *
     * @param word
     * @param language
     */
    mnemonics_word_index(word: string, language?: CryptoModule.Language): Promise<number>;
    /**
     * Returns the list of mnemonic words
     *
     * @param language
     */
    word_list(language?: CryptoModule.Language): Promise<string[]>;
    /**
     * Returns the list of mnemonic words that have been trimmed to
     * the minimum number of characters per word
     *
     * @param language
     */
    word_list_trimmed(language?: CryptoModule.Language): Promise<string[]>;
    /**
     * Calculates the exponent of 2^e that matches the target value
     *
     * @param value
     */
    calculate_base2_exponent(value: number): Promise<number>;
    /**
     * Encrypts the provides string using the supplied password into a hexadecimal encoded string
     *
     * @param input
     * @param password
     * @param iterations
     */
    aes_encrypt<InputType = string>(input: InputType, password: string, iterations?: number): Promise<string>;
    /**
     * Decrypts the data from the provided hexidecimal encoded encrypted string using the supplied password
     *
     * @param input
     * @param password
     * @param iterations
     */
    aes_decrypt<OutputType = string>(input: string, password: string, iterations?: number): Promise<OutputType>;
    /**
     * Returns a list of the supported languages
     */
    languages(): Promise<CryptoModule.Language[]>;
    /**
     * Generates a BIP-39 seed from the provided entropy
     *
     * @param entropy
     * @param passphrase
     */
    generate_seed(entropy: string, passphrase?: string): Promise<string>;
    /**
     * Generates a Hierarchical Deterministic Key Pair using the provided path
     *
     * @param seed
     * @param purposeOrPath the purpose (numeric) or path (e.g. m/44'/0'/1/3)
     * @param coin_type
     * @param account
     * @param change
     * @param address_index
     * @param hmac_key
     */
    generate_child_key(seed: string, purposeOrPath?: number | string, coin_type?: number, account?: number, change?: number, address_index?: number, hmac_key?: string): Promise<key_pair_t>;
    /**
     * Generates a hardened Hierarchical Deterministic Key path
     *
     * @param purposeOrPath the purpose (numeric) or path (e.g. m/44'/0'/1/3)
     * @param coin_type
     * @param account
     * @param change
     * @param address_index
     */
    make_path(purposeOrPath?: number | string, coin_type?: number, account?: number, change?: number, address_index?: number): string;
    /**
     * Executes the method call using the underlying library
     *
     * @param method
     * @param argument
     * @private
     */
    private execute;
}
export declare namespace CryptoModule {
    /**
     * The type of the underlying cryptographic library
     */
    enum Type {
        UNKNOWN = 0,
        NODE = 1,
        WASM = 2,
        JS = 3
    }
    /**
     * The type of the mnemonic phrase language
     *
     * Note: You will want to call the module `languages()` to get
     * the list of languages supported by the underlying cryptographic
     * module before attempting to use a particular language
     */
    enum Language {
        CHINESE_SIMPLIFIED = 0,
        CHINESE_TRADITIONAL = 1,
        CZECH = 2,
        ENGLISH = 3,
        FRENCH = 4,
        ITALIAN = 5,
        JAPANESE = 6,
        KOREAN = 7,
        PORTUGUESE = 8,
        SPANISH = 9
    }
    namespace External {
        /**
         * Defines the structure for when we interact with the generation of ring
         * signatures using our underlying cryptographic library
         */
        type GenerateRingSignature<SignatureType = any> = {
            message_digest?: string;
            secret_ephemeral?: string;
            public_keys?: string[];
            input_blinding_factor?: string;
            public_commitments?: string[];
            pseudo_blinding_factor?: string;
            pseudo_commitment?: string;
            real_output_index?: number;
            key_image?: string;
            signature?: SignatureType;
            h?: string[];
            mu_P?: string;
            xpow?: string;
        };
        /**
         * Defines the structure for when we interact with the AES methods
         * in our underlying cryptographic library
         */
        type AES = {
            input: string;
            password: string;
            iterations?: number;
        };
        /**
         * Defines the structure for when we interact with the checking of ring
         * signatures using our underlying cryptographic library
         */
        type CheckRingSignature<SignatureType> = {
            message_digest: string;
            key_image: string;
            public_keys: string[];
            signature: SignatureType;
            commitments?: string[];
        };
    }
    /**
     * Defines the Call types going into our underlying cryptographic library
     */
    namespace Call {
        type WithArguments = (input: string) => Promise<string>;
        type WithoutArguments = () => Promise<string>;
        type Signature = WithArguments | WithoutArguments;
        /**
         * @ignore
         */
        type Result<Type> = {
            error: boolean;
            result: Type;
            error_message?: string;
        };
    }
    /**
     * Defines the interface uses with our underlying cryptographic library
     * or an externally provided library
     */
    type Interface = {
        random_entropy: Call.WithoutArguments;
        random_hash: Call.WithoutArguments;
        random_hashes: Call.WithArguments;
        random_scalar: Call.WithoutArguments;
        random_scalars: Call.WithArguments;
        random_point: Call.WithoutArguments;
        random_points: Call.WithArguments;
        sha3: Call.WithArguments;
        sha3_slow: Call.WithArguments;
        argon2i: Call.WithArguments;
        argon2d: Call.WithArguments;
        argon2id: Call.WithArguments;
        entropy_recover: Call.WithArguments;
        generate_derivation: Call.WithArguments;
        generate_derivation_scalar: Call.WithArguments;
        derive_public_key: Call.WithArguments;
        derive_secret_key: Call.WithArguments;
        generate_key_image: Call.WithArguments;
        generate_key_image_v2: Call.WithArguments;
        generate_keys: Call.WithoutArguments;
        underive_public_key: Call.WithArguments;
        secret_key_to_public_key: Call.WithArguments;
        hash_to_point: Call.WithArguments;
        hash_to_scalar: Call.WithArguments;
        scalar_reduce: Call.WithArguments;
        tree_depth: Call.WithArguments;
        root_hash: Call.WithArguments;
        root_hash_from_branch: Call.WithArguments;
        tree_branch: Call.WithArguments;
        generate_signature: Call.WithArguments;
        prepare_signature: Call.WithArguments;
        complete_signature: Call.WithArguments;
        check_signature: Call.WithArguments;
        generate_borromean_signature: Call.WithArguments;
        prepare_borromean_signature: Call.WithArguments;
        complete_borromean_signature: Call.WithArguments;
        check_borromean_signature: Call.WithArguments;
        generate_clsag_signature: Call.WithArguments;
        prepare_clsag_signature: Call.WithArguments;
        complete_clsag_signature: Call.WithArguments;
        check_clsag_signature: Call.WithArguments;
        generate_triptych_signature: Call.WithArguments;
        prepare_triptych_signature: Call.WithArguments;
        complete_triptych_signature: Call.WithArguments;
        check_triptych_signature: Call.WithArguments;
        generate_bulletproof: Call.WithArguments;
        check_bulletproof: Call.WithArguments;
        check_bulletproof_batch: Call.WithArguments;
        generate_bulletproof_plus: Call.WithArguments;
        check_bulletproof_plus: Call.WithArguments;
        check_bulletproof_plus_batch: Call.WithArguments;
        check_commitment_parity: Call.WithArguments;
        generate_amount_mask: Call.WithArguments;
        generate_commitment_blinding_factor: Call.WithArguments;
        generate_pedersen_commitment: Call.WithArguments;
        generate_pseudo_commitments: Call.WithArguments;
        toggle_masked_amount: Call.WithArguments;
        base58_address_decode: Call.WithArguments;
        cn_base58_address_decode: Call.WithArguments;
        generate_outputs_proof: Call.WithArguments;
        check_outputs_proof: Call.WithArguments;
        base58_encode: Call.WithArguments;
        base58_encode_check: Call.WithArguments;
        base58_decode: Call.WithArguments;
        base58_decode_check: Call.WithArguments;
        cn_base58_encode: Call.WithArguments;
        cn_base58_encode_check: Call.WithArguments;
        cn_base58_decode: Call.WithArguments;
        cn_base58_decode_check: Call.WithArguments;
        check_scalar: Call.WithArguments;
        check_point: Call.WithArguments;
        generate_keys_m: Call.WithArguments;
        mnemonics_encode: Call.WithArguments;
        mnemonics_decode: Call.WithArguments;
        mnemonics_calculate_checksum_index: Call.WithArguments;
        mnemonics_word_index: Call.WithArguments;
        word_list: Call.WithoutArguments;
        word_list_trimmed: Call.WithoutArguments;
        calculate_base2_exponent: Call.WithArguments;
        aes_encrypt: Call.WithArguments;
        aes_decrypt: Call.WithArguments;
        generate_seed: Call.WithArguments;
        generate_child_key: Call.WithArguments;
        private_key_to_keys: Call.WithArguments;
        [key: string]: Call.Signature;
    };
    /** @ignore */
    type Settings = {
        library?: Interface;
        type: Type;
    };
}
export default CryptoModule;