import { Core } from "../../../isolation";
import { ByteArray, Uint32 } from "../../types";
export * from "../../core/bip32";
declare const Node_base: {
    new (...args: any[]): {
        readonly "__#4@#revokers": Set<() => void>;
        "__#4@#revoked": boolean;
        readonly revoke: () => void;
        readonly addRevoker: (revoker: () => void) => void;
    };
} & {
    new (): {};
};
export declare class Node extends Node_base implements Core.BIP32.Node, Core.SecP256K1.ECDSARecoverableKey, Core.SecP256K1.ECDHKey {
    #private;
    readonly chainCode: Buffer & Core.BIP32.ChainCode;
    readonly explicitPath?: string;
    protected constructor(privateKey: Uint8Array, chainCode: Uint8Array, explicitPath?: string);
    static create(privateKey: Uint8Array, chainCode: Uint8Array, explicitPath?: string): Promise<Core.BIP32.Node>;
    getPublicKey(): Promise<Core.SecP256K1.CompressedPoint>;
    getChainCode(): Promise<Buffer<ArrayBufferLike> & Uint8Array & {
        length: 32;
    }>;
    ecdsaSign(digestAlgorithm: null, msg: ByteArray<32>, counter?: Uint32): Promise<Core.SecP256K1.Signature>;
    ecdsaSign(digestAlgorithm: Core.Digest.AlgorithmName<32>, msg: Uint8Array, counter?: Uint32): Promise<Core.SecP256K1.Signature>;
    ecdsaSignRecoverable(digestAlgorithm: null, msg: ByteArray<32>, counter?: Uint32): Promise<Core.SecP256K1.RecoverableSignature>;
    ecdsaSignRecoverable(digestAlgorithm: Core.Digest.AlgorithmName<32>, msg: Uint8Array, counter?: Uint32): Promise<Core.SecP256K1.RecoverableSignature>;
    derive(index: Uint32): Promise<this>;
    ecdh(publicKey: Core.SecP256K1.CurvePoint, digestAlgorithm?: Core.Digest.AlgorithmName<32>): Promise<ByteArray<32>>;
    ecdhRaw(publicKey: Core.SecP256K1.CurvePoint): Promise<Core.SecP256K1.UncompressedPoint>;
    private _ecdh;
}
declare const Seed_base: {
    new (...args: any[]): {
        readonly "__#4@#revokers": Set<() => void>;
        "__#4@#revoked": boolean;
        readonly revoke: () => void;
        readonly addRevoker: (revoker: () => void) => void;
    };
} & {
    new (): {};
};
export declare class Seed extends Seed_base implements Core.BIP32.Seed {
    #private;
    protected constructor(seed: Uint8Array);
    static create(seed: Uint8Array): Promise<Core.BIP32.Seed>;
    toSecp256k1MasterKey(): Promise<Core.BIP32.Node>;
    toEd25519MasterKey(): Promise<Core.Ed25519.Node>;
    /**
     * Create Stark master key for Starknet
     *
     * Uses "Bitcoin seed" HMAC key per SLIP-0010 because Starknet follows the
     * industry standard of using secp256k1 BIP32 derivation math, then applying
     * Stark-specific operations (grinding, STARK curve signing) only at the end.
     *
     * This matches implementations by Argent and Ledger.
     *
     * References:
     * - https://github.com/argentlabs/argent-starknet-recover/blob/main/keyDerivation.ts
     * - https://community.starknet.io/t/account-keys-and-addresses-derivation-standard/1230
     */
    toStarkMasterKey(): Promise<Core.Stark.Node>;
}
declare const TonSeed_base: {
    new (...args: any[]): {
        readonly "__#4@#revokers": Set<() => void>;
        "__#4@#revoked": boolean;
        readonly revoke: () => void;
        readonly addRevoker: (revoker: () => void) => void;
    };
} & {
    new (): {};
};
export declare class TonSeed extends TonSeed_base {
    #private;
    protected constructor(seed: Uint8Array);
    static create(seed: Uint8Array): Promise<TonSeed>;
    toTonMasterKey(): Promise<Core.Ed25519.Node>;
}
//# sourceMappingURL=bip32.d.ts.map