import { Transaction } from './qrl_types.js';
import { HexString } from './primitives_types.js';
export type Cipher = 'aes-256-gcm';
export type CipherOptions = {
    salt?: Uint8Array | string;
    iv?: Uint8Array | string;
    kdf?: 'argon2id';
    dklen?: number;
    t?: number;
    m?: number;
    p?: number;
};
export type Argon2idParams = {
    dklen: number;
    t: number;
    m: number;
    p: number;
    salt: Uint8Array | string;
};
export type KeyStore = {
    crypto: {
        cipher: Cipher;
        ciphertext: string;
        cipherparams: {
            iv: string;
        };
        kdf: 'argon2id';
        kdfparams: Argon2idParams;
    };
    id: string;
    version: 1;
    address: string;
};
export interface Web3BaseWalletAccount {
    [key: string]: unknown;
    readonly address: string;
    readonly seed: string;
    readonly signTransaction: (tx: Transaction) => Promise<{
        readonly messageHash: HexString;
        readonly signature: HexString;
        readonly rawTransaction: HexString;
        readonly transactionHash: HexString;
    }>;
    readonly sign: (data: Record<string, unknown> | string) => {
        readonly messageHash: HexString;
        readonly message?: string;
        readonly signature: HexString;
    };
    readonly encrypt: (password: string, options?: Record<string, unknown>) => Promise<KeyStore>;
}
export interface Web3AccountProvider<T> {
    seedToAccount: (seed: string) => T;
    create: () => T;
    decrypt: (keystore: KeyStore | string, password: string, options?: Record<string, unknown>) => Promise<T>;
}
export declare abstract class Web3BaseWallet<T extends Web3BaseWalletAccount> extends Array<T> {
    protected readonly _accountProvider: Web3AccountProvider<T>;
    constructor(accountProvider: Web3AccountProvider<T>);
    abstract create(numberOfAccounts: number): this;
    abstract add(account: T | string): this;
    abstract get(addressOrIndex: string | number): T | undefined;
    abstract remove(addressOrIndex: string | number): boolean;
    abstract clear(): this;
    abstract encrypt(password: string, options?: Record<string, unknown>): Promise<KeyStore[]>;
    abstract decrypt(encryptedWallet: KeyStore[], password: string, options?: Record<string, unknown>): Promise<this>;
    abstract save(password: string, keyName?: string, options?: Record<string, unknown>): Promise<boolean | never>;
    abstract load(password: string, keyName?: string): Promise<this | never>;
}