// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"

	"github.com/getAlby/hub/lnclient"
	mock "github.com/stretchr/testify/mock"
)

// NewMockLNClient creates a new instance of MockLNClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockLNClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockLNClient {
	mock := &MockLNClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockLNClient is an autogenerated mock type for the LNClient type
type MockLNClient struct {
	mock.Mock
}

type MockLNClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockLNClient) EXPECT() *MockLNClient_Expecter {
	return &MockLNClient_Expecter{mock: &_m.Mock}
}

// CancelHoldInvoice provides a mock function for the type MockLNClient
func (_mock *MockLNClient) CancelHoldInvoice(ctx context.Context, paymentHash string) error {
	ret := _mock.Called(ctx, paymentHash)

	if len(ret) == 0 {
		panic("no return value specified for CancelHoldInvoice")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, paymentHash)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockLNClient_CancelHoldInvoice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelHoldInvoice'
type MockLNClient_CancelHoldInvoice_Call struct {
	*mock.Call
}

// CancelHoldInvoice is a helper method to define mock.On call
//   - ctx context.Context
//   - paymentHash string
func (_e *MockLNClient_Expecter) CancelHoldInvoice(ctx interface{}, paymentHash interface{}) *MockLNClient_CancelHoldInvoice_Call {
	return &MockLNClient_CancelHoldInvoice_Call{Call: _e.mock.On("CancelHoldInvoice", ctx, paymentHash)}
}

func (_c *MockLNClient_CancelHoldInvoice_Call) Run(run func(ctx context.Context, paymentHash string)) *MockLNClient_CancelHoldInvoice_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_CancelHoldInvoice_Call) Return(err error) *MockLNClient_CancelHoldInvoice_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockLNClient_CancelHoldInvoice_Call) RunAndReturn(run func(ctx context.Context, paymentHash string) error) *MockLNClient_CancelHoldInvoice_Call {
	_c.Call.Return(run)
	return _c
}

// CloseChannel provides a mock function for the type MockLNClient
func (_mock *MockLNClient) CloseChannel(ctx context.Context, closeChannelRequest *lnclient.CloseChannelRequest) error {
	ret := _mock.Called(ctx, closeChannelRequest)

	if len(ret) == 0 {
		panic("no return value specified for CloseChannel")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *lnclient.CloseChannelRequest) error); ok {
		r0 = returnFunc(ctx, closeChannelRequest)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockLNClient_CloseChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseChannel'
type MockLNClient_CloseChannel_Call struct {
	*mock.Call
}

// CloseChannel is a helper method to define mock.On call
//   - ctx context.Context
//   - closeChannelRequest *lnclient.CloseChannelRequest
func (_e *MockLNClient_Expecter) CloseChannel(ctx interface{}, closeChannelRequest interface{}) *MockLNClient_CloseChannel_Call {
	return &MockLNClient_CloseChannel_Call{Call: _e.mock.On("CloseChannel", ctx, closeChannelRequest)}
}

func (_c *MockLNClient_CloseChannel_Call) Run(run func(ctx context.Context, closeChannelRequest *lnclient.CloseChannelRequest)) *MockLNClient_CloseChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *lnclient.CloseChannelRequest
		if args[1] != nil {
			arg1 = args[1].(*lnclient.CloseChannelRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_CloseChannel_Call) Return(err error) *MockLNClient_CloseChannel_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockLNClient_CloseChannel_Call) RunAndReturn(run func(ctx context.Context, closeChannelRequest *lnclient.CloseChannelRequest) error) *MockLNClient_CloseChannel_Call {
	_c.Call.Return(run)
	return _c
}

// ConnectPeer provides a mock function for the type MockLNClient
func (_mock *MockLNClient) ConnectPeer(ctx context.Context, connectPeerRequest *lnclient.ConnectPeerRequest) error {
	ret := _mock.Called(ctx, connectPeerRequest)

	if len(ret) == 0 {
		panic("no return value specified for ConnectPeer")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *lnclient.ConnectPeerRequest) error); ok {
		r0 = returnFunc(ctx, connectPeerRequest)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockLNClient_ConnectPeer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectPeer'
type MockLNClient_ConnectPeer_Call struct {
	*mock.Call
}

// ConnectPeer is a helper method to define mock.On call
//   - ctx context.Context
//   - connectPeerRequest *lnclient.ConnectPeerRequest
func (_e *MockLNClient_Expecter) ConnectPeer(ctx interface{}, connectPeerRequest interface{}) *MockLNClient_ConnectPeer_Call {
	return &MockLNClient_ConnectPeer_Call{Call: _e.mock.On("ConnectPeer", ctx, connectPeerRequest)}
}

func (_c *MockLNClient_ConnectPeer_Call) Run(run func(ctx context.Context, connectPeerRequest *lnclient.ConnectPeerRequest)) *MockLNClient_ConnectPeer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *lnclient.ConnectPeerRequest
		if args[1] != nil {
			arg1 = args[1].(*lnclient.ConnectPeerRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_ConnectPeer_Call) Return(err error) *MockLNClient_ConnectPeer_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockLNClient_ConnectPeer_Call) RunAndReturn(run func(ctx context.Context, connectPeerRequest *lnclient.ConnectPeerRequest) error) *MockLNClient_ConnectPeer_Call {
	_c.Call.Return(run)
	return _c
}

// DisconnectPeer provides a mock function for the type MockLNClient
func (_mock *MockLNClient) DisconnectPeer(ctx context.Context, peerId string) error {
	ret := _mock.Called(ctx, peerId)

	if len(ret) == 0 {
		panic("no return value specified for DisconnectPeer")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, peerId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockLNClient_DisconnectPeer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectPeer'
type MockLNClient_DisconnectPeer_Call struct {
	*mock.Call
}

// DisconnectPeer is a helper method to define mock.On call
//   - ctx context.Context
//   - peerId string
func (_e *MockLNClient_Expecter) DisconnectPeer(ctx interface{}, peerId interface{}) *MockLNClient_DisconnectPeer_Call {
	return &MockLNClient_DisconnectPeer_Call{Call: _e.mock.On("DisconnectPeer", ctx, peerId)}
}

func (_c *MockLNClient_DisconnectPeer_Call) Run(run func(ctx context.Context, peerId string)) *MockLNClient_DisconnectPeer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_DisconnectPeer_Call) Return(err error) *MockLNClient_DisconnectPeer_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockLNClient_DisconnectPeer_Call) RunAndReturn(run func(ctx context.Context, peerId string) error) *MockLNClient_DisconnectPeer_Call {
	_c.Call.Return(run)
	return _c
}

// ExecuteCustomNodeCommand provides a mock function for the type MockLNClient
func (_mock *MockLNClient) ExecuteCustomNodeCommand(ctx context.Context, command *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error) {
	ret := _mock.Called(ctx, command)

	if len(ret) == 0 {
		panic("no return value specified for ExecuteCustomNodeCommand")
	}

	var r0 *lnclient.CustomNodeCommandResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error)); ok {
		return returnFunc(ctx, command)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *lnclient.CustomNodeCommandRequest) *lnclient.CustomNodeCommandResponse); ok {
		r0 = returnFunc(ctx, command)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lnclient.CustomNodeCommandResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *lnclient.CustomNodeCommandRequest) error); ok {
		r1 = returnFunc(ctx, command)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_ExecuteCustomNodeCommand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExecuteCustomNodeCommand'
type MockLNClient_ExecuteCustomNodeCommand_Call struct {
	*mock.Call
}

// ExecuteCustomNodeCommand is a helper method to define mock.On call
//   - ctx context.Context
//   - command *lnclient.CustomNodeCommandRequest
func (_e *MockLNClient_Expecter) ExecuteCustomNodeCommand(ctx interface{}, command interface{}) *MockLNClient_ExecuteCustomNodeCommand_Call {
	return &MockLNClient_ExecuteCustomNodeCommand_Call{Call: _e.mock.On("ExecuteCustomNodeCommand", ctx, command)}
}

func (_c *MockLNClient_ExecuteCustomNodeCommand_Call) Run(run func(ctx context.Context, command *lnclient.CustomNodeCommandRequest)) *MockLNClient_ExecuteCustomNodeCommand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *lnclient.CustomNodeCommandRequest
		if args[1] != nil {
			arg1 = args[1].(*lnclient.CustomNodeCommandRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_ExecuteCustomNodeCommand_Call) Return(customNodeCommandResponse *lnclient.CustomNodeCommandResponse, err error) *MockLNClient_ExecuteCustomNodeCommand_Call {
	_c.Call.Return(customNodeCommandResponse, err)
	return _c
}

func (_c *MockLNClient_ExecuteCustomNodeCommand_Call) RunAndReturn(run func(ctx context.Context, command *lnclient.CustomNodeCommandRequest) (*lnclient.CustomNodeCommandResponse, error)) *MockLNClient_ExecuteCustomNodeCommand_Call {
	_c.Call.Return(run)
	return _c
}

// GetBalances provides a mock function for the type MockLNClient
func (_mock *MockLNClient) GetBalances(ctx context.Context, includeInactiveChannels bool) (*lnclient.BalancesResponse, error) {
	ret := _mock.Called(ctx, includeInactiveChannels)

	if len(ret) == 0 {
		panic("no return value specified for GetBalances")
	}

	var r0 *lnclient.BalancesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, bool) (*lnclient.BalancesResponse, error)); ok {
		return returnFunc(ctx, includeInactiveChannels)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, bool) *lnclient.BalancesResponse); ok {
		r0 = returnFunc(ctx, includeInactiveChannels)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lnclient.BalancesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, bool) error); ok {
		r1 = returnFunc(ctx, includeInactiveChannels)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_GetBalances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBalances'
type MockLNClient_GetBalances_Call struct {
	*mock.Call
}

// GetBalances is a helper method to define mock.On call
//   - ctx context.Context
//   - includeInactiveChannels bool
func (_e *MockLNClient_Expecter) GetBalances(ctx interface{}, includeInactiveChannels interface{}) *MockLNClient_GetBalances_Call {
	return &MockLNClient_GetBalances_Call{Call: _e.mock.On("GetBalances", ctx, includeInactiveChannels)}
}

func (_c *MockLNClient_GetBalances_Call) Run(run func(ctx context.Context, includeInactiveChannels bool)) *MockLNClient_GetBalances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_GetBalances_Call) Return(balancesResponse *lnclient.BalancesResponse, err error) *MockLNClient_GetBalances_Call {
	_c.Call.Return(balancesResponse, err)
	return _c
}

