lightning_rpc_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: lnd/lnrpc/lightning_grpc.pb.go
//
// Generated by this command:
//
//	mockgen -destination lightning_rpc_mock.go -source lnd/lnrpc/lightning_grpc.pb.go -package main
//

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

import (
	context "context"
	reflect "reflect"

	lnrpc "github.com/lightningnetwork/lnd/lnrpc"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
)

// MockLightningClient is a mock of LightningClient interface.
type MockLightningClient struct {
	ctrl     *gomock.Controller
	recorder *MockLightningClientMockRecorder
}

// MockLightningClientMockRecorder is the mock recorder for MockLightningClient.
type MockLightningClientMockRecorder struct {
	mock *MockLightningClient
}

// NewMockLightningClient creates a new mock instance.
func NewMockLightningClient(ctrl *gomock.Controller) *MockLightningClient {
	mock := &MockLightningClient{ctrl: ctrl}
	mock.recorder = &MockLightningClientMockRecorder{mock}
	return mock
}

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

// AbandonChannel mocks base method.
func (m *MockLightningClient) AbandonChannel(ctx context.Context, in *lnrpc.AbandonChannelRequest, opts ...grpc.CallOption) (*lnrpc.AbandonChannelResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AbandonChannel", varargs...)
	ret0, _ := ret[0].(*lnrpc.AbandonChannelResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddInvoice mocks base method.
func (m *MockLightningClient) AddInvoice(ctx context.Context, in *lnrpc.Invoice, opts ...grpc.CallOption) (*lnrpc.AddInvoiceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddInvoice", varargs...)
	ret0, _ := ret[0].(*lnrpc.AddInvoiceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BakeMacaroon mocks base method.
func (m *MockLightningClient) BakeMacaroon(ctx context.Context, in *lnrpc.BakeMacaroonRequest, opts ...grpc.CallOption) (*lnrpc.BakeMacaroonResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BakeMacaroon", varargs...)
	ret0, _ := ret[0].(*lnrpc.BakeMacaroonResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BatchOpenChannel mocks base method.
func (m *MockLightningClient) BatchOpenChannel(ctx context.Context, in *lnrpc.BatchOpenChannelRequest, opts ...grpc.CallOption) (*lnrpc.BatchOpenChannelResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchOpenChannel", varargs...)
	ret0, _ := ret[0].(*lnrpc.BatchOpenChannelResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ChannelAcceptor mocks base method.
func (m *MockLightningClient) ChannelAcceptor(ctx context.Context, opts ...grpc.CallOption) (lnrpc.Lightning_ChannelAcceptorClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChannelAcceptor", varargs...)
	ret0, _ := ret[0].(lnrpc.Lightning_ChannelAcceptorClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ChannelBalance mocks base method.
func (m *MockLightningClient) ChannelBalance(ctx context.Context, in *lnrpc.ChannelBalanceRequest, opts ...grpc.CallOption) (*lnrpc.ChannelBalanceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChannelBalance", varargs...)
	ret0, _ := ret[0].(*lnrpc.ChannelBalanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CheckMacaroonPermissions mocks base method.
func (m *MockLightningClient) CheckMacaroonPermissions(ctx context.Context, in *lnrpc.CheckMacPermRequest, opts ...grpc.CallOption) (*lnrpc.CheckMacPermResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CheckMacaroonPermissions", varargs...)
	ret0, _ := ret[0].(*lnrpc.CheckMacPermResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CloseChannel mocks base method.
func (m *MockLightningClient) CloseChannel(ctx context.Context, in *lnrpc.CloseChannelRequest, opts ...grpc.CallOption) (lnrpc.Lightning_CloseChannelClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CloseChannel", varargs...)
	ret0, _ := ret[0].(lnrpc.Lightning_CloseChannelClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ClosedChannels mocks base method.
func (m *MockLightningClient) ClosedChannels(ctx context.Context, in *lnrpc.ClosedChannelsRequest, opts ...grpc.CallOption) (*lnrpc.ClosedChannelsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ClosedChannels", varargs...)
	ret0, _ := ret[0].(*lnrpc.ClosedChannelsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ConnectPeer mocks base method.
func (m *MockLightningClient) ConnectPeer(ctx context.Context, in *lnrpc.ConnectPeerRequest, opts ...grpc.CallOption) (*lnrpc.ConnectPeerResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ConnectPeer", varargs...)
	ret0, _ := ret[0].(*lnrpc.ConnectPeerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DebugLevel mocks base method.
func (m *MockLightningClient) DebugLevel(ctx context.Context, in *lnrpc.DebugLevelRequest, opts ...grpc.CallOption) (*lnrpc.DebugLevelResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DebugLevel", varargs...)
	ret0, _ := ret[0].(*lnrpc.DebugLevelResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DecodePayReq mocks base method.
func (m *MockLightningClient) DecodePayReq(ctx context.Context, in *lnrpc.PayReqString, opts ...grpc.CallOption) (*lnrpc.PayReq, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DecodePayReq", varargs...)
	ret0, _ := ret[0].(*lnrpc.PayReq)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAllPayments mocks base method.
func (m *MockLightningClient) DeleteAllPayments(ctx context.Context, in *lnrpc.DeleteAllPaymentsRequest, opts ...grpc.CallOption) (*lnrpc.DeleteAllPaymentsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAllPayments", varargs...)
	ret0, _ := ret[0].(*lnrpc.DeleteAllPaymentsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteMacaroonID mocks base method.
func (m *MockLightningClient) DeleteMacaroonID(ctx context.Context, in *lnrpc.DeleteMacaroonIDRequest, opts ...grpc.CallOption) (*lnrpc.DeleteMacaroonIDResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMacaroonID", varargs...)
	ret0, _ := ret[0].(*lnrpc.DeleteMacaroonIDResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePayment mocks base method.
func (m *MockLightningClient) DeletePayment(ctx context.Context, in *lnrpc.DeletePaymentRequest, opts ...grpc.CallOption) (*lnrpc.DeletePaymentResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePayment", varargs...)
	ret0, _ := ret[0].(*lnrpc.DeletePaymentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeGraph mocks base method.
func (m *MockLightningClient) DescribeGraph(ctx context.Context, in *lnrpc.ChannelGraphRequest, opts ...grpc.CallOption) (*lnrpc.ChannelGraph, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGraph", varargs...)
	ret0, _ := ret[0].(*lnrpc.ChannelGraph)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisconnectPeer mocks base method.
func (m *MockLightningClient) DisconnectPeer(ctx context.Context, in *lnrpc.DisconnectPeerRequest, opts ...grpc.CallOption) (*lnrpc.DisconnectPeerResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisconnectPeer", varargs...)
	ret0, _ := ret[0].(*lnrpc.DisconnectPeerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EstimateFee mocks base method.
func (m *MockLightningClient) EstimateFee(ctx context.Context, in *lnrpc.EstimateFeeRequest, opts ...grpc.CallOption) (*lnrpc.EstimateFeeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EstimateFee", varargs...)
	ret0, _ := ret[0].(*lnrpc.EstimateFeeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExportAllChannelBackups mocks base method.
func (m *MockLightningClient) ExportAllChannelBackups(ctx context.Context, in *lnrpc.ChanBackupExportRequest, opts ...grpc.CallOption) (*lnrpc.ChanBackupSnapshot, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExportAllChannelBackups", varargs...)
	ret0, _ := ret[0].(*lnrpc.ChanBackupSnapshot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExportChannelBackup mocks base method.
func (m *MockLightningClient) ExportChannelBackup(ctx context.Context, in *lnrpc.ExportChannelBackupRequest, opts ...grpc.CallOption) (*lnrpc.ChannelBackup, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExportChannelBackup", varargs...)
	ret0, _ := ret[0].(*lnrpc.ChannelBackup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// FeeReport mocks base method.
func (m *MockLightningClient) FeeReport(ctx context.Context, in *lnrpc.FeeReportRequest, opts ...grpc.CallOption) (*lnrpc.FeeReportResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FeeReport", varargs...)
	ret0, _ := ret[0].(*lnrpc.FeeReportResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ForwardingHistory mocks base method.
func (m *MockLightningClient) ForwardingHistory(ctx context.Context, in *lnrpc.ForwardingHistoryRequest, opts ...grpc.CallOption) (*lnrpc.ForwardingHistoryResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ForwardingHistory", varargs...)
	ret0, _ := ret[0].(*lnrpc.ForwardingHistoryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// FundingStateStep mocks base method.
func (m *MockLightningClient) FundingStateStep(ctx context.Context, in *lnrpc.FundingTransitionMsg, opts ...grpc.CallOption) (*lnrpc.FundingStateStepResp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FundingStateStep", varargs...)
	ret0, _ := ret[0].(*lnrpc.FundingStateStepResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChanInfo mocks base method.
func (m *MockLightningClient) GetChanInfo(ctx context.Context, in *lnrpc.ChanInfoRequest, opts ...grpc.CallOption) (*lnrpc.ChannelEdge, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetChanInfo", varargs...)
	ret0, _ := ret[0].(*lnrpc.ChannelEdge)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetInfo mocks base method.
func (m *MockLightningClient) GetInfo(ctx context.Context, in *lnrpc.GetInfoRequest, opts ...grpc.CallOption) (*lnrpc.GetInfoResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInfo", varargs...)
	ret0, _ := ret[0].(*lnrpc.GetInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkInfo mocks base method.
func (m *MockLightningClient) GetNetworkInfo(ctx context.Context, in *lnrpc.NetworkInfoRequest, opts ...grpc.CallOption) (*lnrpc.NetworkInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNetworkInfo", varargs...)
	ret0, _ := ret[0].(*lnrpc.NetworkInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNodeInfo mocks base method.
func (m *MockLightningClient) GetNodeInfo(ctx context.Context, in *lnrpc.NodeInfoRequest, opts ...grpc.CallOption) (*lnrpc.NodeInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNodeInfo", varargs...)
	ret0, _ := ret[0].(*lnrpc.NodeInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNodeMetrics mocks base method.
func (m *MockLightningClient) GetNodeMetrics(ctx context.Context, in *lnrpc.NodeMetricsRequest, opts ...grpc.CallOption) (*lnrpc.NodeMetricsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNodeMetrics", varargs...)
	ret0, _ := ret[0].(*lnrpc.NodeMetricsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRecoveryInfo mocks base method.
func (m *MockLightningClient) GetRecoveryInfo(ctx context.Context, in *lnrpc.GetRecoveryInfoRequest, opts ...grpc.CallOption) (*lnrpc.GetRecoveryInfoResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRecoveryInfo", varargs...)
	ret0, _ := ret[0].(*lnrpc.GetRecoveryInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTransactions mocks base method.
func (m *MockLightningClient) GetTransactions(ctx context.Context, in *lnrpc.GetTransactionsRequest, opts ...grpc.CallOption) (*lnrpc.TransactionDetails, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransactions", varargs...)
	ret0, _ := ret[0].(*lnrpc.TransactionDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAliases mocks base method.
func (m *MockLightningClient) ListAliases(ctx context.Context, in *lnrpc.ListAliasesRequest, opts ...grpc.CallOption) (*lnrpc.ListAliasesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAliases", varargs...)
	ret0, _ := ret[0].(*lnrpc.ListAliasesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListChannels mocks base method.
func (m *MockLightningClient) ListChannels(ctx context.Context, in *lnrpc.ListChannelsRequest, opts ...grpc.CallOption) (*lnrpc.ListChannelsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListChannels", varargs...)
	ret0, _ := ret[0].(*lnrpc.ListChannelsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListInvoices mocks base method.
func (m *MockLightningClient) ListInvoices(ctx context.Context, in *lnrpc.ListInvoiceRequest, opts ...grpc.CallOption) (*lnrpc.ListInvoiceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListInvoices", varargs...)
	ret0, _ := ret[0].(*lnrpc.ListInvoiceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListMacaroonIDs mocks base method.
func (m *MockLightningClient) ListMacaroonIDs(ctx context.Context, in *lnrpc.ListMacaroonIDsRequest, opts ...grpc.CallOption) (*lnrpc.ListMacaroonIDsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMacaroonIDs", varargs...)
	ret0, _ := ret[0].(*lnrpc.ListMacaroonIDsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPayments mocks base method.
func (m *MockLightningClient) ListPayments(ctx context.Context, in *lnrpc.ListPaymentsRequest, opts ...grpc.CallOption) (*lnrpc.ListPaymentsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPayments", varargs...)
	ret0, _ := ret[0].(*lnrpc.ListPaymentsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPeers mocks base method.
func (m *MockLightningClient) ListPeers(ctx context.Context, in *lnrpc.ListPeersRequest, opts ...grpc.CallOption) (*lnrpc.ListPeersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPeers", varargs...)
	ret0, _ := ret[0].(*lnrpc.ListPeersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPermissions mocks base method.
func (m *MockLightningClient) ListPermissions(ctx context.Context, in *lnrpc.ListPermissionsRequest, opts ...grpc.CallOption) (*lnrpc.ListPermissionsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPermissions", varargs...)
	ret0, _ := ret[0].(*lnrpc.ListPermissionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListUnspent mocks base method.
func (m *MockLightningClient) ListUnspent(ctx context.Context, in *lnrpc.ListUnspentRequest, opts ...grpc.CallOption) (*lnrpc.ListUnspentResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUnspent", varargs...)
	ret0, _ := ret[0].(*lnrpc.ListUnspentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LookupHtlcResolution mocks base method.
func (m *MockLightningClient) LookupHtlcResolution(ctx context.Context, in *lnrpc.LookupHtlcResolutionRequest, opts ...grpc.CallOption) (*lnrpc.LookupHtlcResolutionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LookupHtlcResolution", varargs...)
	ret0, _ := ret[0].(*lnrpc.LookupHtlcResolutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LookupInvoice mocks base method.
func (m *MockLightningClient) LookupInvoice(ctx context.Context, in *lnrpc.PaymentHash, opts ...grpc.CallOption) (*lnrpc.Invoice, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LookupInvoice", varargs...)
	ret0, _ := ret[0].(*lnrpc.Invoice)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewAddress mocks base method.
func (m *MockLightningClient) NewAddress(ctx context.Context, in *lnrpc.NewAddressRequest, opts ...grpc.CallOption) (*lnrpc.NewAddressResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NewAddress", varargs...)
	ret0, _ := ret[0].(*lnrpc.NewAddressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// OpenChannel mocks base method.
func (m *MockLightningClient) OpenChannel(ctx context.Context, in *lnrpc.OpenChannelRequest, opts ...grpc.CallOption) (lnrpc.Lightning_OpenChannelClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OpenChannel", varargs...)
	ret0, _ := ret[0].(lnrpc.Lightning_OpenChannelClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// OpenChannelSync mocks base method.
func (m *MockLightningClient) OpenChannelSync(ctx context.Context, in *lnrpc.OpenChannelRequest, opts ...grpc.CallOption) (*lnrpc.ChannelPoint, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OpenChannelSync", varargs...)
	ret0, _ := ret[0].(*lnrpc.ChannelPoint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PendingChannels mocks base method.
func (m *MockLightningClient) PendingChannels(ctx context.Context, in *lnrpc.PendingChannelsRequest, opts ...grpc.CallOption) (*lnrpc.PendingChannelsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PendingChannels", varargs...)
	ret0, _ := ret[0].(*lnrpc.PendingChannelsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryRoutes mocks base method.
func (m *MockLightningClient) QueryRoutes(ctx context.Context, in *lnrpc.QueryRoutesRequest, opts ...grpc.CallOption) (*lnrpc.QueryRoutesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryRoutes", varargs...)
	ret0, _ := ret[0].(*lnrpc.QueryRoutesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterRPCMiddleware mocks base method.
func (m *MockLightningClient) RegisterRPCMiddleware(ctx context.Context, opts ...grpc.CallOption) (lnrpc.Lightning_RegisterRPCMiddlewareClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterRPCMiddleware", varargs...)
	ret0, _ := ret[0].(lnrpc.Lightning_RegisterRPCMiddlewareClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RestoreChannelBackups mocks base method.
func (m *MockLightningClient) RestoreChannelBackups(ctx context.Context, in *lnrpc.RestoreChanBackupRequest, opts ...grpc.CallOption) (*lnrpc.RestoreBackupResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestoreChannelBackups", varargs...)
	ret0, _ := ret[0].(*lnrpc.RestoreBackupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SendCoins mocks base method.
func (m *MockLightningClient) SendCoins(ctx context.Context, in *lnrpc.SendCoinsRequest, opts ...grpc.CallOption) (*lnrpc.SendCoinsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendCoins", varargs...)
	ret0, _ := ret[0].(*lnrpc.SendCoinsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SendCustomMessage mocks base method.
func (m *MockLightningClient) SendCustomMessage(ctx context.Context, in *lnrpc.SendCustomMessageRequest, opts ...grpc.CallOption) (*lnrpc.SendCustomMessageResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendCustomMessage", varargs...)
	ret0, _ := ret[0].(*lnrpc.SendCustomMessageResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SendMany mocks base method.
func (m *MockLightningClient) SendMany(ctx context.Context, in *lnrpc.SendManyRequest, opts ...grpc.CallOption) (*lnrpc.SendManyResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendMany", varargs...)
	ret0, _ := ret[0].(*lnrpc.SendManyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SendPayment mocks base method.
func (m *MockLightningClient) SendPayment(ctx context.Context, opts ...grpc.CallOption) (lnrpc.Lightning_SendPaymentClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendPayment", varargs...)
	ret0, _ := ret[0].(lnrpc.Lightning_SendPaymentClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SendPaymentSync mocks base method.
func (m *MockLightningClient) SendPaymentSync(ctx context.Context, in *lnrpc.SendRequest, opts ...grpc.CallOption) (*lnrpc.SendResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendPaymentSync", varargs...)
	ret0, _ := ret[0].(*lnrpc.SendResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SendToRoute mocks base method.
func (m *MockLightningClient) SendToRoute(ctx context.Context, opts ...grpc.CallOption) (lnrpc.Lightning_SendToRouteClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendToRoute", varargs...)
	ret0, _ := ret[0].(lnrpc.Lightning_SendToRouteClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SendToRouteSync mocks base method.
func (m *MockLightningClient) SendToRouteSync(ctx context.Context, in *lnrpc.SendToRouteRequest, opts ...grpc.CallOption) (*lnrpc.SendResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendToRouteSync", varargs...)
	ret0, _ := ret[0].(*lnrpc.SendResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SignMessage mocks base method.
func (m *MockLightningClient) SignMessage(ctx context.Context, in *lnrpc.SignMessageRequest, opts ...grpc.CallOption) (*lnrpc.SignMessageResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SignMessage", varargs...)
	ret0, _ := ret[0].(*lnrpc.SignMessageResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopDaemon mocks base method.
func (m *MockLightningClient) StopDaemon(ctx context.Context, in *lnrpc.StopRequest, opts ...grpc.CallOption) (*lnrpc.StopResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopDaemon", varargs...)
	ret0, _ := ret[0].(*lnrpc.StopResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SubscribeChannelBackups mocks base method.
func (m *MockLightningClient) SubscribeChannelBackups(ctx context.Context, in *lnrpc.ChannelBackupSubscription, opts ...grpc.CallOption) (lnrpc.Lightning_SubscribeChannelBackupsClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubscribeChannelBackups", varargs...)
	ret0, _ := ret[0].(lnrpc.Lightning_SubscribeChannelBackupsClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SubscribeChannelEvents mocks base method.
func (m *MockLightningClient) SubscribeChannelEvents(ctx context.Context, in *lnrpc.ChannelEventSubscription, opts ...grpc.CallOption) (lnrpc.Lightning_SubscribeChannelEventsClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubscribeChannelEvents", varargs...)
	ret0, _ := ret[0].(lnrpc.Lightning_SubscribeChannelEventsClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SubscribeChannelGraph mocks base method.
func (m *MockLightningClient) SubscribeChannelGraph(ctx context.Context, in *lnrpc.GraphTopologySubscription, opts ...grpc.CallOption) (lnrpc.Lightning_SubscribeChannelGraphClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubscribeChannelGraph", varargs...)
	ret0, _ := ret[0].(lnrpc.Lightning_SubscribeChannelGraphClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SubscribeCustomMessages mocks base method.
func (m *MockLightningClient) SubscribeCustomMessages(ctx context.Context, in *lnrpc.SubscribeCustomMessagesRequest, opts ...grpc.CallOption) (lnrpc.Lightning_SubscribeCustomMessagesClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubscribeCustomMessages", varargs...)
	ret0, _ := ret[0].(lnrpc.Lightning_SubscribeCustomMessagesClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SubscribeInvoices mocks base method.
func (m *MockLightningClient) SubscribeInvoices(ctx context.Context, in *lnrpc.InvoiceSubscription, opts ...grpc.CallOption) (lnrpc.Lightning_SubscribeInvoicesClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubscribeInvoices", varargs...)
	ret0, _ := ret[0].(lnrpc.Lightning_SubscribeInvoicesClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SubscribePeerEvents mocks base method.
func (m *MockLightningClient) SubscribePeerEvents(ctx context.Context, in *lnrpc.PeerEventSubscription, opts ...grpc.CallOption) (lnrpc.Lightning_SubscribePeerEventsClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubscribePeerEvents", varargs...)
	ret0, _ := ret[0].(lnrpc.Lightning_SubscribePeerEventsClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SubscribeTransactions mocks base method.
func (m *MockLightningClient) SubscribeTransactions(ctx context.Context, in *lnrpc.GetTransactionsRequest, opts ...grpc.CallOption) (lnrpc.Lightning_SubscribeTransactionsClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubscribeTransactions", varargs...)
	ret0, _ := ret[0].(lnrpc.Lightning_SubscribeTransactionsClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateChannelPolicy mocks base method.
func (m *MockLightningClient) UpdateChannelPolicy(ctx context.Context, in *lnrpc.PolicyUpdateRequest, opts ...grpc.CallOption) (*lnrpc.PolicyUpdateResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateChannelPolicy", varargs...)
	ret0, _ := ret[0].(*lnrpc.PolicyUpdateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// VerifyChanBackup mocks base method.
func (m *MockLightningClient) VerifyChanBackup(ctx context.Context, in *lnrpc.ChanBackupSnapshot, opts ...grpc.CallOption) (*lnrpc.VerifyChanBackupResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyChanBackup", varargs...)
	ret0, _ := ret[0].(*lnrpc.VerifyChanBackupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// VerifyMessage mocks base method.
func (m *MockLightningClient) VerifyMessage(ctx context.Context, in *lnrpc.VerifyMessageRequest, opts ...grpc.CallOption) (*lnrpc.VerifyMessageResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyMessage", varargs...)
	ret0, _ := ret[0].(*lnrpc.VerifyMessageResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// WalletBalance mocks base method.
func (m *MockLightningClient) WalletBalance(ctx context.Context, in *lnrpc.WalletBalanceRequest, opts ...grpc.CallOption) (*lnrpc.WalletBalanceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WalletBalance", varargs...)
	ret0, _ := ret[0].(*lnrpc.WalletBalanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockLightning_SubscribeTransactionsClient is a mock of Lightning_SubscribeTransactionsClient interface.
type MockLightning_SubscribeTransactionsClient struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SubscribeTransactionsClientMockRecorder
}

// MockLightning_SubscribeTransactionsClientMockRecorder is the mock recorder for MockLightning_SubscribeTransactionsClient.
type MockLightning_SubscribeTransactionsClientMockRecorder struct {
	mock *MockLightning_SubscribeTransactionsClient
}

// NewMockLightning_SubscribeTransactionsClient creates a new mock instance.
func NewMockLightning_SubscribeTransactionsClient(ctrl *gomock.Controller) *MockLightning_SubscribeTransactionsClient {
	mock := &MockLightning_SubscribeTransactionsClient{ctrl: ctrl}
	mock.recorder = &MockLightning_SubscribeTransactionsClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLightning_SubscribeTransactionsClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLightning_SubscribeTransactionsClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLightning_SubscribeTransactionsClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLightning_SubscribeTransactionsClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SubscribeTransactionsClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SubscribeTransactionsClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLightning_SubscribeTransactionsClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLightning_SubscribeTransactionsClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLightning_SubscribeTransactionsClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLightning_SubscribeTransactionsClient) Recv() (*lnrpc.Transaction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.Transaction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_SubscribeTransactionsClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_SubscribeTransactionsClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SubscribeTransactionsClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SubscribeTransactionsClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SubscribeTransactionsClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SubscribeTransactionsClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SubscribeTransactionsClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SubscribeTransactionsClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockLightning_SubscribeTransactionsClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLightning_SubscribeTransactionsClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLightning_SubscribeTransactionsClient)(nil).Trailer))
}

// MockLightning_SubscribePeerEventsClient is a mock of Lightning_SubscribePeerEventsClient interface.
type MockLightning_SubscribePeerEventsClient struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SubscribePeerEventsClientMockRecorder
}

// MockLightning_SubscribePeerEventsClientMockRecorder is the mock recorder for MockLightning_SubscribePeerEventsClient.
type MockLightning_SubscribePeerEventsClientMockRecorder struct {
	mock *MockLightning_SubscribePeerEventsClient
}

// NewMockLightning_SubscribePeerEventsClient creates a new mock instance.
func NewMockLightning_SubscribePeerEventsClient(ctrl *gomock.Controller) *MockLightning_SubscribePeerEventsClient {
	mock := &MockLightning_SubscribePeerEventsClient{ctrl: ctrl}
	mock.recorder = &MockLightning_SubscribePeerEventsClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLightning_SubscribePeerEventsClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLightning_SubscribePeerEventsClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLightning_SubscribePeerEventsClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLightning_SubscribePeerEventsClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SubscribePeerEventsClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SubscribePeerEventsClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLightning_SubscribePeerEventsClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLightning_SubscribePeerEventsClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLightning_SubscribePeerEventsClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLightning_SubscribePeerEventsClient) Recv() (*lnrpc.PeerEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.PeerEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_SubscribePeerEventsClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_SubscribePeerEventsClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SubscribePeerEventsClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SubscribePeerEventsClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SubscribePeerEventsClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SubscribePeerEventsClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SubscribePeerEventsClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SubscribePeerEventsClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockLightning_SubscribePeerEventsClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLightning_SubscribePeerEventsClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLightning_SubscribePeerEventsClient)(nil).Trailer))
}

// MockLightning_SubscribeChannelEventsClient is a mock of Lightning_SubscribeChannelEventsClient interface.
type MockLightning_SubscribeChannelEventsClient struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SubscribeChannelEventsClientMockRecorder
}

// MockLightning_SubscribeChannelEventsClientMockRecorder is the mock recorder for MockLightning_SubscribeChannelEventsClient.
type MockLightning_SubscribeChannelEventsClientMockRecorder struct {
	mock *MockLightning_SubscribeChannelEventsClient
}

// NewMockLightning_SubscribeChannelEventsClient creates a new mock instance.
func NewMockLightning_SubscribeChannelEventsClient(ctrl *gomock.Controller) *MockLightning_SubscribeChannelEventsClient {
	mock := &MockLightning_SubscribeChannelEventsClient{ctrl: ctrl}
	mock.recorder = &MockLightning_SubscribeChannelEventsClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLightning_SubscribeChannelEventsClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLightning_SubscribeChannelEventsClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLightning_SubscribeChannelEventsClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLightning_SubscribeChannelEventsClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SubscribeChannelEventsClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SubscribeChannelEventsClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLightning_SubscribeChannelEventsClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLightning_SubscribeChannelEventsClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLightning_SubscribeChannelEventsClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLightning_SubscribeChannelEventsClient) Recv() (*lnrpc.ChannelEventUpdate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.ChannelEventUpdate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_SubscribeChannelEventsClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_SubscribeChannelEventsClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SubscribeChannelEventsClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SubscribeChannelEventsClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SubscribeChannelEventsClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SubscribeChannelEventsClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SubscribeChannelEventsClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SubscribeChannelEventsClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockLightning_SubscribeChannelEventsClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLightning_SubscribeChannelEventsClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLightning_SubscribeChannelEventsClient)(nil).Trailer))
}

// MockLightning_OpenChannelClient is a mock of Lightning_OpenChannelClient interface.
type MockLightning_OpenChannelClient struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_OpenChannelClientMockRecorder
}

// MockLightning_OpenChannelClientMockRecorder is the mock recorder for MockLightning_OpenChannelClient.
type MockLightning_OpenChannelClientMockRecorder struct {
	mock *MockLightning_OpenChannelClient
}

// NewMockLightning_OpenChannelClient creates a new mock instance.
func NewMockLightning_OpenChannelClient(ctrl *gomock.Controller) *MockLightning_OpenChannelClient {
	mock := &MockLightning_OpenChannelClient{ctrl: ctrl}
	mock.recorder = &MockLightning_OpenChannelClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLightning_OpenChannelClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLightning_OpenChannelClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLightning_OpenChannelClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLightning_OpenChannelClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_OpenChannelClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_OpenChannelClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLightning_OpenChannelClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLightning_OpenChannelClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLightning_OpenChannelClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLightning_OpenChannelClient) Recv() (*lnrpc.OpenStatusUpdate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.OpenStatusUpdate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_OpenChannelClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_OpenChannelClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_OpenChannelClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_OpenChannelClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_OpenChannelClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_OpenChannelClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_OpenChannelClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_OpenChannelClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockLightning_OpenChannelClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLightning_OpenChannelClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLightning_OpenChannelClient)(nil).Trailer))
}

// MockLightning_ChannelAcceptorClient is a mock of Lightning_ChannelAcceptorClient interface.
type MockLightning_ChannelAcceptorClient struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_ChannelAcceptorClientMockRecorder
}

// MockLightning_ChannelAcceptorClientMockRecorder is the mock recorder for MockLightning_ChannelAcceptorClient.
type MockLightning_ChannelAcceptorClientMockRecorder struct {
	mock *MockLightning_ChannelAcceptorClient
}

// NewMockLightning_ChannelAcceptorClient creates a new mock instance.
func NewMockLightning_ChannelAcceptorClient(ctrl *gomock.Controller) *MockLightning_ChannelAcceptorClient {
	mock := &MockLightning_ChannelAcceptorClient{ctrl: ctrl}
	mock.recorder = &MockLightning_ChannelAcceptorClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLightning_ChannelAcceptorClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLightning_ChannelAcceptorClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLightning_ChannelAcceptorClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLightning_ChannelAcceptorClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_ChannelAcceptorClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_ChannelAcceptorClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLightning_ChannelAcceptorClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLightning_ChannelAcceptorClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLightning_ChannelAcceptorClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLightning_ChannelAcceptorClient) Recv() (*lnrpc.ChannelAcceptRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.ChannelAcceptRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_ChannelAcceptorClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_ChannelAcceptorClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_ChannelAcceptorClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_ChannelAcceptorClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_ChannelAcceptorClient)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_ChannelAcceptorClient) Send(arg0 *lnrpc.ChannelAcceptResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_ChannelAcceptorClientMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_ChannelAcceptorClient)(nil).Send), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_ChannelAcceptorClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_ChannelAcceptorClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_ChannelAcceptorClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockLightning_ChannelAcceptorClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLightning_ChannelAcceptorClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLightning_ChannelAcceptorClient)(nil).Trailer))
}

// MockLightning_CloseChannelClient is a mock of Lightning_CloseChannelClient interface.
type MockLightning_CloseChannelClient struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_CloseChannelClientMockRecorder
}

// MockLightning_CloseChannelClientMockRecorder is the mock recorder for MockLightning_CloseChannelClient.
type MockLightning_CloseChannelClientMockRecorder struct {
	mock *MockLightning_CloseChannelClient
}

// NewMockLightning_CloseChannelClient creates a new mock instance.
func NewMockLightning_CloseChannelClient(ctrl *gomock.Controller) *MockLightning_CloseChannelClient {
	mock := &MockLightning_CloseChannelClient{ctrl: ctrl}
	mock.recorder = &MockLightning_CloseChannelClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLightning_CloseChannelClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLightning_CloseChannelClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLightning_CloseChannelClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLightning_CloseChannelClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_CloseChannelClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_CloseChannelClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLightning_CloseChannelClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLightning_CloseChannelClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLightning_CloseChannelClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLightning_CloseChannelClient) Recv() (*lnrpc.CloseStatusUpdate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.CloseStatusUpdate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_CloseChannelClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_CloseChannelClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_CloseChannelClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_CloseChannelClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_CloseChannelClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_CloseChannelClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_CloseChannelClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_CloseChannelClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockLightning_CloseChannelClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLightning_CloseChannelClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLightning_CloseChannelClient)(nil).Trailer))
}

// MockLightning_SendPaymentClient is a mock of Lightning_SendPaymentClient interface.
type MockLightning_SendPaymentClient struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SendPaymentClientMockRecorder
}

// MockLightning_SendPaymentClientMockRecorder is the mock recorder for MockLightning_SendPaymentClient.
type MockLightning_SendPaymentClientMockRecorder struct {
	mock *MockLightning_SendPaymentClient
}

// NewMockLightning_SendPaymentClient creates a new mock instance.
func NewMockLightning_SendPaymentClient(ctrl *gomock.Controller) *MockLightning_SendPaymentClient {
	mock := &MockLightning_SendPaymentClient{ctrl: ctrl}
	mock.recorder = &MockLightning_SendPaymentClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLightning_SendPaymentClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLightning_SendPaymentClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLightning_SendPaymentClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLightning_SendPaymentClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SendPaymentClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SendPaymentClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLightning_SendPaymentClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLightning_SendPaymentClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLightning_SendPaymentClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLightning_SendPaymentClient) Recv() (*lnrpc.SendResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.SendResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_SendPaymentClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_SendPaymentClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SendPaymentClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SendPaymentClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SendPaymentClient)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_SendPaymentClient) Send(arg0 *lnrpc.SendRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_SendPaymentClientMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_SendPaymentClient)(nil).Send), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SendPaymentClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SendPaymentClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SendPaymentClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockLightning_SendPaymentClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLightning_SendPaymentClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLightning_SendPaymentClient)(nil).Trailer))
}

// MockLightning_SendToRouteClient is a mock of Lightning_SendToRouteClient interface.
type MockLightning_SendToRouteClient struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SendToRouteClientMockRecorder
}

// MockLightning_SendToRouteClientMockRecorder is the mock recorder for MockLightning_SendToRouteClient.
type MockLightning_SendToRouteClientMockRecorder struct {
	mock *MockLightning_SendToRouteClient
}

// NewMockLightning_SendToRouteClient creates a new mock instance.
func NewMockLightning_SendToRouteClient(ctrl *gomock.Controller) *MockLightning_SendToRouteClient {
	mock := &MockLightning_SendToRouteClient{ctrl: ctrl}
	mock.recorder = &MockLightning_SendToRouteClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLightning_SendToRouteClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLightning_SendToRouteClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLightning_SendToRouteClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLightning_SendToRouteClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SendToRouteClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SendToRouteClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLightning_SendToRouteClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLightning_SendToRouteClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLightning_SendToRouteClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLightning_SendToRouteClient) Recv() (*lnrpc.SendResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.SendResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_SendToRouteClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_SendToRouteClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SendToRouteClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SendToRouteClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SendToRouteClient)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_SendToRouteClient) Send(arg0 *lnrpc.SendToRouteRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_SendToRouteClientMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_SendToRouteClient)(nil).Send), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SendToRouteClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SendToRouteClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SendToRouteClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockLightning_SendToRouteClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLightning_SendToRouteClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLightning_SendToRouteClient)(nil).Trailer))
}

// MockLightning_SubscribeInvoicesClient is a mock of Lightning_SubscribeInvoicesClient interface.
type MockLightning_SubscribeInvoicesClient struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SubscribeInvoicesClientMockRecorder
}

// MockLightning_SubscribeInvoicesClientMockRecorder is the mock recorder for MockLightning_SubscribeInvoicesClient.
type MockLightning_SubscribeInvoicesClientMockRecorder struct {
	mock *MockLightning_SubscribeInvoicesClient
}

// NewMockLightning_SubscribeInvoicesClient creates a new mock instance.
func NewMockLightning_SubscribeInvoicesClient(ctrl *gomock.Controller) *MockLightning_SubscribeInvoicesClient {
	mock := &MockLightning_SubscribeInvoicesClient{ctrl: ctrl}
	mock.recorder = &MockLightning_SubscribeInvoicesClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLightning_SubscribeInvoicesClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLightning_SubscribeInvoicesClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLightning_SubscribeInvoicesClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLightning_SubscribeInvoicesClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SubscribeInvoicesClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SubscribeInvoicesClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLightning_SubscribeInvoicesClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLightning_SubscribeInvoicesClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLightning_SubscribeInvoicesClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLightning_SubscribeInvoicesClient) Recv() (*lnrpc.Invoice, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.Invoice)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_SubscribeInvoicesClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_SubscribeInvoicesClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SubscribeInvoicesClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SubscribeInvoicesClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SubscribeInvoicesClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SubscribeInvoicesClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SubscribeInvoicesClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SubscribeInvoicesClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockLightning_SubscribeInvoicesClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLightning_SubscribeInvoicesClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLightning_SubscribeInvoicesClient)(nil).Trailer))
}

// MockLightning_SubscribeChannelGraphClient is a mock of Lightning_SubscribeChannelGraphClient interface.
type MockLightning_SubscribeChannelGraphClient struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SubscribeChannelGraphClientMockRecorder
}

// MockLightning_SubscribeChannelGraphClientMockRecorder is the mock recorder for MockLightning_SubscribeChannelGraphClient.
type MockLightning_SubscribeChannelGraphClientMockRecorder struct {
	mock *MockLightning_SubscribeChannelGraphClient
}

// NewMockLightning_SubscribeChannelGraphClient creates a new mock instance.
func NewMockLightning_SubscribeChannelGraphClient(ctrl *gomock.Controller) *MockLightning_SubscribeChannelGraphClient {
	mock := &MockLightning_SubscribeChannelGraphClient{ctrl: ctrl}
	mock.recorder = &MockLightning_SubscribeChannelGraphClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLightning_SubscribeChannelGraphClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLightning_SubscribeChannelGraphClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLightning_SubscribeChannelGraphClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLightning_SubscribeChannelGraphClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SubscribeChannelGraphClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SubscribeChannelGraphClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLightning_SubscribeChannelGraphClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLightning_SubscribeChannelGraphClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLightning_SubscribeChannelGraphClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLightning_SubscribeChannelGraphClient) Recv() (*lnrpc.GraphTopologyUpdate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.GraphTopologyUpdate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_SubscribeChannelGraphClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_SubscribeChannelGraphClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SubscribeChannelGraphClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SubscribeChannelGraphClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SubscribeChannelGraphClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SubscribeChannelGraphClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SubscribeChannelGraphClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SubscribeChannelGraphClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockLightning_SubscribeChannelGraphClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLightning_SubscribeChannelGraphClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLightning_SubscribeChannelGraphClient)(nil).Trailer))
}

// MockLightning_SubscribeChannelBackupsClient is a mock of Lightning_SubscribeChannelBackupsClient interface.
type MockLightning_SubscribeChannelBackupsClient struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SubscribeChannelBackupsClientMockRecorder
}

// MockLightning_SubscribeChannelBackupsClientMockRecorder is the mock recorder for MockLightning_SubscribeChannelBackupsClient.
type MockLightning_SubscribeChannelBackupsClientMockRecorder struct {
	mock *MockLightning_SubscribeChannelBackupsClient
}

// NewMockLightning_SubscribeChannelBackupsClient creates a new mock instance.
func NewMockLightning_SubscribeChannelBackupsClient(ctrl *gomock.Controller) *MockLightning_SubscribeChannelBackupsClient {
	mock := &MockLightning_SubscribeChannelBackupsClient{ctrl: ctrl}
	mock.recorder = &MockLightning_SubscribeChannelBackupsClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLightning_SubscribeChannelBackupsClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLightning_SubscribeChannelBackupsClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLightning_SubscribeChannelBackupsClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLightning_SubscribeChannelBackupsClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SubscribeChannelBackupsClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SubscribeChannelBackupsClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLightning_SubscribeChannelBackupsClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLightning_SubscribeChannelBackupsClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLightning_SubscribeChannelBackupsClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLightning_SubscribeChannelBackupsClient) Recv() (*lnrpc.ChanBackupSnapshot, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.ChanBackupSnapshot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_SubscribeChannelBackupsClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_SubscribeChannelBackupsClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SubscribeChannelBackupsClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SubscribeChannelBackupsClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SubscribeChannelBackupsClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SubscribeChannelBackupsClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SubscribeChannelBackupsClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SubscribeChannelBackupsClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockLightning_SubscribeChannelBackupsClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLightning_SubscribeChannelBackupsClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLightning_SubscribeChannelBackupsClient)(nil).Trailer))
}

// MockLightning_RegisterRPCMiddlewareClient is a mock of Lightning_RegisterRPCMiddlewareClient interface.
type MockLightning_RegisterRPCMiddlewareClient struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_RegisterRPCMiddlewareClientMockRecorder
}

// MockLightning_RegisterRPCMiddlewareClientMockRecorder is the mock recorder for MockLightning_RegisterRPCMiddlewareClient.
type MockLightning_RegisterRPCMiddlewareClientMockRecorder struct {
	mock *MockLightning_RegisterRPCMiddlewareClient
}

// NewMockLightning_RegisterRPCMiddlewareClient creates a new mock instance.
func NewMockLightning_RegisterRPCMiddlewareClient(ctrl *gomock.Controller) *MockLightning_RegisterRPCMiddlewareClient {
	mock := &MockLightning_RegisterRPCMiddlewareClient{ctrl: ctrl}
	mock.recorder = &MockLightning_RegisterRPCMiddlewareClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLightning_RegisterRPCMiddlewareClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLightning_RegisterRPCMiddlewareClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLightning_RegisterRPCMiddlewareClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_RegisterRPCMiddlewareClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLightning_RegisterRPCMiddlewareClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLightning_RegisterRPCMiddlewareClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLightning_RegisterRPCMiddlewareClient) Recv() (*lnrpc.RPCMiddlewareRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.RPCMiddlewareRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_RegisterRPCMiddlewareClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_RegisterRPCMiddlewareClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_RegisterRPCMiddlewareClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareClient)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_RegisterRPCMiddlewareClient) Send(arg0 *lnrpc.RPCMiddlewareResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_RegisterRPCMiddlewareClientMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareClient)(nil).Send), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_RegisterRPCMiddlewareClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_RegisterRPCMiddlewareClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockLightning_RegisterRPCMiddlewareClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLightning_RegisterRPCMiddlewareClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareClient)(nil).Trailer))
}

// MockLightning_SubscribeCustomMessagesClient is a mock of Lightning_SubscribeCustomMessagesClient interface.
type MockLightning_SubscribeCustomMessagesClient struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SubscribeCustomMessagesClientMockRecorder
}

// MockLightning_SubscribeCustomMessagesClientMockRecorder is the mock recorder for MockLightning_SubscribeCustomMessagesClient.
type MockLightning_SubscribeCustomMessagesClientMockRecorder struct {
	mock *MockLightning_SubscribeCustomMessagesClient
}

// NewMockLightning_SubscribeCustomMessagesClient creates a new mock instance.
func NewMockLightning_SubscribeCustomMessagesClient(ctrl *gomock.Controller) *MockLightning_SubscribeCustomMessagesClient {
	mock := &MockLightning_SubscribeCustomMessagesClient{ctrl: ctrl}
	mock.recorder = &MockLightning_SubscribeCustomMessagesClientMockRecorder{mock}
	return mock
}

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

// CloseSend mocks base method.
func (m *MockLightning_SubscribeCustomMessagesClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockLightning_SubscribeCustomMessagesClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockLightning_SubscribeCustomMessagesClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockLightning_SubscribeCustomMessagesClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SubscribeCustomMessagesClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SubscribeCustomMessagesClient)(nil).Context))
}

// Header mocks base method.
func (m *MockLightning_SubscribeCustomMessagesClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockLightning_SubscribeCustomMessagesClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockLightning_SubscribeCustomMessagesClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockLightning_SubscribeCustomMessagesClient) Recv() (*lnrpc.CustomMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.CustomMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_SubscribeCustomMessagesClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_SubscribeCustomMessagesClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SubscribeCustomMessagesClient) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SubscribeCustomMessagesClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SubscribeCustomMessagesClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SubscribeCustomMessagesClient) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SubscribeCustomMessagesClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SubscribeCustomMessagesClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockLightning_SubscribeCustomMessagesClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockLightning_SubscribeCustomMessagesClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockLightning_SubscribeCustomMessagesClient)(nil).Trailer))
}

// MockLightningServer is a mock of LightningServer interface.
type MockLightningServer struct {
	ctrl     *gomock.Controller
	recorder *MockLightningServerMockRecorder
}

// MockLightningServerMockRecorder is the mock recorder for MockLightningServer.
type MockLightningServerMockRecorder struct {
	mock *MockLightningServer
}

// NewMockLightningServer creates a new mock instance.
func NewMockLightningServer(ctrl *gomock.Controller) *MockLightningServer {
	mock := &MockLightningServer{ctrl: ctrl}
	mock.recorder = &MockLightningServerMockRecorder{mock}
	return mock
}

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

// AbandonChannel mocks base method.
func (m *MockLightningServer) AbandonChannel(arg0 context.Context, arg1 *lnrpc.AbandonChannelRequest) (*lnrpc.AbandonChannelResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AbandonChannel", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.AbandonChannelResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AbandonChannel indicates an expected call of AbandonChannel.
func (mr *MockLightningServerMockRecorder) AbandonChannel(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbandonChannel", reflect.TypeOf((*MockLightningServer)(nil).AbandonChannel), arg0, arg1)
}

// AddInvoice mocks base method.
func (m *MockLightningServer) AddInvoice(arg0 context.Context, arg1 *lnrpc.Invoice) (*lnrpc.AddInvoiceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddInvoice", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.AddInvoiceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddInvoice indicates an expected call of AddInvoice.
func (mr *MockLightningServerMockRecorder) AddInvoice(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddInvoice", reflect.TypeOf((*MockLightningServer)(nil).AddInvoice), arg0, arg1)
}

// BakeMacaroon mocks base method.
func (m *MockLightningServer) BakeMacaroon(arg0 context.Context, arg1 *lnrpc.BakeMacaroonRequest) (*lnrpc.BakeMacaroonResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BakeMacaroon", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.BakeMacaroonResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BakeMacaroon indicates an expected call of BakeMacaroon.
func (mr *MockLightningServerMockRecorder) BakeMacaroon(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BakeMacaroon", reflect.TypeOf((*MockLightningServer)(nil).BakeMacaroon), arg0, arg1)
}

// BatchOpenChannel mocks base method.
func (m *MockLightningServer) BatchOpenChannel(arg0 context.Context, arg1 *lnrpc.BatchOpenChannelRequest) (*lnrpc.BatchOpenChannelResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchOpenChannel", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.BatchOpenChannelResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchOpenChannel indicates an expected call of BatchOpenChannel.
func (mr *MockLightningServerMockRecorder) BatchOpenChannel(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchOpenChannel", reflect.TypeOf((*MockLightningServer)(nil).BatchOpenChannel), arg0, arg1)
}

// ChannelAcceptor mocks base method.
func (m *MockLightningServer) ChannelAcceptor(arg0 lnrpc.Lightning_ChannelAcceptorServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChannelAcceptor", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// ChannelAcceptor indicates an expected call of ChannelAcceptor.
func (mr *MockLightningServerMockRecorder) ChannelAcceptor(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChannelAcceptor", reflect.TypeOf((*MockLightningServer)(nil).ChannelAcceptor), arg0)
}

// ChannelBalance mocks base method.
func (m *MockLightningServer) ChannelBalance(arg0 context.Context, arg1 *lnrpc.ChannelBalanceRequest) (*lnrpc.ChannelBalanceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChannelBalance", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ChannelBalanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChannelBalance indicates an expected call of ChannelBalance.
func (mr *MockLightningServerMockRecorder) ChannelBalance(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChannelBalance", reflect.TypeOf((*MockLightningServer)(nil).ChannelBalance), arg0, arg1)
}

// CheckMacaroonPermissions mocks base method.
func (m *MockLightningServer) CheckMacaroonPermissions(arg0 context.Context, arg1 *lnrpc.CheckMacPermRequest) (*lnrpc.CheckMacPermResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckMacaroonPermissions", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.CheckMacPermResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckMacaroonPermissions indicates an expected call of CheckMacaroonPermissions.
func (mr *MockLightningServerMockRecorder) CheckMacaroonPermissions(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckMacaroonPermissions", reflect.TypeOf((*MockLightningServer)(nil).CheckMacaroonPermissions), arg0, arg1)
}

// CloseChannel mocks base method.
func (m *MockLightningServer) CloseChannel(arg0 *lnrpc.CloseChannelRequest, arg1 lnrpc.Lightning_CloseChannelServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseChannel", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseChannel indicates an expected call of CloseChannel.
func (mr *MockLightningServerMockRecorder) CloseChannel(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseChannel", reflect.TypeOf((*MockLightningServer)(nil).CloseChannel), arg0, arg1)
}

// ClosedChannels mocks base method.
func (m *MockLightningServer) ClosedChannels(arg0 context.Context, arg1 *lnrpc.ClosedChannelsRequest) (*lnrpc.ClosedChannelsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClosedChannels", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ClosedChannelsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ClosedChannels indicates an expected call of ClosedChannels.
func (mr *MockLightningServerMockRecorder) ClosedChannels(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClosedChannels", reflect.TypeOf((*MockLightningServer)(nil).ClosedChannels), arg0, arg1)
}

// ConnectPeer mocks base method.
func (m *MockLightningServer) ConnectPeer(arg0 context.Context, arg1 *lnrpc.ConnectPeerRequest) (*lnrpc.ConnectPeerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConnectPeer", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ConnectPeerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConnectPeer indicates an expected call of ConnectPeer.
func (mr *MockLightningServerMockRecorder) ConnectPeer(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectPeer", reflect.TypeOf((*MockLightningServer)(nil).ConnectPeer), arg0, arg1)
}

// DebugLevel mocks base method.
func (m *MockLightningServer) DebugLevel(arg0 context.Context, arg1 *lnrpc.DebugLevelRequest) (*lnrpc.DebugLevelResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DebugLevel", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.DebugLevelResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DebugLevel indicates an expected call of DebugLevel.
func (mr *MockLightningServerMockRecorder) DebugLevel(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugLevel", reflect.TypeOf((*MockLightningServer)(nil).DebugLevel), arg0, arg1)
}

// DecodePayReq mocks base method.
func (m *MockLightningServer) DecodePayReq(arg0 context.Context, arg1 *lnrpc.PayReqString) (*lnrpc.PayReq, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecodePayReq", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.PayReq)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DecodePayReq indicates an expected call of DecodePayReq.
func (mr *MockLightningServerMockRecorder) DecodePayReq(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodePayReq", reflect.TypeOf((*MockLightningServer)(nil).DecodePayReq), arg0, arg1)
}

// DeleteAllPayments mocks base method.
func (m *MockLightningServer) DeleteAllPayments(arg0 context.Context, arg1 *lnrpc.DeleteAllPaymentsRequest) (*lnrpc.DeleteAllPaymentsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAllPayments", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.DeleteAllPaymentsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAllPayments indicates an expected call of DeleteAllPayments.
func (mr *MockLightningServerMockRecorder) DeleteAllPayments(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllPayments", reflect.TypeOf((*MockLightningServer)(nil).DeleteAllPayments), arg0, arg1)
}

// DeleteMacaroonID mocks base method.
func (m *MockLightningServer) DeleteMacaroonID(arg0 context.Context, arg1 *lnrpc.DeleteMacaroonIDRequest) (*lnrpc.DeleteMacaroonIDResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMacaroonID", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.DeleteMacaroonIDResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMacaroonID indicates an expected call of DeleteMacaroonID.
func (mr *MockLightningServerMockRecorder) DeleteMacaroonID(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMacaroonID", reflect.TypeOf((*MockLightningServer)(nil).DeleteMacaroonID), arg0, arg1)
}

// DeletePayment mocks base method.
func (m *MockLightningServer) DeletePayment(arg0 context.Context, arg1 *lnrpc.DeletePaymentRequest) (*lnrpc.DeletePaymentResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePayment", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.DeletePaymentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePayment indicates an expected call of DeletePayment.
func (mr *MockLightningServerMockRecorder) DeletePayment(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePayment", reflect.TypeOf((*MockLightningServer)(nil).DeletePayment), arg0, arg1)
}

// DescribeGraph mocks base method.
func (m *MockLightningServer) DescribeGraph(arg0 context.Context, arg1 *lnrpc.ChannelGraphRequest) (*lnrpc.ChannelGraph, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGraph", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ChannelGraph)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeGraph indicates an expected call of DescribeGraph.
func (mr *MockLightningServerMockRecorder) DescribeGraph(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGraph", reflect.TypeOf((*MockLightningServer)(nil).DescribeGraph), arg0, arg1)
}

// DisconnectPeer mocks base method.
func (m *MockLightningServer) DisconnectPeer(arg0 context.Context, arg1 *lnrpc.DisconnectPeerRequest) (*lnrpc.DisconnectPeerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisconnectPeer", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.DisconnectPeerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisconnectPeer indicates an expected call of DisconnectPeer.
func (mr *MockLightningServerMockRecorder) DisconnectPeer(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisconnectPeer", reflect.TypeOf((*MockLightningServer)(nil).DisconnectPeer), arg0, arg1)
}

// EstimateFee mocks base method.
func (m *MockLightningServer) EstimateFee(arg0 context.Context, arg1 *lnrpc.EstimateFeeRequest) (*lnrpc.EstimateFeeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EstimateFee", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.EstimateFeeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EstimateFee indicates an expected call of EstimateFee.
func (mr *MockLightningServerMockRecorder) EstimateFee(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateFee", reflect.TypeOf((*MockLightningServer)(nil).EstimateFee), arg0, arg1)
}

// ExportAllChannelBackups mocks base method.
func (m *MockLightningServer) ExportAllChannelBackups(arg0 context.Context, arg1 *lnrpc.ChanBackupExportRequest) (*lnrpc.ChanBackupSnapshot, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportAllChannelBackups", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ChanBackupSnapshot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExportAllChannelBackups indicates an expected call of ExportAllChannelBackups.
func (mr *MockLightningServerMockRecorder) ExportAllChannelBackups(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportAllChannelBackups", reflect.TypeOf((*MockLightningServer)(nil).ExportAllChannelBackups), arg0, arg1)
}

// ExportChannelBackup mocks base method.
func (m *MockLightningServer) ExportChannelBackup(arg0 context.Context, arg1 *lnrpc.ExportChannelBackupRequest) (*lnrpc.ChannelBackup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportChannelBackup", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ChannelBackup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExportChannelBackup indicates an expected call of ExportChannelBackup.
func (mr *MockLightningServerMockRecorder) ExportChannelBackup(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportChannelBackup", reflect.TypeOf((*MockLightningServer)(nil).ExportChannelBackup), arg0, arg1)
}

// FeeReport mocks base method.
func (m *MockLightningServer) FeeReport(arg0 context.Context, arg1 *lnrpc.FeeReportRequest) (*lnrpc.FeeReportResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FeeReport", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.FeeReportResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FeeReport indicates an expected call of FeeReport.
func (mr *MockLightningServerMockRecorder) FeeReport(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeeReport", reflect.TypeOf((*MockLightningServer)(nil).FeeReport), arg0, arg1)
}

// ForwardingHistory mocks base method.
func (m *MockLightningServer) ForwardingHistory(arg0 context.Context, arg1 *lnrpc.ForwardingHistoryRequest) (*lnrpc.ForwardingHistoryResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForwardingHistory", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ForwardingHistoryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ForwardingHistory indicates an expected call of ForwardingHistory.
func (mr *MockLightningServerMockRecorder) ForwardingHistory(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForwardingHistory", reflect.TypeOf((*MockLightningServer)(nil).ForwardingHistory), arg0, arg1)
}

// FundingStateStep mocks base method.
func (m *MockLightningServer) FundingStateStep(arg0 context.Context, arg1 *lnrpc.FundingTransitionMsg) (*lnrpc.FundingStateStepResp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FundingStateStep", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.FundingStateStepResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FundingStateStep indicates an expected call of FundingStateStep.
func (mr *MockLightningServerMockRecorder) FundingStateStep(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FundingStateStep", reflect.TypeOf((*MockLightningServer)(nil).FundingStateStep), arg0, arg1)
}

// GetChanInfo mocks base method.
func (m *MockLightningServer) GetChanInfo(arg0 context.Context, arg1 *lnrpc.ChanInfoRequest) (*lnrpc.ChannelEdge, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChanInfo", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ChannelEdge)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChanInfo indicates an expected call of GetChanInfo.
func (mr *MockLightningServerMockRecorder) GetChanInfo(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChanInfo", reflect.TypeOf((*MockLightningServer)(nil).GetChanInfo), arg0, arg1)
}

// GetInfo mocks base method.
func (m *MockLightningServer) GetInfo(arg0 context.Context, arg1 *lnrpc.GetInfoRequest) (*lnrpc.GetInfoResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInfo", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.GetInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInfo indicates an expected call of GetInfo.
func (mr *MockLightningServerMockRecorder) GetInfo(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInfo", reflect.TypeOf((*MockLightningServer)(nil).GetInfo), arg0, arg1)
}

// GetNetworkInfo mocks base method.
func (m *MockLightningServer) GetNetworkInfo(arg0 context.Context, arg1 *lnrpc.NetworkInfoRequest) (*lnrpc.NetworkInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworkInfo", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.NetworkInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNetworkInfo indicates an expected call of GetNetworkInfo.
func (mr *MockLightningServerMockRecorder) GetNetworkInfo(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInfo", reflect.TypeOf((*MockLightningServer)(nil).GetNetworkInfo), arg0, arg1)
}

// GetNodeInfo mocks base method.
func (m *MockLightningServer) GetNodeInfo(arg0 context.Context, arg1 *lnrpc.NodeInfoRequest) (*lnrpc.NodeInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodeInfo", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.NodeInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeInfo indicates an expected call of GetNodeInfo.
func (mr *MockLightningServerMockRecorder) GetNodeInfo(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeInfo", reflect.TypeOf((*MockLightningServer)(nil).GetNodeInfo), arg0, arg1)
}

// GetNodeMetrics mocks base method.
func (m *MockLightningServer) GetNodeMetrics(arg0 context.Context, arg1 *lnrpc.NodeMetricsRequest) (*lnrpc.NodeMetricsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodeMetrics", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.NodeMetricsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeMetrics indicates an expected call of GetNodeMetrics.
func (mr *MockLightningServerMockRecorder) GetNodeMetrics(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeMetrics", reflect.TypeOf((*MockLightningServer)(nil).GetNodeMetrics), arg0, arg1)
}

// GetRecoveryInfo mocks base method.
func (m *MockLightningServer) GetRecoveryInfo(arg0 context.Context, arg1 *lnrpc.GetRecoveryInfoRequest) (*lnrpc.GetRecoveryInfoResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRecoveryInfo", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.GetRecoveryInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRecoveryInfo indicates an expected call of GetRecoveryInfo.
func (mr *MockLightningServerMockRecorder) GetRecoveryInfo(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecoveryInfo", reflect.TypeOf((*MockLightningServer)(nil).GetRecoveryInfo), arg0, arg1)
}

// GetTransactions mocks base method.
func (m *MockLightningServer) GetTransactions(arg0 context.Context, arg1 *lnrpc.GetTransactionsRequest) (*lnrpc.TransactionDetails, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransactions", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.TransactionDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransactions indicates an expected call of GetTransactions.
func (mr *MockLightningServerMockRecorder) GetTransactions(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactions", reflect.TypeOf((*MockLightningServer)(nil).GetTransactions), arg0, arg1)
}

// ListAliases mocks base method.
func (m *MockLightningServer) ListAliases(arg0 context.Context, arg1 *lnrpc.ListAliasesRequest) (*lnrpc.ListAliasesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAliases", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ListAliasesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAliases indicates an expected call of ListAliases.
func (mr *MockLightningServerMockRecorder) ListAliases(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliases", reflect.TypeOf((*MockLightningServer)(nil).ListAliases), arg0, arg1)
}

// ListChannels mocks base method.
func (m *MockLightningServer) ListChannels(arg0 context.Context, arg1 *lnrpc.ListChannelsRequest) (*lnrpc.ListChannelsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChannels", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ListChannelsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListChannels indicates an expected call of ListChannels.
func (mr *MockLightningServerMockRecorder) ListChannels(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChannels", reflect.TypeOf((*MockLightningServer)(nil).ListChannels), arg0, arg1)
}

// ListInvoices mocks base method.
func (m *MockLightningServer) ListInvoices(arg0 context.Context, arg1 *lnrpc.ListInvoiceRequest) (*lnrpc.ListInvoiceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInvoices", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ListInvoiceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListInvoices indicates an expected call of ListInvoices.
func (mr *MockLightningServerMockRecorder) ListInvoices(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInvoices", reflect.TypeOf((*MockLightningServer)(nil).ListInvoices), arg0, arg1)
}

// ListMacaroonIDs mocks base method.
func (m *MockLightningServer) ListMacaroonIDs(arg0 context.Context, arg1 *lnrpc.ListMacaroonIDsRequest) (*lnrpc.ListMacaroonIDsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMacaroonIDs", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ListMacaroonIDsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMacaroonIDs indicates an expected call of ListMacaroonIDs.
func (mr *MockLightningServerMockRecorder) ListMacaroonIDs(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMacaroonIDs", reflect.TypeOf((*MockLightningServer)(nil).ListMacaroonIDs), arg0, arg1)
}

// ListPayments mocks base method.
func (m *MockLightningServer) ListPayments(arg0 context.Context, arg1 *lnrpc.ListPaymentsRequest) (*lnrpc.ListPaymentsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPayments", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ListPaymentsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPayments indicates an expected call of ListPayments.
func (mr *MockLightningServerMockRecorder) ListPayments(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPayments", reflect.TypeOf((*MockLightningServer)(nil).ListPayments), arg0, arg1)
}

// ListPeers mocks base method.
func (m *MockLightningServer) ListPeers(arg0 context.Context, arg1 *lnrpc.ListPeersRequest) (*lnrpc.ListPeersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPeers", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ListPeersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPeers indicates an expected call of ListPeers.
func (mr *MockLightningServerMockRecorder) ListPeers(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPeers", reflect.TypeOf((*MockLightningServer)(nil).ListPeers), arg0, arg1)
}

// ListPermissions mocks base method.
func (m *MockLightningServer) ListPermissions(arg0 context.Context, arg1 *lnrpc.ListPermissionsRequest) (*lnrpc.ListPermissionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPermissions", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ListPermissionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPermissions indicates an expected call of ListPermissions.
func (mr *MockLightningServerMockRecorder) ListPermissions(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPermissions", reflect.TypeOf((*MockLightningServer)(nil).ListPermissions), arg0, arg1)
}

// ListUnspent mocks base method.
func (m *MockLightningServer) ListUnspent(arg0 context.Context, arg1 *lnrpc.ListUnspentRequest) (*lnrpc.ListUnspentResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUnspent", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ListUnspentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListUnspent indicates an expected call of ListUnspent.
func (mr *MockLightningServerMockRecorder) ListUnspent(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUnspent", reflect.TypeOf((*MockLightningServer)(nil).ListUnspent), arg0, arg1)
}

// LookupHtlcResolution mocks base method.
func (m *MockLightningServer) LookupHtlcResolution(arg0 context.Context, arg1 *lnrpc.LookupHtlcResolutionRequest) (*lnrpc.LookupHtlcResolutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LookupHtlcResolution", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.LookupHtlcResolutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LookupHtlcResolution indicates an expected call of LookupHtlcResolution.
func (mr *MockLightningServerMockRecorder) LookupHtlcResolution(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupHtlcResolution", reflect.TypeOf((*MockLightningServer)(nil).LookupHtlcResolution), arg0, arg1)
}

// LookupInvoice mocks base method.
func (m *MockLightningServer) LookupInvoice(arg0 context.Context, arg1 *lnrpc.PaymentHash) (*lnrpc.Invoice, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LookupInvoice", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.Invoice)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LookupInvoice indicates an expected call of LookupInvoice.
func (mr *MockLightningServerMockRecorder) LookupInvoice(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupInvoice", reflect.TypeOf((*MockLightningServer)(nil).LookupInvoice), arg0, arg1)
}

// NewAddress mocks base method.
func (m *MockLightningServer) NewAddress(arg0 context.Context, arg1 *lnrpc.NewAddressRequest) (*lnrpc.NewAddressResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewAddress", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.NewAddressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewAddress indicates an expected call of NewAddress.
func (mr *MockLightningServerMockRecorder) NewAddress(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAddress", reflect.TypeOf((*MockLightningServer)(nil).NewAddress), arg0, arg1)
}

// OpenChannel mocks base method.
func (m *MockLightningServer) OpenChannel(arg0 *lnrpc.OpenChannelRequest, arg1 lnrpc.Lightning_OpenChannelServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenChannel", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// OpenChannel indicates an expected call of OpenChannel.
func (mr *MockLightningServerMockRecorder) OpenChannel(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenChannel", reflect.TypeOf((*MockLightningServer)(nil).OpenChannel), arg0, arg1)
}

// OpenChannelSync mocks base method.
func (m *MockLightningServer) OpenChannelSync(arg0 context.Context, arg1 *lnrpc.OpenChannelRequest) (*lnrpc.ChannelPoint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenChannelSync", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.ChannelPoint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenChannelSync indicates an expected call of OpenChannelSync.
func (mr *MockLightningServerMockRecorder) OpenChannelSync(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenChannelSync", reflect.TypeOf((*MockLightningServer)(nil).OpenChannelSync), arg0, arg1)
}

// PendingChannels mocks base method.
func (m *MockLightningServer) PendingChannels(arg0 context.Context, arg1 *lnrpc.PendingChannelsRequest) (*lnrpc.PendingChannelsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PendingChannels", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.PendingChannelsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PendingChannels indicates an expected call of PendingChannels.
func (mr *MockLightningServerMockRecorder) PendingChannels(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingChannels", reflect.TypeOf((*MockLightningServer)(nil).PendingChannels), arg0, arg1)
}

// QueryRoutes mocks base method.
func (m *MockLightningServer) QueryRoutes(arg0 context.Context, arg1 *lnrpc.QueryRoutesRequest) (*lnrpc.QueryRoutesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryRoutes", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.QueryRoutesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryRoutes indicates an expected call of QueryRoutes.
func (mr *MockLightningServerMockRecorder) QueryRoutes(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRoutes", reflect.TypeOf((*MockLightningServer)(nil).QueryRoutes), arg0, arg1)
}

// RegisterRPCMiddleware mocks base method.
func (m *MockLightningServer) RegisterRPCMiddleware(arg0 lnrpc.Lightning_RegisterRPCMiddlewareServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterRPCMiddleware", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterRPCMiddleware indicates an expected call of RegisterRPCMiddleware.
func (mr *MockLightningServerMockRecorder) RegisterRPCMiddleware(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterRPCMiddleware", reflect.TypeOf((*MockLightningServer)(nil).RegisterRPCMiddleware), arg0)
}

// RestoreChannelBackups mocks base method.
func (m *MockLightningServer) RestoreChannelBackups(arg0 context.Context, arg1 *lnrpc.RestoreChanBackupRequest) (*lnrpc.RestoreBackupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreChannelBackups", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.RestoreBackupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreChannelBackups indicates an expected call of RestoreChannelBackups.
func (mr *MockLightningServerMockRecorder) RestoreChannelBackups(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreChannelBackups", reflect.TypeOf((*MockLightningServer)(nil).RestoreChannelBackups), arg0, arg1)
}

// SendCoins mocks base method.
func (m *MockLightningServer) SendCoins(arg0 context.Context, arg1 *lnrpc.SendCoinsRequest) (*lnrpc.SendCoinsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendCoins", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.SendCoinsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendCoins indicates an expected call of SendCoins.
func (mr *MockLightningServerMockRecorder) SendCoins(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoins", reflect.TypeOf((*MockLightningServer)(nil).SendCoins), arg0, arg1)
}

// SendCustomMessage mocks base method.
func (m *MockLightningServer) SendCustomMessage(arg0 context.Context, arg1 *lnrpc.SendCustomMessageRequest) (*lnrpc.SendCustomMessageResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendCustomMessage", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.SendCustomMessageResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendCustomMessage indicates an expected call of SendCustomMessage.
func (mr *MockLightningServerMockRecorder) SendCustomMessage(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCustomMessage", reflect.TypeOf((*MockLightningServer)(nil).SendCustomMessage), arg0, arg1)
}

// SendMany mocks base method.
func (m *MockLightningServer) SendMany(arg0 context.Context, arg1 *lnrpc.SendManyRequest) (*lnrpc.SendManyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMany", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.SendManyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendMany indicates an expected call of SendMany.
func (mr *MockLightningServerMockRecorder) SendMany(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMany", reflect.TypeOf((*MockLightningServer)(nil).SendMany), arg0, arg1)
}

// SendPayment mocks base method.
func (m *MockLightningServer) SendPayment(arg0 lnrpc.Lightning_SendPaymentServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendPayment", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendPayment indicates an expected call of SendPayment.
func (mr *MockLightningServerMockRecorder) SendPayment(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPayment", reflect.TypeOf((*MockLightningServer)(nil).SendPayment), arg0)
}

// SendPaymentSync mocks base method.
func (m *MockLightningServer) SendPaymentSync(arg0 context.Context, arg1 *lnrpc.SendRequest) (*lnrpc.SendResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendPaymentSync", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.SendResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendPaymentSync indicates an expected call of SendPaymentSync.
func (mr *MockLightningServerMockRecorder) SendPaymentSync(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendPaymentSync", reflect.TypeOf((*MockLightningServer)(nil).SendPaymentSync), arg0, arg1)
}

// SendToRoute mocks base method.
func (m *MockLightningServer) SendToRoute(arg0 lnrpc.Lightning_SendToRouteServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendToRoute", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendToRoute indicates an expected call of SendToRoute.
func (mr *MockLightningServerMockRecorder) SendToRoute(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendToRoute", reflect.TypeOf((*MockLightningServer)(nil).SendToRoute), arg0)
}

// SendToRouteSync mocks base method.
func (m *MockLightningServer) SendToRouteSync(arg0 context.Context, arg1 *lnrpc.SendToRouteRequest) (*lnrpc.SendResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendToRouteSync", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.SendResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendToRouteSync indicates an expected call of SendToRouteSync.
func (mr *MockLightningServerMockRecorder) SendToRouteSync(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendToRouteSync", reflect.TypeOf((*MockLightningServer)(nil).SendToRouteSync), arg0, arg1)
}

// SignMessage mocks base method.
func (m *MockLightningServer) SignMessage(arg0 context.Context, arg1 *lnrpc.SignMessageRequest) (*lnrpc.SignMessageResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignMessage", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.SignMessageResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignMessage indicates an expected call of SignMessage.
func (mr *MockLightningServerMockRecorder) SignMessage(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMessage", reflect.TypeOf((*MockLightningServer)(nil).SignMessage), arg0, arg1)
}

// StopDaemon mocks base method.
func (m *MockLightningServer) StopDaemon(arg0 context.Context, arg1 *lnrpc.StopRequest) (*lnrpc.StopResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopDaemon", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.StopResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopDaemon indicates an expected call of StopDaemon.
func (mr *MockLightningServerMockRecorder) StopDaemon(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopDaemon", reflect.TypeOf((*MockLightningServer)(nil).StopDaemon), arg0, arg1)
}

// SubscribeChannelBackups mocks base method.
func (m *MockLightningServer) SubscribeChannelBackups(arg0 *lnrpc.ChannelBackupSubscription, arg1 lnrpc.Lightning_SubscribeChannelBackupsServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeChannelBackups", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SubscribeChannelBackups indicates an expected call of SubscribeChannelBackups.
func (mr *MockLightningServerMockRecorder) SubscribeChannelBackups(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChannelBackups", reflect.TypeOf((*MockLightningServer)(nil).SubscribeChannelBackups), arg0, arg1)
}

// SubscribeChannelEvents mocks base method.
func (m *MockLightningServer) SubscribeChannelEvents(arg0 *lnrpc.ChannelEventSubscription, arg1 lnrpc.Lightning_SubscribeChannelEventsServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeChannelEvents", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SubscribeChannelEvents indicates an expected call of SubscribeChannelEvents.
func (mr *MockLightningServerMockRecorder) SubscribeChannelEvents(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChannelEvents", reflect.TypeOf((*MockLightningServer)(nil).SubscribeChannelEvents), arg0, arg1)
}

// SubscribeChannelGraph mocks base method.
func (m *MockLightningServer) SubscribeChannelGraph(arg0 *lnrpc.GraphTopologySubscription, arg1 lnrpc.Lightning_SubscribeChannelGraphServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeChannelGraph", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SubscribeChannelGraph indicates an expected call of SubscribeChannelGraph.
func (mr *MockLightningServerMockRecorder) SubscribeChannelGraph(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChannelGraph", reflect.TypeOf((*MockLightningServer)(nil).SubscribeChannelGraph), arg0, arg1)
}

// SubscribeCustomMessages mocks base method.
func (m *MockLightningServer) SubscribeCustomMessages(arg0 *lnrpc.SubscribeCustomMessagesRequest, arg1 lnrpc.Lightning_SubscribeCustomMessagesServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeCustomMessages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SubscribeCustomMessages indicates an expected call of SubscribeCustomMessages.
func (mr *MockLightningServerMockRecorder) SubscribeCustomMessages(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeCustomMessages", reflect.TypeOf((*MockLightningServer)(nil).SubscribeCustomMessages), arg0, arg1)
}

// SubscribeInvoices mocks base method.
func (m *MockLightningServer) SubscribeInvoices(arg0 *lnrpc.InvoiceSubscription, arg1 lnrpc.Lightning_SubscribeInvoicesServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeInvoices", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SubscribeInvoices indicates an expected call of SubscribeInvoices.
func (mr *MockLightningServerMockRecorder) SubscribeInvoices(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeInvoices", reflect.TypeOf((*MockLightningServer)(nil).SubscribeInvoices), arg0, arg1)
}

// SubscribePeerEvents mocks base method.
func (m *MockLightningServer) SubscribePeerEvents(arg0 *lnrpc.PeerEventSubscription, arg1 lnrpc.Lightning_SubscribePeerEventsServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribePeerEvents", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SubscribePeerEvents indicates an expected call of SubscribePeerEvents.
func (mr *MockLightningServerMockRecorder) SubscribePeerEvents(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribePeerEvents", reflect.TypeOf((*MockLightningServer)(nil).SubscribePeerEvents), arg0, arg1)
}

// SubscribeTransactions mocks base method.
func (m *MockLightningServer) SubscribeTransactions(arg0 *lnrpc.GetTransactionsRequest, arg1 lnrpc.Lightning_SubscribeTransactionsServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeTransactions", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SubscribeTransactions indicates an expected call of SubscribeTransactions.
func (mr *MockLightningServerMockRecorder) SubscribeTransactions(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeTransactions", reflect.TypeOf((*MockLightningServer)(nil).SubscribeTransactions), arg0, arg1)
}

// UpdateChannelPolicy mocks base method.
func (m *MockLightningServer) UpdateChannelPolicy(arg0 context.Context, arg1 *lnrpc.PolicyUpdateRequest) (*lnrpc.PolicyUpdateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChannelPolicy", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.PolicyUpdateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChannelPolicy indicates an expected call of UpdateChannelPolicy.
func (mr *MockLightningServerMockRecorder) UpdateChannelPolicy(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChannelPolicy", reflect.TypeOf((*MockLightningServer)(nil).UpdateChannelPolicy), arg0, arg1)
}

// VerifyChanBackup mocks base method.
func (m *MockLightningServer) VerifyChanBackup(arg0 context.Context, arg1 *lnrpc.ChanBackupSnapshot) (*lnrpc.VerifyChanBackupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyChanBackup", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.VerifyChanBackupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyChanBackup indicates an expected call of VerifyChanBackup.
func (mr *MockLightningServerMockRecorder) VerifyChanBackup(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyChanBackup", reflect.TypeOf((*MockLightningServer)(nil).VerifyChanBackup), arg0, arg1)
}

// VerifyMessage mocks base method.
func (m *MockLightningServer) VerifyMessage(arg0 context.Context, arg1 *lnrpc.VerifyMessageRequest) (*lnrpc.VerifyMessageResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyMessage", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.VerifyMessageResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyMessage indicates an expected call of VerifyMessage.
func (mr *MockLightningServerMockRecorder) VerifyMessage(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyMessage", reflect.TypeOf((*MockLightningServer)(nil).VerifyMessage), arg0, arg1)
}

// WalletBalance mocks base method.
func (m *MockLightningServer) WalletBalance(arg0 context.Context, arg1 *lnrpc.WalletBalanceRequest) (*lnrpc.WalletBalanceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WalletBalance", arg0, arg1)
	ret0, _ := ret[0].(*lnrpc.WalletBalanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WalletBalance indicates an expected call of WalletBalance.
func (mr *MockLightningServerMockRecorder) WalletBalance(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WalletBalance", reflect.TypeOf((*MockLightningServer)(nil).WalletBalance), arg0, arg1)
}

// mustEmbedUnimplementedLightningServer mocks base method.
func (m *MockLightningServer) mustEmbedUnimplementedLightningServer() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "mustEmbedUnimplementedLightningServer")
}

// mustEmbedUnimplementedLightningServer indicates an expected call of mustEmbedUnimplementedLightningServer.
func (mr *MockLightningServerMockRecorder) mustEmbedUnimplementedLightningServer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedLightningServer", reflect.TypeOf((*MockLightningServer)(nil).mustEmbedUnimplementedLightningServer))
}

// MockUnsafeLightningServer is a mock of UnsafeLightningServer interface.
type MockUnsafeLightningServer struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeLightningServerMockRecorder
}

// MockUnsafeLightningServerMockRecorder is the mock recorder for MockUnsafeLightningServer.
type MockUnsafeLightningServerMockRecorder struct {
	mock *MockUnsafeLightningServer
}

// NewMockUnsafeLightningServer creates a new mock instance.
func NewMockUnsafeLightningServer(ctrl *gomock.Controller) *MockUnsafeLightningServer {
	mock := &MockUnsafeLightningServer{ctrl: ctrl}
	mock.recorder = &MockUnsafeLightningServerMockRecorder{mock}
	return mock
}

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

// mustEmbedUnimplementedLightningServer mocks base method.
func (m *MockUnsafeLightningServer) mustEmbedUnimplementedLightningServer() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "mustEmbedUnimplementedLightningServer")
}

// mustEmbedUnimplementedLightningServer indicates an expected call of mustEmbedUnimplementedLightningServer.
func (mr *MockUnsafeLightningServerMockRecorder) mustEmbedUnimplementedLightningServer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedLightningServer", reflect.TypeOf((*MockUnsafeLightningServer)(nil).mustEmbedUnimplementedLightningServer))
}

// MockLightning_SubscribeTransactionsServer is a mock of Lightning_SubscribeTransactionsServer interface.
type MockLightning_SubscribeTransactionsServer struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SubscribeTransactionsServerMockRecorder
}

// MockLightning_SubscribeTransactionsServerMockRecorder is the mock recorder for MockLightning_SubscribeTransactionsServer.
type MockLightning_SubscribeTransactionsServerMockRecorder struct {
	mock *MockLightning_SubscribeTransactionsServer
}

// NewMockLightning_SubscribeTransactionsServer creates a new mock instance.
func NewMockLightning_SubscribeTransactionsServer(ctrl *gomock.Controller) *MockLightning_SubscribeTransactionsServer {
	mock := &MockLightning_SubscribeTransactionsServer{ctrl: ctrl}
	mock.recorder = &MockLightning_SubscribeTransactionsServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockLightning_SubscribeTransactionsServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SubscribeTransactionsServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SubscribeTransactionsServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SubscribeTransactionsServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SubscribeTransactionsServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SubscribeTransactionsServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_SubscribeTransactionsServer) Send(arg0 *lnrpc.Transaction) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_SubscribeTransactionsServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_SubscribeTransactionsServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockLightning_SubscribeTransactionsServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockLightning_SubscribeTransactionsServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockLightning_SubscribeTransactionsServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SubscribeTransactionsServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SubscribeTransactionsServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SubscribeTransactionsServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockLightning_SubscribeTransactionsServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockLightning_SubscribeTransactionsServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockLightning_SubscribeTransactionsServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockLightning_SubscribeTransactionsServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockLightning_SubscribeTransactionsServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockLightning_SubscribeTransactionsServer)(nil).SetTrailer), arg0)
}

// MockLightning_SubscribePeerEventsServer is a mock of Lightning_SubscribePeerEventsServer interface.
type MockLightning_SubscribePeerEventsServer struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SubscribePeerEventsServerMockRecorder
}

// MockLightning_SubscribePeerEventsServerMockRecorder is the mock recorder for MockLightning_SubscribePeerEventsServer.
type MockLightning_SubscribePeerEventsServerMockRecorder struct {
	mock *MockLightning_SubscribePeerEventsServer
}

// NewMockLightning_SubscribePeerEventsServer creates a new mock instance.
func NewMockLightning_SubscribePeerEventsServer(ctrl *gomock.Controller) *MockLightning_SubscribePeerEventsServer {
	mock := &MockLightning_SubscribePeerEventsServer{ctrl: ctrl}
	mock.recorder = &MockLightning_SubscribePeerEventsServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockLightning_SubscribePeerEventsServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SubscribePeerEventsServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SubscribePeerEventsServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SubscribePeerEventsServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SubscribePeerEventsServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SubscribePeerEventsServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_SubscribePeerEventsServer) Send(arg0 *lnrpc.PeerEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_SubscribePeerEventsServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_SubscribePeerEventsServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockLightning_SubscribePeerEventsServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockLightning_SubscribePeerEventsServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockLightning_SubscribePeerEventsServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SubscribePeerEventsServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SubscribePeerEventsServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SubscribePeerEventsServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockLightning_SubscribePeerEventsServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockLightning_SubscribePeerEventsServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockLightning_SubscribePeerEventsServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockLightning_SubscribePeerEventsServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockLightning_SubscribePeerEventsServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockLightning_SubscribePeerEventsServer)(nil).SetTrailer), arg0)
}

// MockLightning_SubscribeChannelEventsServer is a mock of Lightning_SubscribeChannelEventsServer interface.
type MockLightning_SubscribeChannelEventsServer struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SubscribeChannelEventsServerMockRecorder
}

// MockLightning_SubscribeChannelEventsServerMockRecorder is the mock recorder for MockLightning_SubscribeChannelEventsServer.
type MockLightning_SubscribeChannelEventsServerMockRecorder struct {
	mock *MockLightning_SubscribeChannelEventsServer
}

// NewMockLightning_SubscribeChannelEventsServer creates a new mock instance.
func NewMockLightning_SubscribeChannelEventsServer(ctrl *gomock.Controller) *MockLightning_SubscribeChannelEventsServer {
	mock := &MockLightning_SubscribeChannelEventsServer{ctrl: ctrl}
	mock.recorder = &MockLightning_SubscribeChannelEventsServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockLightning_SubscribeChannelEventsServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SubscribeChannelEventsServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SubscribeChannelEventsServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SubscribeChannelEventsServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SubscribeChannelEventsServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SubscribeChannelEventsServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_SubscribeChannelEventsServer) Send(arg0 *lnrpc.ChannelEventUpdate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_SubscribeChannelEventsServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_SubscribeChannelEventsServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockLightning_SubscribeChannelEventsServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockLightning_SubscribeChannelEventsServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockLightning_SubscribeChannelEventsServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SubscribeChannelEventsServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SubscribeChannelEventsServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SubscribeChannelEventsServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockLightning_SubscribeChannelEventsServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockLightning_SubscribeChannelEventsServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockLightning_SubscribeChannelEventsServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockLightning_SubscribeChannelEventsServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockLightning_SubscribeChannelEventsServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockLightning_SubscribeChannelEventsServer)(nil).SetTrailer), arg0)
}

// MockLightning_OpenChannelServer is a mock of Lightning_OpenChannelServer interface.
type MockLightning_OpenChannelServer struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_OpenChannelServerMockRecorder
}

// MockLightning_OpenChannelServerMockRecorder is the mock recorder for MockLightning_OpenChannelServer.
type MockLightning_OpenChannelServerMockRecorder struct {
	mock *MockLightning_OpenChannelServer
}

// NewMockLightning_OpenChannelServer creates a new mock instance.
func NewMockLightning_OpenChannelServer(ctrl *gomock.Controller) *MockLightning_OpenChannelServer {
	mock := &MockLightning_OpenChannelServer{ctrl: ctrl}
	mock.recorder = &MockLightning_OpenChannelServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockLightning_OpenChannelServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_OpenChannelServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_OpenChannelServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_OpenChannelServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_OpenChannelServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_OpenChannelServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_OpenChannelServer) Send(arg0 *lnrpc.OpenStatusUpdate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_OpenChannelServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_OpenChannelServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockLightning_OpenChannelServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockLightning_OpenChannelServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockLightning_OpenChannelServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_OpenChannelServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_OpenChannelServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_OpenChannelServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockLightning_OpenChannelServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockLightning_OpenChannelServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockLightning_OpenChannelServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockLightning_OpenChannelServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockLightning_OpenChannelServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockLightning_OpenChannelServer)(nil).SetTrailer), arg0)
}

// MockLightning_ChannelAcceptorServer is a mock of Lightning_ChannelAcceptorServer interface.
type MockLightning_ChannelAcceptorServer struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_ChannelAcceptorServerMockRecorder
}

// MockLightning_ChannelAcceptorServerMockRecorder is the mock recorder for MockLightning_ChannelAcceptorServer.
type MockLightning_ChannelAcceptorServerMockRecorder struct {
	mock *MockLightning_ChannelAcceptorServer
}

// NewMockLightning_ChannelAcceptorServer creates a new mock instance.
func NewMockLightning_ChannelAcceptorServer(ctrl *gomock.Controller) *MockLightning_ChannelAcceptorServer {
	mock := &MockLightning_ChannelAcceptorServer{ctrl: ctrl}
	mock.recorder = &MockLightning_ChannelAcceptorServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockLightning_ChannelAcceptorServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_ChannelAcceptorServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_ChannelAcceptorServer)(nil).Context))
}

// Recv mocks base method.
func (m *MockLightning_ChannelAcceptorServer) Recv() (*lnrpc.ChannelAcceptResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.ChannelAcceptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_ChannelAcceptorServerMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_ChannelAcceptorServer)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_ChannelAcceptorServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_ChannelAcceptorServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_ChannelAcceptorServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_ChannelAcceptorServer) Send(arg0 *lnrpc.ChannelAcceptRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_ChannelAcceptorServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_ChannelAcceptorServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockLightning_ChannelAcceptorServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockLightning_ChannelAcceptorServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockLightning_ChannelAcceptorServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_ChannelAcceptorServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_ChannelAcceptorServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_ChannelAcceptorServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockLightning_ChannelAcceptorServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockLightning_ChannelAcceptorServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockLightning_ChannelAcceptorServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockLightning_ChannelAcceptorServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockLightning_ChannelAcceptorServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockLightning_ChannelAcceptorServer)(nil).SetTrailer), arg0)
}

// MockLightning_CloseChannelServer is a mock of Lightning_CloseChannelServer interface.
type MockLightning_CloseChannelServer struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_CloseChannelServerMockRecorder
}

// MockLightning_CloseChannelServerMockRecorder is the mock recorder for MockLightning_CloseChannelServer.
type MockLightning_CloseChannelServerMockRecorder struct {
	mock *MockLightning_CloseChannelServer
}

// NewMockLightning_CloseChannelServer creates a new mock instance.
func NewMockLightning_CloseChannelServer(ctrl *gomock.Controller) *MockLightning_CloseChannelServer {
	mock := &MockLightning_CloseChannelServer{ctrl: ctrl}
	mock.recorder = &MockLightning_CloseChannelServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockLightning_CloseChannelServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_CloseChannelServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_CloseChannelServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_CloseChannelServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_CloseChannelServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_CloseChannelServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_CloseChannelServer) Send(arg0 *lnrpc.CloseStatusUpdate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_CloseChannelServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_CloseChannelServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockLightning_CloseChannelServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockLightning_CloseChannelServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockLightning_CloseChannelServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_CloseChannelServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_CloseChannelServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_CloseChannelServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockLightning_CloseChannelServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockLightning_CloseChannelServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockLightning_CloseChannelServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockLightning_CloseChannelServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockLightning_CloseChannelServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockLightning_CloseChannelServer)(nil).SetTrailer), arg0)
}

// MockLightning_SendPaymentServer is a mock of Lightning_SendPaymentServer interface.
type MockLightning_SendPaymentServer struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SendPaymentServerMockRecorder
}

// MockLightning_SendPaymentServerMockRecorder is the mock recorder for MockLightning_SendPaymentServer.
type MockLightning_SendPaymentServerMockRecorder struct {
	mock *MockLightning_SendPaymentServer
}

// NewMockLightning_SendPaymentServer creates a new mock instance.
func NewMockLightning_SendPaymentServer(ctrl *gomock.Controller) *MockLightning_SendPaymentServer {
	mock := &MockLightning_SendPaymentServer{ctrl: ctrl}
	mock.recorder = &MockLightning_SendPaymentServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockLightning_SendPaymentServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SendPaymentServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SendPaymentServer)(nil).Context))
}

// Recv mocks base method.
func (m *MockLightning_SendPaymentServer) Recv() (*lnrpc.SendRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.SendRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_SendPaymentServerMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_SendPaymentServer)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SendPaymentServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SendPaymentServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SendPaymentServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_SendPaymentServer) Send(arg0 *lnrpc.SendResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_SendPaymentServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_SendPaymentServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockLightning_SendPaymentServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockLightning_SendPaymentServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockLightning_SendPaymentServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SendPaymentServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SendPaymentServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SendPaymentServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockLightning_SendPaymentServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockLightning_SendPaymentServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockLightning_SendPaymentServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockLightning_SendPaymentServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockLightning_SendPaymentServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockLightning_SendPaymentServer)(nil).SetTrailer), arg0)
}

// MockLightning_SendToRouteServer is a mock of Lightning_SendToRouteServer interface.
type MockLightning_SendToRouteServer struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SendToRouteServerMockRecorder
}

// MockLightning_SendToRouteServerMockRecorder is the mock recorder for MockLightning_SendToRouteServer.
type MockLightning_SendToRouteServerMockRecorder struct {
	mock *MockLightning_SendToRouteServer
}

// NewMockLightning_SendToRouteServer creates a new mock instance.
func NewMockLightning_SendToRouteServer(ctrl *gomock.Controller) *MockLightning_SendToRouteServer {
	mock := &MockLightning_SendToRouteServer{ctrl: ctrl}
	mock.recorder = &MockLightning_SendToRouteServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockLightning_SendToRouteServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SendToRouteServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SendToRouteServer)(nil).Context))
}

// Recv mocks base method.
func (m *MockLightning_SendToRouteServer) Recv() (*lnrpc.SendToRouteRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.SendToRouteRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_SendToRouteServerMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_SendToRouteServer)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SendToRouteServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SendToRouteServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SendToRouteServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_SendToRouteServer) Send(arg0 *lnrpc.SendResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_SendToRouteServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_SendToRouteServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockLightning_SendToRouteServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockLightning_SendToRouteServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockLightning_SendToRouteServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SendToRouteServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SendToRouteServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SendToRouteServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockLightning_SendToRouteServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockLightning_SendToRouteServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockLightning_SendToRouteServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockLightning_SendToRouteServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockLightning_SendToRouteServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockLightning_SendToRouteServer)(nil).SetTrailer), arg0)
}

// MockLightning_SubscribeInvoicesServer is a mock of Lightning_SubscribeInvoicesServer interface.
type MockLightning_SubscribeInvoicesServer struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SubscribeInvoicesServerMockRecorder
}

// MockLightning_SubscribeInvoicesServerMockRecorder is the mock recorder for MockLightning_SubscribeInvoicesServer.
type MockLightning_SubscribeInvoicesServerMockRecorder struct {
	mock *MockLightning_SubscribeInvoicesServer
}

// NewMockLightning_SubscribeInvoicesServer creates a new mock instance.
func NewMockLightning_SubscribeInvoicesServer(ctrl *gomock.Controller) *MockLightning_SubscribeInvoicesServer {
	mock := &MockLightning_SubscribeInvoicesServer{ctrl: ctrl}
	mock.recorder = &MockLightning_SubscribeInvoicesServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockLightning_SubscribeInvoicesServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SubscribeInvoicesServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SubscribeInvoicesServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SubscribeInvoicesServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SubscribeInvoicesServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SubscribeInvoicesServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_SubscribeInvoicesServer) Send(arg0 *lnrpc.Invoice) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_SubscribeInvoicesServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_SubscribeInvoicesServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockLightning_SubscribeInvoicesServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockLightning_SubscribeInvoicesServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockLightning_SubscribeInvoicesServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SubscribeInvoicesServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SubscribeInvoicesServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SubscribeInvoicesServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockLightning_SubscribeInvoicesServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockLightning_SubscribeInvoicesServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockLightning_SubscribeInvoicesServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockLightning_SubscribeInvoicesServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockLightning_SubscribeInvoicesServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockLightning_SubscribeInvoicesServer)(nil).SetTrailer), arg0)
}

// MockLightning_SubscribeChannelGraphServer is a mock of Lightning_SubscribeChannelGraphServer interface.
type MockLightning_SubscribeChannelGraphServer struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SubscribeChannelGraphServerMockRecorder
}

// MockLightning_SubscribeChannelGraphServerMockRecorder is the mock recorder for MockLightning_SubscribeChannelGraphServer.
type MockLightning_SubscribeChannelGraphServerMockRecorder struct {
	mock *MockLightning_SubscribeChannelGraphServer
}

// NewMockLightning_SubscribeChannelGraphServer creates a new mock instance.
func NewMockLightning_SubscribeChannelGraphServer(ctrl *gomock.Controller) *MockLightning_SubscribeChannelGraphServer {
	mock := &MockLightning_SubscribeChannelGraphServer{ctrl: ctrl}
	mock.recorder = &MockLightning_SubscribeChannelGraphServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockLightning_SubscribeChannelGraphServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SubscribeChannelGraphServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SubscribeChannelGraphServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SubscribeChannelGraphServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SubscribeChannelGraphServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SubscribeChannelGraphServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_SubscribeChannelGraphServer) Send(arg0 *lnrpc.GraphTopologyUpdate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_SubscribeChannelGraphServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_SubscribeChannelGraphServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockLightning_SubscribeChannelGraphServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockLightning_SubscribeChannelGraphServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockLightning_SubscribeChannelGraphServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SubscribeChannelGraphServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SubscribeChannelGraphServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SubscribeChannelGraphServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockLightning_SubscribeChannelGraphServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockLightning_SubscribeChannelGraphServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockLightning_SubscribeChannelGraphServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockLightning_SubscribeChannelGraphServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockLightning_SubscribeChannelGraphServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockLightning_SubscribeChannelGraphServer)(nil).SetTrailer), arg0)
}

// MockLightning_SubscribeChannelBackupsServer is a mock of Lightning_SubscribeChannelBackupsServer interface.
type MockLightning_SubscribeChannelBackupsServer struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SubscribeChannelBackupsServerMockRecorder
}

// MockLightning_SubscribeChannelBackupsServerMockRecorder is the mock recorder for MockLightning_SubscribeChannelBackupsServer.
type MockLightning_SubscribeChannelBackupsServerMockRecorder struct {
	mock *MockLightning_SubscribeChannelBackupsServer
}

// NewMockLightning_SubscribeChannelBackupsServer creates a new mock instance.
func NewMockLightning_SubscribeChannelBackupsServer(ctrl *gomock.Controller) *MockLightning_SubscribeChannelBackupsServer {
	mock := &MockLightning_SubscribeChannelBackupsServer{ctrl: ctrl}
	mock.recorder = &MockLightning_SubscribeChannelBackupsServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockLightning_SubscribeChannelBackupsServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SubscribeChannelBackupsServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SubscribeChannelBackupsServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SubscribeChannelBackupsServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SubscribeChannelBackupsServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SubscribeChannelBackupsServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_SubscribeChannelBackupsServer) Send(arg0 *lnrpc.ChanBackupSnapshot) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_SubscribeChannelBackupsServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_SubscribeChannelBackupsServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockLightning_SubscribeChannelBackupsServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockLightning_SubscribeChannelBackupsServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockLightning_SubscribeChannelBackupsServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SubscribeChannelBackupsServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SubscribeChannelBackupsServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SubscribeChannelBackupsServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockLightning_SubscribeChannelBackupsServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockLightning_SubscribeChannelBackupsServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockLightning_SubscribeChannelBackupsServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockLightning_SubscribeChannelBackupsServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockLightning_SubscribeChannelBackupsServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockLightning_SubscribeChannelBackupsServer)(nil).SetTrailer), arg0)
}

// MockLightning_RegisterRPCMiddlewareServer is a mock of Lightning_RegisterRPCMiddlewareServer interface.
type MockLightning_RegisterRPCMiddlewareServer struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_RegisterRPCMiddlewareServerMockRecorder
}

// MockLightning_RegisterRPCMiddlewareServerMockRecorder is the mock recorder for MockLightning_RegisterRPCMiddlewareServer.
type MockLightning_RegisterRPCMiddlewareServerMockRecorder struct {
	mock *MockLightning_RegisterRPCMiddlewareServer
}

// NewMockLightning_RegisterRPCMiddlewareServer creates a new mock instance.
func NewMockLightning_RegisterRPCMiddlewareServer(ctrl *gomock.Controller) *MockLightning_RegisterRPCMiddlewareServer {
	mock := &MockLightning_RegisterRPCMiddlewareServer{ctrl: ctrl}
	mock.recorder = &MockLightning_RegisterRPCMiddlewareServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockLightning_RegisterRPCMiddlewareServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_RegisterRPCMiddlewareServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareServer)(nil).Context))
}

// Recv mocks base method.
func (m *MockLightning_RegisterRPCMiddlewareServer) Recv() (*lnrpc.RPCMiddlewareResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*lnrpc.RPCMiddlewareResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockLightning_RegisterRPCMiddlewareServerMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareServer)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_RegisterRPCMiddlewareServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_RegisterRPCMiddlewareServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_RegisterRPCMiddlewareServer) Send(arg0 *lnrpc.RPCMiddlewareRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_RegisterRPCMiddlewareServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockLightning_RegisterRPCMiddlewareServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockLightning_RegisterRPCMiddlewareServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_RegisterRPCMiddlewareServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_RegisterRPCMiddlewareServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockLightning_RegisterRPCMiddlewareServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockLightning_RegisterRPCMiddlewareServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockLightning_RegisterRPCMiddlewareServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockLightning_RegisterRPCMiddlewareServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockLightning_RegisterRPCMiddlewareServer)(nil).SetTrailer), arg0)
}

// MockLightning_SubscribeCustomMessagesServer is a mock of Lightning_SubscribeCustomMessagesServer interface.
type MockLightning_SubscribeCustomMessagesServer struct {
	ctrl     *gomock.Controller
	recorder *MockLightning_SubscribeCustomMessagesServerMockRecorder
}

// MockLightning_SubscribeCustomMessagesServerMockRecorder is the mock recorder for MockLightning_SubscribeCustomMessagesServer.
type MockLightning_SubscribeCustomMessagesServerMockRecorder struct {
	mock *MockLightning_SubscribeCustomMessagesServer
}

// NewMockLightning_SubscribeCustomMessagesServer creates a new mock instance.
func NewMockLightning_SubscribeCustomMessagesServer(ctrl *gomock.Controller) *MockLightning_SubscribeCustomMessagesServer {
	mock := &MockLightning_SubscribeCustomMessagesServer{ctrl: ctrl}
	mock.recorder = &MockLightning_SubscribeCustomMessagesServerMockRecorder{mock}
	return mock
}

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

// Context mocks base method.
func (m *MockLightning_SubscribeCustomMessagesServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockLightning_SubscribeCustomMessagesServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockLightning_SubscribeCustomMessagesServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockLightning_SubscribeCustomMessagesServer) RecvMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockLightning_SubscribeCustomMessagesServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockLightning_SubscribeCustomMessagesServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockLightning_SubscribeCustomMessagesServer) Send(arg0 *lnrpc.CustomMessage) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockLightning_SubscribeCustomMessagesServerMockRecorder) Send(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockLightning_SubscribeCustomMessagesServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockLightning_SubscribeCustomMessagesServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockLightning_SubscribeCustomMessagesServerMockRecorder) SendHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockLightning_SubscribeCustomMessagesServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockLightning_SubscribeCustomMessagesServer) SendMsg(m any) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockLightning_SubscribeCustomMessagesServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockLightning_SubscribeCustomMessagesServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockLightning_SubscribeCustomMessagesServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockLightning_SubscribeCustomMessagesServerMockRecorder) SetHeader(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockLightning_SubscribeCustomMessagesServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockLightning_SubscribeCustomMessagesServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockLightning_SubscribeCustomMessagesServerMockRecorder) SetTrailer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockLightning_SubscribeCustomMessagesServer)(nil).SetTrailer), arg0)
}