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

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

import (
	reflect "reflect"

	entity "github.com/toc-taiwan/toc-machine-trading/internal/entity"
	pb "github.com/toc-taiwan/toc-trade-protobuf/golang/pb"
	gomock "go.uber.org/mock/gomock"
)

// MockBasicgRPCAPI is a mock of BasicgRPCAPI interface.
type MockBasicgRPCAPI struct {
	ctrl     *gomock.Controller
	recorder *MockBasicgRPCAPIMockRecorder
}

// MockBasicgRPCAPIMockRecorder is the mock recorder for MockBasicgRPCAPI.
type MockBasicgRPCAPIMockRecorder struct {
	mock *MockBasicgRPCAPI
}

// NewMockBasicgRPCAPI creates a new mock instance.
func NewMockBasicgRPCAPI(ctrl *gomock.Controller) *MockBasicgRPCAPI {
	mock := &MockBasicgRPCAPI{ctrl: ctrl}
	mock.recorder = &MockBasicgRPCAPIMockRecorder{mock}
	return mock
}

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

// CheckUsage mocks base method.
func (m *MockBasicgRPCAPI) CheckUsage() (*pb.ShioajiUsage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckUsage")
	ret0, _ := ret[0].(*pb.ShioajiUsage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetAllFutureDetail mocks base method.
func (m *MockBasicgRPCAPI) GetAllFutureDetail() ([]*pb.FutureDetailMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllFutureDetail")
	ret0, _ := ret[0].([]*pb.FutureDetailMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAllOptionDetail mocks base method.
func (m *MockBasicgRPCAPI) GetAllOptionDetail() ([]*pb.OptionDetailMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllOptionDetail")
	ret0, _ := ret[0].([]*pb.OptionDetailMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAllStockDetail mocks base method.
func (m *MockBasicgRPCAPI) GetAllStockDetail() ([]*pb.StockDetailMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllStockDetail")
	ret0, _ := ret[0].([]*pb.StockDetailMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockHistorygRPCAPI is a mock of HistorygRPCAPI interface.
type MockHistorygRPCAPI struct {
	ctrl     *gomock.Controller
	recorder *MockHistorygRPCAPIMockRecorder
}

// MockHistorygRPCAPIMockRecorder is the mock recorder for MockHistorygRPCAPI.
type MockHistorygRPCAPIMockRecorder struct {
	mock *MockHistorygRPCAPI
}

// NewMockHistorygRPCAPI creates a new mock instance.
func NewMockHistorygRPCAPI(ctrl *gomock.Controller) *MockHistorygRPCAPI {
	mock := &MockHistorygRPCAPI{ctrl: ctrl}
	mock.recorder = &MockHistorygRPCAPIMockRecorder{mock}
	return mock
}

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

// GetFutureHistoryKbar mocks base method.
func (m *MockHistorygRPCAPI) GetFutureHistoryKbar(codeArr []string, date string) (*pb.HistoryKbarResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFutureHistoryKbar", codeArr, date)
	ret0, _ := ret[0].(*pb.HistoryKbarResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFutureHistoryKbar indicates an expected call of GetFutureHistoryKbar.
func (mr *MockHistorygRPCAPIMockRecorder) GetFutureHistoryKbar(codeArr, date any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFutureHistoryKbar", reflect.TypeOf((*MockHistorygRPCAPI)(nil).GetFutureHistoryKbar), codeArr, date)
}

// GetStockHistoryClose mocks base method.
func (m *MockHistorygRPCAPI) GetStockHistoryClose(stockNumArr []string, date string) ([]*pb.HistoryCloseMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStockHistoryClose", stockNumArr, date)
	ret0, _ := ret[0].([]*pb.HistoryCloseMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStockHistoryClose indicates an expected call of GetStockHistoryClose.
func (mr *MockHistorygRPCAPIMockRecorder) GetStockHistoryClose(stockNumArr, date any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStockHistoryClose", reflect.TypeOf((*MockHistorygRPCAPI)(nil).GetStockHistoryClose), stockNumArr, date)
}

// GetStockHistoryKbar mocks base method.
func (m *MockHistorygRPCAPI) GetStockHistoryKbar(stockNumArr []string, date string) ([]*pb.HistoryKbarMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStockHistoryKbar", stockNumArr, date)
	ret0, _ := ret[0].([]*pb.HistoryKbarMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStockHistoryKbar indicates an expected call of GetStockHistoryKbar.
func (mr *MockHistorygRPCAPIMockRecorder) GetStockHistoryKbar(stockNumArr, date any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStockHistoryKbar", reflect.TypeOf((*MockHistorygRPCAPI)(nil).GetStockHistoryKbar), stockNumArr, date)
}

// GetStockHistoryTick mocks base method.
func (m *MockHistorygRPCAPI) GetStockHistoryTick(stockNumArr []string, date string) ([]*pb.HistoryTickMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStockHistoryTick", stockNumArr, date)
	ret0, _ := ret[0].([]*pb.HistoryTickMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStockHistoryTick indicates an expected call of GetStockHistoryTick.
func (mr *MockHistorygRPCAPIMockRecorder) GetStockHistoryTick(stockNumArr, date any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStockHistoryTick", reflect.TypeOf((*MockHistorygRPCAPI)(nil).GetStockHistoryTick), stockNumArr, date)
}

// MockRealTimegRPCAPI is a mock of RealTimegRPCAPI interface.
type MockRealTimegRPCAPI struct {
	ctrl     *gomock.Controller
	recorder *MockRealTimegRPCAPIMockRecorder
}

// MockRealTimegRPCAPIMockRecorder is the mock recorder for MockRealTimegRPCAPI.
type MockRealTimegRPCAPIMockRecorder struct {
	mock *MockRealTimegRPCAPI
}

// NewMockRealTimegRPCAPI creates a new mock instance.
func NewMockRealTimegRPCAPI(ctrl *gomock.Controller) *MockRealTimegRPCAPI {
	mock := &MockRealTimegRPCAPI{ctrl: ctrl}
	mock.recorder = &MockRealTimegRPCAPIMockRecorder{mock}
	return mock
}

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

// GetAllStockSnapshot mocks base method.
func (m *MockRealTimegRPCAPI) GetAllStockSnapshot() ([]*pb.SnapshotMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllStockSnapshot")
	ret0, _ := ret[0].([]*pb.SnapshotMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetFutureSnapshotByCode mocks base method.
func (m *MockRealTimegRPCAPI) GetFutureSnapshotByCode(code string) (*pb.SnapshotMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFutureSnapshotByCode", code)
	ret0, _ := ret[0].(*pb.SnapshotMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFutureSnapshotByCode indicates an expected call of GetFutureSnapshotByCode.
func (mr *MockRealTimegRPCAPIMockRecorder) GetFutureSnapshotByCode(code any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFutureSnapshotByCode", reflect.TypeOf((*MockRealTimegRPCAPI)(nil).GetFutureSnapshotByCode), code)
}

// GetNasdaq mocks base method.
func (m *MockRealTimegRPCAPI) GetNasdaq() (*pb.YahooFinancePrice, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNasdaq")
	ret0, _ := ret[0].(*pb.YahooFinancePrice)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNasdaqFuture mocks base method.
func (m *MockRealTimegRPCAPI) GetNasdaqFuture() (*pb.YahooFinancePrice, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNasdaqFuture")
	ret0, _ := ret[0].(*pb.YahooFinancePrice)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetStockSnapshotByNumArr mocks base method.
func (m *MockRealTimegRPCAPI) GetStockSnapshotByNumArr(stockNumArr []string) ([]*pb.SnapshotMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStockSnapshotByNumArr", stockNumArr)
	ret0, _ := ret[0].([]*pb.SnapshotMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStockSnapshotByNumArr indicates an expected call of GetStockSnapshotByNumArr.
func (mr *MockRealTimegRPCAPIMockRecorder) GetStockSnapshotByNumArr(stockNumArr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStockSnapshotByNumArr", reflect.TypeOf((*MockRealTimegRPCAPI)(nil).GetStockSnapshotByNumArr), stockNumArr)
}

// GetStockSnapshotOTC mocks base method.
func (m *MockRealTimegRPCAPI) GetStockSnapshotOTC() (*pb.SnapshotMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStockSnapshotOTC")
	ret0, _ := ret[0].(*pb.SnapshotMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetStockSnapshotTSE mocks base method.
func (m *MockRealTimegRPCAPI) GetStockSnapshotTSE() (*pb.SnapshotMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStockSnapshotTSE")
	ret0, _ := ret[0].(*pb.SnapshotMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetStockVolumeRank mocks base method.
func (m *MockRealTimegRPCAPI) GetStockVolumeRank(date string) ([]*pb.StockVolumeRankMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStockVolumeRank", date)
	ret0, _ := ret[0].([]*pb.StockVolumeRankMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStockVolumeRank indicates an expected call of GetStockVolumeRank.
func (mr *MockRealTimegRPCAPIMockRecorder) GetStockVolumeRank(date any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStockVolumeRank", reflect.TypeOf((*MockRealTimegRPCAPI)(nil).GetStockVolumeRank), date)
}

// GetStockVolumeRankPB mocks base method.
func (m *MockRealTimegRPCAPI) GetStockVolumeRankPB(date string) (*pb.StockVolumeRankResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStockVolumeRankPB", date)
	ret0, _ := ret[0].(*pb.StockVolumeRankResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStockVolumeRankPB indicates an expected call of GetStockVolumeRankPB.
func (mr *MockRealTimegRPCAPIMockRecorder) GetStockVolumeRankPB(date any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStockVolumeRankPB", reflect.TypeOf((*MockRealTimegRPCAPI)(nil).GetStockVolumeRankPB), date)
}

// MockSubscribegRPCAPI is a mock of SubscribegRPCAPI interface.
type MockSubscribegRPCAPI struct {
	ctrl     *gomock.Controller
	recorder *MockSubscribegRPCAPIMockRecorder
}

// MockSubscribegRPCAPIMockRecorder is the mock recorder for MockSubscribegRPCAPI.
type MockSubscribegRPCAPIMockRecorder struct {
	mock *MockSubscribegRPCAPI
}

// NewMockSubscribegRPCAPI creates a new mock instance.
func NewMockSubscribegRPCAPI(ctrl *gomock.Controller) *MockSubscribegRPCAPI {
	mock := &MockSubscribegRPCAPI{ctrl: ctrl}
	mock.recorder = &MockSubscribegRPCAPIMockRecorder{mock}
	return mock
}

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

// SubscribeFutureBidAsk mocks base method.
func (m *MockSubscribegRPCAPI) SubscribeFutureBidAsk(codeArr []string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeFutureBidAsk", codeArr)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubscribeFutureBidAsk indicates an expected call of SubscribeFutureBidAsk.
func (mr *MockSubscribegRPCAPIMockRecorder) SubscribeFutureBidAsk(codeArr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeFutureBidAsk", reflect.TypeOf((*MockSubscribegRPCAPI)(nil).SubscribeFutureBidAsk), codeArr)
}

// SubscribeFutureTick mocks base method.
func (m *MockSubscribegRPCAPI) SubscribeFutureTick(codeArr []string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeFutureTick", codeArr)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubscribeFutureTick indicates an expected call of SubscribeFutureTick.
func (mr *MockSubscribegRPCAPIMockRecorder) SubscribeFutureTick(codeArr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeFutureTick", reflect.TypeOf((*MockSubscribegRPCAPI)(nil).SubscribeFutureTick), codeArr)
}

// SubscribeStockBidAsk mocks base method.
func (m *MockSubscribegRPCAPI) SubscribeStockBidAsk(stockNumArr []string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeStockBidAsk", stockNumArr)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubscribeStockBidAsk indicates an expected call of SubscribeStockBidAsk.
func (mr *MockSubscribegRPCAPIMockRecorder) SubscribeStockBidAsk(stockNumArr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeStockBidAsk", reflect.TypeOf((*MockSubscribegRPCAPI)(nil).SubscribeStockBidAsk), stockNumArr)
}

// SubscribeStockTick mocks base method.
func (m *MockSubscribegRPCAPI) SubscribeStockTick(stockNumArr []string, odd bool) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeStockTick", stockNumArr, odd)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubscribeStockTick indicates an expected call of SubscribeStockTick.
func (mr *MockSubscribegRPCAPIMockRecorder) SubscribeStockTick(stockNumArr, odd any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeStockTick", reflect.TypeOf((*MockSubscribegRPCAPI)(nil).SubscribeStockTick), stockNumArr, odd)
}

// UnSubscribeAllBidAsk mocks base method.
func (m *MockSubscribegRPCAPI) UnSubscribeAllBidAsk() (*pb.ErrorMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnSubscribeAllBidAsk")
	ret0, _ := ret[0].(*pb.ErrorMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UnSubscribeAllTick mocks base method.
func (m *MockSubscribegRPCAPI) UnSubscribeAllTick() (*pb.ErrorMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnSubscribeAllTick")
	ret0, _ := ret[0].(*pb.ErrorMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UnSubscribeFutureBidAsk mocks base method.
func (m *MockSubscribegRPCAPI) UnSubscribeFutureBidAsk(codeArr []string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnSubscribeFutureBidAsk", codeArr)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnSubscribeFutureBidAsk indicates an expected call of UnSubscribeFutureBidAsk.
func (mr *MockSubscribegRPCAPIMockRecorder) UnSubscribeFutureBidAsk(codeArr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnSubscribeFutureBidAsk", reflect.TypeOf((*MockSubscribegRPCAPI)(nil).UnSubscribeFutureBidAsk), codeArr)
}

// UnSubscribeFutureTick mocks base method.
func (m *MockSubscribegRPCAPI) UnSubscribeFutureTick(codeArr []string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnSubscribeFutureTick", codeArr)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnSubscribeFutureTick indicates an expected call of UnSubscribeFutureTick.
func (mr *MockSubscribegRPCAPIMockRecorder) UnSubscribeFutureTick(codeArr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnSubscribeFutureTick", reflect.TypeOf((*MockSubscribegRPCAPI)(nil).UnSubscribeFutureTick), codeArr)
}

// UnSubscribeStockBidAsk mocks base method.
func (m *MockSubscribegRPCAPI) UnSubscribeStockBidAsk(stockNumArr []string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnSubscribeStockBidAsk", stockNumArr)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnSubscribeStockBidAsk indicates an expected call of UnSubscribeStockBidAsk.
func (mr *MockSubscribegRPCAPIMockRecorder) UnSubscribeStockBidAsk(stockNumArr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnSubscribeStockBidAsk", reflect.TypeOf((*MockSubscribegRPCAPI)(nil).UnSubscribeStockBidAsk), stockNumArr)
}

// UnSubscribeStockTick mocks base method.
func (m *MockSubscribegRPCAPI) UnSubscribeStockTick(stockNumArr []string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnSubscribeStockTick", stockNumArr)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnSubscribeStockTick indicates an expected call of UnSubscribeStockTick.
func (mr *MockSubscribegRPCAPIMockRecorder) UnSubscribeStockTick(stockNumArr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnSubscribeStockTick", reflect.TypeOf((*MockSubscribegRPCAPI)(nil).UnSubscribeStockTick), stockNumArr)
}

// MockTradegRPCAPI is a mock of TradegRPCAPI interface.
type MockTradegRPCAPI struct {
	ctrl     *gomock.Controller
	recorder *MockTradegRPCAPIMockRecorder
}

// MockTradegRPCAPIMockRecorder is the mock recorder for MockTradegRPCAPI.
type MockTradegRPCAPIMockRecorder struct {
	mock *MockTradegRPCAPI
}

// NewMockTradegRPCAPI creates a new mock instance.
func NewMockTradegRPCAPI(ctrl *gomock.Controller) *MockTradegRPCAPI {
	mock := &MockTradegRPCAPI{ctrl: ctrl}
	mock.recorder = &MockTradegRPCAPIMockRecorder{mock}
	return mock
}

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

// BuyFuture mocks base method.
func (m *MockTradegRPCAPI) BuyFuture(order *entity.FutureOrder) (*pb.TradeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuyFuture", order)
	ret0, _ := ret[0].(*pb.TradeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuyFuture indicates an expected call of BuyFuture.
func (mr *MockTradegRPCAPIMockRecorder) BuyFuture(order any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuyFuture", reflect.TypeOf((*MockTradegRPCAPI)(nil).BuyFuture), order)
}

// BuyOddStock mocks base method.
func (m *MockTradegRPCAPI) BuyOddStock(order *entity.StockOrder) (*pb.TradeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuyOddStock", order)
	ret0, _ := ret[0].(*pb.TradeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuyOddStock indicates an expected call of BuyOddStock.
func (mr *MockTradegRPCAPIMockRecorder) BuyOddStock(order any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuyOddStock", reflect.TypeOf((*MockTradegRPCAPI)(nil).BuyOddStock), order)
}

// BuyStock mocks base method.
func (m *MockTradegRPCAPI) BuyStock(order *entity.StockOrder) (*pb.TradeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuyStock", order)
	ret0, _ := ret[0].(*pb.TradeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuyStock indicates an expected call of BuyStock.
func (mr *MockTradegRPCAPIMockRecorder) BuyStock(order any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuyStock", reflect.TypeOf((*MockTradegRPCAPI)(nil).BuyStock), order)
}

// CancelOrder mocks base method.
func (m *MockTradegRPCAPI) CancelOrder(orderID string) (*pb.TradeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelOrder", orderID)
	ret0, _ := ret[0].(*pb.TradeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelOrder indicates an expected call of CancelOrder.
func (mr *MockTradegRPCAPIMockRecorder) CancelOrder(orderID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelOrder", reflect.TypeOf((*MockTradegRPCAPI)(nil).CancelOrder), orderID)
}

// GetAccountBalance mocks base method.
func (m *MockTradegRPCAPI) GetAccountBalance() (*pb.AccountBalance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountBalance")
	ret0, _ := ret[0].(*pb.AccountBalance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetFuturePosition mocks base method.
func (m *MockTradegRPCAPI) GetFuturePosition() (*pb.FuturePositionArr, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFuturePosition")
	ret0, _ := ret[0].(*pb.FuturePositionArr)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetMargin mocks base method.
func (m *MockTradegRPCAPI) GetMargin() (*pb.Margin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMargin")
	ret0, _ := ret[0].(*pb.Margin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSettlement mocks base method.
func (m *MockTradegRPCAPI) GetSettlement() (*pb.SettlementList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSettlement")
	ret0, _ := ret[0].(*pb.SettlementList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetStockPosition mocks base method.
func (m *MockTradegRPCAPI) GetStockPosition() (*pb.StockPositionArr, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStockPosition")
	ret0, _ := ret[0].(*pb.StockPositionArr)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SellFirstFuture mocks base method.
func (m *MockTradegRPCAPI) SellFirstFuture(order *entity.FutureOrder) (*pb.TradeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SellFirstFuture", order)
	ret0, _ := ret[0].(*pb.TradeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SellFirstFuture indicates an expected call of SellFirstFuture.
func (mr *MockTradegRPCAPIMockRecorder) SellFirstFuture(order any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SellFirstFuture", reflect.TypeOf((*MockTradegRPCAPI)(nil).SellFirstFuture), order)
}

// SellFirstStock mocks base method.
func (m *MockTradegRPCAPI) SellFirstStock(order *entity.StockOrder) (*pb.TradeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SellFirstStock", order)
	ret0, _ := ret[0].(*pb.TradeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SellFirstStock indicates an expected call of SellFirstStock.
func (mr *MockTradegRPCAPIMockRecorder) SellFirstStock(order any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SellFirstStock", reflect.TypeOf((*MockTradegRPCAPI)(nil).SellFirstStock), order)
}

// SellFuture mocks base method.
func (m *MockTradegRPCAPI) SellFuture(order *entity.FutureOrder) (*pb.TradeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SellFuture", order)
	ret0, _ := ret[0].(*pb.TradeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SellFuture indicates an expected call of SellFuture.
func (mr *MockTradegRPCAPIMockRecorder) SellFuture(order any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SellFuture", reflect.TypeOf((*MockTradegRPCAPI)(nil).SellFuture), order)
}

// SellOddStock mocks base method.
func (m *MockTradegRPCAPI) SellOddStock(order *entity.StockOrder) (*pb.TradeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SellOddStock", order)
	ret0, _ := ret[0].(*pb.TradeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SellOddStock indicates an expected call of SellOddStock.
func (mr *MockTradegRPCAPIMockRecorder) SellOddStock(order any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SellOddStock", reflect.TypeOf((*MockTradegRPCAPI)(nil).SellOddStock), order)
}

// SellStock mocks base method.
func (m *MockTradegRPCAPI) SellStock(order *entity.StockOrder) (*pb.TradeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SellStock", order)
	ret0, _ := ret[0].(*pb.TradeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SellStock indicates an expected call of SellStock.
func (mr *MockTradegRPCAPIMockRecorder) SellStock(order any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SellStock", reflect.TypeOf((*MockTradegRPCAPI)(nil).SellStock), order)
}