func (_c *MockLNClient_GetBalances_Call) RunAndReturn(run func(ctx context.Context, includeInactiveChannels bool) (*lnclient.BalancesResponse, error)) *MockLNClient_GetBalances_Call {
	_c.Call.Return(run)
	return _c
}

// GetCustomNodeCommandDefinitions provides a mock function for the type MockLNClient
func (_mock *MockLNClient) GetCustomNodeCommandDefinitions() []lnclient.CustomNodeCommandDef {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetCustomNodeCommandDefinitions")
	}

	var r0 []lnclient.CustomNodeCommandDef
	if returnFunc, ok := ret.Get(0).(func() []lnclient.CustomNodeCommandDef); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]lnclient.CustomNodeCommandDef)
		}
	}
	return r0
}

// MockLNClient_GetCustomNodeCommandDefinitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCustomNodeCommandDefinitions'
type MockLNClient_GetCustomNodeCommandDefinitions_Call struct {
	*mock.Call
}

// GetCustomNodeCommandDefinitions is a helper method to define mock.On call
func (_e *MockLNClient_Expecter) GetCustomNodeCommandDefinitions() *MockLNClient_GetCustomNodeCommandDefinitions_Call {
	return &MockLNClient_GetCustomNodeCommandDefinitions_Call{Call: _e.mock.On("GetCustomNodeCommandDefinitions")}
}

func (_c *MockLNClient_GetCustomNodeCommandDefinitions_Call) Run(run func()) *MockLNClient_GetCustomNodeCommandDefinitions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLNClient_GetCustomNodeCommandDefinitions_Call) Return(customNodeCommandDefs []lnclient.CustomNodeCommandDef) *MockLNClient_GetCustomNodeCommandDefinitions_Call {
	_c.Call.Return(customNodeCommandDefs)
	return _c
}

func (_c *MockLNClient_GetCustomNodeCommandDefinitions_Call) RunAndReturn(run func() []lnclient.CustomNodeCommandDef) *MockLNClient_GetCustomNodeCommandDefinitions_Call {
	_c.Call.Return(run)
	return _c
}

// GetInfo provides a mock function for the type MockLNClient
func (_mock *MockLNClient) GetInfo(ctx context.Context) (*lnclient.NodeInfo, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetInfo")
	}

	var r0 *lnclient.NodeInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (*lnclient.NodeInfo, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) *lnclient.NodeInfo); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lnclient.NodeInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_GetInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInfo'
type MockLNClient_GetInfo_Call struct {
	*mock.Call
}

// GetInfo is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockLNClient_Expecter) GetInfo(ctx interface{}) *MockLNClient_GetInfo_Call {
	return &MockLNClient_GetInfo_Call{Call: _e.mock.On("GetInfo", ctx)}
}

func (_c *MockLNClient_GetInfo_Call) Run(run func(ctx context.Context)) *MockLNClient_GetInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLNClient_GetInfo_Call) Return(info *lnclient.NodeInfo, err error) *MockLNClient_GetInfo_Call {
	_c.Call.Return(info, err)
	return _c
}

func (_c *MockLNClient_GetInfo_Call) RunAndReturn(run func(ctx context.Context) (*lnclient.NodeInfo, error)) *MockLNClient_GetInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetLogOutput provides a mock function for the type MockLNClient
func (_mock *MockLNClient) GetLogOutput(ctx context.Context, maxLen int) ([]byte, error) {
	ret := _mock.Called(ctx, maxLen)

	if len(ret) == 0 {
		panic("no return value specified for GetLogOutput")
	}

	var r0 []byte
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]byte, error)); ok {
		return returnFunc(ctx, maxLen)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []byte); ok {
		r0 = returnFunc(ctx, maxLen)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
		r1 = returnFunc(ctx, maxLen)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_GetLogOutput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLogOutput'
type MockLNClient_GetLogOutput_Call struct {
	*mock.Call
}

// GetLogOutput is a helper method to define mock.On call
//   - ctx context.Context
//   - maxLen int
func (_e *MockLNClient_Expecter) GetLogOutput(ctx interface{}, maxLen interface{}) *MockLNClient_GetLogOutput_Call {
	return &MockLNClient_GetLogOutput_Call{Call: _e.mock.On("GetLogOutput", ctx, maxLen)}
}

func (_c *MockLNClient_GetLogOutput_Call) Run(run func(ctx context.Context, maxLen int)) *MockLNClient_GetLogOutput_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_GetLogOutput_Call) Return(bytes []byte, err error) *MockLNClient_GetLogOutput_Call {
	_c.Call.Return(bytes, err)
	return _c
}

