// Code generated by MockGen. DO NOT EDIT.
// Source: internal/test/interfaces.go
//
// Generated by this command:
//
//	mockgen -source=internal/test/interfaces.go -package=test -destination=internal/test/mock_interfaces.go
//

// Package test is a generated GoMock package.
package test

import (
	context "context"
	reflect "reflect"
	time "time"

	btcec "github.com/btcsuite/btcd/btcec/v2"
	btcutil "github.com/btcsuite/btcd/btcutil"
	psbt "github.com/btcsuite/btcd/btcutil/psbt"
	chainhash "github.com/btcsuite/btcd/chaincfg/chainhash"
	wire "github.com/btcsuite/btcd/wire"
	waddrmgr "github.com/btcsuite/btcwallet/waddrmgr"
	wtxmgr "github.com/btcsuite/btcwallet/wtxmgr"
	lndclient "github.com/lightninglabs/lndclient"
	chainntnfs "github.com/lightningnetwork/lnd/chainntnfs"
	input "github.com/lightningnetwork/lnd/input"
	keychain "github.com/lightningnetwork/lnd/keychain"
	chainrpc "github.com/lightningnetwork/lnd/lnrpc/chainrpc"
	signrpc "github.com/lightningnetwork/lnd/lnrpc/signrpc"
	walletrpc "github.com/lightningnetwork/lnd/lnrpc/walletrpc"
	lnwallet "github.com/lightningnetwork/lnd/lnwallet"
	chainfee "github.com/lightningnetwork/lnd/lnwallet/chainfee"
	gomock "go.uber.org/mock/gomock"
)

// MockSignerClient is a mock of SignerClient interface.
type MockSignerClient struct {
	ctrl     *gomock.Controller
	recorder *MockSignerClientMockRecorder
}

// MockSignerClientMockRecorder is the mock recorder for MockSignerClient.
type MockSignerClientMockRecorder struct {
	mock *MockSignerClient
}

// NewMockSignerClient creates a new mock instance.
func NewMockSignerClient(ctrl *gomock.Controller) *MockSignerClient {
	mock := &MockSignerClient{ctrl: ctrl}
	mock.recorder = &MockSignerClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSignerClient) EXPECT() *MockSignerClientMockRecorder {
	return m.recorder
}

