/**
 * Bitcoin Cash Node (BCHN) JSON-RPC Schema
 *
 * Based on https://docs.bitcoincashnode.org/doc/json-rpc/
 * Covers BCHN v29.x JSON-RPC interface.
 *
 * Methods are categorized into three groups:
 * - Public: Read-only blockchain queries and stateless tx utilities
 * - Internal: Node administration, mining, network management
 * - Wallet: Key management, fund management, wallet operations
 *
 * BCHN uses ZMQ for pub/sub, not JSON-RPC subscriptions,
 * so the subscriptions tuple is empty.
 */
export type BCHNScriptPubKey = {
    asm: string;
    hex: string;
    reqSigs: number;
    type: string;
    addresses: string[];
};
export type BCHNTokenData = {
    category: string;
    amount: string;
    nft?: {
        capability: 'none' | 'minting' | 'mutable';
        commitment: string;
    };
};
export type BCHNScriptSig = {
    asm: string;
    hex: string;
};
export type BCHNVin = {
    coinbase?: string;
    txid: string;
    vout: number;
    scriptSig: BCHNScriptSig;
    sequence: number;
};
export type BCHNVout = {
    value: number;
    n: number;
    scriptPubKey: BCHNScriptPubKey;
    tokenData?: BCHNTokenData;
};
export type BCHNBlockVerbose = {
    hash: string;
    confirmations: number;
    size: number;
    height: number;
    version: number;
    versionHex: string;
    merkleroot: string;
    tx: string[];
    time: number;
    mediantime: number;
    nonce: number;
    bits: string;
    difficulty: number;
    chainwork: string;
    nTx: number;
    previousblockhash?: string;
    nextblockhash?: string;
    ablastate?: {
        epsilon: number;
        beta: number;
        blocksize: number;
        blocksizelimit: number;
        nextblocksizelimit: number;
    };
};
export type BCHNBlockVerboseTx = Omit<BCHNBlockVerbose, 'tx'> & {
    tx: Array<{
        txid: string;
        hash: string;
        version: number;
        size: number;
        locktime: number;
        vin: BCHNVin[];
        vout: BCHNVout[];
        hex: string;
        fee?: number;
    }>;
};
export type BCHNBlockHeader = {
    hash: string;
    confirmations: number;
    height: number;
    version: number;
    versionHex: string;
    merkleroot: string;
    time: number;
    mediantime: number;
    nonce: number;
    bits: string;
    difficulty: number;
    chainwork: string;
    nTx: number;
    previousblockhash?: string;
    nextblockhash?: string;
    ablastate?: {
        epsilon: number;
        beta: number;
        blocksize: number;
        blocksizelimit: number;
        nextblocksizelimit: number;
    };
};
export type BCHNMempoolEntry = {
    size: number;
    time: number;
    fees: {
        base: number;
        modified: number;
    };
    depends: string[];
    spentby: string[];
};
export type BCHNDecodedTransaction = {
    txid: string;
    hash: string;
    size: number;
    version: number;
    locktime: number;
    vin: BCHNVin[];
    vout: BCHNVout[];
};
export type BCHNVerboseTransaction = BCHNDecodedTransaction & {
    hex: string;
    blockhash: string;
    confirmations: number;
    time: number;
    blocktime: number;
    in_active_chain?: boolean;
    fee?: number;
};
export type BCHNDsProof = {
    dspid: string;
    txid: string | null;
    outpoint: {
        txid: string;
        vout: number;
    };
    descendants: string[];
    path: string[];
};
export type BCHNPublicRequests = [
    {
        method: 'getbestblockhash';
        params: [];
        return: string;
    },
    {
        method: 'getblock';
        params: [blockhash: string, verbosity?: number];
        return: string | BCHNBlockVerbose | BCHNBlockVerboseTx;
    },
    {
        method: 'getblockchaininfo';
        params: [];
        return: {
            chain: string;
            blocks: number;
            headers: number;
            bestblockhash: string;
            difficulty: number;
            mediantime: number;
            verificationprogress: number;
            initialblockdownload: boolean;
            chainwork: string;
            size_on_disk: number;
            pruned: boolean;
            pruneheight?: number;
            automatic_pruning?: boolean;
            prune_target_size?: number;
            warnings: string;
        };
    },
    {
        method: 'getblockcount';
        params: [];
        return: number;
    },
    {
        method: 'getblockhash';
        params: [height: number];
        return: string;
    },
    {
        method: 'getblockheader';
        params: [hash_or_height: string, verbose?: boolean];
        return: string | BCHNBlockHeader;
    },
    {
        method: 'getblockstats';
        params: [hash_or_height: string | number, stats?: string[]];
        return: {
            avgfee: number;
            avgfeerate: number;
            avgtxsize: number;
            blockhash: string;
            feerate_percentiles: number[];
            height: number;
            ins: number;
            maxfee: number;
            maxfeerate: number;
            maxtxsize: number;
            medianfee: number;
            mediantime: number;
            mediantxsize: number;
            minfee: number;
            minfeerate: number;
            mintxsize: number;
            outs: number;
            subsidy: number;
            time: number;
            total_out: number;
            total_size: number;
            totalfee: number;
            txs: number;
            utxo_increase: number;
            utxo_size_inc: number;
        };
    },
    {
        method: 'getchaintips';
        params: [];
        return: Array<{
            height: number;
            hash: string;
            branchlen: number;
            status: 'active' | 'valid-fork' | 'valid-headers' | 'headers-only' | 'invalid';
        }>;
    },
    {
        method: 'getchaintxstats';
        params: [nblocks?: number, blockhash?: string];
        return: {
            time: number;
            txcount: number;
            window_final_block_hash: string;
            window_block_count: number;
            window_tx_count?: number;
            window_interval?: number;
            txrate?: number;
        };
    },
    {
        method: 'getdifficulty';
        params: [];
        return: number;
    },
    {
        method: 'getfinalizedblockhash';
        params: [];
        return: string;
    },
    {
        method: 'getmempoolancestors';
        params: [txid: string, verbose?: boolean];
        return: string[] | Record<string, BCHNMempoolEntry>;
    },
    {
        method: 'getmempooldescendants';
        params: [txid: string, verbose?: boolean];
        return: string[] | Record<string, BCHNMempoolEntry>;
    },
    {
        method: 'getmempoolentry';
        params: [txid: string];
        return: BCHNMempoolEntry;
    },
    {
        method: 'getmempoolinfo';
        params: [];
        return: {
            loaded: boolean;
            size: number;
            bytes: number;
            usage: number;
            maxmempool: number;
            mempoolminfee: number;
            minrelaytxfee: number;
        };
    },
    {
        method: 'getrawmempool';
        params: [verbose?: boolean];
        return: string[] | Record<string, BCHNMempoolEntry>;
    },
    {
        method: 'getrawtransaction';
        params: [txid: string, verbose?: boolean | number, blockhash?: string];
        return: string | BCHNVerboseTransaction;
    },
    {
        method: 'gettxout';
        params: [txid: string, n: number, include_mempool?: boolean];
        return: {
            bestblock: string;
            confirmations: number;
            value: number;
            scriptPubKey: BCHNScriptPubKey;
            tokenData?: BCHNTokenData;
            coinbase: boolean;
        } | null;
    },
    {
        method: 'gettxoutproof';
        params: [txids: string[], blockhash?: string];
        return: string;
    },
    {
        method: 'verifytxoutproof';
        params: [proof: string];
        return: string[];
    },
    {
        method: 'getdsproof';
        params: [
            dspid_or_txid_or_outpoint: string | {
                txid: string;
                vout: number;
            },
            verbosity?: number,
            recursive?: boolean
        ];
        return: BCHNDsProof | null;
    },
    {
        method: 'getdsprooflist';
        params: [];
        return: string[];
    },
    {
        method: 'getdsproofscore';
        params: [txid: string];
        return: number;
    },
    {
        method: 'createrawtransaction';
        params: [
            inputs: Array<{
                txid: string;
                vout: number;
                sequence?: number;
            }>,
            outputs: Array<Record<string, number | string>>,
            locktime?: number
        ];
        return: string;
    },
    {
        method: 'decoderawtransaction';
        params: [hexstring: string];
        return: BCHNDecodedTransaction;
    },
    {
        method: 'decodescript';
        params: [hexstring: string];
        return: {
            asm: string;
            type: string;
            reqSigs: number;
            addresses: string[];
            p2sh?: string;
        };
    },
    {
        method: 'combinerawtransaction';
        params: [txs: string[]];
        return: string;
    },
    {
        method: 'signrawtransactionwithkey';
        params: [
            hexstring: string,
            privkeys: string[],
            prevtxs?: Array<{
                txid: string;
                vout: number;
                scriptPubKey: string;
                redeemScript?: string;
                amount: number;
            }>,
            sighashtype?: string
        ];
        return: {
            hex: string;
            complete: boolean;
            errors?: Array<{
                txid: string;
                vout: number;
                scriptSig: string;
                sequence: number;
                error: string;
            }>;
        };
    },
    {
        method: 'sendrawtransaction';
        params: [hexstring: string, allowhighfees?: boolean];
        return: string;
    },
    {
        method: 'testmempoolaccept';
        params: [rawtxs: string[], allowhighfees?: boolean];
        return: Array<{
            txid: string;
            allowed: boolean;
            'reject-reason'?: string;
        }>;
    },
    {
        method: 'combinepsbt';
        params: [txs: string[]];
        return: string;
    },
    {
        method: 'createpsbt';
        params: [
            inputs: Array<{
                txid: string;
                vout: number;
                sequence?: number;
            }>,
            outputs: Array<Record<string, number | string>>,
            locktime?: number
        ];
        return: string;
    },
    {
        method: 'decodepsbt';
        params: [psbt: string];
        return: {
            tx: BCHNDecodedTransaction;
            unknown: Record<string, string>;
            inputs: Array<{
                non_witness_utxo?: BCHNDecodedTransaction;
                final_scriptSig?: {
                    asm: string;
                    hex: string;
                };
                unknown?: Record<string, string>;
            }>;
            outputs: Array<{
                unknown?: Record<string, string>;
            }>;
            fee?: number;
        };
    },
    {
        method: 'converttopsbt';
        params: [hexstring: string, permitsigdata?: boolean];
        return: string;
    },
    {
        method: 'finalizepsbt';
        params: [psbt: string, extract?: boolean];
        return: {
            psbt?: string;
            hex?: string;
            complete: boolean;
        };
    },
    {
        method: 'createmultisig';
        params: [nrequired: number, keys: string[]];
        return: {
            address: string;
            redeemScript: string;
        };
    },
    {
        method: 'estimatefee';
        params: [];
        return: number;
    },
    {
        method: 'validateaddress';
        params: [address: string];
        return: {
            isvalid: boolean;
            address?: string;
            scriptPubKey?: string;
            isscript?: boolean;
        };
    },
    {
        method: 'verifymessage';
        params: [address: string, signature: string, message: string];
        return: boolean;
    },
    {
        method: 'help';
        params: [command?: string];
        return: string;
    },
    {
        method: 'getmininginfo';
        params: [];
        return: {
            blocks: number;
            currentblocksize: number;
            currentblocktx: number;
            difficulty: number;
            networkhashps: number;
            pooledtx: number;
            chain: string;
            warnings: string;
        };
    },
    {
        method: 'getnetworkhashps';
        params: [nblocks?: number, height?: number];
        return: number;
    }
];
export type BCHNInternalRequests = [
    {
        method: 'getmemoryinfo';
        params: [mode?: string];
        return: {
            locked: {
                used: number;
                free: number;
                total: number;
                locked: number;
                chunks_used: number;
                chunks_free: number;
            };
        };
    },
    {
        method: 'getrpcinfo';
        params: [];
        return: {
            active_commands: Array<{
                method: string;
                duration: number;
            }>;
        };
    },
    {
        method: 'logging';
        params: [include?: string[], exclude?: string[]];
        return: Record<string, boolean>;
    },
    {
        method: 'stop';
        params: [];
        return: string;
    },
    {
        method: 'uptime';
        params: [];
        return: number;
    },
    {
        method: 'finalizeblock';
        params: [blockhash: string];
        return: null;
    },
    {
        method: 'invalidateblock';
        params: [blockhash: string];
        return: null;
    },
    {
        method: 'parkblock';
        params: [blockhash: string];
        return: null;
    },
    {
        method: 'unparkblock';
        params: [blockhash: string];
        return: null;
    },
    {
        method: 'preciousblock';
        params: [blockhash: string];
        return: null;
    },
    {
        method: 'reconsiderblock';
        params: [blockhash: string];
        return: null;
    },
    {
        method: 'pruneblockchain';
        params: [height: number];
        return: number;
    },
    {
        method: 'savemempool';
        params: [];
        return: null;
    },
    {
        method: 'verifychain';
        params: [checklevel?: number, nblocks?: number];
        return: boolean;
    },
    {
        method: 'scantxoutset';
        params: [action: 'start' | 'abort' | 'status', scanobjects?: Array<string | {
            desc: string;
            range?: number;
        }>];
        return: {
            success: boolean;
            searched_items: number;
            unspents: Array<{
                txid: string;
                vout: number;
                scriptPubKey: string;
                amount: number;
                height: number;
            }>;
            total_amount: number;
        };
    },
    {
        method: 'gettxoutsetinfo';
        params: [];
        return: {
            height: number;
            bestblock: string;
            transactions: number;
            txouts: number;
            bogosize: number;
            hash_serialized: string;
            disk_size: number;
            total_amount: number;
        };
    },
    {
        method: 'addnode';
        params: [node: string, command: 'add' | 'remove' | 'onetry'];
        return: null;
    },
    {
        method: 'clearbanned';
        params: [];
        return: null;
    },
    {
        method: 'disconnectnode';
        params: [address?: string, nodeid?: number];
        return: null;
    },
    {
        method: 'getaddednodeinfo';
        params: [node?: string];
        return: Array<{
            addednode: string;
            connected: boolean;
            addresses: Array<{
                address: string;
                connected: 'inbound' | 'outbound';
            }>;
        }>;
    },
    {
        method: 'getconnectioncount';
        params: [];
        return: number;
    },
    {
        method: 'getexcessiveblock';
        params: [];
        return: {
            excessiveBlockSize: number;
        };
    },
    {
        method: 'getnettotals';
        params: [];
        return: {
            totalbytesrecv: number;
            totalbytessent: number;
            timemillis: number;
            uploadtarget: {
                timeframe: number;
                target: number;
                target_reached: boolean;
                serve_historical_blocks: boolean;
                bytes_left_in_cycle: number;
                time_left_in_cycle: number;
            };
        };
    },
    {
        method: 'getnetworkinfo';
        params: [];
        return: {
            version: number;
            subversion: string;
            protocolversion: number;
            localservices: string;
            localrelay: boolean;
            timeoffset: number;
            connections: number;
            connections_in: number;
            connections_out: number;
            networkactive: boolean;
            networks: Array<{
                name: string;
                limited: boolean;
                reachable: boolean;
                proxy: string;
                proxy_randomize_credentials: boolean;
            }>;
            relayfee: number;
            excessutxocharge: number;
            localaddresses: Array<{
                address: string;
                port: number;
                score: number;
            }>;
            warnings: string;
        };
    },
    {
        method: 'getnodeaddresses';
        params: [count?: number];
        return: Array<{
            time: number;
            services: number;
            address: string;
            port: number;
        }>;
    },
    {
        method: 'getpeerinfo';
        params: [];
        return: Array<{
            id: number;
            addr: string;
            addrbind: string;
            addrlocal: string;
            services: string;
            relaytxes: boolean;
            lastsend: number;
            lastrecv: number;
            bytessent: number;
            bytesrecv: number;
            conntime: number;
            timeoffset: number;
            pingtime: number;
            minping: number;
            version: number;
            subver: string;
            inbound: boolean;
            addnode: boolean;
            startingheight: number;
            banscore: number;
            synced_headers: number;
            synced_blocks: number;
            whitelisted: boolean;
        }>;
    },
    {
        method: 'listbanned';
        params: [];
        return: Array<{
            address: string;
            banned_until: number;
            ban_created: number;
            ban_reason: string;
        }>;
    },
    {
        method: 'ping';
        params: [];
        return: null;
    },
    {
        method: 'setban';
        params: [subnet: string, command: 'add' | 'remove', bantime?: number, absolute?: boolean];
        return: null;
    },
    {
        method: 'setnetworkactive';
        params: [state: boolean];
        return: boolean;
    },
    {
        method: 'generate';
        params: [nblocks: number, maxtries?: number];
        return: string[];
    },
    {
        method: 'generatetoaddress';
        params: [nblocks: number, address: string, maxtries?: number];
        return: string[];
    },
    {
        method: 'getblocktemplate';
        params: [template_request?: {
            mode?: string;
            capabilities?: string[];
            rules?: string[];
        }];
        return: {
            capabilities: string[];
            version: number;
            previousblockhash: string;
            transactions: Array<{
                data: string;
                txid: string;
                hash: string;
                depends: number[];
                fee: number;
                sigops: number;
            }>;
            coinbaseaux: Record<string, string>;
            coinbasevalue: number;
            longpollid: string;
            target: string;
            mintime: number;
            mutable: string[];
            noncerange: string;
            sigoplimit: number;
            sizelimit: number;
            curtime: number;
            bits: string;
            height: number;
        };
    },
    {
        method: 'getblocktemplatelight';
        params: [template_request?: {
            mode?: string;
            capabilities?: string[];
            rules?: string[];
        }, additional_txs?: string[]];
        return: {
            capabilities: string[];
            version: number;
            previousblockhash: string;
            job_id: string;
            coinbaseaux: Record<string, string>;
            coinbasevalue: number;
            longpollid: string;
            target: string;
            mintime: number;
            mutable: string[];
            noncerange: string;
            sigoplimit: number;
            sizelimit: number;
            curtime: number;
            bits: string;
            height: number;
            merkle: string[];
        };
    },
    {
        method: 'prioritisetransaction';
        params: [txid: string, dummy: number, fee_delta: number];
        return: boolean;
    },
    {
        method: 'submitblock';
        params: [hexdata: string];
        return: string | null;
    },
    {
        method: 'submitblocklight';
        params: [hexdata: string, job_id: string];
        return: string | null;
    },
    {
        method: 'submitheader';
        params: [hexdata: string];
        return: null;
    },
    {
        method: 'validateblocktemplate';
        params: [hexdata: string];
        return: null;
    },
    {
        method: 'signmessagewithprivkey';
        params: [privkey: string, message: string];
        return: string;
    },
    {
        method: 'getindexinfo';
        params: [];
        return: Record<string, {
            synced: boolean;
            best_block_height: number;
        }>;
    },
    {
        method: 'fundrawtransaction';
        params: [hexstring: string, options?: {
            changeAddress?: string;
            changePosition?: number;
            includeWatching?: boolean;
            lockUnspents?: boolean;
            feeRate?: number;
            subtractFeeFromOutputs?: number[];
        }];
        return: {
            hex: string;
            fee: number;
            changepos: number;
        };
    },
    {
        method: 'getzmqnotifications';
        params: [];
        return: Array<{
            type: string;
            address: string;
            hwm: number;
        }>;
    }
];
export type BCHNWalletRequests = [
    {
        method: 'abandontransaction';
        params: [txid: string];
        return: null;
    },
    {
        method: 'abortrescan';
        params: [];
        return: boolean;
    },
    {
        method: 'addmultisigaddress';
        params: [nrequired: number, keys: string[], label?: string];
        return: {
            address: string;
            redeemScript: string;
        };
    },
    {
        method: 'backupwallet';
        params: [destination: string];
        return: null;
    },
    {
        method: 'createwallet';
        params: [wallet_name: string, disable_private_keys?: boolean, blank?: boolean];
        return: {
            name: string;
            warning: string;
        };
    },
    {
        method: 'dumpprivkey';
        params: [address: string];
        return: string;
    },
    {
        method: 'dumpwallet';
        params: [filename: string];
        return: {
            filename: string;
        };
    },
    {
        method: 'encryptwallet';
        params: [passphrase: string];
        return: string;
    },
    {
        method: 'getaddressesbylabel';
        params: [label: string];
        return: Record<string, {
            purpose: string;
        }>;
    },
    {
        method: 'getaddressinfo';
        params: [address: string];
        return: {
            address: string;
            scriptPubKey: string;
            ismine: boolean;
            iswatchonly: boolean;
            isscript: boolean;
            ischange: boolean;
            script?: string;
            hex?: string;
            pubkey?: string;
            embedded?: object;
            label: string;
            timestamp?: number;
            hdkeypath?: string;
            hdseedid?: string;
            labels: Array<{
                name: string;
                purpose: string;
            }>;
        };
    },
    {
        method: 'getbalance';
        params: [dummy?: string, minconf?: number, include_watchonly?: boolean];
        return: number;
    },
    {
        method: 'getnewaddress';
        params: [label?: string];
        return: string;
    },
    {
        method: 'getrawchangeaddress';
        params: [];
        return: string;
    },
    {
        method: 'getreceivedbyaddress';
        params: [address: string, minconf?: number];
        return: number;
    },
    {
        method: 'getreceivedbylabel';
        params: [label: string, minconf?: number];
        return: number;
    },
    {
        method: 'gettransaction';
        params: [txid: string, include_watchonly?: boolean];
        return: {
            amount: number;
            fee?: number;
            confirmations: number;
            blockhash?: string;
            blockindex?: number;
            blocktime?: number;
            txid: string;
            time: number;
            timereceived: number;
            details: Array<{
                address: string;
                category: 'send' | 'receive' | 'generate' | 'immature' | 'orphan';
                amount: number;
                label?: string;
                vout: number;
                fee?: number;
            }>;
            hex: string;
        };
    },
    {
        method: 'getunconfirmedbalance';
        params: [];
        return: number;
    },
    {
        method: 'getwalletinfo';
        params: [];
        return: {
            walletname: string;
            walletversion: number;
            balance: number;
            unconfirmed_balance: number;
            immature_balance: number;
            txcount: number;
            keypoololdest: number;
            keypoolsize: number;
            keypoolsize_hd_internal: number;
            unlocked_until?: number;
            paytxfee: number;
            hdseedid?: string;
            private_keys_enabled: boolean;
        };
    },
    {
        method: 'importaddress';
        params: [address: string, label?: string, rescan?: boolean, p2sh?: boolean];
        return: null;
    },
    {
        method: 'importmulti';
        params: [
            requests: Array<{
                scriptPubKey: string | {
                    address: string;
                };
                timestamp: number | 'now';
                redeemscript?: string;
                pubkeys?: string[];
                keys?: string[];
                internal?: boolean;
                watchonly?: boolean;
                label?: string;
            }>,
            options?: {
                rescan?: boolean;
            }
        ];
        return: Array<{
            success: boolean;
            error?: {
                code: number;
                message: string;
            };
        }>;
    },
    {
        method: 'importprivkey';
        params: [privkey: string, label?: string, rescan?: boolean];
        return: null;
    },
    {
        method: 'importprunedfunds';
        params: [rawtransaction: string, txoutproof: string];
        return: null;
    },
    {
        method: 'importpubkey';
        params: [pubkey: string, label?: string, rescan?: boolean];
        return: null;
    },
    {
        method: 'importwallet';
        params: [filename: string];
        return: null;
    },
    {
        method: 'keypoolrefill';
        params: [newsize?: number];
        return: null;
    },
    {
        method: 'listaddressgroupings';
        params: [];
        return: Array<Array<[address: string, amount: number, label?: string]>>;
    },
    {
        method: 'listlabels';
        params: [purpose?: string];
        return: string[];
    },
    {
        method: 'listlockunspent';
        params: [];
        return: Array<{
            txid: string;
            vout: number;
        }>;
    },
    {
        method: 'listreceivedbyaddress';
        params: [minconf?: number, include_empty?: boolean, include_watchonly?: boolean];
        return: Array<{
            address: string;
            amount: number;
            confirmations: number;
            label: string;
            txids: string[];
        }>;
    },
    {
        method: 'listreceivedbylabel';
        params: [minconf?: number, include_empty?: boolean, include_watchonly?: boolean];
        return: Array<{
            label: string;
            amount: number;
            confirmations: number;
        }>;
    },
    {
        method: 'listsinceblock';
        params: [blockhash?: string, target_confirmations?: number, include_watchonly?: boolean, include_removed?: boolean];
        return: {
            transactions: Array<{
                address: string;
                category: 'send' | 'receive' | 'generate' | 'immature' | 'orphan';
                amount: number;
                vout: number;
                fee?: number;
                confirmations: number;
                blockhash: string;
                blockindex: number;
                blocktime: number;
                txid: string;
                time: number;
                timereceived: number;
                label?: string;
            }>;
            removed?: Array<{
                address: string;
                category: 'send' | 'receive';
                amount: number;
                vout: number;
                fee?: number;
                confirmations: number;
                blockhash: string;
                blockindex: number;
                blocktime: number;
                txid: string;
                time: number;
                timereceived: number;
                label?: string;
            }>;
            lastblock: string;
        };
    },
    {
        method: 'listtransactions';
        params: [label?: string, count?: number, skip?: number, include_watchonly?: boolean];
        return: Array<{
            address: string;
            category: 'send' | 'receive' | 'generate' | 'immature' | 'orphan';
            amount: number;
            label?: string;
            vout: number;
            fee?: number;
            confirmations: number;
            blockhash?: string;
            blockindex?: number;
            blocktime?: number;
            txid: string;
            time: number;
            timereceived: number;
        }>;
    },
    {
        method: 'listunspent';
        params: [
            minconf?: number,
            maxconf?: number,
            addresses?: string[],
            include_unsafe?: boolean,
            query_options?: {
                minimumAmount?: number;
                maximumAmount?: number;
                maximumCount?: number;
                minimumSumAmount?: number;
            }
        ];
        return: Array<{
            txid: string;
            vout: number;
            address: string;
            label: string;
            scriptPubKey: string;
            amount: number;
            confirmations: number;
            spendable: boolean;
            solvable: boolean;
            safe: boolean;
            tokenData?: BCHNTokenData;
        }>;
    },
    {
        method: 'listwalletdir';
        params: [];
        return: {
            wallets: Array<{
                name: string;
            }>;
        };
    },
    {
        method: 'listwallets';
        params: [];
        return: string[];
    },
    {
        method: 'loadwallet';
        params: [filename: string];
        return: {
            name: string;
            warning: string;
        };
    },
    {
        method: 'lockunspent';
        params: [unlock: boolean, transactions?: Array<{
            txid: string;
            vout: number;
        }>];
        return: boolean;
    },
    {
        method: 'removeprunedfunds';
        params: [txid: string];
        return: null;
    },
    {
        method: 'rescanblockchain';
        params: [start_height?: number, stop_height?: number];
        return: {
            start_height: number;
            stop_height: number;
        };
    },
    {
        method: 'sendmany';
        params: [
            dummy: string,
            amounts: Record<string, number>,
            minconf?: number,
            comment?: string,
            subtractfeefrom?: string[]
        ];
        return: string;
    },
    {
        method: 'sendtoaddress';
        params: [
            address: string,
            amount: number,
            comment?: string,
            comment_to?: string,
            subtractfeefromamount?: boolean
        ];
        return: string;
    },
    {
        method: 'sethdseed';
        params: [newkeypool?: boolean, seed?: string];
        return: null;
    },
    {
        method: 'setlabel';
        params: [address: string, label: string];
        return: null;
    },
    {
        method: 'settxfee';
        params: [amount: number];
        return: boolean;
    },
    {
        method: 'signmessage';
        params: [address: string, message: string];
        return: string;
    },
    {
        method: 'signrawtransactionwithwallet';
        params: [
            hexstring: string,
            prevtxs?: Array<{
                txid: string;
                vout: number;
                scriptPubKey: string;
                redeemScript?: string;
                amount: number;
            }>,
            sighashtype?: string
        ];
        return: {
            hex: string;
            complete: boolean;
            errors?: Array<{
                txid: string;
                vout: number;
                scriptSig: string;
                sequence: number;
                error: string;
            }>;
        };
    },
    {
        method: 'unloadwallet';
        params: [wallet_name?: string];
        return: {
            warning: string;
        };
    },
    {
        method: 'walletcreatefundedpsbt';
        params: [
            inputs: Array<{
                txid: string;
                vout: number;
                sequence?: number;
            }>,
            outputs: Array<Record<string, number | string>>,
            locktime?: number,
            options?: {
                changeAddress?: string;
                changePosition?: number;
                includeWatching?: boolean;
                lockUnspents?: boolean;
                feeRate?: number;
                subtractFeeFromOutputs?: number[];
            }
        ];
        return: {
            psbt: string;
            fee: number;
            changepos: number;
        };
    },
    {
        method: 'walletlock';
        params: [];
        return: null;
    },
    {
        method: 'walletpassphrase';
        params: [passphrase: string, timeout: number];
        return: null;
    },
    {
        method: 'walletpassphrasechange';
        params: [oldpassphrase: string, newpassphrase: string];
        return: null;
    },
    {
        method: 'walletprocesspsbt';
        params: [psbt: string, sign?: boolean, sighashtype?: string];
        return: {
            psbt: string;
            complete: boolean;
        };
    }
];
/** Full BCHN schema — all methods (public + internal + wallet) */
export type BCHNSchema = {
    requests: [...BCHNPublicRequests, ...BCHNInternalRequests, ...BCHNWalletRequests];
    subscriptions: [];
};
/** Public-only subset — safe for external-facing RPC proxies */
export type BCHNPublicSchema = {
    requests: BCHNPublicRequests;
    subscriptions: [];
};
//# sourceMappingURL=schema.d.ts.map