@btc-vision/bitcoin-rpc/build/rpc/external/rpc.d.ts

The one and only fully typed Bitcoin RPC client for Node.js

import { RESTClient, RESTIniOptions } from './rest.js';
import { BlockData } from '../types/BlockData.js';
import { RawTransaction } from '../types/BitcoinRawTransaction.js';
import { BitcoinVerbosity } from '../types/BitcoinVerbosity.js';
import { BlockTemplateCapability, BlockTemplateRule } from '../types/BlockTemplate.js';
export type RPCIniOptions = RESTIniOptions & {
    user?: string;
    pass: string;
    wallet?: string;
    fullResponse?: boolean;
};
export type JSONRPC = {
    jsonrpc?: string | number;
    id?: string | number;
    method: string;
    params?: object;
};
export type Verbosity = {
    verbosity?: 0 | 1 | 2;
};
export type Verbose = {
    verbose?: boolean;
};
export type Height = {
    height: number;
};
export type Blockhash = {
    blockhash: string;
};
export type TxId = {
    txid: string;
};
export type GetBlockParams = Verbosity & Blockhash;
export type GetBlockFilterParams = Blockhash & {
    filtertype?: string;
};
export type GetBlockHeaderParams = Blockhash & Verbose;
export type GetBlockStatsParams = {
    hash_or_height: string | number;
    stats?: string[];
};
export type GetChainTxStatsParams = {
    nblocks?: number;
    blockhash?: string;
};
export type GetMemPoolParams = TxId & Verbose;
export type GetTxOutParams = TxId & {
    n: number;
    include_mempool?: boolean;
};
export type GetTxOutProofParams = {
    txids: string[];
    blockhash?: string;
};
export type Descriptor = string | {
    desc: string;
    range: number | [number, number];
};
export type ScanTxOutSetParams = {
    action: 'start' | 'abort' | 'status';
    scanobjects: Descriptor[];
};
export type HelpParams = {
    command?: string;
};
export type LoggingParams = {
    include?: string[] | 'all' | 'none' | 0 | 1;
    exclude?: string[] | 'all' | 'none' | 0 | 1;
};
export type GenerateParams = {
    nblocks: number;
    maxtries?: number;
};
export type GenerateToAddressParams = GenerateParams & {
    address: string;
};
export declare enum GetBlockTemplateMode {
    TEMPLATE = "template",
    PROPOSAL = "proposal"
}
export type GetBlockTemplateParams = {
    template_request: {
        mode?: GetBlockTemplateMode;
        capabilities?: BlockTemplateCapability[];
        rules: BlockTemplateRule[];
    };
};
export type PrioritiseTransactionParams = TxId & {
    fee_delta: number;
};
export type HexData = {
    hexdata: string;
};
export type AddNodeParams = {
    node: string;
    command: 'add' | 'remove' | 'onetry';
};
export type DisconnectNodeParams = {
    address: string;
} | {
    nodeid: number;
};
export type SetBanParams = {
    subnet: string;
    command: 'add' | 'remove';
    bantime?: number;
    absolute?: boolean;
};
export type AddressType = 'legacy' | 'p2sh-segwit' | 'bech32';
export type CreateMultiSigParams = {
    nrequired: number;
    keys: string[];
    address_type?: AddressType;
};
export type DeriveAddressesParams = {
    descriptor: string;
    range?: number | [number, number];
};
export type EstimateMode = {
    estimate_mode?: 'UNSET' | 'ECONOMICAL' | 'CONSERVATIVE';
};
export type EstimateSmartFeeParams = EstimateMode & {
    conf_target: number;
};
export type SignMessageWithPrivKeyParams = {
    privkey: string;
    message: string;
};
export type VerifyMessageParams = {
    address: string;
    signature: string;
    message: string;
};
export type HexString = {
    hexstring: string;
};
export type ConvertToPsbtParams = HexString & {
    permitsigdata?: boolean;
    iswitness?: boolean;
};
export type BaseTransactionInput = {
    txid: string;
    vout: number;
};
export type TransactionInput = BaseTransactionInput & {
    sequence?: number;
};
export type TransactionOutput = {
    [address: string]: string | number;
} | {
    data: string;
};
export type BaseCreateTransaction = {
    inputs: TransactionInput[];
    outputs: TransactionOutput[];
    locktime?: number;
};
export type CreateTransactionParams = BaseCreateTransaction & {
    replaceable?: boolean;
};
export type DecodeRawTransactionParams = HexString & {
    iswitness?: boolean;
};
export type FinalizePsbtParams = {
    psbt: string;
    extract?: boolean;
};
export type BaseFundOptions = {
    options?: EstimateMode & {
        changeAddress?: string;
        changePosition?: number;
        change_type?: string;
        includeWatching?: boolean;
        lockUnspents?: boolean;
        feeRate?: number | string;
        subtractFeeFromOutputs?: number[];
        replaceable?: boolean;
        conf_target?: number;
    };
};
export type FundRawTransactionParams = HexString & {
    options?: BaseFundOptions;
    iswitness?: boolean;
};
export type GetRawTransactionParams = TxId & Verbose & {
    blockhash?: string;
};
export type SendRawTransactionParams = HexString & {
    maxfeerate?: number | string;
};
export type PrevTx = {
    txid: string;
    vout: number;
    scriptPubKey: string;
    redeemScript?: string;
    witnessScript?: string;
    amount: number | string;
};
export type SigHashType = 'ALL' | 'NONE' | 'SINGLE' | 'ALL|ANYONECANPAY' | 'NONE|ANYONECANPAY' | 'SINGLE|ANYONECANPAY';
export type SignRawTransactionWithWalletParams = HexString & {
    prevtxs?: PrevTx[];
    sighashtype?: SigHashType;
};
export type SignRawTransactionWithKeyParams = {
    privkeys: string[];
} & SignRawTransactionWithWalletParams;
export type TestmemPoolAcceptParams = {
    rawtxs: string[];
    maxfeerate?: string | number;
};
export type UtxoUpdatePsbtParams = {
    psbt: string;
    descriptors?: (string | {
        desc: string;
        range?: number | [number, number];
    })[];
};
export type Label = {
    label?: string;
};
export type AddMultiSigAddressParams = CreateMultiSigParams & Label;
export type BumpFeeParams = {
    txid: string;
    options?: EstimateMode & {
        replaceable?: boolean;
    } & ({
        confTarget?: number;
    } | {
        totalFee?: number;
    });
};
export type CreateWalletParams = {
    passphrase?: string;
    avoid_reuse?: boolean;
    wallet_name: string;
    disable_private_keys?: boolean;
    blank?: boolean;
};
export type GetBalanceParams = {
    avoid_reuse?: boolean;
    minconf?: number;
    include_watchonly?: boolean;
};
export type GetNewAddressParams = {
    address_type?: AddressType;
} & Label;
export type GetReceivedByAddressParams = {
    address: string;
    minconf?: number;
};
export type GetReceivedByLabelParams = {
    label: string;
    minconf?: number;
};
export type GetTransactionParams = TxId & {
    include_watchonly?: boolean;
    verbose?: boolean;
};
export type ImportAddressParams = {
    address: string;
    label?: string;
    rescan?: boolean;
    p2sh?: boolean;
};
export type ImportMultiRequest = {
    timestamp: number | 'now';
    internal?: boolean;
    watchonly?: boolean;
    label?: string;
    keypool?: boolean;
} & ({
    desc: string;
    range?: number | [number, number];
} | {
    scriptPubKey: {
        address: string;
    } | string;
    redeemscript?: string;
    witnessscript?: string;
    pubkeys?: string[];
    keys?: string[];
});
export type ImportMultiParams = {
    requests: ImportMultiRequest[];
    options?: {
        rescan?: boolean;
    };
};
export type ImportPrivKeyParams = {
    privkey: string;
    label?: string;
    rescan?: boolean;
};
export type ImportPrunedFundsParams = {
    rawtransaction: string;
    txoutproof: string;
};
export type ImportPubKeyParams = {
    pubkey: string;
    label?: string;
    rescan?: boolean;
};
export type ListLabelsParams = {
    purpose: 'receive' | 'send';
};
export type ListReceivedByAddressParams = ListReceivedByLabelParams & {
    address_filter?: string;
};
export type ListReceivedByLabelParams = {
    minconf?: number;
    include_empty?: boolean;
    include_watchonly?: boolean;
};
export type ListSinceBlockParams = {
    blockhash?: string;
    target_confirmations?: number;
    include_watchonly?: boolean;
    include_removed?: boolean;
};
export type ListTransactionsParams = {
    label?: string;
    count?: number;
    skip?: number;
    include_watchonly?: boolean;
};
export type ListUnspentParams = {
    minconf?: number;
    maxconf?: number;
    addresses?: string[];
    include_unsafe?: boolean;
    query_options?: {
        minimumAmount?: number | string;
        maximumAmount?: number | string;
        maximumCount?: number;
        minimumSumAmount?: number | string;
    };
};
export type LockUnspentParams = {
    unlock: boolean;
    transactions?: BaseTransactionInput[];
};
export type RescanBlockchainParams = {
    start_height?: number;
    stop_height?: number;
};
export type BaseSendParams = EstimateMode & {
    comment?: string;
    replaceable?: boolean;
    conf_target?: number;
};
export type SendManyParams = BaseSendParams & {
    amounts: {
        [address: string]: number | string;
    };
    subtractfeefrom?: string[];
};
export type SendToAddressParams = BaseSendParams & {
    avoid_reuse?: boolean;
    address: string;
    amount: string | number;
    comment_to?: string;
    subtractfeefromamount?: boolean;
};
export type SetHDSeedParams = {
    newkeypool?: boolean;
    seed?: string;
};
export type SetLabelParams = {
    address: string;
    label: string;
};
export type SetWalletFlagParams = {
    flag: string;
    value?: boolean;
};
export type SignMessageParams = {
    address: string;
    message: string;
};
export type WalletCreateFundedPsbtParams = BaseCreateTransaction & BaseFundOptions & {
    bip32derivs?: boolean;
};
export type WalletPassphraseParams = {
    passphrase: string;
    timeout: number;
};
export type WalletPassphraseChangeParams = {
    oldpassphrase: string;
    newpassphrase: string;
};
export type WalletProcessPsbtParams = {
    psbt: string;
    sign?: boolean;
    sighashtype?: SigHashType;
    bip32derivs?: boolean;
};
interface JSONRPCError {
    code: number;
    message: string;
}
interface JSONRPCResult {
    result: object | null;
    error: JSONRPCError | null;
    id: string;
}
export type GetBestBlockHeaderParams = Verbose;
export type GetDeploymentInfoParams = {
    blockhash?: string;
};
export type GetMempoolEntryByIdParams = {
    wtxid: string;
};
export type GenerateBlockParams = {
    output: string;
    transactions?: string[];
    submit?: boolean;
};
export type AddPeerAddressParams = {
    address: string;
    port: number;
    tried?: boolean;
};
export type GetNodeAddressesParams = {
    count?: number;
};
export type SendMsgToPeerParams = {
    peer_id: number;
    msg_type: string;
    data: string;
};
export type SubmitPackageParams = {
    package: string[];
    maxfeerate?: number | string;
    maxburnamount?: number | string;
};
export type GetIndexInfoParams = {
    index_name?: string;
};
export type VerifyChainLockParams = {
    blockhash: string;
    signature: string;
    height: number;
};
export type CreateWalletDescriptorParams = {
    type: 'wpkh' | 'pkh' | 'sh' | 'tr';
    internal?: boolean;
    hdkey?: string;
};
export type GetHDKeysParams = {
    active_only?: boolean;
    private?: boolean;
};
export type ImportDescriptorRequest = {
    desc: string;
    timestamp: number | 'now';
    active?: boolean;
    range?: number | [number, number];
    next_index?: number;
    internal?: boolean;
    label?: string;
};
export type ImportDescriptorsParams = {
    requests: ImportDescriptorRequest[];
};
export type ListDescriptorsParams = {
    private?: boolean;
};
export type MigrateWalletParams = {
    wallet_name?: string;
    passphrase?: string;
};
export type PsbtBumpFeeParams = {
    txid: string;
    options?: EstimateMode & {
        conf_target?: number;
        fee_rate?: number | string;
        replaceable?: boolean;
        outputs?: Array<{
            [address: string]: number | string;
        }>;
        reduce_output?: number;
    };
};
export type SendParams = {
    outputs: Array<{
        [address: string]: number | string;
    }>;
    conf_target?: number;
    estimate_mode?: 'UNSET' | 'ECONOMICAL' | 'CONSERVATIVE';
    fee_rate?: number | string;
    options?: {
        add_inputs?: boolean;
        include_unsafe?: boolean;
        add_to_wallet?: boolean;
        change_address?: string;
        change_position?: number;
        change_type?: string;
        fee_rate?: number | string;
        include_watching?: boolean;
        inputs?: Array<{
            txid: string;
            vout: number;
            weight?: number;
        }>;
        lock_unspents?: boolean;
        locktime?: number;
        max_tx_weight?: number;
        psbt?: boolean;
        subtract_fee_from_outputs?: number[];
        conf_target?: number;
        replaceable?: boolean;
    };
};
export type SendAllParams = {
    recipients: Array<{
        [address: string]: number | string;
    }> | string[];
    conf_target?: number;
    estimate_mode?: 'UNSET' | 'ECONOMICAL' | 'CONSERVATIVE';
    fee_rate?: number | string;
    options?: {
        add_to_wallet?: boolean;
        fee_rate?: number | string;
        include_watching?: boolean;
        inputs?: Array<{
            txid: string;
            vout: number;
            weight?: number;
        }>;
        lock_unspents?: boolean;
        locktime?: number;
        max_tx_weight?: number;
        minconf?: number;
        maxconf?: number;
        psbt?: boolean;
        send_max?: boolean;
        conf_target?: number;
        replaceable?: boolean;
    };
};
export type SimulateRawTransactionParams = {
    rawtxs?: string[];
    options?: {
        include_watchonly?: boolean;
    };
};
export type UpgradeWalletParams = {
    version?: number;
};
export declare class RPCClient extends RESTClient {
    wallet?: string;
    fullResponse?: boolean;
    constructor({ user, pass, wallet, fullResponse, ...options }: RPCIniOptions);
    batch(body: JSONRPC | JSONRPC[], uri?: string): Promise<JSONRPCResult>;
    rpc<T = unknown>(method: string, params?: {}, wallet?: string): Promise<T>;
    getbestblockhash(): Promise<unknown>;
    getblock({ blockhash, verbosity }: GetBlockParams): Promise<unknown>;
    getblockBatch(blockhashes: string[], verbosity?: number): Promise<(BlockData | null)[]>;
    getblockchaininfo(): Promise<unknown>;
    getblockcount(): Promise<unknown>;
    getblockfilter(options: GetBlockFilterParams): Promise<unknown>;
    getblockhash({ height }: Height): Promise<unknown>;
    getblockhashes(heights: Height, count: number): Promise<(string | null)[]>;
    getblockheader({ blockhash, verbose }: GetBlockHeaderParams): Promise<unknown>;
    getblockstats({ hash_or_height, stats }: GetBlockStatsParams): Promise<unknown>;
    getchaintips(): Promise<unknown>;
    getchaintxstats({ nblocks, blockhash }: GetChainTxStatsParams): Promise<unknown>;
    getdifficulty(): Promise<unknown>;
    getmempoolancestors({ txid, verbose }: GetMemPoolParams): Promise<unknown>;
    getmempooldescendants({ txid, verbose }: GetMemPoolParams): Promise<unknown>;
    getmempoolentry({ txid }: TxId): Promise<unknown>;
    getmempoolinfo(): Promise<unknown>;
    getrawmempool({ verbose }?: Verbose): Promise<unknown>;
    gettxout({ txid, n, include_mempool }: GetTxOutParams): Promise<unknown>;
    gettxoutproof({ txids, blockhash }: GetTxOutProofParams): Promise<unknown>;
    gettxoutsetinfo(): Promise<unknown>;
    preciousblock({ blockhash }: Blockhash): Promise<unknown>;
    pruneblockchain({ height }: Height): Promise<unknown>;
    savemempool(): Promise<unknown>;
    scantxoutset({ action, scanobjects }: ScanTxOutSetParams): Promise<unknown>;
    verifychain({ checklevel, nblocks }?: {
        checklevel?: number | undefined;
        nblocks?: number | undefined;
    }): Promise<unknown>;
    verifytxoutproof({ proof }: {
        proof: string;
    }): Promise<unknown>;
    getmemoryinfo({ mode }?: {
        mode?: string | undefined;
    }): Promise<unknown>;
    getrpcinfo(): Promise<unknown>;
    help({ command }?: HelpParams): Promise<unknown>;
    logging({ include, exclude }?: LoggingParams): Promise<unknown>;
    stop(): Promise<unknown>;
    uptime(): Promise<unknown>;
    getbestblockheader({ verbose }?: GetBestBlockHeaderParams): Promise<unknown>;
    getdeploymentinfo({ blockhash }?: GetDeploymentInfoParams): Promise<unknown>;
    getmempoolentrybyid({ wtxid }: GetMempoolEntryByIdParams): Promise<unknown>;
    generate({ nblocks, maxtries }: GenerateParams, wallet?: string): Promise<unknown>;
    generateblock({ output, transactions, submit }: GenerateBlockParams): Promise<unknown>;
    addpeeraddress({ address, port, tried }: AddPeerAddressParams): Promise<unknown>;
    sendmsgtopeer({ peer_id, msg_type, data }: SendMsgToPeerParams): Promise<unknown>;
    submitpackage({ package: pkg, maxfeerate, maxburnamount }: SubmitPackageParams): Promise<unknown>;
    generatetoaddress(options: GenerateToAddressParams, wallet?: string): Promise<unknown>;
    getindexinfo({ index_name }?: GetIndexInfoParams): Promise<unknown>;
    verifychainlock({ blockhash, signature, height }: VerifyChainLockParams): Promise<unknown>;
    createwalletdescriptor(options: CreateWalletDescriptorParams, wallet?: string): Promise<unknown>;
    gethdkeys(options?: GetHDKeysParams, wallet?: string): Promise<unknown>;
    importdescriptors({ requests }: ImportDescriptorsParams, wallet?: string): Promise<unknown>;
    listdescriptors({ private: priv }?: ListDescriptorsParams, wallet?: string): Promise<unknown>;
    migratewallet({ wallet_name, passphrase }?: MigrateWalletParams): Promise<unknown>;
    newkeypool(wallet?: string): Promise<unknown>;
    psbtbumpfee(options: PsbtBumpFeeParams, wallet?: string): Promise<unknown>;
    send({ outputs, conf_target, estimate_mode, fee_rate, options }: SendParams, wallet?: string): Promise<unknown>;
    sendall({ recipients, conf_target, estimate_mode, fee_rate, options }: SendAllParams, wallet?: string): Promise<unknown>;
    simulaterawtransaction({ rawtxs, options }?: SimulateRawTransactionParams, wallet?: string): Promise<unknown>;
    upgradewallet({ version }?: UpgradeWalletParams, wallet?: string): Promise<unknown>;
    getblocktemplate(options: GetBlockTemplateParams): Promise<unknown>;
    getmininginfo(): Promise<unknown>;
    getnetworkhashps(options?: {}): Promise<unknown>;
    prioritisetransaction(options: PrioritiseTransactionParams): Promise<unknown>;
    submitblock(options: HexData): Promise<unknown>;
    submitheader(options: HexData): Promise<unknown>;
    addnode(options: AddNodeParams): Promise<unknown>;
    clearbanned(): Promise<unknown>;
    disconnectnode(params: DisconnectNodeParams): Promise<unknown>;
    getaddednodeinfo(options?: {
        node?: string;
    }): Promise<unknown>;
    getconnectioncount(): Promise<unknown>;
    getnettotals(): Promise<unknown>;
    getnetworkinfo(): Promise<unknown>;
    getnodeaddresses({ count }?: GetNodeAddressesParams): Promise<unknown>;
    getpeerinfo(): Promise<unknown>;
    listbanned(): Promise<unknown>;
    ping(): Promise<unknown>;
    setban(options: SetBanParams): Promise<unknown>;
    setnetworkactive(options: {
        state: boolean;
    }): Promise<unknown>;
    analyzepsbt(options: {
        psbt: string;
    }): Promise<unknown>;
    combinepsbt(options: {
        txs: string[];
    }): Promise<unknown>;
    combinerawtransaction(options: {
        txs: string[];
    }): Promise<unknown>;
    converttopsbt(options: ConvertToPsbtParams): Promise<unknown>;
    createpsbt(options: CreateTransactionParams): Promise<unknown>;
    createrawtransaction(options: CreateTransactionParams): Promise<unknown>;
    decodepsbt(options: {
        psbt: string;
    }): Promise<unknown>;
    decoderawtransaction(options: DecodeRawTransactionParams): Promise<unknown>;
    decodescript(options: HexString): Promise<unknown>;
    finalizepsbt(options: FinalizePsbtParams): Promise<unknown>;
    fundrawtransaction(options: FundRawTransactionParams, wallet?: string): Promise<unknown>;
    getrawtransaction(options: GetRawTransactionParams): Promise<unknown>;
    getrawtransactionBatch<V extends BitcoinVerbosity>(txids: string[], verbose?: boolean): Promise<(RawTransaction<V> | null)[]>;
    joinpsbts(options: {
        txs: string[];
    }): Promise<unknown>;
    sendrawtransaction(options: SendRawTransactionParams): Promise<unknown>;
    signrawtransactionwithkey(options: SignRawTransactionWithKeyParams): Promise<unknown>;
    testmempoolaccept(options: TestmemPoolAcceptParams): Promise<unknown>;
    utxoupdatepsbt(options: UtxoUpdatePsbtParams): Promise<unknown>;
    createmultisig(options: CreateMultiSigParams): Promise<unknown>;
    deriveaddresses({ descriptor, range }: DeriveAddressesParams): Promise<unknown>;
    estimatesmartfee(options: EstimateSmartFeeParams): Promise<unknown>;
    getdescriptorinfo(options: {
        descriptor: string;
    }): Promise<unknown>;
    signmessagewithprivkey(options: SignMessageWithPrivKeyParams): Promise<unknown>;
    validateaddress(options: {
        address: string;
    }): Promise<unknown>;
    verifymessage(options: VerifyMessageParams): Promise<unknown>;
    abandontransaction(options: TxId, wallet?: string): Promise<unknown>;
    abortrescan(wallet?: string): Promise<unknown>;
    addmultisigaddress(options: AddMultiSigAddressParams, wallet?: string): Promise<unknown>;
    backupwallet(options: {
        destination: string;
    }, wallet?: string): Promise<unknown>;
    bumpfee(options: BumpFeeParams, wallet?: string): Promise<unknown>;
    createwallet(options: CreateWalletParams): Promise<unknown>;
    dumpprivkey(options: {
        address: string;
    }, wallet?: string): Promise<unknown>;
    dumpwallet(options: {
        filename: string;
    }, wallet?: string): Promise<unknown>;
    encryptwallet(options: {
        passphrase: string;
    }, wallet?: string): Promise<unknown>;
    getaddressesbylabel(options: {
        label: string;
    }, wallet?: string): Promise<unknown>;
    getaddressinfo(options: {
        address: string;
    }, wallet?: string): Promise<unknown>;
    getbalance(options: GetBalanceParams, wallet?: string): Promise<unknown>;
    getbalances(wallet?: string): Promise<unknown>;
    getnewaddress(options: GetNewAddressParams, wallet?: string): Promise<unknown>;
    getrawchangeaddress(options: {
        address_type?: AddressType;
    }, wallet?: string): Promise<unknown>;
    getreceivedbyaddress(options: GetReceivedByAddressParams, wallet?: string): Promise<unknown>;
    getreceivedbylabel(options: GetReceivedByLabelParams, wallet?: string): Promise<unknown>;
    gettransaction(options: GetTransactionParams, wallet?: string): Promise<unknown>;
    getunconfirmedbalance(wallet?: string): Promise<unknown>;
    getwalletinfo(wallet?: string): Promise<unknown>;
    invalidateblock({ blockhash }: Blockhash): Promise<unknown>;
    reconsiderblock({ blockhash }: Blockhash): Promise<unknown>;
    importaddress(options: ImportAddressParams, wallet?: string): Promise<unknown>;
    importmulti(options: ImportMultiParams, wallet?: string): Promise<unknown>;
    importprivkey(options: ImportPrivKeyParams, wallet?: string): Promise<unknown>;
    importprunedfunds(options: ImportPrunedFundsParams, wallet?: string): Promise<unknown>;
    importpubkey(options: ImportPubKeyParams, wallet?: string): Promise<unknown>;
    importwallet(options: {
        filename: string;
    }, wallet?: string): Promise<unknown>;
    keypoolrefill(options: {
        newsize?: number;
    }, wallet?: string): Promise<unknown>;
    listaddressgroupings(wallet?: string): Promise<unknown>;
    listlabels(options: ListLabelsParams, wallet?: string): Promise<unknown>;
    listlockunspent(wallet?: string): Promise<unknown>;
    listreceivedbyaddress(options: ListReceivedByAddressParams, wallet?: string): Promise<unknown>;
    listreceivedbylabel(options: ListReceivedByLabelParams, wallet?: string): Promise<unknown>;
    listsinceblock(options: ListSinceBlockParams, wallet?: string): Promise<unknown>;
    listtransactions(options: ListTransactionsParams, wallet?: string): Promise<unknown>;
    listunspent(options: ListUnspentParams, wallet?: string): Promise<unknown>;
    listwalletdir(): Promise<unknown>;
    listwallets(): Promise<unknown>;
    loadwallet({ filename }: {
        filename: string;
    }): Promise<unknown>;
    lockunspent(options: LockUnspentParams, wallet?: string): Promise<unknown>;
    removeprunedfunds(options: TxId, wallet?: string): Promise<unknown>;
    rescanblockchain(options: RescanBlockchainParams, wallet?: string): Promise<unknown>;
    sendmany(options: SendManyParams, wallet?: string): Promise<unknown>;
    sendtoaddress(options: SendToAddressParams, wallet?: string): Promise<unknown>;
    sethdseed(options: SetHDSeedParams, wallet?: string): Promise<unknown>;
    setlabel(options: SetLabelParams, wallet?: string): Promise<unknown>;
    settxfee(options: {
        amount: number | string;
    }, wallet?: string): Promise<unknown>;
    setwalletflag(options: SetWalletFlagParams, wallet?: string): Promise<unknown>;
    signmessage(options: SignMessageParams, wallet?: string): Promise<unknown>;
    signrawtransactionwithwallet(options: SignRawTransactionWithWalletParams, wallet?: string): Promise<unknown>;
    unloadwallet({ wallet_name }?: {
        wallet_name?: string;
    }): Promise<unknown>;
    walletcreatefundedpsbt(options: WalletCreateFundedPsbtParams, wallet?: string): Promise<unknown>;
    walletlock(wallet?: string): Promise<unknown>;
    walletpassphrase(options: WalletPassphraseParams, wallet?: string): Promise<unknown>;
    walletpassphrasechange(options: WalletPassphraseChangeParams, wallet?: string): Promise<unknown>;
    walletprocesspsbt(options: WalletProcessPsbtParams, wallet?: string): Promise<unknown>;
    getzmqnotifications(): Promise<unknown>;
}
export {};