import { WasmBIP32 } from "./wasm/wasm_utxo.js";
/**
 * BIP32Arg represents the various forms that BIP32 keys can take
 * before being converted to a WasmBIP32 instance
 */
export type BIP32Arg = 
/** base58-encoded extended key string (xpub/xprv/tpub/tprv) */
string
/** BIP32 instance */
 | BIP32
/** WasmBIP32 instance */
 | WasmBIP32
/** BIP32Interface compatible object */
 | BIP32Interface;
/**
 * BIP32 interface for extended key operations
 */
export interface BIP32Interface {
    chainCode: Uint8Array;
    depth: number;
    index: number;
    parentFingerprint: number;
    privateKey?: Uint8Array;
    publicKey: Uint8Array;
    identifier: Uint8Array;
    fingerprint: Uint8Array;
    isNeutered(): boolean;
    neutered(): BIP32Interface;
    toBase58(): string;
    toWIF(): string;
    derive(index: number): BIP32Interface;
    deriveHardened(index: number): BIP32Interface;
    derivePath(path: string): BIP32Interface;
}
/**
 * BIP32 wrapper class for extended key operations
 */
export declare class BIP32 implements BIP32Interface {
    private _wasm;
    private constructor();
    /**
     * Create a BIP32 instance from a WasmBIP32 instance (internal use)
     * @internal
     */
    static fromWasm(wasm: WasmBIP32): BIP32;
    /**
     * Convert BIP32Arg to BIP32 instance
     * @param key - The BIP32 key in various formats
     * @returns BIP32 instance
     */
    static from(key: BIP32Arg): BIP32;
    /**
     * Create a BIP32 key from a base58 string (xpub/xprv/tpub/tprv)
     * @param base58Str - The base58-encoded extended key string
     * @returns A BIP32 instance
     */
    static fromBase58(base58Str: string): BIP32;
    /**
     * Create a BIP32 master key from a seed
     * @param seed - The seed bytes
     * @param network - Optional network string
     * @returns A BIP32 instance
     */
    static fromSeed(seed: Uint8Array, network?: string | null): BIP32;
    /**
     * Get the chain code as a Uint8Array
     */
    get chainCode(): Uint8Array;
    /**
     * Get the depth
     */
    get depth(): number;
    /**
     * Get the child index
     */
    get index(): number;
    /**
     * Get the parent fingerprint
     */
    get parentFingerprint(): number;
    /**
     * Get the private key as a Uint8Array (if available)
     */
    get privateKey(): Uint8Array | undefined;
    /**
     * Get the public key as a Uint8Array
     */
    get publicKey(): Uint8Array;
    /**
     * Get the identifier as a Uint8Array
     */
    get identifier(): Uint8Array;
    /**
     * Get the fingerprint as a Uint8Array
     */
    get fingerprint(): Uint8Array;
    /**
     * Check if this is a neutered (public) key
     * @returns True if the key is public-only (neutered)
     */
    isNeutered(): boolean;
    /**
     * Get the neutered (public) version of this key
     * @returns A new BIP32 instance containing only the public key
     */
    neutered(): BIP32;
    /**
     * Serialize to base58 string
     * @returns The base58-encoded extended key string
     */
    toBase58(): string;
    /**
     * Get the WIF encoding of the private key
     * @returns The WIF-encoded private key
     */
    toWIF(): string;
    /**
     * Derive a normal (non-hardened) child key
     * @param index - The child index
     * @returns A new BIP32 instance for the derived key
     */
    derive(index: number): BIP32;
    /**
     * Derive a hardened child key (only works for private keys)
     * @param index - The child index
     * @returns A new BIP32 instance for the derived key
     */
    deriveHardened(index: number): BIP32;
    /**
     * Derive a key using a derivation path (e.g., "0/1/2" or "m/0/1/2")
     * @param path - The derivation path string
     * @returns A new BIP32 instance for the derived key
     */
    derivePath(path: string): BIP32;
    /**
     * Get the underlying WASM instance (internal use only)
     * @internal
     */
    get wasm(): WasmBIP32;
}