// ComputeInputScript mocks base method.
func (m *MockSignerClient) ComputeInputScript(ctx context.Context, tx *wire.MsgTx, signDescriptors []*lndclient.SignDescriptor, prevOutputs []*wire.TxOut) ([]*input.Script, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ComputeInputScript", ctx, tx, signDescriptors, prevOutputs)
	ret0, _ := ret[0].([]*input.Script)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ComputeInputScript indicates an expected call of ComputeInputScript.
func (mr *MockSignerClientMockRecorder) ComputeInputScript(ctx, tx, signDescriptors, prevOutputs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ComputeInputScript", reflect.TypeOf((*MockSignerClient)(nil).ComputeInputScript), ctx, tx, signDescriptors, prevOutputs)
}

// DeriveSharedKey mocks base method.
func (m *MockSignerClient) DeriveSharedKey(ctx context.Context, ephemeralPubKey *btcec.PublicKey, keyLocator *keychain.KeyLocator) ([32]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeriveSharedKey", ctx, ephemeralPubKey, keyLocator)
	ret0, _ := ret[0].([32]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeriveSharedKey indicates an expected call of DeriveSharedKey.
func (mr *MockSignerClientMockRecorder) DeriveSharedKey(ctx, ephemeralPubKey, keyLocator any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeriveSharedKey", reflect.TypeOf((*MockSignerClient)(nil).DeriveSharedKey), ctx, ephemeralPubKey, keyLocator)
}

// MuSig2Cleanup mocks base method.
func (m *MockSignerClient) MuSig2Cleanup(ctx context.Context, sessionID [32]byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MuSig2Cleanup", ctx, sessionID)
	ret0, _ := ret[0].(error)
	return ret0
}

// MuSig2Cleanup indicates an expected call of MuSig2Cleanup.
func (mr *MockSignerClientMockRecorder) MuSig2Cleanup(ctx, sessionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MuSig2Cleanup", reflect.TypeOf((*MockSignerClient)(nil).MuSig2Cleanup), ctx, sessionID)
}

// MuSig2CombineSig mocks base method.
func (m *MockSignerClient) MuSig2CombineSig(ctx context.Context, sessionID [32]byte, otherPartialSigs [][]byte) (bool, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MuSig2CombineSig", ctx, sessionID, otherPartialSigs)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// MuSig2CombineSig indicates an expected call of MuSig2CombineSig.
func (mr *MockSignerClientMockRecorder) MuSig2CombineSig(ctx, sessionID, otherPartialSigs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MuSig2CombineSig", reflect.TypeOf((*MockSignerClient)(nil).MuSig2CombineSig), ctx, sessionID, otherPartialSigs)
}

// MuSig2CreateSession mocks base method.
func (m *MockSignerClient) MuSig2CreateSession(ctx context.Context, version input.MuSig2Version, signerLoc *keychain.KeyLocator, signers [][]byte, opts ...lndclient.MuSig2SessionOpts) (*input.MuSig2SessionInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, version, signerLoc, signers}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MuSig2CreateSession", varargs...)
	ret0, _ := ret[0].(*input.MuSig2SessionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MuSig2CreateSession indicates an expected call of MuSig2CreateSession.
func (mr *MockSignerClientMockRecorder) MuSig2CreateSession(ctx, version, signerLoc, signers any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, version, signerLoc, signers}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MuSig2CreateSession", reflect.TypeOf((*MockSignerClient)(nil).MuSig2CreateSession), varargs...)
}

// MuSig2RegisterNonces mocks base method.
func (m *MockSignerClient) MuSig2RegisterNonces(ctx context.Context, sessionID [32]byte, nonces [][66]byte) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MuSig2RegisterNonces", ctx, sessionID, nonces)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MuSig2RegisterNonces indicates an expected call of MuSig2RegisterNonces.
func (mr *MockSignerClientMockRecorder) MuSig2RegisterNonces(ctx, sessionID, nonces any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MuSig2RegisterNonces", reflect.TypeOf((*MockSignerClient)(nil).MuSig2RegisterNonces), ctx, sessionID, nonces)
}

// MuSig2Sign mocks base method.
func (m *MockSignerClient) MuSig2Sign(ctx context.Context, sessionID, message [32]byte, cleanup bool) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MuSig2Sign", ctx, sessionID, message, cleanup)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MuSig2Sign indicates an expected call of MuSig2Sign.
func (mr *MockSignerClientMockRecorder) MuSig2Sign(ctx, sessionID, message, cleanup any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MuSig2Sign", reflect.TypeOf((*MockSignerClient)(nil).MuSig2Sign), ctx, sessionID, message, cleanup)
}

// RawClientWithMacAuth mocks base method.
func (m *MockSignerClient) RawClientWithMacAuth(parentCtx context.Context) (context.Context, time.Duration, signrpc.SignerClient) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RawClientWithMacAuth", parentCtx)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(time.Duration)
	ret2, _ := ret[2].(signrpc.SignerClient)
	return ret0, ret1, ret2
}

// RawClientWithMacAuth indicates an expected call of RawClientWithMacAuth.
func (mr *MockSignerClientMockRecorder) RawClientWithMacAuth(parentCtx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RawClientWithMacAuth", reflect.TypeOf((*MockSignerClient)(nil).RawClientWithMacAuth), parentCtx)
}

// SignMessage mocks base method.
func (m *MockSignerClient) SignMessage(ctx context.Context, msg []byte, locator keychain.KeyLocator, opts ...lndclient.SignMessageOption) ([]byte, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, msg, locator}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SignMessage", varargs...)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignMessage indicates an expected call of SignMessage.
func (mr *MockSignerClientMockRecorder) SignMessage(ctx, msg, locator any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, msg, locator}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMessage", reflect.TypeOf((*MockSignerClient)(nil).SignMessage), varargs...)
}

// SignOutputRaw mocks base method.
func (m *MockSignerClient) SignOutputRaw(ctx context.Context, tx *wire.MsgTx, signDescriptors []*lndclient.SignDescriptor, prevOutputs []*wire.TxOut) ([][]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignOutputRaw", ctx, tx, signDescriptors, prevOutputs)
	ret0, _ := ret[0].([][]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignOutputRaw indicates an expected call of SignOutputRaw.
func (mr *MockSignerClientMockRecorder) SignOutputRaw(ctx, tx, signDescriptors, prevOutputs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignOutputRaw", reflect.TypeOf((*MockSignerClient)(nil).SignOutputRaw), ctx, tx, signDescriptors, prevOutputs)
}

// SignOutputRawKeyLocator mocks base method.
func (m *MockSignerClient) SignOutputRawKeyLocator(ctx context.Context, tx *wire.MsgTx, signDescriptors []*lndclient.SignDescriptor, prevOutputs []*wire.TxOut) ([][]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignOutputRawKeyLocator", ctx, tx, signDescriptors, prevOutputs)
	ret0, _ := ret[0].([][]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignOutputRawKeyLocator indicates an expected call of SignOutputRawKeyLocator.
func (mr *MockSignerClientMockRecorder) SignOutputRawKeyLocator(ctx, tx, signDescriptors, prevOutputs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignOutputRawKeyLocator", reflect.TypeOf((*MockSignerClient)(nil).SignOutputRawKeyLocator), ctx, tx, signDescriptors, prevOutputs)
}

// VerifyMessage mocks base method.
func (m *MockSignerClient) VerifyMessage(ctx context.Context, msg, sig []byte, pubkey [33]byte, opts ...lndclient.VerifyMessageOption) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, msg, sig, pubkey}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyMessage", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyMessage indicates an expected call of VerifyMessage.
func (mr *MockSignerClientMockRecorder) VerifyMessage(ctx, msg, sig, pubkey any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, msg, sig, pubkey}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyMessage", reflect.TypeOf((*MockSignerClient)(nil).VerifyMessage), varargs...)
}

// MockWalletKitClient is a mock of WalletKitClient interface.
type MockWalletKitClient struct {
	ctrl     *gomock.Controller
	recorder *MockWalletKitClientMockRecorder
}

// MockWalletKitClientMockRecorder is the mock recorder for MockWalletKitClient.
type MockWalletKitClientMockRecorder struct {
	mock *MockWalletKitClient
}

// NewMockWalletKitClient creates a new mock instance.
func NewMockWalletKitClient(ctrl *gomock.Controller) *MockWalletKitClient {
	mock := &MockWalletKitClient{ctrl: ctrl}
	mock.recorder = &MockWalletKitClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWalletKitClient) EXPECT() *MockWalletKitClientMockRecorder {
	return m.recorder
}

// BumpFee mocks base method.
func (m *MockWalletKitClient) BumpFee(arg0 context.Context, arg1 wire.OutPoint, arg2 chainfee.SatPerKWeight, arg3 ...lndclient.BumpFeeOption) error {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BumpFee", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// BumpFee indicates an expected call of BumpFee.
func (mr *MockWalletKitClientMockRecorder) BumpFee(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BumpFee", reflect.TypeOf((*MockWalletKitClient)(nil).BumpFee), varargs...)
}

// DeriveKey mocks base method.
func (m *MockWalletKitClient) DeriveKey(ctx context.Context, locator *keychain.KeyLocator) (*keychain.KeyDescriptor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeriveKey", ctx, locator)
	ret0, _ := ret[0].(*keychain.KeyDescriptor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeriveKey indicates an expected call of DeriveKey.
func (mr *MockWalletKitClientMockRecorder) DeriveKey(ctx, locator any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeriveKey", reflect.TypeOf((*MockWalletKitClient)(nil).DeriveKey), ctx, locator)
}

// DeriveNextKey mocks base method.
func (m *MockWalletKitClient) DeriveNextKey(ctx context.Context, family int32) (*keychain.KeyDescriptor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeriveNextKey", ctx, family)
	ret0, _ := ret[0].(*keychain.KeyDescriptor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeriveNextKey indicates an expected call of DeriveNextKey.
func (mr *MockWalletKitClientMockRecorder) DeriveNextKey(ctx, family any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeriveNextKey", reflect.TypeOf((*MockWalletKitClient)(nil).DeriveNextKey), ctx, family)
}

// EstimateFeeRate mocks base method.
func (m *MockWalletKitClient) EstimateFeeRate(ctx context.Context, confTarget int32) (chainfee.SatPerKWeight, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EstimateFeeRate", ctx, confTarget)
	ret0, _ := ret[0].(chainfee.SatPerKWeight)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EstimateFeeRate indicates an expected call of EstimateFeeRate.
func (mr *MockWalletKitClientMockRecorder) EstimateFeeRate(ctx, confTarget any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateFeeRate", reflect.TypeOf((*MockWalletKitClient)(nil).EstimateFeeRate), ctx, confTarget)
}

// FinalizePsbt mocks base method.
func (m *MockWalletKitClient) FinalizePsbt(ctx context.Context, packet *psbt.Packet, account string) (*psbt.Packet, *wire.MsgTx, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizePsbt", ctx, packet, account)
	ret0, _ := ret[0].(*psbt.Packet)
	ret1, _ := ret[1].(*wire.MsgTx)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FinalizePsbt indicates an expected call of FinalizePsbt.
func (mr *MockWalletKitClientMockRecorder) FinalizePsbt(ctx, packet, account any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizePsbt", reflect.TypeOf((*MockWalletKitClient)(nil).FinalizePsbt), ctx, packet, account)
}

// FundPsbt mocks base method.
func (m *MockWalletKitClient) FundPsbt(ctx context.Context, req *walletrpc.FundPsbtRequest) (*psbt.Packet, int32, []*walletrpc.UtxoLease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FundPsbt", ctx, req)
	ret0, _ := ret[0].(*psbt.Packet)
	ret1, _ := ret[1].(int32)
	ret2, _ := ret[2].([]*walletrpc.UtxoLease)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// FundPsbt indicates an expected call of FundPsbt.
func (mr *MockWalletKitClientMockRecorder) FundPsbt(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FundPsbt", reflect.TypeOf((*MockWalletKitClient)(nil).FundPsbt), ctx, req)
}

// ImportPublicKey mocks base method.
func (m *MockWalletKitClient) ImportPublicKey(ctx context.Context, pubkey *btcec.PublicKey, addrType lnwallet.AddressType) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportPublicKey", ctx, pubkey, addrType)
	ret0, _ := ret[0].(error)
	return ret0
}

// ImportPublicKey indicates an expected call of ImportPublicKey.
func (mr *MockWalletKitClientMockRecorder) ImportPublicKey(ctx, pubkey, addrType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportPublicKey", reflect.TypeOf((*MockWalletKitClient)(nil).ImportPublicKey), ctx, pubkey, addrType)
}

// ImportTaprootScript mocks base method.
func (m *MockWalletKitClient) ImportTaprootScript(ctx context.Context, tapscript *waddrmgr.Tapscript) (btcutil.Address, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportTaprootScript", ctx, tapscript)
	ret0, _ := ret[0].(btcutil.Address)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportTaprootScript indicates an expected call of ImportTaprootScript.
func (mr *MockWalletKitClientMockRecorder) ImportTaprootScript(ctx, tapscript any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportTaprootScript", reflect.TypeOf((*MockWalletKitClient)(nil).ImportTaprootScript), ctx, tapscript)
}

// LeaseOutput mocks base method.
func (m *MockWalletKitClient) LeaseOutput(ctx context.Context, lockID wtxmgr.LockID, op wire.OutPoint, leaseTime time.Duration) (time.Time, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LeaseOutput", ctx, lockID, op, leaseTime)
	ret0, _ := ret[0].(time.Time)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LeaseOutput indicates an expected call of LeaseOutput.
func (mr *MockWalletKitClientMockRecorder) LeaseOutput(ctx, lockID, op, leaseTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LeaseOutput", reflect.TypeOf((*MockWalletKitClient)(nil).LeaseOutput), ctx, lockID, op, leaseTime)
}

// ListAccounts mocks base method.
func (m *MockWalletKitClient) ListAccounts(ctx context.Context, name string, addressType walletrpc.AddressType) ([]*walletrpc.Account, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAccounts", ctx, name, addressType)
	ret0, _ := ret[0].([]*walletrpc.Account)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAccounts indicates an expected call of ListAccounts.
func (mr *MockWalletKitClientMockRecorder) ListAccounts(ctx, name, addressType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccounts", reflect.TypeOf((*MockWalletKitClient)(nil).ListAccounts), ctx, name, addressType)
}

// ListLeases mocks base method.
func (m *MockWalletKitClient) ListLeases(ctx context.Context) ([]lndclient.LeaseDescriptor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLeases", ctx)
	ret0, _ := ret[0].([]lndclient.LeaseDescriptor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLeases indicates an expected call of ListLeases.
func (mr *MockWalletKitClientMockRecorder) ListLeases(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLeases", reflect.TypeOf((*MockWalletKitClient)(nil).ListLeases), ctx)
}

// ListSweeps mocks base method.
func (m *MockWalletKitClient) ListSweeps(ctx context.Context, startHeight int32) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSweeps", ctx, startHeight)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSweeps indicates an expected call of ListSweeps.
func (mr *MockWalletKitClientMockRecorder) ListSweeps(ctx, startHeight any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSweeps", reflect.TypeOf((*MockWalletKitClient)(nil).ListSweeps), ctx, startHeight)
}

// ListSweepsVerbose mocks base method.
func (m *MockWalletKitClient) ListSweepsVerbose(ctx context.Context, startHeight int32) ([]lnwallet.TransactionDetail, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSweepsVerbose", ctx, startHeight)
	ret0, _ := ret[0].([]lnwallet.TransactionDetail)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSweepsVerbose indicates an expected call of ListSweepsVerbose.
func (mr *MockWalletKitClientMockRecorder) ListSweepsVerbose(ctx, startHeight any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSweepsVerbose", reflect.TypeOf((*MockWalletKitClient)(nil).ListSweepsVerbose), ctx, startHeight)
}

// ListUnspent mocks base method.
func (m *MockWalletKitClient) ListUnspent(ctx context.Context, minConfs, maxConfs int32, opts ...lndclient.ListUnspentOption) ([]*lnwallet.Utxo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, minConfs, maxConfs}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUnspent", varargs...)
	ret0, _ := ret[0].([]*lnwallet.Utxo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListUnspent indicates an expected call of ListUnspent.
func (mr *MockWalletKitClientMockRecorder) ListUnspent(ctx, minConfs, maxConfs any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, minConfs, maxConfs}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUnspent", reflect.TypeOf((*MockWalletKitClient)(nil).ListUnspent), varargs...)
}

// MinRelayFee mocks base method.
func (m *MockWalletKitClient) MinRelayFee(ctx context.Context) (chainfee.SatPerKWeight, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MinRelayFee", ctx)
	ret0, _ := ret[0].(chainfee.SatPerKWeight)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MinRelayFee indicates an expected call of MinRelayFee.
func (mr *MockWalletKitClientMockRecorder) MinRelayFee(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MinRelayFee", reflect.TypeOf((*MockWalletKitClient)(nil).MinRelayFee), ctx)
}

// NextAddr mocks base method.
func (m *MockWalletKitClient) NextAddr(ctx context.Context, accountName string, addressType walletrpc.AddressType, change bool) (btcutil.Address, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NextAddr", ctx, accountName, addressType, change)
	ret0, _ := ret[0].(btcutil.Address)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NextAddr indicates an expected call of NextAddr.
func (mr *MockWalletKitClientMockRecorder) NextAddr(ctx, accountName, addressType, change any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NextAddr", reflect.TypeOf((*MockWalletKitClient)(nil).NextAddr), ctx, accountName, addressType, change)
}

// PublishTransaction mocks base method.
func (m *MockWalletKitClient) PublishTransaction(ctx context.Context, tx *wire.MsgTx, label string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishTransaction", ctx, tx, label)
	ret0, _ := ret[0].(error)
	return ret0
}

// PublishTransaction indicates an expected call of PublishTransaction.
func (mr *MockWalletKitClientMockRecorder) PublishTransaction(ctx, tx, label any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishTransaction", reflect.TypeOf((*MockWalletKitClient)(nil).PublishTransaction), ctx, tx, label)
}

// RawClientWithMacAuth mocks base method.
func (m *MockWalletKitClient) RawClientWithMacAuth(parentCtx context.Context) (context.Context, time.Duration, walletrpc.WalletKitClient) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RawClientWithMacAuth", parentCtx)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(time.Duration)
	ret2, _ := ret[2].(walletrpc.WalletKitClient)
	return ret0, ret1, ret2
}

// RawClientWithMacAuth indicates an expected call of RawClientWithMacAuth.
func (mr *MockWalletKitClientMockRecorder) RawClientWithMacAuth(parentCtx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RawClientWithMacAuth", reflect.TypeOf((*MockWalletKitClient)(nil).RawClientWithMacAuth), parentCtx)
}

// ReleaseOutput mocks base method.
func (m *MockWalletKitClient) ReleaseOutput(ctx context.Context, lockID wtxmgr.LockID, op wire.OutPoint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseOutput", ctx, lockID, op)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReleaseOutput indicates an expected call of ReleaseOutput.
func (mr *MockWalletKitClientMockRecorder) ReleaseOutput(ctx, lockID, op any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseOutput", reflect.TypeOf((*MockWalletKitClient)(nil).ReleaseOutput), ctx, lockID, op)
}

// SendOutputs mocks base method.
func (m *MockWalletKitClient) SendOutputs(ctx context.Context, outputs []*wire.TxOut, feeRate chainfee.SatPerKWeight, label string) (*wire.MsgTx, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendOutputs", ctx, outputs, feeRate, label)
	ret0, _ := ret[0].(*wire.MsgTx)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendOutputs indicates an expected call of SendOutputs.
func (mr *MockWalletKitClientMockRecorder) SendOutputs(ctx, outputs, feeRate, label any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendOutputs", reflect.TypeOf((*MockWalletKitClient)(nil).SendOutputs), ctx, outputs, feeRate, label)
}

// SignPsbt mocks base method.
func (m *MockWalletKitClient) SignPsbt(ctx context.Context, packet *psbt.Packet) (*psbt.Packet, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignPsbt", ctx, packet)
	ret0, _ := ret[0].(*psbt.Packet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignPsbt indicates an expected call of SignPsbt.
func (mr *MockWalletKitClientMockRecorder) SignPsbt(ctx, packet any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignPsbt", reflect.TypeOf((*MockWalletKitClient)(nil).SignPsbt), ctx, packet)
}

// MockChainNotifierClient is a mock of ChainNotifierClient interface.
type MockChainNotifierClient struct {
	ctrl     *gomock.Controller
	recorder *MockChainNotifierClientMockRecorder
}

// MockChainNotifierClientMockRecorder is the mock recorder for MockChainNotifierClient.
type MockChainNotifierClientMockRecorder struct {
	mock *MockChainNotifierClient
}

// NewMockChainNotifierClient creates a new mock instance.
func NewMockChainNotifierClient(ctrl *gomock.Controller) *MockChainNotifierClient {
	mock := &MockChainNotifierClient{ctrl: ctrl}
	mock.recorder = &MockChainNotifierClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockChainNotifierClient) EXPECT() *MockChainNotifierClientMockRecorder {
	return m.recorder
}

// RawClientWithMacAuth mocks base method.
func (m *MockChainNotifierClient) RawClientWithMacAuth(parentCtx context.Context) (context.Context, time.Duration, chainrpc.ChainNotifierClient) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RawClientWithMacAuth", parentCtx)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(time.Duration)
	ret2, _ := ret[2].(chainrpc.ChainNotifierClient)
	return ret0, ret1, ret2
}

// RawClientWithMacAuth indicates an expected call of RawClientWithMacAuth.
func (mr *MockChainNotifierClientMockRecorder) RawClientWithMacAuth(parentCtx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RawClientWithMacAuth", reflect.TypeOf((*MockChainNotifierClient)(nil).RawClientWithMacAuth), parentCtx)
}

// RegisterBlockEpochNtfn mocks base method.
func (m *MockChainNotifierClient) RegisterBlockEpochNtfn(ctx context.Context) (chan int32, chan error, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterBlockEpochNtfn", ctx)
	ret0, _ := ret[0].(chan int32)
	ret1, _ := ret[1].(chan error)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RegisterBlockEpochNtfn indicates an expected call of RegisterBlockEpochNtfn.
func (mr *MockChainNotifierClientMockRecorder) RegisterBlockEpochNtfn(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterBlockEpochNtfn", reflect.TypeOf((*MockChainNotifierClient)(nil).RegisterBlockEpochNtfn), ctx)
}

// RegisterConfirmationsNtfn mocks base method.
func (m *MockChainNotifierClient) RegisterConfirmationsNtfn(ctx context.Context, txid *chainhash.Hash, pkScript []byte, numConfs, heightHint int32, opts ...lndclient.NotifierOption) (chan *chainntnfs.TxConfirmation, chan error, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, txid, pkScript, numConfs, heightHint}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterConfirmationsNtfn", varargs...)
	ret0, _ := ret[0].(chan *chainntnfs.TxConfirmation)
	ret1, _ := ret[1].(chan error)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RegisterConfirmationsNtfn indicates an expected call of RegisterConfirmationsNtfn.
func (mr *MockChainNotifierClientMockRecorder) RegisterConfirmationsNtfn(ctx, txid, pkScript, numConfs, heightHint any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, txid, pkScript, numConfs, heightHint}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterConfirmationsNtfn", reflect.TypeOf((*MockChainNotifierClient)(nil).RegisterConfirmationsNtfn), varargs...)
}

// RegisterSpendNtfn mocks base method.
func (m *MockChainNotifierClient) RegisterSpendNtfn(ctx context.Context, outpoint *wire.OutPoint, pkScript []byte, heightHint int32) (chan *chainntnfs.SpendDetail, chan error, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterSpendNtfn", ctx, outpoint, pkScript, heightHint)
	ret0, _ := ret[0].(chan *chainntnfs.SpendDetail)
	ret1, _ := ret[1].(chan error)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RegisterSpendNtfn indicates an expected call of RegisterSpendNtfn.
func (mr *MockChainNotifierClientMockRecorder) RegisterSpendNtfn(ctx, outpoint, pkScript, heightHint any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterSpendNtfn", reflect.TypeOf((*MockChainNotifierClient)(nil).RegisterSpendNtfn), ctx, outpoint, pkScript, heightHint)
}