code.vegaprotocol.io/vega@v0.79.0/mocks/mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: code.vegaprotocol.io/vega/datanode/gateway/graphql (interfaces: CoreProxyServiceClient,TradingDataServiceClientV2)

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

import (
	context "context"
	reflect "reflect"

	v2 "code.vegaprotocol.io/vega/protos/data-node/api/v2"
	v1 "code.vegaprotocol.io/vega/protos/vega/api/v1"
	gomock "github.com/golang/mock/gomock"
	grpc "google.golang.org/grpc"
)

// MockCoreProxyServiceClient is a mock of CoreProxyServiceClient interface.
type MockCoreProxyServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockCoreProxyServiceClientMockRecorder
}

// MockCoreProxyServiceClientMockRecorder is the mock recorder for MockCoreProxyServiceClient.
type MockCoreProxyServiceClientMockRecorder struct {
	mock *MockCoreProxyServiceClient
}

// NewMockCoreProxyServiceClient creates a new mock instance.
func NewMockCoreProxyServiceClient(ctrl *gomock.Controller) *MockCoreProxyServiceClient {
	mock := &MockCoreProxyServiceClient{ctrl: ctrl}
	mock.recorder = &MockCoreProxyServiceClientMockRecorder{mock}
	return mock
}

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

// CheckRawTransaction mocks base method.
func (m *MockCoreProxyServiceClient) CheckRawTransaction(arg0 context.Context, arg1 *v1.CheckRawTransactionRequest, arg2 ...grpc.CallOption) (*v1.CheckRawTransactionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CheckRawTransaction", varargs...)
	ret0, _ := ret[0].(*v1.CheckRawTransactionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CheckTransaction mocks base method.
func (m *MockCoreProxyServiceClient) CheckTransaction(arg0 context.Context, arg1 *v1.CheckTransactionRequest, arg2 ...grpc.CallOption) (*v1.CheckTransactionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CheckTransaction", varargs...)
	ret0, _ := ret[0].(*v1.CheckTransactionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSpamStatistics mocks base method.
func (m *MockCoreProxyServiceClient) GetSpamStatistics(arg0 context.Context, arg1 *v1.GetSpamStatisticsRequest, arg2 ...grpc.CallOption) (*v1.GetSpamStatisticsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSpamStatistics", varargs...)
	ret0, _ := ret[0].(*v1.GetSpamStatisticsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetVegaTime mocks base method.
func (m *MockCoreProxyServiceClient) GetVegaTime(arg0 context.Context, arg1 *v1.GetVegaTimeRequest, arg2 ...grpc.CallOption) (*v1.GetVegaTimeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVegaTime", varargs...)
	ret0, _ := ret[0].(*v1.GetVegaTimeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LastBlockHeight mocks base method.
func (m *MockCoreProxyServiceClient) LastBlockHeight(arg0 context.Context, arg1 *v1.LastBlockHeightRequest, arg2 ...grpc.CallOption) (*v1.LastBlockHeightResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LastBlockHeight", varargs...)
	ret0, _ := ret[0].(*v1.LastBlockHeightResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObserveEventBus mocks base method.
func (m *MockCoreProxyServiceClient) ObserveEventBus(arg0 context.Context, arg1 ...grpc.CallOption) (v1.CoreService_ObserveEventBusClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveEventBus", varargs...)
	ret0, _ := ret[0].(v1.CoreService_ObserveEventBusClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ObserveEventBus indicates an expected call of ObserveEventBus.
func (mr *MockCoreProxyServiceClientMockRecorder) ObserveEventBus(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObserveEventBus", reflect.TypeOf((*MockCoreProxyServiceClient)(nil).ObserveEventBus), varargs...)
}

// PropagateChainEvent mocks base method.
func (m *MockCoreProxyServiceClient) PropagateChainEvent(arg0 context.Context, arg1 *v1.PropagateChainEventRequest, arg2 ...grpc.CallOption) (*v1.PropagateChainEventResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PropagateChainEvent", varargs...)
	ret0, _ := ret[0].(*v1.PropagateChainEventResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Statistics mocks base method.
func (m *MockCoreProxyServiceClient) Statistics(arg0 context.Context, arg1 *v1.StatisticsRequest, arg2 ...grpc.CallOption) (*v1.StatisticsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Statistics", varargs...)
	ret0, _ := ret[0].(*v1.StatisticsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SubmitRawTransaction mocks base method.
func (m *MockCoreProxyServiceClient) SubmitRawTransaction(arg0 context.Context, arg1 *v1.SubmitRawTransactionRequest, arg2 ...grpc.CallOption) (*v1.SubmitRawTransactionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubmitRawTransaction", varargs...)
	ret0, _ := ret[0].(*v1.SubmitRawTransactionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SubmitTransaction mocks base method.
func (m *MockCoreProxyServiceClient) SubmitTransaction(arg0 context.Context, arg1 *v1.SubmitTransactionRequest, arg2 ...grpc.CallOption) (*v1.SubmitTransactionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubmitTransaction", varargs...)
	ret0, _ := ret[0].(*v1.SubmitTransactionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockTradingDataServiceClientV2 is a mock of TradingDataServiceClientV2 interface.
type MockTradingDataServiceClientV2 struct {
	ctrl     *gomock.Controller
	recorder *MockTradingDataServiceClientV2MockRecorder
}

// MockTradingDataServiceClientV2MockRecorder is the mock recorder for MockTradingDataServiceClientV2.
type MockTradingDataServiceClientV2MockRecorder struct {
	mock *MockTradingDataServiceClientV2
}

// NewMockTradingDataServiceClientV2 creates a new mock instance.
func NewMockTradingDataServiceClientV2(ctrl *gomock.Controller) *MockTradingDataServiceClientV2 {
	mock := &MockTradingDataServiceClientV2{ctrl: ctrl}
	mock.recorder = &MockTradingDataServiceClientV2MockRecorder{mock}
	return mock
}

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

// EstimateFee mocks base method.
func (m *MockTradingDataServiceClientV2) EstimateFee(arg0 context.Context, arg1 *v2.EstimateFeeRequest, arg2 ...grpc.CallOption) (*v2.EstimateFeeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EstimateFee", varargs...)
	ret0, _ := ret[0].(*v2.EstimateFeeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EstimateMargin mocks base method.
func (m *MockTradingDataServiceClientV2) EstimateMargin(arg0 context.Context, arg1 *v2.EstimateMarginRequest, arg2 ...grpc.CallOption) (*v2.EstimateMarginResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EstimateMargin", varargs...)
	ret0, _ := ret[0].(*v2.EstimateMarginResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EstimatePosition mocks base method.
func (m *MockTradingDataServiceClientV2) EstimatePosition(arg0 context.Context, arg1 *v2.EstimatePositionRequest, arg2 ...grpc.CallOption) (*v2.EstimatePositionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EstimatePosition", varargs...)
	ret0, _ := ret[0].(*v2.EstimatePositionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EstimateTransferFee mocks base method.
func (m *MockTradingDataServiceClientV2) EstimateTransferFee(arg0 context.Context, arg1 *v2.EstimateTransferFeeRequest, arg2 ...grpc.CallOption) (*v2.EstimateTransferFeeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EstimateTransferFee", varargs...)
	ret0, _ := ret[0].(*v2.EstimateTransferFeeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExportLedgerEntries mocks base method.
func (m *MockTradingDataServiceClientV2) ExportLedgerEntries(arg0 context.Context, arg1 *v2.ExportLedgerEntriesRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ExportLedgerEntriesClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExportLedgerEntries", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ExportLedgerEntriesClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExportNetworkHistory mocks base method.
func (m *MockTradingDataServiceClientV2) ExportNetworkHistory(arg0 context.Context, arg1 *v2.ExportNetworkHistoryRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ExportNetworkHistoryClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExportNetworkHistory", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ExportNetworkHistoryClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetActiveNetworkHistoryPeerAddresses mocks base method.
func (m *MockTradingDataServiceClientV2) GetActiveNetworkHistoryPeerAddresses(arg0 context.Context, arg1 *v2.GetActiveNetworkHistoryPeerAddressesRequest, arg2 ...grpc.CallOption) (*v2.GetActiveNetworkHistoryPeerAddressesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetActiveNetworkHistoryPeerAddresses", varargs...)
	ret0, _ := ret[0].(*v2.GetActiveNetworkHistoryPeerAddressesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAsset mocks base method.
func (m *MockTradingDataServiceClientV2) GetAsset(arg0 context.Context, arg1 *v2.GetAssetRequest, arg2 ...grpc.CallOption) (*v2.GetAssetResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAsset", varargs...)
	ret0, _ := ret[0].(*v2.GetAssetResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCurrentReferralProgram mocks base method.
func (m *MockTradingDataServiceClientV2) GetCurrentReferralProgram(arg0 context.Context, arg1 *v2.GetCurrentReferralProgramRequest, arg2 ...grpc.CallOption) (*v2.GetCurrentReferralProgramResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCurrentReferralProgram", varargs...)
	ret0, _ := ret[0].(*v2.GetCurrentReferralProgramResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCurrentVolumeDiscountProgram mocks base method.
func (m *MockTradingDataServiceClientV2) GetCurrentVolumeDiscountProgram(arg0 context.Context, arg1 *v2.GetCurrentVolumeDiscountProgramRequest, arg2 ...grpc.CallOption) (*v2.GetCurrentVolumeDiscountProgramResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCurrentVolumeDiscountProgram", varargs...)
	ret0, _ := ret[0].(*v2.GetCurrentVolumeDiscountProgramResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDeposit mocks base method.
func (m *MockTradingDataServiceClientV2) GetDeposit(arg0 context.Context, arg1 *v2.GetDepositRequest, arg2 ...grpc.CallOption) (*v2.GetDepositResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDeposit", varargs...)
	ret0, _ := ret[0].(*v2.GetDepositResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetERC20ListAssetBundle mocks base method.
func (m *MockTradingDataServiceClientV2) GetERC20ListAssetBundle(arg0 context.Context, arg1 *v2.GetERC20ListAssetBundleRequest, arg2 ...grpc.CallOption) (*v2.GetERC20ListAssetBundleResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetERC20ListAssetBundle", varargs...)
	ret0, _ := ret[0].(*v2.GetERC20ListAssetBundleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetERC20SetAssetLimitsBundle mocks base method.
func (m *MockTradingDataServiceClientV2) GetERC20SetAssetLimitsBundle(arg0 context.Context, arg1 *v2.GetERC20SetAssetLimitsBundleRequest, arg2 ...grpc.CallOption) (*v2.GetERC20SetAssetLimitsBundleResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetERC20SetAssetLimitsBundle", varargs...)
	ret0, _ := ret[0].(*v2.GetERC20SetAssetLimitsBundleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetERC20WithdrawalApproval mocks base method.
func (m *MockTradingDataServiceClientV2) GetERC20WithdrawalApproval(arg0 context.Context, arg1 *v2.GetERC20WithdrawalApprovalRequest, arg2 ...grpc.CallOption) (*v2.GetERC20WithdrawalApprovalResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetERC20WithdrawalApproval", varargs...)
	ret0, _ := ret[0].(*v2.GetERC20WithdrawalApprovalResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetEpoch mocks base method.
func (m *MockTradingDataServiceClientV2) GetEpoch(arg0 context.Context, arg1 *v2.GetEpochRequest, arg2 ...grpc.CallOption) (*v2.GetEpochResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetEpoch", varargs...)
	ret0, _ := ret[0].(*v2.GetEpochResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetFeesStats mocks base method.
func (m *MockTradingDataServiceClientV2) GetFeesStats(arg0 context.Context, arg1 *v2.GetFeesStatsRequest, arg2 ...grpc.CallOption) (*v2.GetFeesStatsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetFeesStats", varargs...)
	ret0, _ := ret[0].(*v2.GetFeesStatsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetFeesStatsForParty mocks base method.
func (m *MockTradingDataServiceClientV2) GetFeesStatsForParty(arg0 context.Context, arg1 *v2.GetFeesStatsForPartyRequest, arg2 ...grpc.CallOption) (*v2.GetFeesStatsForPartyResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetFeesStatsForParty", varargs...)
	ret0, _ := ret[0].(*v2.GetFeesStatsForPartyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGovernanceData mocks base method.
func (m *MockTradingDataServiceClientV2) GetGovernanceData(arg0 context.Context, arg1 *v2.GetGovernanceDataRequest, arg2 ...grpc.CallOption) (*v2.GetGovernanceDataResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGovernanceData", varargs...)
	ret0, _ := ret[0].(*v2.GetGovernanceDataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLastTrade mocks base method.
func (m *MockTradingDataServiceClientV2) GetLastTrade(arg0 context.Context, arg1 *v2.GetLastTradeRequest, arg2 ...grpc.CallOption) (*v2.GetLastTradeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLastTrade", varargs...)
	ret0, _ := ret[0].(*v2.GetLastTradeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLatestMarketData mocks base method.
func (m *MockTradingDataServiceClientV2) GetLatestMarketData(arg0 context.Context, arg1 *v2.GetLatestMarketDataRequest, arg2 ...grpc.CallOption) (*v2.GetLatestMarketDataResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLatestMarketData", varargs...)
	ret0, _ := ret[0].(*v2.GetLatestMarketDataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLatestMarketDepth mocks base method.
func (m *MockTradingDataServiceClientV2) GetLatestMarketDepth(arg0 context.Context, arg1 *v2.GetLatestMarketDepthRequest, arg2 ...grpc.CallOption) (*v2.GetLatestMarketDepthResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLatestMarketDepth", varargs...)
	ret0, _ := ret[0].(*v2.GetLatestMarketDepthResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMarket mocks base method.
func (m *MockTradingDataServiceClientV2) GetMarket(arg0 context.Context, arg1 *v2.GetMarketRequest, arg2 ...grpc.CallOption) (*v2.GetMarketResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMarket", varargs...)
	ret0, _ := ret[0].(*v2.GetMarketResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMarketDataHistoryByID mocks base method.
func (m *MockTradingDataServiceClientV2) GetMarketDataHistoryByID(arg0 context.Context, arg1 *v2.GetMarketDataHistoryByIDRequest, arg2 ...grpc.CallOption) (*v2.GetMarketDataHistoryByIDResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMarketDataHistoryByID", varargs...)
	ret0, _ := ret[0].(*v2.GetMarketDataHistoryByIDResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMostRecentNetworkHistorySegment mocks base method.
func (m *MockTradingDataServiceClientV2) GetMostRecentNetworkHistorySegment(arg0 context.Context, arg1 *v2.GetMostRecentNetworkHistorySegmentRequest, arg2 ...grpc.CallOption) (*v2.GetMostRecentNetworkHistorySegmentResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMostRecentNetworkHistorySegment", varargs...)
	ret0, _ := ret[0].(*v2.GetMostRecentNetworkHistorySegmentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkData mocks base method.
func (m *MockTradingDataServiceClientV2) GetNetworkData(arg0 context.Context, arg1 *v2.GetNetworkDataRequest, arg2 ...grpc.CallOption) (*v2.GetNetworkDataResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNetworkData", varargs...)
	ret0, _ := ret[0].(*v2.GetNetworkDataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkHistoryBootstrapPeers mocks base method.
func (m *MockTradingDataServiceClientV2) GetNetworkHistoryBootstrapPeers(arg0 context.Context, arg1 *v2.GetNetworkHistoryBootstrapPeersRequest, arg2 ...grpc.CallOption) (*v2.GetNetworkHistoryBootstrapPeersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNetworkHistoryBootstrapPeers", varargs...)
	ret0, _ := ret[0].(*v2.GetNetworkHistoryBootstrapPeersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkHistoryStatus mocks base method.
func (m *MockTradingDataServiceClientV2) GetNetworkHistoryStatus(arg0 context.Context, arg1 *v2.GetNetworkHistoryStatusRequest, arg2 ...grpc.CallOption) (*v2.GetNetworkHistoryStatusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNetworkHistoryStatus", varargs...)
	ret0, _ := ret[0].(*v2.GetNetworkHistoryStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkLimits mocks base method.
func (m *MockTradingDataServiceClientV2) GetNetworkLimits(arg0 context.Context, arg1 *v2.GetNetworkLimitsRequest, arg2 ...grpc.CallOption) (*v2.GetNetworkLimitsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNetworkLimits", varargs...)
	ret0, _ := ret[0].(*v2.GetNetworkLimitsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNetworkParameter mocks base method.
func (m *MockTradingDataServiceClientV2) GetNetworkParameter(arg0 context.Context, arg1 *v2.GetNetworkParameterRequest, arg2 ...grpc.CallOption) (*v2.GetNetworkParameterResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNetworkParameter", varargs...)
	ret0, _ := ret[0].(*v2.GetNetworkParameterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNode mocks base method.
func (m *MockTradingDataServiceClientV2) GetNode(arg0 context.Context, arg1 *v2.GetNodeRequest, arg2 ...grpc.CallOption) (*v2.GetNodeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNode", varargs...)
	ret0, _ := ret[0].(*v2.GetNodeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOracleSpec mocks base method.
func (m *MockTradingDataServiceClientV2) GetOracleSpec(arg0 context.Context, arg1 *v2.GetOracleSpecRequest, arg2 ...grpc.CallOption) (*v2.GetOracleSpecResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetOracleSpec", varargs...)
	ret0, _ := ret[0].(*v2.GetOracleSpecResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOrder mocks base method.
func (m *MockTradingDataServiceClientV2) GetOrder(arg0 context.Context, arg1 *v2.GetOrderRequest, arg2 ...grpc.CallOption) (*v2.GetOrderResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetOrder", varargs...)
	ret0, _ := ret[0].(*v2.GetOrderResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetParty mocks base method.
func (m *MockTradingDataServiceClientV2) GetParty(arg0 context.Context, arg1 *v2.GetPartyRequest, arg2 ...grpc.CallOption) (*v2.GetPartyResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetParty", varargs...)
	ret0, _ := ret[0].(*v2.GetPartyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPartyActivityStreak mocks base method.
func (m *MockTradingDataServiceClientV2) GetPartyActivityStreak(arg0 context.Context, arg1 *v2.GetPartyActivityStreakRequest, arg2 ...grpc.CallOption) (*v2.GetPartyActivityStreakResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPartyActivityStreak", varargs...)
	ret0, _ := ret[0].(*v2.GetPartyActivityStreakResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPartyVestingStats mocks base method.
func (m *MockTradingDataServiceClientV2) GetPartyVestingStats(arg0 context.Context, arg1 *v2.GetPartyVestingStatsRequest, arg2 ...grpc.CallOption) (*v2.GetPartyVestingStatsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPartyVestingStats", varargs...)
	ret0, _ := ret[0].(*v2.GetPartyVestingStatsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetProtocolUpgradeStatus mocks base method.
func (m *MockTradingDataServiceClientV2) GetProtocolUpgradeStatus(arg0 context.Context, arg1 *v2.GetProtocolUpgradeStatusRequest, arg2 ...grpc.CallOption) (*v2.GetProtocolUpgradeStatusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetProtocolUpgradeStatus", varargs...)
	ret0, _ := ret[0].(*v2.GetProtocolUpgradeStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetReferralSetStats mocks base method.
func (m *MockTradingDataServiceClientV2) GetReferralSetStats(arg0 context.Context, arg1 *v2.GetReferralSetStatsRequest, arg2 ...grpc.CallOption) (*v2.GetReferralSetStatsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetReferralSetStats", varargs...)
	ret0, _ := ret[0].(*v2.GetReferralSetStatsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRiskFactors mocks base method.
func (m *MockTradingDataServiceClientV2) GetRiskFactors(arg0 context.Context, arg1 *v2.GetRiskFactorsRequest, arg2 ...grpc.CallOption) (*v2.GetRiskFactorsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRiskFactors", varargs...)
	ret0, _ := ret[0].(*v2.GetRiskFactorsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetStake mocks base method.
func (m *MockTradingDataServiceClientV2) GetStake(arg0 context.Context, arg1 *v2.GetStakeRequest, arg2 ...grpc.CallOption) (*v2.GetStakeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetStake", varargs...)
	ret0, _ := ret[0].(*v2.GetStakeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetStopOrder mocks base method.
func (m *MockTradingDataServiceClientV2) GetStopOrder(arg0 context.Context, arg1 *v2.GetStopOrderRequest, arg2 ...grpc.CallOption) (*v2.GetStopOrderResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetStopOrder", varargs...)
	ret0, _ := ret[0].(*v2.GetStopOrderResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTimeWeightedNotionalPosition mocks base method.
func (m *MockTradingDataServiceClientV2) GetTimeWeightedNotionalPosition(arg0 context.Context, arg1 *v2.GetTimeWeightedNotionalPositionRequest, arg2 ...grpc.CallOption) (*v2.GetTimeWeightedNotionalPositionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTimeWeightedNotionalPosition", varargs...)
	ret0, _ := ret[0].(*v2.GetTimeWeightedNotionalPositionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTotalTransferFeeDiscount mocks base method.
func (m *MockTradingDataServiceClientV2) GetTotalTransferFeeDiscount(arg0 context.Context, arg1 *v2.GetTotalTransferFeeDiscountRequest, arg2 ...grpc.CallOption) (*v2.GetTotalTransferFeeDiscountResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTotalTransferFeeDiscount", varargs...)
	ret0, _ := ret[0].(*v2.GetTotalTransferFeeDiscountResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTransfer mocks base method.
func (m *MockTradingDataServiceClientV2) GetTransfer(arg0 context.Context, arg1 *v2.GetTransferRequest, arg2 ...grpc.CallOption) (*v2.GetTransferResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTransfer", varargs...)
	ret0, _ := ret[0].(*v2.GetTransferResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetVegaTime mocks base method.
func (m *MockTradingDataServiceClientV2) GetVegaTime(arg0 context.Context, arg1 *v2.GetVegaTimeRequest, arg2 ...grpc.CallOption) (*v2.GetVegaTimeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVegaTime", varargs...)
	ret0, _ := ret[0].(*v2.GetVegaTimeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetVestingBalancesSummary mocks base method.
func (m *MockTradingDataServiceClientV2) GetVestingBalancesSummary(arg0 context.Context, arg1 *v2.GetVestingBalancesSummaryRequest, arg2 ...grpc.CallOption) (*v2.GetVestingBalancesSummaryResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVestingBalancesSummary", varargs...)
	ret0, _ := ret[0].(*v2.GetVestingBalancesSummaryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetVolumeDiscountStats mocks base method.
func (m *MockTradingDataServiceClientV2) GetVolumeDiscountStats(arg0 context.Context, arg1 *v2.GetVolumeDiscountStatsRequest, arg2 ...grpc.CallOption) (*v2.GetVolumeDiscountStatsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVolumeDiscountStats", varargs...)
	ret0, _ := ret[0].(*v2.GetVolumeDiscountStatsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWithdrawal mocks base method.
func (m *MockTradingDataServiceClientV2) GetWithdrawal(arg0 context.Context, arg1 *v2.GetWithdrawalRequest, arg2 ...grpc.CallOption) (*v2.GetWithdrawalResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetWithdrawal", varargs...)
	ret0, _ := ret[0].(*v2.GetWithdrawalResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Info mocks base method.
func (m *MockTradingDataServiceClientV2) Info(arg0 context.Context, arg1 *v2.InfoRequest, arg2 ...grpc.CallOption) (*v2.InfoResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Info", varargs...)
	ret0, _ := ret[0].(*v2.InfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAccounts mocks base method.
func (m *MockTradingDataServiceClientV2) ListAccounts(arg0 context.Context, arg1 *v2.ListAccountsRequest, arg2 ...grpc.CallOption) (*v2.ListAccountsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAccounts", varargs...)
	ret0, _ := ret[0].(*v2.ListAccountsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAllLiquidityProvisions mocks base method.
func (m *MockTradingDataServiceClientV2) ListAllLiquidityProvisions(arg0 context.Context, arg1 *v2.ListAllLiquidityProvisionsRequest, arg2 ...grpc.CallOption) (*v2.ListAllLiquidityProvisionsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAllLiquidityProvisions", varargs...)
	ret0, _ := ret[0].(*v2.ListAllLiquidityProvisionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAllNetworkHistorySegments mocks base method.
func (m *MockTradingDataServiceClientV2) ListAllNetworkHistorySegments(arg0 context.Context, arg1 *v2.ListAllNetworkHistorySegmentsRequest, arg2 ...grpc.CallOption) (*v2.ListAllNetworkHistorySegmentsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAllNetworkHistorySegments", varargs...)
	ret0, _ := ret[0].(*v2.ListAllNetworkHistorySegmentsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAllPositions mocks base method.
func (m *MockTradingDataServiceClientV2) ListAllPositions(arg0 context.Context, arg1 *v2.ListAllPositionsRequest, arg2 ...grpc.CallOption) (*v2.ListAllPositionsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAllPositions", varargs...)
	ret0, _ := ret[0].(*v2.ListAllPositionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAssets mocks base method.
func (m *MockTradingDataServiceClientV2) ListAssets(arg0 context.Context, arg1 *v2.ListAssetsRequest, arg2 ...grpc.CallOption) (*v2.ListAssetsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAssets", varargs...)
	ret0, _ := ret[0].(*v2.ListAssetsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBalanceChanges mocks base method.
func (m *MockTradingDataServiceClientV2) ListBalanceChanges(arg0 context.Context, arg1 *v2.ListBalanceChangesRequest, arg2 ...grpc.CallOption) (*v2.ListBalanceChangesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBalanceChanges", varargs...)
	ret0, _ := ret[0].(*v2.ListBalanceChangesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListCandleData mocks base method.
func (m *MockTradingDataServiceClientV2) ListCandleData(arg0 context.Context, arg1 *v2.ListCandleDataRequest, arg2 ...grpc.CallOption) (*v2.ListCandleDataResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCandleData", varargs...)
	ret0, _ := ret[0].(*v2.ListCandleDataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListCandleIntervals mocks base method.
func (m *MockTradingDataServiceClientV2) ListCandleIntervals(arg0 context.Context, arg1 *v2.ListCandleIntervalsRequest, arg2 ...grpc.CallOption) (*v2.ListCandleIntervalsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCandleIntervals", varargs...)
	ret0, _ := ret[0].(*v2.ListCandleIntervalsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListCheckpoints mocks base method.
func (m *MockTradingDataServiceClientV2) ListCheckpoints(arg0 context.Context, arg1 *v2.ListCheckpointsRequest, arg2 ...grpc.CallOption) (*v2.ListCheckpointsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCheckpoints", varargs...)
	ret0, _ := ret[0].(*v2.ListCheckpointsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListCoreSnapshots mocks base method.
func (m *MockTradingDataServiceClientV2) ListCoreSnapshots(arg0 context.Context, arg1 *v2.ListCoreSnapshotsRequest, arg2 ...grpc.CallOption) (*v2.ListCoreSnapshotsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCoreSnapshots", varargs...)
	ret0, _ := ret[0].(*v2.ListCoreSnapshotsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDelegations mocks base method.
func (m *MockTradingDataServiceClientV2) ListDelegations(arg0 context.Context, arg1 *v2.ListDelegationsRequest, arg2 ...grpc.CallOption) (*v2.ListDelegationsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDelegations", varargs...)
	ret0, _ := ret[0].(*v2.ListDelegationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDeposits mocks base method.
func (m *MockTradingDataServiceClientV2) ListDeposits(arg0 context.Context, arg1 *v2.ListDepositsRequest, arg2 ...grpc.CallOption) (*v2.ListDepositsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDeposits", varargs...)
	ret0, _ := ret[0].(*v2.ListDepositsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListERC20MultiSigSignerAddedBundles mocks base method.
func (m *MockTradingDataServiceClientV2) ListERC20MultiSigSignerAddedBundles(arg0 context.Context, arg1 *v2.ListERC20MultiSigSignerAddedBundlesRequest, arg2 ...grpc.CallOption) (*v2.ListERC20MultiSigSignerAddedBundlesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListERC20MultiSigSignerAddedBundles", varargs...)
	ret0, _ := ret[0].(*v2.ListERC20MultiSigSignerAddedBundlesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListERC20MultiSigSignerRemovedBundles mocks base method.
func (m *MockTradingDataServiceClientV2) ListERC20MultiSigSignerRemovedBundles(arg0 context.Context, arg1 *v2.ListERC20MultiSigSignerRemovedBundlesRequest, arg2 ...grpc.CallOption) (*v2.ListERC20MultiSigSignerRemovedBundlesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListERC20MultiSigSignerRemovedBundles", varargs...)
	ret0, _ := ret[0].(*v2.ListERC20MultiSigSignerRemovedBundlesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListEntities mocks base method.
func (m *MockTradingDataServiceClientV2) ListEntities(arg0 context.Context, arg1 *v2.ListEntitiesRequest, arg2 ...grpc.CallOption) (*v2.ListEntitiesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListEntities", varargs...)
	ret0, _ := ret[0].(*v2.ListEntitiesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListEpochRewardSummaries mocks base method.
func (m *MockTradingDataServiceClientV2) ListEpochRewardSummaries(arg0 context.Context, arg1 *v2.ListEpochRewardSummariesRequest, arg2 ...grpc.CallOption) (*v2.ListEpochRewardSummariesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListEpochRewardSummaries", varargs...)
	ret0, _ := ret[0].(*v2.ListEpochRewardSummariesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListEthereumKeyRotations mocks base method.
func (m *MockTradingDataServiceClientV2) ListEthereumKeyRotations(arg0 context.Context, arg1 *v2.ListEthereumKeyRotationsRequest, arg2 ...grpc.CallOption) (*v2.ListEthereumKeyRotationsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListEthereumKeyRotations", varargs...)
	ret0, _ := ret[0].(*v2.ListEthereumKeyRotationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListFundingPayments mocks base method.
func (m *MockTradingDataServiceClientV2) ListFundingPayments(arg0 context.Context, arg1 *v2.ListFundingPaymentsRequest, arg2 ...grpc.CallOption) (*v2.ListFundingPaymentsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListFundingPayments", varargs...)
	ret0, _ := ret[0].(*v2.ListFundingPaymentsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListFundingPeriodDataPoints mocks base method.
func (m *MockTradingDataServiceClientV2) ListFundingPeriodDataPoints(arg0 context.Context, arg1 *v2.ListFundingPeriodDataPointsRequest, arg2 ...grpc.CallOption) (*v2.ListFundingPeriodDataPointsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListFundingPeriodDataPoints", varargs...)
	ret0, _ := ret[0].(*v2.ListFundingPeriodDataPointsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListFundingPeriods mocks base method.
func (m *MockTradingDataServiceClientV2) ListFundingPeriods(arg0 context.Context, arg1 *v2.ListFundingPeriodsRequest, arg2 ...grpc.CallOption) (*v2.ListFundingPeriodsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListFundingPeriods", varargs...)
	ret0, _ := ret[0].(*v2.ListFundingPeriodsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGamePartyScores mocks base method.
func (m *MockTradingDataServiceClientV2) ListGamePartyScores(arg0 context.Context, arg1 *v2.ListGamePartyScoresRequest, arg2 ...grpc.CallOption) (*v2.ListGamePartyScoresResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGamePartyScores", varargs...)
	ret0, _ := ret[0].(*v2.ListGamePartyScoresResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGameTeamScores mocks base method.
func (m *MockTradingDataServiceClientV2) ListGameTeamScores(arg0 context.Context, arg1 *v2.ListGameTeamScoresRequest, arg2 ...grpc.CallOption) (*v2.ListGameTeamScoresResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGameTeamScores", varargs...)
	ret0, _ := ret[0].(*v2.ListGameTeamScoresResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGames mocks base method.
func (m *MockTradingDataServiceClientV2) ListGames(arg0 context.Context, arg1 *v2.ListGamesRequest, arg2 ...grpc.CallOption) (*v2.ListGamesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGames", varargs...)
	ret0, _ := ret[0].(*v2.ListGamesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGovernanceData mocks base method.
func (m *MockTradingDataServiceClientV2) ListGovernanceData(arg0 context.Context, arg1 *v2.ListGovernanceDataRequest, arg2 ...grpc.CallOption) (*v2.ListGovernanceDataResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGovernanceData", varargs...)
	ret0, _ := ret[0].(*v2.ListGovernanceDataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListKeyRotations mocks base method.
func (m *MockTradingDataServiceClientV2) ListKeyRotations(arg0 context.Context, arg1 *v2.ListKeyRotationsRequest, arg2 ...grpc.CallOption) (*v2.ListKeyRotationsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListKeyRotations", varargs...)
	ret0, _ := ret[0].(*v2.ListKeyRotationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListLatestMarketData mocks base method.
func (m *MockTradingDataServiceClientV2) ListLatestMarketData(arg0 context.Context, arg1 *v2.ListLatestMarketDataRequest, arg2 ...grpc.CallOption) (*v2.ListLatestMarketDataResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListLatestMarketData", varargs...)
	ret0, _ := ret[0].(*v2.ListLatestMarketDataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListLedgerEntries mocks base method.
func (m *MockTradingDataServiceClientV2) ListLedgerEntries(arg0 context.Context, arg1 *v2.ListLedgerEntriesRequest, arg2 ...grpc.CallOption) (*v2.ListLedgerEntriesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListLedgerEntries", varargs...)
	ret0, _ := ret[0].(*v2.ListLedgerEntriesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListLiquidityProviders mocks base method.
func (m *MockTradingDataServiceClientV2) ListLiquidityProviders(arg0 context.Context, arg1 *v2.ListLiquidityProvidersRequest, arg2 ...grpc.CallOption) (*v2.ListLiquidityProvidersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListLiquidityProviders", varargs...)
	ret0, _ := ret[0].(*v2.ListLiquidityProvidersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListLiquidityProvisions mocks base method.
func (m *MockTradingDataServiceClientV2) ListLiquidityProvisions(arg0 context.Context, arg1 *v2.ListLiquidityProvisionsRequest, arg2 ...grpc.CallOption) (*v2.ListLiquidityProvisionsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListLiquidityProvisions", varargs...)
	ret0, _ := ret[0].(*v2.ListLiquidityProvisionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListMarginLevels mocks base method.
func (m *MockTradingDataServiceClientV2) ListMarginLevels(arg0 context.Context, arg1 *v2.ListMarginLevelsRequest, arg2 ...grpc.CallOption) (*v2.ListMarginLevelsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMarginLevels", varargs...)
	ret0, _ := ret[0].(*v2.ListMarginLevelsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListMarkets mocks base method.
func (m *MockTradingDataServiceClientV2) ListMarkets(arg0 context.Context, arg1 *v2.ListMarketsRequest, arg2 ...grpc.CallOption) (*v2.ListMarketsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMarkets", varargs...)
	ret0, _ := ret[0].(*v2.ListMarketsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNetworkParameters mocks base method.
func (m *MockTradingDataServiceClientV2) ListNetworkParameters(arg0 context.Context, arg1 *v2.ListNetworkParametersRequest, arg2 ...grpc.CallOption) (*v2.ListNetworkParametersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNetworkParameters", varargs...)
	ret0, _ := ret[0].(*v2.ListNetworkParametersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNodeSignatures mocks base method.
func (m *MockTradingDataServiceClientV2) ListNodeSignatures(arg0 context.Context, arg1 *v2.ListNodeSignaturesRequest, arg2 ...grpc.CallOption) (*v2.ListNodeSignaturesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNodeSignatures", varargs...)
	ret0, _ := ret[0].(*v2.ListNodeSignaturesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNodes mocks base method.
func (m *MockTradingDataServiceClientV2) ListNodes(arg0 context.Context, arg1 *v2.ListNodesRequest, arg2 ...grpc.CallOption) (*v2.ListNodesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNodes", varargs...)
	ret0, _ := ret[0].(*v2.ListNodesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListOracleData mocks base method.
func (m *MockTradingDataServiceClientV2) ListOracleData(arg0 context.Context, arg1 *v2.ListOracleDataRequest, arg2 ...grpc.CallOption) (*v2.ListOracleDataResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListOracleData", varargs...)
	ret0, _ := ret[0].(*v2.ListOracleDataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListOracleSpecs mocks base method.
func (m *MockTradingDataServiceClientV2) ListOracleSpecs(arg0 context.Context, arg1 *v2.ListOracleSpecsRequest, arg2 ...grpc.CallOption) (*v2.ListOracleSpecsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListOracleSpecs", varargs...)
	ret0, _ := ret[0].(*v2.ListOracleSpecsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListOrderVersions mocks base method.
func (m *MockTradingDataServiceClientV2) ListOrderVersions(arg0 context.Context, arg1 *v2.ListOrderVersionsRequest, arg2 ...grpc.CallOption) (*v2.ListOrderVersionsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListOrderVersions", varargs...)
	ret0, _ := ret[0].(*v2.ListOrderVersionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListOrders mocks base method.
func (m *MockTradingDataServiceClientV2) ListOrders(arg0 context.Context, arg1 *v2.ListOrdersRequest, arg2 ...grpc.CallOption) (*v2.ListOrdersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListOrders", varargs...)
	ret0, _ := ret[0].(*v2.ListOrdersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPaidLiquidityFees mocks base method.
func (m *MockTradingDataServiceClientV2) ListPaidLiquidityFees(arg0 context.Context, arg1 *v2.ListPaidLiquidityFeesRequest, arg2 ...grpc.CallOption) (*v2.ListPaidLiquidityFeesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPaidLiquidityFees", varargs...)
	ret0, _ := ret[0].(*v2.ListPaidLiquidityFeesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListParties mocks base method.
func (m *MockTradingDataServiceClientV2) ListParties(arg0 context.Context, arg1 *v2.ListPartiesRequest, arg2 ...grpc.CallOption) (*v2.ListPartiesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListParties", varargs...)
	ret0, _ := ret[0].(*v2.ListPartiesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPartiesProfiles mocks base method.
func (m *MockTradingDataServiceClientV2) ListPartiesProfiles(arg0 context.Context, arg1 *v2.ListPartiesProfilesRequest, arg2 ...grpc.CallOption) (*v2.ListPartiesProfilesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPartiesProfiles", varargs...)
	ret0, _ := ret[0].(*v2.ListPartiesProfilesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPartyMarginModes mocks base method.
func (m *MockTradingDataServiceClientV2) ListPartyMarginModes(arg0 context.Context, arg1 *v2.ListPartyMarginModesRequest, arg2 ...grpc.CallOption) (*v2.ListPartyMarginModesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPartyMarginModes", varargs...)
	ret0, _ := ret[0].(*v2.ListPartyMarginModesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPositions mocks base method.
func (m *MockTradingDataServiceClientV2) ListPositions(arg0 context.Context, arg1 *v2.ListPositionsRequest, arg2 ...grpc.CallOption) (*v2.ListPositionsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPositions", varargs...)
	ret0, _ := ret[0].(*v2.ListPositionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListProtocolUpgradeProposals mocks base method.
func (m *MockTradingDataServiceClientV2) ListProtocolUpgradeProposals(arg0 context.Context, arg1 *v2.ListProtocolUpgradeProposalsRequest, arg2 ...grpc.CallOption) (*v2.ListProtocolUpgradeProposalsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListProtocolUpgradeProposals", varargs...)
	ret0, _ := ret[0].(*v2.ListProtocolUpgradeProposalsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListReferralSetReferees mocks base method.
func (m *MockTradingDataServiceClientV2) ListReferralSetReferees(arg0 context.Context, arg1 *v2.ListReferralSetRefereesRequest, arg2 ...grpc.CallOption) (*v2.ListReferralSetRefereesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListReferralSetReferees", varargs...)
	ret0, _ := ret[0].(*v2.ListReferralSetRefereesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListReferralSets mocks base method.
func (m *MockTradingDataServiceClientV2) ListReferralSets(arg0 context.Context, arg1 *v2.ListReferralSetsRequest, arg2 ...grpc.CallOption) (*v2.ListReferralSetsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListReferralSets", varargs...)
	ret0, _ := ret[0].(*v2.ListReferralSetsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListRewardSummaries mocks base method.
func (m *MockTradingDataServiceClientV2) ListRewardSummaries(arg0 context.Context, arg1 *v2.ListRewardSummariesRequest, arg2 ...grpc.CallOption) (*v2.ListRewardSummariesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRewardSummaries", varargs...)
	ret0, _ := ret[0].(*v2.ListRewardSummariesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListRewards mocks base method.
func (m *MockTradingDataServiceClientV2) ListRewards(arg0 context.Context, arg1 *v2.ListRewardsRequest, arg2 ...grpc.CallOption) (*v2.ListRewardsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListRewards", varargs...)
	ret0, _ := ret[0].(*v2.ListRewardsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListStopOrders mocks base method.
func (m *MockTradingDataServiceClientV2) ListStopOrders(arg0 context.Context, arg1 *v2.ListStopOrdersRequest, arg2 ...grpc.CallOption) (*v2.ListStopOrdersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListStopOrders", varargs...)
	ret0, _ := ret[0].(*v2.ListStopOrdersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListSuccessorMarkets mocks base method.
func (m *MockTradingDataServiceClientV2) ListSuccessorMarkets(arg0 context.Context, arg1 *v2.ListSuccessorMarketsRequest, arg2 ...grpc.CallOption) (*v2.ListSuccessorMarketsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSuccessorMarkets", varargs...)
	ret0, _ := ret[0].(*v2.ListSuccessorMarketsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTeamMembersStatistics mocks base method.
func (m *MockTradingDataServiceClientV2) ListTeamMembersStatistics(arg0 context.Context, arg1 *v2.ListTeamMembersStatisticsRequest, arg2 ...grpc.CallOption) (*v2.ListTeamMembersStatisticsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTeamMembersStatistics", varargs...)
	ret0, _ := ret[0].(*v2.ListTeamMembersStatisticsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTeamRefereeHistory mocks base method.
func (m *MockTradingDataServiceClientV2) ListTeamRefereeHistory(arg0 context.Context, arg1 *v2.ListTeamRefereeHistoryRequest, arg2 ...grpc.CallOption) (*v2.ListTeamRefereeHistoryResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTeamRefereeHistory", varargs...)
	ret0, _ := ret[0].(*v2.ListTeamRefereeHistoryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTeamReferees mocks base method.
func (m *MockTradingDataServiceClientV2) ListTeamReferees(arg0 context.Context, arg1 *v2.ListTeamRefereesRequest, arg2 ...grpc.CallOption) (*v2.ListTeamRefereesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTeamReferees", varargs...)
	ret0, _ := ret[0].(*v2.ListTeamRefereesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTeams mocks base method.
func (m *MockTradingDataServiceClientV2) ListTeams(arg0 context.Context, arg1 *v2.ListTeamsRequest, arg2 ...grpc.CallOption) (*v2.ListTeamsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTeams", varargs...)
	ret0, _ := ret[0].(*v2.ListTeamsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTeamsStatistics mocks base method.
func (m *MockTradingDataServiceClientV2) ListTeamsStatistics(arg0 context.Context, arg1 *v2.ListTeamsStatisticsRequest, arg2 ...grpc.CallOption) (*v2.ListTeamsStatisticsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTeamsStatistics", varargs...)
	ret0, _ := ret[0].(*v2.ListTeamsStatisticsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTrades mocks base method.
func (m *MockTradingDataServiceClientV2) ListTrades(arg0 context.Context, arg1 *v2.ListTradesRequest, arg2 ...grpc.CallOption) (*v2.ListTradesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTrades", varargs...)
	ret0, _ := ret[0].(*v2.ListTradesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTransfers mocks base method.
func (m *MockTradingDataServiceClientV2) ListTransfers(arg0 context.Context, arg1 *v2.ListTransfersRequest, arg2 ...grpc.CallOption) (*v2.ListTransfersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTransfers", varargs...)
	ret0, _ := ret[0].(*v2.ListTransfersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListVotes mocks base method.
func (m *MockTradingDataServiceClientV2) ListVotes(arg0 context.Context, arg1 *v2.ListVotesRequest, arg2 ...grpc.CallOption) (*v2.ListVotesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListVotes", varargs...)
	ret0, _ := ret[0].(*v2.ListVotesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListWithdrawals mocks base method.
func (m *MockTradingDataServiceClientV2) ListWithdrawals(arg0 context.Context, arg1 *v2.ListWithdrawalsRequest, arg2 ...grpc.CallOption) (*v2.ListWithdrawalsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListWithdrawals", varargs...)
	ret0, _ := ret[0].(*v2.ListWithdrawalsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObserveAccounts mocks base method.
func (m *MockTradingDataServiceClientV2) ObserveAccounts(arg0 context.Context, arg1 *v2.ObserveAccountsRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ObserveAccountsClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveAccounts", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObserveAccountsClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObserveCandleData mocks base method.
func (m *MockTradingDataServiceClientV2) ObserveCandleData(arg0 context.Context, arg1 *v2.ObserveCandleDataRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ObserveCandleDataClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveCandleData", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObserveCandleDataClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObserveEventBus mocks base method.
func (m *MockTradingDataServiceClientV2) ObserveEventBus(arg0 context.Context, arg1 ...grpc.CallOption) (v2.TradingDataService_ObserveEventBusClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveEventBus", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObserveEventBusClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ObserveEventBus indicates an expected call of ObserveEventBus.
func (mr *MockTradingDataServiceClientV2MockRecorder) ObserveEventBus(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObserveEventBus", reflect.TypeOf((*MockTradingDataServiceClientV2)(nil).ObserveEventBus), varargs...)
}

// ObserveGovernance mocks base method.
func (m *MockTradingDataServiceClientV2) ObserveGovernance(arg0 context.Context, arg1 *v2.ObserveGovernanceRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ObserveGovernanceClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveGovernance", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObserveGovernanceClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObserveLedgerMovements mocks base method.
func (m *MockTradingDataServiceClientV2) ObserveLedgerMovements(arg0 context.Context, arg1 *v2.ObserveLedgerMovementsRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ObserveLedgerMovementsClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveLedgerMovements", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObserveLedgerMovementsClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObserveLiquidityProvisions mocks base method.
func (m *MockTradingDataServiceClientV2) ObserveLiquidityProvisions(arg0 context.Context, arg1 *v2.ObserveLiquidityProvisionsRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ObserveLiquidityProvisionsClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveLiquidityProvisions", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObserveLiquidityProvisionsClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObserveMarginLevels mocks base method.
func (m *MockTradingDataServiceClientV2) ObserveMarginLevels(arg0 context.Context, arg1 *v2.ObserveMarginLevelsRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ObserveMarginLevelsClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveMarginLevels", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObserveMarginLevelsClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObserveMarketsData mocks base method.
func (m *MockTradingDataServiceClientV2) ObserveMarketsData(arg0 context.Context, arg1 *v2.ObserveMarketsDataRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ObserveMarketsDataClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveMarketsData", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObserveMarketsDataClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObserveMarketsDepth mocks base method.
func (m *MockTradingDataServiceClientV2) ObserveMarketsDepth(arg0 context.Context, arg1 *v2.ObserveMarketsDepthRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ObserveMarketsDepthClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveMarketsDepth", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObserveMarketsDepthClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObserveMarketsDepthUpdates mocks base method.
func (m *MockTradingDataServiceClientV2) ObserveMarketsDepthUpdates(arg0 context.Context, arg1 *v2.ObserveMarketsDepthUpdatesRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ObserveMarketsDepthUpdatesClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveMarketsDepthUpdates", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObserveMarketsDepthUpdatesClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObserveOrders mocks base method.
func (m *MockTradingDataServiceClientV2) ObserveOrders(arg0 context.Context, arg1 *v2.ObserveOrdersRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ObserveOrdersClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveOrders", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObserveOrdersClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObservePositions mocks base method.
func (m *MockTradingDataServiceClientV2) ObservePositions(arg0 context.Context, arg1 *v2.ObservePositionsRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ObservePositionsClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObservePositions", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObservePositionsClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObserveTrades mocks base method.
func (m *MockTradingDataServiceClientV2) ObserveTrades(arg0 context.Context, arg1 *v2.ObserveTradesRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ObserveTradesClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveTrades", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObserveTradesClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObserveTransactionResults mocks base method.
func (m *MockTradingDataServiceClientV2) ObserveTransactionResults(arg0 context.Context, arg1 *v2.ObserveTransactionResultsRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ObserveTransactionResultsClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveTransactionResults", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObserveTransactionResultsClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ObserveVotes mocks base method.
func (m *MockTradingDataServiceClientV2) ObserveVotes(arg0 context.Context, arg1 *v2.ObserveVotesRequest, arg2 ...grpc.CallOption) (v2.TradingDataService_ObserveVotesClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ObserveVotes", varargs...)
	ret0, _ := ret[0].(v2.TradingDataService_ObserveVotesClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Ping mocks base method.
func (m *MockTradingDataServiceClientV2) Ping(arg0 context.Context, arg1 *v2.PingRequest, arg2 ...grpc.CallOption) (*v2.PingResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Ping", varargs...)
	ret0, _ := ret[0].(*v2.PingResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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