func (_c *MockLNClient_GetLogOutput_Call) RunAndReturn(run func(ctx context.Context, maxLen int) ([]byte, error)) *MockLNClient_GetLogOutput_Call {
	_c.Call.Return(run)
	return _c
}

// GetNetworkGraph provides a mock function for the type MockLNClient
func (_mock *MockLNClient) GetNetworkGraph(ctx context.Context, nodeIds []string) (lnclient.NetworkGraphResponse, error) {
	ret := _mock.Called(ctx, nodeIds)

	if len(ret) == 0 {
		panic("no return value specified for GetNetworkGraph")
	}

	var r0 lnclient.NetworkGraphResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string) (lnclient.NetworkGraphResponse, error)); ok {
		return returnFunc(ctx, nodeIds)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string) lnclient.NetworkGraphResponse); ok {
		r0 = returnFunc(ctx, nodeIds)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(lnclient.NetworkGraphResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []string) error); ok {
		r1 = returnFunc(ctx, nodeIds)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_GetNetworkGraph_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNetworkGraph'
type MockLNClient_GetNetworkGraph_Call struct {
	*mock.Call
}

// GetNetworkGraph is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeIds []string
func (_e *MockLNClient_Expecter) GetNetworkGraph(ctx interface{}, nodeIds interface{}) *MockLNClient_GetNetworkGraph_Call {
	return &MockLNClient_GetNetworkGraph_Call{Call: _e.mock.On("GetNetworkGraph", ctx, nodeIds)}
}

func (_c *MockLNClient_GetNetworkGraph_Call) Run(run func(ctx context.Context, nodeIds []string)) *MockLNClient_GetNetworkGraph_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []string
		if args[1] != nil {
			arg1 = args[1].([]string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_GetNetworkGraph_Call) Return(v lnclient.NetworkGraphResponse, err error) *MockLNClient_GetNetworkGraph_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *MockLNClient_GetNetworkGraph_Call) RunAndReturn(run func(ctx context.Context, nodeIds []string) (lnclient.NetworkGraphResponse, error)) *MockLNClient_GetNetworkGraph_Call {
	_c.Call.Return(run)
	return _c
}

// GetNewOnchainAddress provides a mock function for the type MockLNClient
func (_mock *MockLNClient) GetNewOnchainAddress(ctx context.Context) (string, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetNewOnchainAddress")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_GetNewOnchainAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNewOnchainAddress'
type MockLNClient_GetNewOnchainAddress_Call struct {
	*mock.Call
}

// GetNewOnchainAddress is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockLNClient_Expecter) GetNewOnchainAddress(ctx interface{}) *MockLNClient_GetNewOnchainAddress_Call {
	return &MockLNClient_GetNewOnchainAddress_Call{Call: _e.mock.On("GetNewOnchainAddress", ctx)}
}

func (_c *MockLNClient_GetNewOnchainAddress_Call) Run(run func(ctx context.Context)) *MockLNClient_GetNewOnchainAddress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLNClient_GetNewOnchainAddress_Call) Return(s string, err error) *MockLNClient_GetNewOnchainAddress_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockLNClient_GetNewOnchainAddress_Call) RunAndReturn(run func(ctx context.Context) (string, error)) *MockLNClient_GetNewOnchainAddress_Call {
	_c.Call.Return(run)
	return _c
}

// GetNodeConnectionInfo provides a mock function for the type MockLNClient
func (_mock *MockLNClient) GetNodeConnectionInfo(ctx context.Context) (*lnclient.NodeConnectionInfo, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetNodeConnectionInfo")
	}

	var r0 *lnclient.NodeConnectionInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (*lnclient.NodeConnectionInfo, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) *lnclient.NodeConnectionInfo); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lnclient.NodeConnectionInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_GetNodeConnectionInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNodeConnectionInfo'
type MockLNClient_GetNodeConnectionInfo_Call struct {
	*mock.Call
}

// GetNodeConnectionInfo is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockLNClient_Expecter) GetNodeConnectionInfo(ctx interface{}) *MockLNClient_GetNodeConnectionInfo_Call {
	return &MockLNClient_GetNodeConnectionInfo_Call{Call: _e.mock.On("GetNodeConnectionInfo", ctx)}
}

func (_c *MockLNClient_GetNodeConnectionInfo_Call) Run(run func(ctx context.Context)) *MockLNClient_GetNodeConnectionInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLNClient_GetNodeConnectionInfo_Call) Return(nodeConnectionInfo *lnclient.NodeConnectionInfo, err error) *MockLNClient_GetNodeConnectionInfo_Call {
	_c.Call.Return(nodeConnectionInfo, err)
	return _c
}

func (_c *MockLNClient_GetNodeConnectionInfo_Call) RunAndReturn(run func(ctx context.Context) (*lnclient.NodeConnectionInfo, error)) *MockLNClient_GetNodeConnectionInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetNodeStatus provides a mock function for the type MockLNClient
func (_mock *MockLNClient) GetNodeStatus(ctx context.Context) (*lnclient.NodeStatus, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetNodeStatus")
	}

	var r0 *lnclient.NodeStatus
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (*lnclient.NodeStatus, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) *lnclient.NodeStatus); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lnclient.NodeStatus)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_GetNodeStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNodeStatus'
type MockLNClient_GetNodeStatus_Call struct {
	*mock.Call
}

// GetNodeStatus is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockLNClient_Expecter) GetNodeStatus(ctx interface{}) *MockLNClient_GetNodeStatus_Call {
	return &MockLNClient_GetNodeStatus_Call{Call: _e.mock.On("GetNodeStatus", ctx)}
}

func (_c *MockLNClient_GetNodeStatus_Call) Run(run func(ctx context.Context)) *MockLNClient_GetNodeStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLNClient_GetNodeStatus_Call) Return(nodeStatus *lnclient.NodeStatus, err error) *MockLNClient_GetNodeStatus_Call {
	_c.Call.Return(nodeStatus, err)
	return _c
}

func (_c *MockLNClient_GetNodeStatus_Call) RunAndReturn(run func(ctx context.Context) (*lnclient.NodeStatus, error)) *MockLNClient_GetNodeStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetOnchainBalance provides a mock function for the type MockLNClient
func (_mock *MockLNClient) GetOnchainBalance(ctx context.Context) (*lnclient.OnchainBalanceResponse, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetOnchainBalance")
	}

	var r0 *lnclient.OnchainBalanceResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (*lnclient.OnchainBalanceResponse, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) *lnclient.OnchainBalanceResponse); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lnclient.OnchainBalanceResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_GetOnchainBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOnchainBalance'
