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

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

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

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

// MockBasicRepo is a mock of BasicRepo interface.
type MockBasicRepo struct {
	ctrl     *gomock.Controller
	recorder *MockBasicRepoMockRecorder
}

// MockBasicRepoMockRecorder is the mock recorder for MockBasicRepo.
type MockBasicRepoMockRecorder struct {
	mock *MockBasicRepo
}

// NewMockBasicRepo creates a new mock instance.
func NewMockBasicRepo(ctrl *gomock.Controller) *MockBasicRepo {
	mock := &MockBasicRepo{ctrl: ctrl}
	mock.recorder = &MockBasicRepoMockRecorder{mock}
	return mock
}

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

// InsertOrUpdatetCalendarDateArr mocks base method.
func (m *MockBasicRepo) InsertOrUpdatetCalendarDateArr(ctx context.Context, t []*entity.CalendarDate) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrUpdatetCalendarDateArr", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertOrUpdatetFutureArr mocks base method.
func (m *MockBasicRepo) InsertOrUpdatetFutureArr(ctx context.Context, t []*entity.Future) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrUpdatetFutureArr", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertOrUpdatetOptionArr mocks base method.
func (m *MockBasicRepo) InsertOrUpdatetOptionArr(ctx context.Context, t []*entity.Option) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrUpdatetOptionArr", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertOrUpdatetStockArr mocks base method.
func (m *MockBasicRepo) InsertOrUpdatetStockArr(ctx context.Context, t []*entity.Stock) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrUpdatetStockArr", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// MockHistoryRepo is a mock of HistoryRepo interface.
type MockHistoryRepo struct {
	ctrl     *gomock.Controller
	recorder *MockHistoryRepoMockRecorder
}

// MockHistoryRepoMockRecorder is the mock recorder for MockHistoryRepo.
type MockHistoryRepoMockRecorder struct {
	mock *MockHistoryRepo
}

// NewMockHistoryRepo creates a new mock instance.
func NewMockHistoryRepo(ctrl *gomock.Controller) *MockHistoryRepo {
	mock := &MockHistoryRepo{ctrl: ctrl}
	mock.recorder = &MockHistoryRepoMockRecorder{mock}
	return mock
}

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