type MockLNClient_GetOnchainBalance_Call struct {
	*mock.Call
}

// GetOnchainBalance is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockLNClient_Expecter) GetOnchainBalance(ctx interface{}) *MockLNClient_GetOnchainBalance_Call {
	return &MockLNClient_GetOnchainBalance_Call{Call: _e.mock.On("GetOnchainBalance", ctx)}
}

func (_c *MockLNClient_GetOnchainBalance_Call) Run(run func(ctx context.Context)) *MockLNClient_GetOnchainBalance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLNClient_GetOnchainBalance_Call) Return(onchainBalanceResponse *lnclient.OnchainBalanceResponse, err error) *MockLNClient_GetOnchainBalance_Call {
	_c.Call.Return(onchainBalanceResponse, err)
	return _c
}

func (_c *MockLNClient_GetOnchainBalance_Call) RunAndReturn(run func(ctx context.Context) (*lnclient.OnchainBalanceResponse, error)) *MockLNClient_GetOnchainBalance_Call {
	_c.Call.Return(run)
	return _c
}

// GetPubkey provides a mock function for the type MockLNClient
func (_mock *MockLNClient) GetPubkey() string {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPubkey")
	}

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

// MockLNClient_GetPubkey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPubkey'
type MockLNClient_GetPubkey_Call struct {
	*mock.Call
}

// GetPubkey is a helper method to define mock.On call
func (_e *MockLNClient_Expecter) GetPubkey() *MockLNClient_GetPubkey_Call {
	return &MockLNClient_GetPubkey_Call{Call: _e.mock.On("GetPubkey")}
}

func (_c *MockLNClient_GetPubkey_Call) Run(run func()) *MockLNClient_GetPubkey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLNClient_GetPubkey_Call) Return(s string) *MockLNClient_GetPubkey_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockLNClient_GetPubkey_Call) RunAndReturn(run func() string) *MockLNClient_GetPubkey_Call {
	_c.Call.Return(run)
	return _c
}

// GetStorageDir provides a mock function for the type MockLNClient
func (_mock *MockLNClient) GetStorageDir() (string, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetStorageDir")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_GetStorageDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStorageDir'
type MockLNClient_GetStorageDir_Call struct {
	*mock.Call
}

// GetStorageDir is a helper method to define mock.On call
func (_e *MockLNClient_Expecter) GetStorageDir() *MockLNClient_GetStorageDir_Call {
	return &MockLNClient_GetStorageDir_Call{Call: _e.mock.On("GetStorageDir")}
}

func (_c *MockLNClient_GetStorageDir_Call) Run(run func()) *MockLNClient_GetStorageDir_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLNClient_GetStorageDir_Call) Return(s string, err error) *MockLNClient_GetStorageDir_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockLNClient_GetStorageDir_Call) RunAndReturn(run func() (string, error)) *MockLNClient_GetStorageDir_Call {
	_c.Call.Return(run)
	return _c
}

// GetSupportedNIP47Methods provides a mock function for the type MockLNClient
func (_mock *MockLNClient) GetSupportedNIP47Methods() []string {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetSupportedNIP47Methods")
	}

	var r0 []string
	if returnFunc, ok := ret.Get(0).(func() []string); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	return r0
}

// MockLNClient_GetSupportedNIP47Methods_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSupportedNIP47Methods'
type MockLNClient_GetSupportedNIP47Methods_Call struct {
	*mock.Call
}

// GetSupportedNIP47Methods is a helper method to define mock.On call
func (_e *MockLNClient_Expecter) GetSupportedNIP47Methods() *MockLNClient_GetSupportedNIP47Methods_Call {
	return &MockLNClient_GetSupportedNIP47Methods_Call{Call: _e.mock.On("GetSupportedNIP47Methods")}
}

func (_c *MockLNClient_GetSupportedNIP47Methods_Call) Run(run func()) *MockLNClient_GetSupportedNIP47Methods_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLNClient_GetSupportedNIP47Methods_Call) Return(strings []string) *MockLNClient_GetSupportedNIP47Methods_Call {
	_c.Call.Return(strings)
	return _c
}

func (_c *MockLNClient_GetSupportedNIP47Methods_Call) RunAndReturn(run func() []string) *MockLNClient_GetSupportedNIP47Methods_Call {
	_c.Call.Return(run)
	return _c
}

// GetSupportedNIP47NotificationTypes provides a mock function for the type MockLNClient
func (_mock *MockLNClient) GetSupportedNIP47NotificationTypes() []string {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetSupportedNIP47NotificationTypes")
	}

	var r0 []string
	if returnFunc, ok := ret.Get(0).(func() []string); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	return r0
}

// MockLNClient_GetSupportedNIP47NotificationTypes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSupportedNIP47NotificationTypes'
type MockLNClient_GetSupportedNIP47NotificationTypes_Call struct {
	*mock.Call
}

// GetSupportedNIP47NotificationTypes is a helper method to define mock.On call
func (_e *MockLNClient_Expecter) GetSupportedNIP47NotificationTypes() *MockLNClient_GetSupportedNIP47NotificationTypes_Call {
	return &MockLNClient_GetSupportedNIP47NotificationTypes_Call{Call: _e.mock.On("GetSupportedNIP47NotificationTypes")}
}

func (_c *MockLNClient_GetSupportedNIP47NotificationTypes_Call) Run(run func()) *MockLNClient_GetSupportedNIP47NotificationTypes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLNClient_GetSupportedNIP47NotificationTypes_Call) Return(strings []string) *MockLNClient_GetSupportedNIP47NotificationTypes_Call {
	_c.Call.Return(strings)
	return _c
}

func (_c *MockLNClient_GetSupportedNIP47NotificationTypes_Call) RunAndReturn(run func() []string) *MockLNClient_GetSupportedNIP47NotificationTypes_Call {
	_c.Call.Return(run)
	return _c
}

// ListChannels provides a mock function for the type MockLNClient
func (_mock *MockLNClient) ListChannels(ctx context.Context) ([]lnclient.Channel, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ListChannels")
	}

	var r0 []lnclient.Channel
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]lnclient.Channel, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) []lnclient.Channel); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]lnclient.Channel)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_ListChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListChannels'
type MockLNClient_ListChannels_Call struct {
	*mock.Call
}

// ListChannels is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockLNClient_Expecter) ListChannels(ctx interface{}) *MockLNClient_ListChannels_Call {
	return &MockLNClient_ListChannels_Call{Call: _e.mock.On("ListChannels", ctx)}
}

func (_c *MockLNClient_ListChannels_Call) Run(run func(ctx context.Context)) *MockLNClient_ListChannels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLNClient_ListChannels_Call) Return(channels []lnclient.Channel, err error) *MockLNClient_ListChannels_Call {
	_c.Call.Return(channels, err)
	return _c
}

func (_c *MockLNClient_ListChannels_Call) RunAndReturn(run func(ctx context.Context) ([]lnclient.Channel, error)) *MockLNClient_ListChannels_Call {
	_c.Call.Return(run)
	return _c
}

// ListOnchainTransactions provides a mock function for the type MockLNClient
func (_mock *MockLNClient) ListOnchainTransactions(ctx context.Context) ([]lnclient.OnchainTransaction, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ListOnchainTransactions")
	}

	var r0 []lnclient.OnchainTransaction
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]lnclient.OnchainTransaction, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) []lnclient.OnchainTransaction); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]lnclient.OnchainTransaction)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_ListOnchainTransactions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOnchainTransactions'
type MockLNClient_ListOnchainTransactions_Call struct {
	*mock.Call
}

// ListOnchainTransactions is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockLNClient_Expecter) ListOnchainTransactions(ctx interface{}) *MockLNClient_ListOnchainTransactions_Call {
	return &MockLNClient_ListOnchainTransactions_Call{Call: _e.mock.On("ListOnchainTransactions", ctx)}
}

func (_c *MockLNClient_ListOnchainTransactions_Call) Run(run func(ctx context.Context)) *MockLNClient_ListOnchainTransactions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLNClient_ListOnchainTransactions_Call) Return(onchainTransactions []lnclient.OnchainTransaction, err error) *MockLNClient_ListOnchainTransactions_Call {
	_c.Call.Return(onchainTransactions, err)
	return _c
}

func (_c *MockLNClient_ListOnchainTransactions_Call) RunAndReturn(run func(ctx context.Context) ([]lnclient.OnchainTransaction, error)) *MockLNClient_ListOnchainTransactions_Call {
	_c.Call.Return(run)
	return _c
}

// ListPeers provides a mock function for the type MockLNClient
func (_mock *MockLNClient) ListPeers(ctx context.Context) ([]lnclient.PeerDetails, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ListPeers")
	}

	var r0 []lnclient.PeerDetails
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]lnclient.PeerDetails, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) []lnclient.PeerDetails); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]lnclient.PeerDetails)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_ListPeers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPeers'
type MockLNClient_ListPeers_Call struct {
	*mock.Call
}

// ListPeers is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockLNClient_Expecter) ListPeers(ctx interface{}) *MockLNClient_ListPeers_Call {
	return &MockLNClient_ListPeers_Call{Call: _e.mock.On("ListPeers", ctx)}
}

func (_c *MockLNClient_ListPeers_Call) Run(run func(ctx context.Context)) *MockLNClient_ListPeers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLNClient_ListPeers_Call) Return(peerDetailss []lnclient.PeerDetails, err error) *MockLNClient_ListPeers_Call {
	_c.Call.Return(peerDetailss, err)
	return _c
}

func (_c *MockLNClient_ListPeers_Call) RunAndReturn(run func(ctx context.Context) ([]lnclient.PeerDetails, error)) *MockLNClient_ListPeers_Call {
	_c.Call.Return(run)
	return _c
}

// LookupInvoice provides a mock function for the type MockLNClient
func (_mock *MockLNClient) LookupInvoice(ctx context.Context, paymentHash string) (*lnclient.Transaction, error) {
	ret := _mock.Called(ctx, paymentHash)

	if len(ret) == 0 {
		panic("no return value specified for LookupInvoice")
	}

	var r0 *lnclient.Transaction
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*lnclient.Transaction, error)); ok {
		return returnFunc(ctx, paymentHash)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *lnclient.Transaction); ok {
		r0 = returnFunc(ctx, paymentHash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lnclient.Transaction)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, paymentHash)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_LookupInvoice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LookupInvoice'
type MockLNClient_LookupInvoice_Call struct {
	*mock.Call
}

// LookupInvoice is a helper method to define mock.On call
//   - ctx context.Context
//   - paymentHash string
func (_e *MockLNClient_Expecter) LookupInvoice(ctx interface{}, paymentHash interface{}) *MockLNClient_LookupInvoice_Call {
	return &MockLNClient_LookupInvoice_Call{Call: _e.mock.On("LookupInvoice", ctx, paymentHash)}
}

func (_c *MockLNClient_LookupInvoice_Call) Run(run func(ctx context.Context, paymentHash string)) *MockLNClient_LookupInvoice_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_LookupInvoice_Call) Return(transaction *lnclient.Transaction, err error) *MockLNClient_LookupInvoice_Call {
	_c.Call.Return(transaction, err)
	return _c
}

func (_c *MockLNClient_LookupInvoice_Call) RunAndReturn(run func(ctx context.Context, paymentHash string) (*lnclient.Transaction, error)) *MockLNClient_LookupInvoice_Call {
	_c.Call.Return(run)
	return _c
}