// DeleteHistoryCloseByStockAndDate mocks base method.
func (m *MockHistoryRepo) DeleteHistoryCloseByStockAndDate(ctx context.Context, stockNumArr []string, date time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHistoryCloseByStockAndDate", ctx, stockNumArr, date)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteHistoryKbarByStockAndDate mocks base method.
func (m *MockHistoryRepo) DeleteHistoryKbarByStockAndDate(ctx context.Context, stockNumArr []string, date time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHistoryKbarByStockAndDate", ctx, stockNumArr, date)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteHistoryTickByStockAndDate mocks base method.
func (m *MockHistoryRepo) DeleteHistoryTickByStockAndDate(ctx context.Context, stockNumArr []string, date time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHistoryTickByStockAndDate", ctx, stockNumArr, date)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertHistoryCloseArr mocks base method.
func (m *MockHistoryRepo) InsertHistoryCloseArr(ctx context.Context, t []*entity.StockHistoryClose) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertHistoryCloseArr", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertHistoryKbarArr mocks base method.
func (m *MockHistoryRepo) InsertHistoryKbarArr(ctx context.Context, t []*entity.StockHistoryKbar) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertHistoryKbarArr", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertHistoryTickArr mocks base method.
func (m *MockHistoryRepo) InsertHistoryTickArr(ctx context.Context, t []*entity.StockHistoryTick) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertHistoryTickArr", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertQuaterMA mocks base method.
func (m *MockHistoryRepo) InsertQuaterMA(ctx context.Context, t *entity.StockHistoryAnalyze) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertQuaterMA", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// QueryAllQuaterMAByStockNum mocks base method.
func (m *MockHistoryRepo) QueryAllQuaterMAByStockNum(ctx context.Context, stockNum string) (map[time.Time]*entity.StockHistoryAnalyze, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryAllQuaterMAByStockNum", ctx, stockNum)
	ret0, _ := ret[0].(map[time.Time]*entity.StockHistoryAnalyze)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryMultiStockKbarArrByDate mocks base method.
func (m *MockHistoryRepo) QueryMultiStockKbarArrByDate(ctx context.Context, stockNumArr []string, date time.Time) (map[string][]*entity.StockHistoryKbar, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryMultiStockKbarArrByDate", ctx, stockNumArr, date)
	ret0, _ := ret[0].(map[string][]*entity.StockHistoryKbar)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryMultiStockTickArrByDate mocks base method.
func (m *MockHistoryRepo) QueryMultiStockTickArrByDate(ctx context.Context, stockNumArr []string, date time.Time) (map[string][]*entity.StockHistoryTick, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryMultiStockTickArrByDate", ctx, stockNumArr, date)
	ret0, _ := ret[0].(map[string][]*entity.StockHistoryTick)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryMutltiStockCloseByDate mocks base method.
func (m *MockHistoryRepo) QueryMutltiStockCloseByDate(ctx context.Context, stockNumArr []string, date time.Time) (map[string]*entity.StockHistoryClose, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryMutltiStockCloseByDate", ctx, stockNumArr, date)
	ret0, _ := ret[0].(map[string]*entity.StockHistoryClose)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockRealTimeRepo is a mock of RealTimeRepo interface.
type MockRealTimeRepo struct {
	ctrl     *gomock.Controller
	recorder *MockRealTimeRepoMockRecorder
}

// MockRealTimeRepoMockRecorder is the mock recorder for MockRealTimeRepo.
type MockRealTimeRepoMockRecorder struct {
	mock *MockRealTimeRepo
}

// NewMockRealTimeRepo creates a new mock instance.
func NewMockRealTimeRepo(ctrl *gomock.Controller) *MockRealTimeRepo {
	mock := &MockRealTimeRepo{ctrl: ctrl}
	mock.recorder = &MockRealTimeRepoMockRecorder{mock}
	return mock
}

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

// InsertEvent mocks base method.
func (m *MockRealTimeRepo) InsertEvent(ctx context.Context, t *entity.SinopacEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertEvent", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockSystemRepo is a mock of SystemRepo interface.
type MockSystemRepo struct {
	ctrl     *gomock.Controller
	recorder *MockSystemRepoMockRecorder
}

// MockSystemRepoMockRecorder is the mock recorder for MockSystemRepo.
type MockSystemRepoMockRecorder struct {
	mock *MockSystemRepo
}

// NewMockSystemRepo creates a new mock instance.
func NewMockSystemRepo(ctrl *gomock.Controller) *MockSystemRepo {
	mock := &MockSystemRepo{ctrl: ctrl}
	mock.recorder = &MockSystemRepoMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// GetPushToken mocks base method.
func (m *MockSystemRepo) GetPushToken(ctx context.Context, token string) (*entity.PushToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPushToken", ctx, token)
	ret0, _ := ret[0].(*entity.PushToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// InsertOrUpdatePushToken mocks base method.
func (m *MockSystemRepo) InsertOrUpdatePushToken(ctx context.Context, token, username string, enabled bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrUpdatePushToken", ctx, token, username, enabled)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertOrUpdatePushToken indicates an expected call of InsertOrUpdatePushToken.
func (mr *MockSystemRepoMockRecorder) InsertOrUpdatePushToken(ctx, token, username, enabled any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertOrUpdatePushToken", reflect.TypeOf((*MockSystemRepo)(nil).InsertOrUpdatePushToken), ctx, token, username, enabled)
}

// InsertUser mocks base method.
func (m *MockSystemRepo) InsertUser(ctx context.Context, t *entity.NewUser) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertUser", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// QueryUserByUsername mocks base method.
func (m *MockSystemRepo) QueryUserByUsername(ctx context.Context, username string) (*entity.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryUserByUsername", ctx, username)
	ret0, _ := ret[0].(*entity.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockTargetRepo is a mock of TargetRepo interface.
type MockTargetRepo struct {
	ctrl     *gomock.Controller
	recorder *MockTargetRepoMockRecorder
}

// MockTargetRepoMockRecorder is the mock recorder for MockTargetRepo.
type MockTargetRepoMockRecorder struct {
	mock *MockTargetRepo
}

// NewMockTargetRepo creates a new mock instance.
func NewMockTargetRepo(ctrl *gomock.Controller) *MockTargetRepo {
	mock := &MockTargetRepo{ctrl: ctrl}
	mock.recorder = &MockTargetRepoMockRecorder{mock}
	return mock
}

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

// InsertOrUpdateTargetArr mocks base method.
func (m *MockTargetRepo) InsertOrUpdateTargetArr(ctx context.Context, t []*entity.StockTarget) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrUpdateTargetArr", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// QueryTargetsByTradeDay mocks base method.
func (m *MockTargetRepo) QueryTargetsByTradeDay(ctx context.Context, tradeDay time.Time) ([]*entity.StockTarget, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTargetsByTradeDay", ctx, tradeDay)
	ret0, _ := ret[0].([]*entity.StockTarget)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockTradeRepo is a mock of TradeRepo interface.
type MockTradeRepo struct {
	ctrl     *gomock.Controller
	recorder *MockTradeRepoMockRecorder
}

// MockTradeRepoMockRecorder is the mock recorder for MockTradeRepo.
type MockTradeRepoMockRecorder struct {
	mock *MockTradeRepo
}

// NewMockTradeRepo creates a new mock instance.
func NewMockTradeRepo(ctrl *gomock.Controller) *MockTradeRepo {
	mock := &MockTradeRepo{ctrl: ctrl}
	mock.recorder = &MockTradeRepoMockRecorder{mock}
	return mock
}

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

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

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

// InsertOrUpdateAccountBalance mocks base method.
func (m *MockTradeRepo) InsertOrUpdateAccountBalance(ctx context.Context, t *entity.AccountBalance) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrUpdateAccountBalance", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertOrUpdateAccountSettlement mocks base method.
func (m *MockTradeRepo) InsertOrUpdateAccountSettlement(ctx context.Context, t *entity.Settlement) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrUpdateAccountSettlement", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertOrUpdateFutureOrderByOrderID mocks base method.
func (m *MockTradeRepo) InsertOrUpdateFutureOrderByOrderID(ctx context.Context, t *entity.FutureOrder) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrUpdateFutureOrderByOrderID", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertOrUpdateFutureTradeBalance mocks base method.
func (m *MockTradeRepo) InsertOrUpdateFutureTradeBalance(ctx context.Context, t *entity.FutureTradeBalance) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrUpdateFutureTradeBalance", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertOrUpdateInventoryStock mocks base method.
func (m *MockTradeRepo) InsertOrUpdateInventoryStock(ctx context.Context, t []*entity.InventoryStock) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrUpdateInventoryStock", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertOrUpdateOrderByOrderID mocks base method.
func (m *MockTradeRepo) InsertOrUpdateOrderByOrderID(ctx context.Context, t *entity.StockOrder) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrUpdateOrderByOrderID", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InsertOrUpdateStockTradeBalance mocks base method.
func (m *MockTradeRepo) InsertOrUpdateStockTradeBalance(ctx context.Context, t *entity.StockTradeBalance) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrUpdateStockTradeBalance", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// QueryAllFutureOrderByDate mocks base method.
func (m *MockTradeRepo) QueryAllFutureOrderByDate(ctx context.Context, timeTange []time.Time) ([]*entity.FutureOrder, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryAllFutureOrderByDate", ctx, timeTange)
	ret0, _ := ret[0].([]*entity.FutureOrder)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// QueryAllStockOrderByDate mocks base method.
func (m *MockTradeRepo) QueryAllStockOrderByDate(ctx context.Context, timeTange []time.Time) ([]*entity.StockOrder, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryAllStockOrderByDate", ctx, timeTange)
	ret0, _ := ret[0].([]*entity.StockOrder)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// QueryInventoryStockByDate mocks base method.
func (m *MockTradeRepo) QueryInventoryStockByDate(ctx context.Context, date time.Time) ([]*entity.InventoryStock, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryInventoryStockByDate", ctx, date)
	ret0, _ := ret[0].([]*entity.InventoryStock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryInventoryUUIDStockByDate mocks base method.
func (m *MockTradeRepo) QueryInventoryUUIDStockByDate(ctx context.Context, date time.Time) (map[string]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryInventoryUUIDStockByDate", ctx, date)
	ret0, _ := ret[0].(map[string]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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