// MakeHoldInvoice provides a mock function for the type MockLNClient
func (_mock *MockLNClient) MakeHoldInvoice(ctx context.Context, amountMsat int64, description string, descriptionHash string, expiry int64, paymentHash string, minCltvExpiryDelta *uint64) (*lnclient.Transaction, error) {
	ret := _mock.Called(ctx, amountMsat, description, descriptionHash, expiry, paymentHash, minCltvExpiryDelta)

	if len(ret) == 0 {
		panic("no return value specified for MakeHoldInvoice")
	}

	var r0 *lnclient.Transaction
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, string, string, int64, string, *uint64) (*lnclient.Transaction, error)); ok {
		return returnFunc(ctx, amountMsat, description, descriptionHash, expiry, paymentHash, minCltvExpiryDelta)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, string, string, int64, string, *uint64) *lnclient.Transaction); ok {
		r0 = returnFunc(ctx, amountMsat, description, descriptionHash, expiry, paymentHash, minCltvExpiryDelta)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lnclient.Transaction)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int64, string, string, int64, string, *uint64) error); ok {
		r1 = returnFunc(ctx, amountMsat, description, descriptionHash, expiry, paymentHash, minCltvExpiryDelta)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_MakeHoldInvoice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MakeHoldInvoice'
type MockLNClient_MakeHoldInvoice_Call struct {
	*mock.Call
}

// MakeHoldInvoice is a helper method to define mock.On call
//   - ctx context.Context
//   - amountMsat int64
//   - description string
//   - descriptionHash string
//   - expiry int64
//   - paymentHash string
//   - minCltvExpiryDelta *uint64
func (_e *MockLNClient_Expecter) MakeHoldInvoice(ctx interface{}, amountMsat interface{}, description interface{}, descriptionHash interface{}, expiry interface{}, paymentHash interface{}, minCltvExpiryDelta interface{}) *MockLNClient_MakeHoldInvoice_Call {
	return &MockLNClient_MakeHoldInvoice_Call{Call: _e.mock.On("MakeHoldInvoice", ctx, amountMsat, description, descriptionHash, expiry, paymentHash, minCltvExpiryDelta)}
}

func (_c *MockLNClient_MakeHoldInvoice_Call) Run(run func(ctx context.Context, amountMsat int64, description string, descriptionHash string, expiry int64, paymentHash string, minCltvExpiryDelta *uint64)) *MockLNClient_MakeHoldInvoice_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int64
		if args[1] != nil {
			arg1 = args[1].(int64)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 int64
		if args[4] != nil {
			arg4 = args[4].(int64)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		var arg6 *uint64
		if args[6] != nil {
			arg6 = args[6].(*uint64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
			arg6,
		)
	})
	return _c
}

func (_c *MockLNClient_MakeHoldInvoice_Call) Return(transaction *lnclient.Transaction, err error) *MockLNClient_MakeHoldInvoice_Call {
	_c.Call.Return(transaction, err)
	return _c
}

func (_c *MockLNClient_MakeHoldInvoice_Call) RunAndReturn(run func(ctx context.Context, amountMsat int64, description string, descriptionHash string, expiry int64, paymentHash string, minCltvExpiryDelta *uint64) (*lnclient.Transaction, error)) *MockLNClient_MakeHoldInvoice_Call {
	_c.Call.Return(run)
	return _c
}

// MakeInvoice provides a mock function for the type MockLNClient
func (_mock *MockLNClient) MakeInvoice(ctx context.Context, amountMsat int64, description string, descriptionHash string, expiry int64, throughNodePubkey *string) (*lnclient.Transaction, error) {
	ret := _mock.Called(ctx, amountMsat, description, descriptionHash, expiry, throughNodePubkey)

	if len(ret) == 0 {
		panic("no return value specified for MakeInvoice")
	}

	var r0 *lnclient.Transaction
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, string, string, int64, *string) (*lnclient.Transaction, error)); ok {
		return returnFunc(ctx, amountMsat, description, descriptionHash, expiry, throughNodePubkey)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, string, string, int64, *string) *lnclient.Transaction); ok {
		r0 = returnFunc(ctx, amountMsat, description, descriptionHash, expiry, throughNodePubkey)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lnclient.Transaction)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int64, string, string, int64, *string) error); ok {
		r1 = returnFunc(ctx, amountMsat, description, descriptionHash, expiry, throughNodePubkey)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_MakeInvoice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MakeInvoice'
type MockLNClient_MakeInvoice_Call struct {
	*mock.Call
}

// MakeInvoice is a helper method to define mock.On call
//   - ctx context.Context
//   - amountMsat int64
//   - description string
//   - descriptionHash string
//   - expiry int64
//   - throughNodePubkey *string
func (_e *MockLNClient_Expecter) MakeInvoice(ctx interface{}, amountMsat interface{}, description interface{}, descriptionHash interface{}, expiry interface{}, throughNodePubkey interface{}) *MockLNClient_MakeInvoice_Call {
	return &MockLNClient_MakeInvoice_Call{Call: _e.mock.On("MakeInvoice", ctx, amountMsat, description, descriptionHash, expiry, throughNodePubkey)}
}

func (_c *MockLNClient_MakeInvoice_Call) Run(run func(ctx context.Context, amountMsat int64, description string, descriptionHash string, expiry int64, throughNodePubkey *string)) *MockLNClient_MakeInvoice_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int64
		if args[1] != nil {
			arg1 = args[1].(int64)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 int64
		if args[4] != nil {
			arg4 = args[4].(int64)
		}
		var arg5 *string
		if args[5] != nil {
			arg5 = args[5].(*string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *MockLNClient_MakeInvoice_Call) Return(transaction *lnclient.Transaction, err error) *MockLNClient_MakeInvoice_Call {
	_c.Call.Return(transaction, err)
	return _c
}

func (_c *MockLNClient_MakeInvoice_Call) RunAndReturn(run func(ctx context.Context, amountMsat int64, description string, descriptionHash string, expiry int64, throughNodePubkey *string) (*lnclient.Transaction, error)) *MockLNClient_MakeInvoice_Call {
	_c.Call.Return(run)
	return _c
}

// MakeOffer provides a mock function for the type MockLNClient
func (_mock *MockLNClient) MakeOffer(ctx context.Context, description string) (string, error) {
	ret := _mock.Called(ctx, description)

	if len(ret) == 0 {
		panic("no return value specified for MakeOffer")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok {
		return returnFunc(ctx, description)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) string); ok {
		r0 = returnFunc(ctx, description)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, description)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_MakeOffer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MakeOffer'
type MockLNClient_MakeOffer_Call struct {
	*mock.Call
}

// MakeOffer is a helper method to define mock.On call
//   - ctx context.Context
//   - description string
func (_e *MockLNClient_Expecter) MakeOffer(ctx interface{}, description interface{}) *MockLNClient_MakeOffer_Call {
	return &MockLNClient_MakeOffer_Call{Call: _e.mock.On("MakeOffer", ctx, description)}
}

func (_c *MockLNClient_MakeOffer_Call) Run(run func(ctx context.Context, description string)) *MockLNClient_MakeOffer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_MakeOffer_Call) Return(s string, err error) *MockLNClient_MakeOffer_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockLNClient_MakeOffer_Call) RunAndReturn(run func(ctx context.Context, description string) (string, error)) *MockLNClient_MakeOffer_Call {
	_c.Call.Return(run)
	return _c
}

// OpenChannel provides a mock function for the type MockLNClient
func (_mock *MockLNClient) OpenChannel(ctx context.Context, openChannelRequest *lnclient.OpenChannelRequest) (*lnclient.OpenChannelResponse, error) {
	ret := _mock.Called(ctx, openChannelRequest)

	if len(ret) == 0 {
		panic("no return value specified for OpenChannel")
	}

	var r0 *lnclient.OpenChannelResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *lnclient.OpenChannelRequest) (*lnclient.OpenChannelResponse, error)); ok {
		return returnFunc(ctx, openChannelRequest)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *lnclient.OpenChannelRequest) *lnclient.OpenChannelResponse); ok {
		r0 = returnFunc(ctx, openChannelRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lnclient.OpenChannelResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *lnclient.OpenChannelRequest) error); ok {
		r1 = returnFunc(ctx, openChannelRequest)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_OpenChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenChannel'
type MockLNClient_OpenChannel_Call struct {
	*mock.Call
}

// OpenChannel is a helper method to define mock.On call
//   - ctx context.Context
//   - openChannelRequest *lnclient.OpenChannelRequest
func (_e *MockLNClient_Expecter) OpenChannel(ctx interface{}, openChannelRequest interface{}) *MockLNClient_OpenChannel_Call {
	return &MockLNClient_OpenChannel_Call{Call: _e.mock.On("OpenChannel", ctx, openChannelRequest)}
}

func (_c *MockLNClient_OpenChannel_Call) Run(run func(ctx context.Context, openChannelRequest *lnclient.OpenChannelRequest)) *MockLNClient_OpenChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *lnclient.OpenChannelRequest
		if args[1] != nil {
			arg1 = args[1].(*lnclient.OpenChannelRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_OpenChannel_Call) Return(openChannelResponse *lnclient.OpenChannelResponse, err error) *MockLNClient_OpenChannel_Call {
	_c.Call.Return(openChannelResponse, err)
	return _c
}

func (_c *MockLNClient_OpenChannel_Call) RunAndReturn(run func(ctx context.Context, openChannelRequest *lnclient.OpenChannelRequest) (*lnclient.OpenChannelResponse, error)) *MockLNClient_OpenChannel_Call {
	_c.Call.Return(run)
	return _c
}

// RedeemOnchainFunds provides a mock function for the type MockLNClient
func (_mock *MockLNClient) RedeemOnchainFunds(ctx context.Context, toAddress string, amountSat uint64, feeRate *uint64, sendAll bool) (string, error) {
	ret := _mock.Called(ctx, toAddress, amountSat, feeRate, sendAll)

	if len(ret) == 0 {
		panic("no return value specified for RedeemOnchainFunds")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, uint64, *uint64, bool) (string, error)); ok {
		return returnFunc(ctx, toAddress, amountSat, feeRate, sendAll)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, uint64, *uint64, bool) string); ok {
		r0 = returnFunc(ctx, toAddress, amountSat, feeRate, sendAll)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, uint64, *uint64, bool) error); ok {
		r1 = returnFunc(ctx, toAddress, amountSat, feeRate, sendAll)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_RedeemOnchainFunds_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RedeemOnchainFunds'
type MockLNClient_RedeemOnchainFunds_Call struct {
	*mock.Call
}

// RedeemOnchainFunds is a helper method to define mock.On call
//   - ctx context.Context
//   - toAddress string
//   - amountSat uint64
//   - feeRate *uint64
//   - sendAll bool
func (_e *MockLNClient_Expecter) RedeemOnchainFunds(ctx interface{}, toAddress interface{}, amountSat interface{}, feeRate interface{}, sendAll interface{}) *MockLNClient_RedeemOnchainFunds_Call {
	return &MockLNClient_RedeemOnchainFunds_Call{Call: _e.mock.On("RedeemOnchainFunds", ctx, toAddress, amountSat, feeRate, sendAll)}
}

func (_c *MockLNClient_RedeemOnchainFunds_Call) Run(run func(ctx context.Context, toAddress string, amountSat uint64, feeRate *uint64, sendAll bool)) *MockLNClient_RedeemOnchainFunds_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 uint64
		if args[2] != nil {
			arg2 = args[2].(uint64)
		}
		var arg3 *uint64
		if args[3] != nil {
			arg3 = args[3].(*uint64)
		}
		var arg4 bool
		if args[4] != nil {
			arg4 = args[4].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MockLNClient_RedeemOnchainFunds_Call) Return(txId string, err error) *MockLNClient_RedeemOnchainFunds_Call {
	_c.Call.Return(txId, err)
	return _c
}

func (_c *MockLNClient_RedeemOnchainFunds_Call) RunAndReturn(run func(ctx context.Context, toAddress string, amountSat uint64, feeRate *uint64, sendAll bool) (string, error)) *MockLNClient_RedeemOnchainFunds_Call {
	_c.Call.Return(run)
	return _c
}

// ResetRouter provides a mock function for the type MockLNClient
func (_mock *MockLNClient) ResetRouter(key string) error {
	ret := _mock.Called(key)

	if len(ret) == 0 {
		panic("no return value specified for ResetRouter")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string) error); ok {
		r0 = returnFunc(key)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockLNClient_ResetRouter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetRouter'
type MockLNClient_ResetRouter_Call struct {
	*mock.Call
}

// ResetRouter is a helper method to define mock.On call
//   - key string
func (_e *MockLNClient_Expecter) ResetRouter(key interface{}) *MockLNClient_ResetRouter_Call {
	return &MockLNClient_ResetRouter_Call{Call: _e.mock.On("ResetRouter", key)}
}

func (_c *MockLNClient_ResetRouter_Call) Run(run func(key string)) *MockLNClient_ResetRouter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLNClient_ResetRouter_Call) Return(err error) *MockLNClient_ResetRouter_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockLNClient_ResetRouter_Call) RunAndReturn(run func(key string) error) *MockLNClient_ResetRouter_Call {
	_c.Call.Return(run)
	return _c
}

// SendKeysend provides a mock function for the type MockLNClient
func (_mock *MockLNClient) SendKeysend(amountMsat uint64, destination string, customRecords []lnclient.TLVRecord, preimage string) (*lnclient.PayKeysendResponse, error) {
	ret := _mock.Called(amountMsat, destination, customRecords, preimage)

	if len(ret) == 0 {
		panic("no return value specified for SendKeysend")
	}

	var r0 *lnclient.PayKeysendResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(uint64, string, []lnclient.TLVRecord, string) (*lnclient.PayKeysendResponse, error)); ok {
		return returnFunc(amountMsat, destination, customRecords, preimage)
	}
	if returnFunc, ok := ret.Get(0).(func(uint64, string, []lnclient.TLVRecord, string) *lnclient.PayKeysendResponse); ok {
		r0 = returnFunc(amountMsat, destination, customRecords, preimage)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lnclient.PayKeysendResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(uint64, string, []lnclient.TLVRecord, string) error); ok {
		r1 = returnFunc(amountMsat, destination, customRecords, preimage)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_SendKeysend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendKeysend'
type MockLNClient_SendKeysend_Call struct {
	*mock.Call
}

// SendKeysend is a helper method to define mock.On call
//   - amountMsat uint64
//   - destination string
//   - customRecords []lnclient.TLVRecord
//   - preimage string
func (_e *MockLNClient_Expecter) SendKeysend(amountMsat interface{}, destination interface{}, customRecords interface{}, preimage interface{}) *MockLNClient_SendKeysend_Call {
	return &MockLNClient_SendKeysend_Call{Call: _e.mock.On("SendKeysend", amountMsat, destination, customRecords, preimage)}
}

func (_c *MockLNClient_SendKeysend_Call) Run(run func(amountMsat uint64, destination string, customRecords []lnclient.TLVRecord, preimage string)) *MockLNClient_SendKeysend_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 uint64
		if args[0] != nil {
			arg0 = args[0].(uint64)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []lnclient.TLVRecord
		if args[2] != nil {
			arg2 = args[2].([]lnclient.TLVRecord)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockLNClient_SendKeysend_Call) Return(payKeysendResponse *lnclient.PayKeysendResponse, err error) *MockLNClient_SendKeysend_Call {
	_c.Call.Return(payKeysendResponse, err)
	return _c
}

func (_c *MockLNClient_SendKeysend_Call) RunAndReturn(run func(amountMsat uint64, destination string, customRecords []lnclient.TLVRecord, preimage string) (*lnclient.PayKeysendResponse, error)) *MockLNClient_SendKeysend_Call {
	_c.Call.Return(run)
	return _c
}

// SendPaymentSync provides a mock function for the type MockLNClient
func (_mock *MockLNClient) SendPaymentSync(payReq string, amountMsat *uint64) (*lnclient.PayInvoiceResponse, error) {
	ret := _mock.Called(payReq, amountMsat)

	if len(ret) == 0 {
		panic("no return value specified for SendPaymentSync")
	}

	var r0 *lnclient.PayInvoiceResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string, *uint64) (*lnclient.PayInvoiceResponse, error)); ok {
		return returnFunc(payReq, amountMsat)
	}
	if returnFunc, ok := ret.Get(0).(func(string, *uint64) *lnclient.PayInvoiceResponse); ok {
		r0 = returnFunc(payReq, amountMsat)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*lnclient.PayInvoiceResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string, *uint64) error); ok {
		r1 = returnFunc(payReq, amountMsat)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_SendPaymentSync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendPaymentSync'
type MockLNClient_SendPaymentSync_Call struct {
	*mock.Call
}

// SendPaymentSync is a helper method to define mock.On call
//   - payReq string
//   - amountMsat *uint64
func (_e *MockLNClient_Expecter) SendPaymentSync(payReq interface{}, amountMsat interface{}) *MockLNClient_SendPaymentSync_Call {
	return &MockLNClient_SendPaymentSync_Call{Call: _e.mock.On("SendPaymentSync", payReq, amountMsat)}
}

func (_c *MockLNClient_SendPaymentSync_Call) Run(run func(payReq string, amountMsat *uint64)) *MockLNClient_SendPaymentSync_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 *uint64
		if args[1] != nil {
			arg1 = args[1].(*uint64)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_SendPaymentSync_Call) Return(payInvoiceResponse *lnclient.PayInvoiceResponse, err error) *MockLNClient_SendPaymentSync_Call {
	_c.Call.Return(payInvoiceResponse, err)
	return _c
}

func (_c *MockLNClient_SendPaymentSync_Call) RunAndReturn(run func(payReq string, amountMsat *uint64) (*lnclient.PayInvoiceResponse, error)) *MockLNClient_SendPaymentSync_Call {
	_c.Call.Return(run)
	return _c
}

// SettleHoldInvoice provides a mock function for the type MockLNClient
func (_mock *MockLNClient) SettleHoldInvoice(ctx context.Context, preimage string) error {
	ret := _mock.Called(ctx, preimage)

	if len(ret) == 0 {
		panic("no return value specified for SettleHoldInvoice")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, preimage)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockLNClient_SettleHoldInvoice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SettleHoldInvoice'
type MockLNClient_SettleHoldInvoice_Call struct {
	*mock.Call
}

// SettleHoldInvoice is a helper method to define mock.On call
//   - ctx context.Context
//   - preimage string
func (_e *MockLNClient_Expecter) SettleHoldInvoice(ctx interface{}, preimage interface{}) *MockLNClient_SettleHoldInvoice_Call {
	return &MockLNClient_SettleHoldInvoice_Call{Call: _e.mock.On("SettleHoldInvoice", ctx, preimage)}
}

func (_c *MockLNClient_SettleHoldInvoice_Call) Run(run func(ctx context.Context, preimage string)) *MockLNClient_SettleHoldInvoice_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_SettleHoldInvoice_Call) Return(err error) *MockLNClient_SettleHoldInvoice_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockLNClient_SettleHoldInvoice_Call) RunAndReturn(run func(ctx context.Context, preimage string) error) *MockLNClient_SettleHoldInvoice_Call {
	_c.Call.Return(run)
	return _c
}

// Shutdown provides a mock function for the type MockLNClient
func (_mock *MockLNClient) Shutdown() error {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for Shutdown")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func() error); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockLNClient_Shutdown_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Shutdown'
type MockLNClient_Shutdown_Call struct {
	*mock.Call
}

// Shutdown is a helper method to define mock.On call
func (_e *MockLNClient_Expecter) Shutdown() *MockLNClient_Shutdown_Call {
	return &MockLNClient_Shutdown_Call{Call: _e.mock.On("Shutdown")}
}

func (_c *MockLNClient_Shutdown_Call) Run(run func()) *MockLNClient_Shutdown_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLNClient_Shutdown_Call) Return(err error) *MockLNClient_Shutdown_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockLNClient_Shutdown_Call) RunAndReturn(run func() error) *MockLNClient_Shutdown_Call {
	_c.Call.Return(run)
	return _c
}

// SignMessage provides a mock function for the type MockLNClient
func (_mock *MockLNClient) SignMessage(ctx context.Context, message string) (string, error) {
	ret := _mock.Called(ctx, message)

	if len(ret) == 0 {
		panic("no return value specified for SignMessage")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok {
		return returnFunc(ctx, message)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) string); ok {
		r0 = returnFunc(ctx, message)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, message)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockLNClient_SignMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignMessage'
type MockLNClient_SignMessage_Call struct {
	*mock.Call
}

// SignMessage is a helper method to define mock.On call
//   - ctx context.Context
//   - message string
func (_e *MockLNClient_Expecter) SignMessage(ctx interface{}, message interface{}) *MockLNClient_SignMessage_Call {
	return &MockLNClient_SignMessage_Call{Call: _e.mock.On("SignMessage", ctx, message)}
}

func (_c *MockLNClient_SignMessage_Call) Run(run func(ctx context.Context, message string)) *MockLNClient_SignMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_SignMessage_Call) Return(s string, err error) *MockLNClient_SignMessage_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockLNClient_SignMessage_Call) RunAndReturn(run func(ctx context.Context, message string) (string, error)) *MockLNClient_SignMessage_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateChannel provides a mock function for the type MockLNClient
func (_mock *MockLNClient) UpdateChannel(ctx context.Context, updateChannelRequest *lnclient.UpdateChannelRequest) error {
	ret := _mock.Called(ctx, updateChannelRequest)

	if len(ret) == 0 {
		panic("no return value specified for UpdateChannel")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *lnclient.UpdateChannelRequest) error); ok {
		r0 = returnFunc(ctx, updateChannelRequest)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockLNClient_UpdateChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateChannel'
type MockLNClient_UpdateChannel_Call struct {
	*mock.Call
}

// UpdateChannel is a helper method to define mock.On call
//   - ctx context.Context
//   - updateChannelRequest *lnclient.UpdateChannelRequest
func (_e *MockLNClient_Expecter) UpdateChannel(ctx interface{}, updateChannelRequest interface{}) *MockLNClient_UpdateChannel_Call {
	return &MockLNClient_UpdateChannel_Call{Call: _e.mock.On("UpdateChannel", ctx, updateChannelRequest)}
}

func (_c *MockLNClient_UpdateChannel_Call) Run(run func(ctx context.Context, updateChannelRequest *lnclient.UpdateChannelRequest)) *MockLNClient_UpdateChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *lnclient.UpdateChannelRequest
		if args[1] != nil {
			arg1 = args[1].(*lnclient.UpdateChannelRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLNClient_UpdateChannel_Call) Return(err error) *MockLNClient_UpdateChannel_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockLNClient_UpdateChannel_Call) RunAndReturn(run func(ctx context.Context, updateChannelRequest *lnclient.UpdateChannelRequest) error) *MockLNClient_UpdateChannel_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateLastWalletSyncRequest provides a mock function for the type MockLNClient
func (_mock *MockLNClient) UpdateLastWalletSyncRequest() {
	_mock.Called()
	return
}

// MockLNClient_UpdateLastWalletSyncRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateLastWalletSyncRequest'
type MockLNClient_UpdateLastWalletSyncRequest_Call struct {
	*mock.Call
}

// UpdateLastWalletSyncRequest is a helper method to define mock.On call
func (_e *MockLNClient_Expecter) UpdateLastWalletSyncRequest() *MockLNClient_UpdateLastWalletSyncRequest_Call {
	return &MockLNClient_UpdateLastWalletSyncRequest_Call{Call: _e.mock.On("UpdateLastWalletSyncRequest")}
}

func (_c *MockLNClient_UpdateLastWalletSyncRequest_Call) Run(run func()) *MockLNClient_UpdateLastWalletSyncRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLNClient_UpdateLastWalletSyncRequest_Call) Return() *MockLNClient_UpdateLastWalletSyncRequest_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLNClient_UpdateLastWalletSyncRequest_Call) RunAndReturn(run func()) *MockLNClient_UpdateLastWalletSyncRequest_Call {
	_c.Run(run)
	return _c
}