Rainbond/db/db_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: db.go

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

import (
	gomock "github.com/golang/mock/gomock"
	dao "github.com/goodrain/rainbond/db/dao"
	gorm "github.com/jinzhu/gorm"
	reflect "reflect"
)

// MockManager is a mock of Manager interface
type MockManager struct {
	ctrl     *gomock.Controller
	recorder *MockManagerMockRecorder
}

// MockManagerMockRecorder is the mock recorder for MockManager
type MockManagerMockRecorder struct {
	mock *MockManager
}

// NewMockManager creates a new mock instance
func NewMockManager(ctrl *gomock.Controller) *MockManager {
	mock := &MockManager{ctrl: ctrl}
	mock.recorder = &MockManagerMockRecorder{mock}
	return mock
}

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

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

// CloseManager indicates an expected call of CloseManager
func (mr *MockManagerMockRecorder) CloseManager() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseManager", reflect.TypeOf((*MockManager)(nil).CloseManager))
}

// Begin mocks base method
func (m *MockManager) Begin() *gorm.DB {
	ret := m.ctrl.Call(m, "Begin")
	ret0, _ := ret[0].(*gorm.DB)
	return ret0
}

// Begin indicates an expected call of Begin
func (mr *MockManagerMockRecorder) Begin() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Begin", reflect.TypeOf((*MockManager)(nil).Begin))
}

// EnsureEndTransactionFunc mocks base method
func (m *MockManager) EnsureEndTransactionFunc() func(*gorm.DB) {
	ret := m.ctrl.Call(m, "EnsureEndTransactionFunc")
	ret0, _ := ret[0].(func(*gorm.DB))
	return ret0
}

// EnsureEndTransactionFunc indicates an expected call of EnsureEndTransactionFunc
func (mr *MockManagerMockRecorder) EnsureEndTransactionFunc() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureEndTransactionFunc", reflect.TypeOf((*MockManager)(nil).EnsureEndTransactionFunc))
}

// VolumeTypeDao mocks base method
func (m *MockManager) VolumeTypeDao() dao.VolumeTypeDao {
	ret := m.ctrl.Call(m, "VolumeTypeDao")
	ret0, _ := ret[0].(dao.VolumeTypeDao)
	return ret0
}

// VolumeTypeDao indicates an expected call of VolumeTypeDao
func (mr *MockManagerMockRecorder) VolumeTypeDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumeTypeDao", reflect.TypeOf((*MockManager)(nil).VolumeTypeDao))
}

// LicenseDao mocks base method
func (m *MockManager) LicenseDao() dao.LicenseDao {
	ret := m.ctrl.Call(m, "LicenseDao")
	ret0, _ := ret[0].(dao.LicenseDao)
	return ret0
}

// LicenseDao indicates an expected call of LicenseDao
func (mr *MockManagerMockRecorder) LicenseDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LicenseDao", reflect.TypeOf((*MockManager)(nil).LicenseDao))
}

// AppDao mocks base method
func (m *MockManager) AppDao() dao.AppDao {
	ret := m.ctrl.Call(m, "AppDao")
	ret0, _ := ret[0].(dao.AppDao)
	return ret0
}

// AppDao indicates an expected call of AppDao
func (mr *MockManagerMockRecorder) AppDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppDao", reflect.TypeOf((*MockManager)(nil).AppDao))
}

// EnterpriseDao mocks base method
func (m *MockManager) EnterpriseDao() dao.EnterpriseDao {
	ret := m.ctrl.Call(m, "EnterpriseDao")
	ret0, _ := ret[0].(dao.EnterpriseDao)
	return ret0
}

// EnterpriseDao indicates an expected call of EnterpriseDao
func (mr *MockManagerMockRecorder) EnterpriseDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnterpriseDao", reflect.TypeOf((*MockManager)(nil).EnterpriseDao))
}

// TenantDao mocks base method
func (m *MockManager) TenantDao() dao.TenantDao {
	ret := m.ctrl.Call(m, "TenantDao")
	ret0, _ := ret[0].(dao.TenantDao)
	return ret0
}

// TenantDao indicates an expected call of TenantDao
func (mr *MockManagerMockRecorder) TenantDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantDao", reflect.TypeOf((*MockManager)(nil).TenantDao))
}

// TenantDaoTransactions mocks base method
func (m *MockManager) TenantDaoTransactions(db *gorm.DB) dao.TenantDao {
	ret := m.ctrl.Call(m, "TenantDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantDao)
	return ret0
}

// TenantDaoTransactions indicates an expected call of TenantDaoTransactions
func (mr *MockManagerMockRecorder) TenantDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantDaoTransactions), db)
}

// TenantServiceDao mocks base method
func (m *MockManager) TenantServiceDao() dao.TenantServiceDao {
	ret := m.ctrl.Call(m, "TenantServiceDao")
	ret0, _ := ret[0].(dao.TenantServiceDao)
	return ret0
}

// TenantServiceDao indicates an expected call of TenantServiceDao
func (mr *MockManagerMockRecorder) TenantServiceDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceDao", reflect.TypeOf((*MockManager)(nil).TenantServiceDao))
}

// TenantServiceDeleteDao mocks base method
func (m *MockManager) TenantServiceDeleteDao() dao.TenantServiceDeleteDao {
	ret := m.ctrl.Call(m, "TenantServiceDeleteDao")
	ret0, _ := ret[0].(dao.TenantServiceDeleteDao)
	return ret0
}

// TenantServiceDeleteDao indicates an expected call of TenantServiceDeleteDao
func (mr *MockManagerMockRecorder) TenantServiceDeleteDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceDeleteDao", reflect.TypeOf((*MockManager)(nil).TenantServiceDeleteDao))
}

// TenantServiceDaoTransactions mocks base method
func (m *MockManager) TenantServiceDaoTransactions(db *gorm.DB) dao.TenantServiceDao {
	ret := m.ctrl.Call(m, "TenantServiceDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantServiceDao)
	return ret0
}

// TenantServiceDaoTransactions indicates an expected call of TenantServiceDaoTransactions
func (mr *MockManagerMockRecorder) TenantServiceDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServiceDaoTransactions), db)
}

// TenantServiceDeleteDaoTransactions mocks base method
func (m *MockManager) TenantServiceDeleteDaoTransactions(db *gorm.DB) dao.TenantServiceDeleteDao {
	ret := m.ctrl.Call(m, "TenantServiceDeleteDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantServiceDeleteDao)
	return ret0
}

// TenantServiceDeleteDaoTransactions indicates an expected call of TenantServiceDeleteDaoTransactions
func (mr *MockManagerMockRecorder) TenantServiceDeleteDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceDeleteDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServiceDeleteDaoTransactions), db)
}

// TenantServicesPortDao mocks base method
func (m *MockManager) TenantServicesPortDao() dao.TenantServicesPortDao {
	ret := m.ctrl.Call(m, "TenantServicesPortDao")
	ret0, _ := ret[0].(dao.TenantServicesPortDao)
	return ret0
}

// TenantServicesPortDao indicates an expected call of TenantServicesPortDao
func (mr *MockManagerMockRecorder) TenantServicesPortDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServicesPortDao", reflect.TypeOf((*MockManager)(nil).TenantServicesPortDao))
}

// TenantServicesPortDaoTransactions mocks base method
func (m *MockManager) TenantServicesPortDaoTransactions(arg0 *gorm.DB) dao.TenantServicesPortDao {
	ret := m.ctrl.Call(m, "TenantServicesPortDaoTransactions", arg0)
	ret0, _ := ret[0].(dao.TenantServicesPortDao)
	return ret0
}

// TenantServicesPortDaoTransactions indicates an expected call of TenantServicesPortDaoTransactions
func (mr *MockManagerMockRecorder) TenantServicesPortDaoTransactions(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServicesPortDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServicesPortDaoTransactions), arg0)
}

// TenantServiceRelationDao mocks base method
func (m *MockManager) TenantServiceRelationDao() dao.TenantServiceRelationDao {
	ret := m.ctrl.Call(m, "TenantServiceRelationDao")
	ret0, _ := ret[0].(dao.TenantServiceRelationDao)
	return ret0
}

// TenantServiceRelationDao indicates an expected call of TenantServiceRelationDao
func (mr *MockManagerMockRecorder) TenantServiceRelationDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceRelationDao", reflect.TypeOf((*MockManager)(nil).TenantServiceRelationDao))
}

// TenantServiceRelationDaoTransactions mocks base method
func (m *MockManager) TenantServiceRelationDaoTransactions(arg0 *gorm.DB) dao.TenantServiceRelationDao {
	ret := m.ctrl.Call(m, "TenantServiceRelationDaoTransactions", arg0)
	ret0, _ := ret[0].(dao.TenantServiceRelationDao)
	return ret0
}

// TenantServiceRelationDaoTransactions indicates an expected call of TenantServiceRelationDaoTransactions
func (mr *MockManagerMockRecorder) TenantServiceRelationDaoTransactions(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceRelationDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServiceRelationDaoTransactions), arg0)
}

// TenantServiceEnvVarDao mocks base method
func (m *MockManager) TenantServiceEnvVarDao() dao.TenantServiceEnvVarDao {
	ret := m.ctrl.Call(m, "TenantServiceEnvVarDao")
	ret0, _ := ret[0].(dao.TenantServiceEnvVarDao)
	return ret0
}

// TenantServiceEnvVarDao indicates an expected call of TenantServiceEnvVarDao
func (mr *MockManagerMockRecorder) TenantServiceEnvVarDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceEnvVarDao", reflect.TypeOf((*MockManager)(nil).TenantServiceEnvVarDao))
}

// TenantServiceEnvVarDaoTransactions mocks base method
func (m *MockManager) TenantServiceEnvVarDaoTransactions(arg0 *gorm.DB) dao.TenantServiceEnvVarDao {
	ret := m.ctrl.Call(m, "TenantServiceEnvVarDaoTransactions", arg0)
	ret0, _ := ret[0].(dao.TenantServiceEnvVarDao)
	return ret0
}

// TenantServiceEnvVarDaoTransactions indicates an expected call of TenantServiceEnvVarDaoTransactions
func (mr *MockManagerMockRecorder) TenantServiceEnvVarDaoTransactions(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceEnvVarDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServiceEnvVarDaoTransactions), arg0)
}

// TenantServiceMountRelationDao mocks base method
func (m *MockManager) TenantServiceMountRelationDao() dao.TenantServiceMountRelationDao {
	ret := m.ctrl.Call(m, "TenantServiceMountRelationDao")
	ret0, _ := ret[0].(dao.TenantServiceMountRelationDao)
	return ret0
}

// TenantServiceMountRelationDao indicates an expected call of TenantServiceMountRelationDao
func (mr *MockManagerMockRecorder) TenantServiceMountRelationDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceMountRelationDao", reflect.TypeOf((*MockManager)(nil).TenantServiceMountRelationDao))
}

// TenantServiceMountRelationDaoTransactions mocks base method
func (m *MockManager) TenantServiceMountRelationDaoTransactions(db *gorm.DB) dao.TenantServiceMountRelationDao {
	ret := m.ctrl.Call(m, "TenantServiceMountRelationDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantServiceMountRelationDao)
	return ret0
}

// TenantServiceMountRelationDaoTransactions indicates an expected call of TenantServiceMountRelationDaoTransactions
func (mr *MockManagerMockRecorder) TenantServiceMountRelationDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceMountRelationDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServiceMountRelationDaoTransactions), db)
}

// TenantServiceVolumeDao mocks base method
func (m *MockManager) TenantServiceVolumeDao() dao.TenantServiceVolumeDao {
	ret := m.ctrl.Call(m, "TenantServiceVolumeDao")
	ret0, _ := ret[0].(dao.TenantServiceVolumeDao)
	return ret0
}

// TenantServiceVolumeDao indicates an expected call of TenantServiceVolumeDao
func (mr *MockManagerMockRecorder) TenantServiceVolumeDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceVolumeDao", reflect.TypeOf((*MockManager)(nil).TenantServiceVolumeDao))
}

// TenantServiceVolumeDaoTransactions mocks base method
func (m *MockManager) TenantServiceVolumeDaoTransactions(arg0 *gorm.DB) dao.TenantServiceVolumeDao {
	ret := m.ctrl.Call(m, "TenantServiceVolumeDaoTransactions", arg0)
	ret0, _ := ret[0].(dao.TenantServiceVolumeDao)
	return ret0
}

// TenantServiceVolumeDaoTransactions indicates an expected call of TenantServiceVolumeDaoTransactions
func (mr *MockManagerMockRecorder) TenantServiceVolumeDaoTransactions(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceVolumeDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServiceVolumeDaoTransactions), arg0)
}

// TenantServiceConfigFileDao mocks base method
func (m *MockManager) TenantServiceConfigFileDao() dao.TenantServiceConfigFileDao {
	ret := m.ctrl.Call(m, "TenantServiceConfigFileDao")
	ret0, _ := ret[0].(dao.TenantServiceConfigFileDao)
	return ret0
}

// TenantServiceConfigFileDao indicates an expected call of TenantServiceConfigFileDao
func (mr *MockManagerMockRecorder) TenantServiceConfigFileDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceConfigFileDao", reflect.TypeOf((*MockManager)(nil).TenantServiceConfigFileDao))
}

// TenantServiceConfigFileDaoTransactions mocks base method
func (m *MockManager) TenantServiceConfigFileDaoTransactions(arg0 *gorm.DB) dao.TenantServiceConfigFileDao {
	ret := m.ctrl.Call(m, "TenantServiceConfigFileDaoTransactions", arg0)
	ret0, _ := ret[0].(dao.TenantServiceConfigFileDao)
	return ret0
}

// TenantServiceConfigFileDaoTransactions indicates an expected call of TenantServiceConfigFileDaoTransactions
func (mr *MockManagerMockRecorder) TenantServiceConfigFileDaoTransactions(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceConfigFileDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServiceConfigFileDaoTransactions), arg0)
}

// ServiceProbeDao mocks base method
func (m *MockManager) ServiceProbeDao() dao.ServiceProbeDao {
	ret := m.ctrl.Call(m, "ServiceProbeDao")
	ret0, _ := ret[0].(dao.ServiceProbeDao)
	return ret0
}

// ServiceProbeDao indicates an expected call of ServiceProbeDao
func (mr *MockManagerMockRecorder) ServiceProbeDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceProbeDao", reflect.TypeOf((*MockManager)(nil).ServiceProbeDao))
}

// ServiceProbeDaoTransactions mocks base method
func (m *MockManager) ServiceProbeDaoTransactions(arg0 *gorm.DB) dao.ServiceProbeDao {
	ret := m.ctrl.Call(m, "ServiceProbeDaoTransactions", arg0)
	ret0, _ := ret[0].(dao.ServiceProbeDao)
	return ret0
}

// ServiceProbeDaoTransactions indicates an expected call of ServiceProbeDaoTransactions
func (mr *MockManagerMockRecorder) ServiceProbeDaoTransactions(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceProbeDaoTransactions", reflect.TypeOf((*MockManager)(nil).ServiceProbeDaoTransactions), arg0)
}

// TenantServiceLBMappingPortDao mocks base method
func (m *MockManager) TenantServiceLBMappingPortDao() dao.TenantServiceLBMappingPortDao {
	ret := m.ctrl.Call(m, "TenantServiceLBMappingPortDao")
	ret0, _ := ret[0].(dao.TenantServiceLBMappingPortDao)
	return ret0
}

// TenantServiceLBMappingPortDao indicates an expected call of TenantServiceLBMappingPortDao
func (mr *MockManagerMockRecorder) TenantServiceLBMappingPortDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceLBMappingPortDao", reflect.TypeOf((*MockManager)(nil).TenantServiceLBMappingPortDao))
}

// TenantServiceLBMappingPortDaoTransactions mocks base method
func (m *MockManager) TenantServiceLBMappingPortDaoTransactions(arg0 *gorm.DB) dao.TenantServiceLBMappingPortDao {
	ret := m.ctrl.Call(m, "TenantServiceLBMappingPortDaoTransactions", arg0)
	ret0, _ := ret[0].(dao.TenantServiceLBMappingPortDao)
	return ret0
}

// TenantServiceLBMappingPortDaoTransactions indicates an expected call of TenantServiceLBMappingPortDaoTransactions
func (mr *MockManagerMockRecorder) TenantServiceLBMappingPortDaoTransactions(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceLBMappingPortDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServiceLBMappingPortDaoTransactions), arg0)
}

// TenantServiceLabelDao mocks base method
func (m *MockManager) TenantServiceLabelDao() dao.TenantServiceLabelDao {
	ret := m.ctrl.Call(m, "TenantServiceLabelDao")
	ret0, _ := ret[0].(dao.TenantServiceLabelDao)
	return ret0
}

// TenantServiceLabelDao indicates an expected call of TenantServiceLabelDao
func (mr *MockManagerMockRecorder) TenantServiceLabelDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceLabelDao", reflect.TypeOf((*MockManager)(nil).TenantServiceLabelDao))
}

// TenantServiceLabelDaoTransactions mocks base method
func (m *MockManager) TenantServiceLabelDaoTransactions(db *gorm.DB) dao.TenantServiceLabelDao {
	ret := m.ctrl.Call(m, "TenantServiceLabelDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantServiceLabelDao)
	return ret0
}

// TenantServiceLabelDaoTransactions indicates an expected call of TenantServiceLabelDaoTransactions
func (mr *MockManagerMockRecorder) TenantServiceLabelDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceLabelDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServiceLabelDaoTransactions), db)
}

// LocalSchedulerDao mocks base method
func (m *MockManager) LocalSchedulerDao() dao.LocalSchedulerDao {
	ret := m.ctrl.Call(m, "LocalSchedulerDao")
	ret0, _ := ret[0].(dao.LocalSchedulerDao)
	return ret0
}

// LocalSchedulerDao indicates an expected call of LocalSchedulerDao
func (mr *MockManagerMockRecorder) LocalSchedulerDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalSchedulerDao", reflect.TypeOf((*MockManager)(nil).LocalSchedulerDao))
}

// TenantPluginDaoTransactions mocks base method
func (m *MockManager) TenantPluginDaoTransactions(db *gorm.DB) dao.TenantPluginDao {
	ret := m.ctrl.Call(m, "TenantPluginDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantPluginDao)
	return ret0
}

// TenantPluginDaoTransactions indicates an expected call of TenantPluginDaoTransactions
func (mr *MockManagerMockRecorder) TenantPluginDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantPluginDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantPluginDaoTransactions), db)
}

// TenantPluginDao mocks base method
func (m *MockManager) TenantPluginDao() dao.TenantPluginDao {
	ret := m.ctrl.Call(m, "TenantPluginDao")
	ret0, _ := ret[0].(dao.TenantPluginDao)
	return ret0
}

// TenantPluginDao indicates an expected call of TenantPluginDao
func (mr *MockManagerMockRecorder) TenantPluginDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantPluginDao", reflect.TypeOf((*MockManager)(nil).TenantPluginDao))
}

// TenantPluginDefaultENVDaoTransactions mocks base method
func (m *MockManager) TenantPluginDefaultENVDaoTransactions(db *gorm.DB) dao.TenantPluginDefaultENVDao {
	ret := m.ctrl.Call(m, "TenantPluginDefaultENVDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantPluginDefaultENVDao)
	return ret0
}

// TenantPluginDefaultENVDaoTransactions indicates an expected call of TenantPluginDefaultENVDaoTransactions
func (mr *MockManagerMockRecorder) TenantPluginDefaultENVDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantPluginDefaultENVDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantPluginDefaultENVDaoTransactions), db)
}

// TenantPluginDefaultENVDao mocks base method
func (m *MockManager) TenantPluginDefaultENVDao() dao.TenantPluginDefaultENVDao {
	ret := m.ctrl.Call(m, "TenantPluginDefaultENVDao")
	ret0, _ := ret[0].(dao.TenantPluginDefaultENVDao)
	return ret0
}

// TenantPluginDefaultENVDao indicates an expected call of TenantPluginDefaultENVDao
func (mr *MockManagerMockRecorder) TenantPluginDefaultENVDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantPluginDefaultENVDao", reflect.TypeOf((*MockManager)(nil).TenantPluginDefaultENVDao))
}

// TenantPluginBuildVersionDao mocks base method
func (m *MockManager) TenantPluginBuildVersionDao() dao.TenantPluginBuildVersionDao {
	ret := m.ctrl.Call(m, "TenantPluginBuildVersionDao")
	ret0, _ := ret[0].(dao.TenantPluginBuildVersionDao)
	return ret0
}

// TenantPluginBuildVersionDao indicates an expected call of TenantPluginBuildVersionDao
func (mr *MockManagerMockRecorder) TenantPluginBuildVersionDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantPluginBuildVersionDao", reflect.TypeOf((*MockManager)(nil).TenantPluginBuildVersionDao))
}

// TenantPluginBuildVersionDaoTransactions mocks base method
func (m *MockManager) TenantPluginBuildVersionDaoTransactions(db *gorm.DB) dao.TenantPluginBuildVersionDao {
	ret := m.ctrl.Call(m, "TenantPluginBuildVersionDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantPluginBuildVersionDao)
	return ret0
}

// TenantPluginBuildVersionDaoTransactions indicates an expected call of TenantPluginBuildVersionDaoTransactions
func (mr *MockManagerMockRecorder) TenantPluginBuildVersionDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantPluginBuildVersionDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantPluginBuildVersionDaoTransactions), db)
}

// TenantPluginVersionENVDao mocks base method
func (m *MockManager) TenantPluginVersionENVDao() dao.TenantPluginVersionEnvDao {
	ret := m.ctrl.Call(m, "TenantPluginVersionENVDao")
	ret0, _ := ret[0].(dao.TenantPluginVersionEnvDao)
	return ret0
}

// TenantPluginVersionENVDao indicates an expected call of TenantPluginVersionENVDao
func (mr *MockManagerMockRecorder) TenantPluginVersionENVDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantPluginVersionENVDao", reflect.TypeOf((*MockManager)(nil).TenantPluginVersionENVDao))
}

// TenantPluginVersionENVDaoTransactions mocks base method
func (m *MockManager) TenantPluginVersionENVDaoTransactions(db *gorm.DB) dao.TenantPluginVersionEnvDao {
	ret := m.ctrl.Call(m, "TenantPluginVersionENVDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantPluginVersionEnvDao)
	return ret0
}

// TenantPluginVersionENVDaoTransactions indicates an expected call of TenantPluginVersionENVDaoTransactions
func (mr *MockManagerMockRecorder) TenantPluginVersionENVDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantPluginVersionENVDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantPluginVersionENVDaoTransactions), db)
}

// TenantPluginVersionConfigDao mocks base method
func (m *MockManager) TenantPluginVersionConfigDao() dao.TenantPluginVersionConfigDao {
	ret := m.ctrl.Call(m, "TenantPluginVersionConfigDao")
	ret0, _ := ret[0].(dao.TenantPluginVersionConfigDao)
	return ret0
}

// TenantPluginVersionConfigDao indicates an expected call of TenantPluginVersionConfigDao
func (mr *MockManagerMockRecorder) TenantPluginVersionConfigDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantPluginVersionConfigDao", reflect.TypeOf((*MockManager)(nil).TenantPluginVersionConfigDao))
}

// TenantPluginVersionConfigDaoTransactions mocks base method
func (m *MockManager) TenantPluginVersionConfigDaoTransactions(db *gorm.DB) dao.TenantPluginVersionConfigDao {
	ret := m.ctrl.Call(m, "TenantPluginVersionConfigDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantPluginVersionConfigDao)
	return ret0
}

// TenantPluginVersionConfigDaoTransactions indicates an expected call of TenantPluginVersionConfigDaoTransactions
func (mr *MockManagerMockRecorder) TenantPluginVersionConfigDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantPluginVersionConfigDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantPluginVersionConfigDaoTransactions), db)
}

// TenantServicePluginRelationDao mocks base method
func (m *MockManager) TenantServicePluginRelationDao() dao.TenantServicePluginRelationDao {
	ret := m.ctrl.Call(m, "TenantServicePluginRelationDao")
	ret0, _ := ret[0].(dao.TenantServicePluginRelationDao)
	return ret0
}

// TenantServicePluginRelationDao indicates an expected call of TenantServicePluginRelationDao
func (mr *MockManagerMockRecorder) TenantServicePluginRelationDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServicePluginRelationDao", reflect.TypeOf((*MockManager)(nil).TenantServicePluginRelationDao))
}

// TenantServicePluginRelationDaoTransactions mocks base method
func (m *MockManager) TenantServicePluginRelationDaoTransactions(db *gorm.DB) dao.TenantServicePluginRelationDao {
	ret := m.ctrl.Call(m, "TenantServicePluginRelationDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantServicePluginRelationDao)
	return ret0
}

// TenantServicePluginRelationDaoTransactions indicates an expected call of TenantServicePluginRelationDaoTransactions
func (mr *MockManagerMockRecorder) TenantServicePluginRelationDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServicePluginRelationDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServicePluginRelationDaoTransactions), db)
}

// TenantServicesStreamPluginPortDao mocks base method
func (m *MockManager) TenantServicesStreamPluginPortDao() dao.TenantServicesStreamPluginPortDao {
	ret := m.ctrl.Call(m, "TenantServicesStreamPluginPortDao")
	ret0, _ := ret[0].(dao.TenantServicesStreamPluginPortDao)
	return ret0
}

// TenantServicesStreamPluginPortDao indicates an expected call of TenantServicesStreamPluginPortDao
func (mr *MockManagerMockRecorder) TenantServicesStreamPluginPortDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServicesStreamPluginPortDao", reflect.TypeOf((*MockManager)(nil).TenantServicesStreamPluginPortDao))
}

// TenantServicesStreamPluginPortDaoTransactions mocks base method
func (m *MockManager) TenantServicesStreamPluginPortDaoTransactions(db *gorm.DB) dao.TenantServicesStreamPluginPortDao {
	ret := m.ctrl.Call(m, "TenantServicesStreamPluginPortDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantServicesStreamPluginPortDao)
	return ret0
}

// TenantServicesStreamPluginPortDaoTransactions indicates an expected call of TenantServicesStreamPluginPortDaoTransactions
func (mr *MockManagerMockRecorder) TenantServicesStreamPluginPortDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServicesStreamPluginPortDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServicesStreamPluginPortDaoTransactions), db)
}

// CodeCheckResultDao mocks base method
func (m *MockManager) CodeCheckResultDao() dao.CodeCheckResultDao {
	ret := m.ctrl.Call(m, "CodeCheckResultDao")
	ret0, _ := ret[0].(dao.CodeCheckResultDao)
	return ret0
}

// CodeCheckResultDao indicates an expected call of CodeCheckResultDao
func (mr *MockManagerMockRecorder) CodeCheckResultDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeCheckResultDao", reflect.TypeOf((*MockManager)(nil).CodeCheckResultDao))
}

// CodeCheckResultDaoTransactions mocks base method
func (m *MockManager) CodeCheckResultDaoTransactions(db *gorm.DB) dao.CodeCheckResultDao {
	ret := m.ctrl.Call(m, "CodeCheckResultDaoTransactions", db)
	ret0, _ := ret[0].(dao.CodeCheckResultDao)
	return ret0
}

// CodeCheckResultDaoTransactions indicates an expected call of CodeCheckResultDaoTransactions
func (mr *MockManagerMockRecorder) CodeCheckResultDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeCheckResultDaoTransactions", reflect.TypeOf((*MockManager)(nil).CodeCheckResultDaoTransactions), db)
}

// ServiceEventDao mocks base method
func (m *MockManager) ServiceEventDao() dao.EventDao {
	ret := m.ctrl.Call(m, "ServiceEventDao")
	ret0, _ := ret[0].(dao.EventDao)
	return ret0
}

// ServiceEventDao indicates an expected call of ServiceEventDao
func (mr *MockManagerMockRecorder) ServiceEventDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceEventDao", reflect.TypeOf((*MockManager)(nil).ServiceEventDao))
}

// ServiceEventDaoTransactions mocks base method
func (m *MockManager) ServiceEventDaoTransactions(db *gorm.DB) dao.EventDao {
	ret := m.ctrl.Call(m, "ServiceEventDaoTransactions", db)
	ret0, _ := ret[0].(dao.EventDao)
	return ret0
}

// ServiceEventDaoTransactions indicates an expected call of ServiceEventDaoTransactions
func (mr *MockManagerMockRecorder) ServiceEventDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceEventDaoTransactions", reflect.TypeOf((*MockManager)(nil).ServiceEventDaoTransactions), db)
}

// VersionInfoDao mocks base method
func (m *MockManager) VersionInfoDao() dao.VersionInfoDao {
	ret := m.ctrl.Call(m, "VersionInfoDao")
	ret0, _ := ret[0].(dao.VersionInfoDao)
	return ret0
}

// VersionInfoDao indicates an expected call of VersionInfoDao
func (mr *MockManagerMockRecorder) VersionInfoDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VersionInfoDao", reflect.TypeOf((*MockManager)(nil).VersionInfoDao))
}

// VersionInfoDaoTransactions mocks base method
func (m *MockManager) VersionInfoDaoTransactions(db *gorm.DB) dao.VersionInfoDao {
	ret := m.ctrl.Call(m, "VersionInfoDaoTransactions", db)
	ret0, _ := ret[0].(dao.VersionInfoDao)
	return ret0
}

// VersionInfoDaoTransactions indicates an expected call of VersionInfoDaoTransactions
func (mr *MockManagerMockRecorder) VersionInfoDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VersionInfoDaoTransactions", reflect.TypeOf((*MockManager)(nil).VersionInfoDaoTransactions), db)
}

// RegionUserInfoDao mocks base method
func (m *MockManager) RegionUserInfoDao() dao.RegionUserInfoDao {
	ret := m.ctrl.Call(m, "RegionUserInfoDao")
	ret0, _ := ret[0].(dao.RegionUserInfoDao)
	return ret0
}

// RegionUserInfoDao indicates an expected call of RegionUserInfoDao
func (mr *MockManagerMockRecorder) RegionUserInfoDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegionUserInfoDao", reflect.TypeOf((*MockManager)(nil).RegionUserInfoDao))
}

// RegionUserInfoDaoTransactions mocks base method
func (m *MockManager) RegionUserInfoDaoTransactions(db *gorm.DB) dao.RegionUserInfoDao {
	ret := m.ctrl.Call(m, "RegionUserInfoDaoTransactions", db)
	ret0, _ := ret[0].(dao.RegionUserInfoDao)
	return ret0
}

// RegionUserInfoDaoTransactions indicates an expected call of RegionUserInfoDaoTransactions
func (mr *MockManagerMockRecorder) RegionUserInfoDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegionUserInfoDaoTransactions", reflect.TypeOf((*MockManager)(nil).RegionUserInfoDaoTransactions), db)
}

// RegionAPIClassDao mocks base method
func (m *MockManager) RegionAPIClassDao() dao.RegionAPIClassDao {
	ret := m.ctrl.Call(m, "RegionAPIClassDao")
	ret0, _ := ret[0].(dao.RegionAPIClassDao)
	return ret0
}

// RegionAPIClassDao indicates an expected call of RegionAPIClassDao
func (mr *MockManagerMockRecorder) RegionAPIClassDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegionAPIClassDao", reflect.TypeOf((*MockManager)(nil).RegionAPIClassDao))
}

// RegionAPIClassDaoTransactions mocks base method
func (m *MockManager) RegionAPIClassDaoTransactions(db *gorm.DB) dao.RegionAPIClassDao {
	ret := m.ctrl.Call(m, "RegionAPIClassDaoTransactions", db)
	ret0, _ := ret[0].(dao.RegionAPIClassDao)
	return ret0
}

// RegionAPIClassDaoTransactions indicates an expected call of RegionAPIClassDaoTransactions
func (mr *MockManagerMockRecorder) RegionAPIClassDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegionAPIClassDaoTransactions", reflect.TypeOf((*MockManager)(nil).RegionAPIClassDaoTransactions), db)
}

// RegionProcotolsDao mocks base method
func (m *MockManager) RegionProcotolsDao() dao.RegionProcotolsDao {
	ret := m.ctrl.Call(m, "RegionProcotolsDao")
	ret0, _ := ret[0].(dao.RegionProcotolsDao)
	return ret0
}

// RegionProcotolsDao indicates an expected call of RegionProcotolsDao
func (mr *MockManagerMockRecorder) RegionProcotolsDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegionProcotolsDao", reflect.TypeOf((*MockManager)(nil).RegionProcotolsDao))
}

// RegionProcotolsDaoTransactions mocks base method
func (m *MockManager) RegionProcotolsDaoTransactions(db *gorm.DB) dao.RegionProcotolsDao {
	ret := m.ctrl.Call(m, "RegionProcotolsDaoTransactions", db)
	ret0, _ := ret[0].(dao.RegionProcotolsDao)
	return ret0
}

// RegionProcotolsDaoTransactions indicates an expected call of RegionProcotolsDaoTransactions
func (mr *MockManagerMockRecorder) RegionProcotolsDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegionProcotolsDaoTransactions", reflect.TypeOf((*MockManager)(nil).RegionProcotolsDaoTransactions), db)
}

// NotificationEventDao mocks base method
func (m *MockManager) NotificationEventDao() dao.NotificationEventDao {
	ret := m.ctrl.Call(m, "NotificationEventDao")
	ret0, _ := ret[0].(dao.NotificationEventDao)
	return ret0
}

// NotificationEventDao indicates an expected call of NotificationEventDao
func (mr *MockManagerMockRecorder) NotificationEventDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotificationEventDao", reflect.TypeOf((*MockManager)(nil).NotificationEventDao))
}

// AppBackupDao mocks base method
func (m *MockManager) AppBackupDao() dao.AppBackupDao {
	ret := m.ctrl.Call(m, "AppBackupDao")
	ret0, _ := ret[0].(dao.AppBackupDao)
	return ret0
}

// AppBackupDao indicates an expected call of AppBackupDao
func (mr *MockManagerMockRecorder) AppBackupDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppBackupDao", reflect.TypeOf((*MockManager)(nil).AppBackupDao))
}

// AppBackupDaoTransactions mocks base method
func (m *MockManager) AppBackupDaoTransactions(db *gorm.DB) dao.AppBackupDao {
	ret := m.ctrl.Call(m, "AppBackupDaoTransactions", db)
	ret0, _ := ret[0].(dao.AppBackupDao)
	return ret0
}

// AppBackupDaoTransactions indicates an expected call of AppBackupDaoTransactions
func (mr *MockManagerMockRecorder) AppBackupDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppBackupDaoTransactions", reflect.TypeOf((*MockManager)(nil).AppBackupDaoTransactions), db)
}

// ServiceSourceDao mocks base method
func (m *MockManager) ServiceSourceDao() dao.ServiceSourceDao {
	ret := m.ctrl.Call(m, "ServiceSourceDao")
	ret0, _ := ret[0].(dao.ServiceSourceDao)
	return ret0
}

// ServiceSourceDao indicates an expected call of ServiceSourceDao
func (mr *MockManagerMockRecorder) ServiceSourceDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceSourceDao", reflect.TypeOf((*MockManager)(nil).ServiceSourceDao))
}

// CertificateDao mocks base method
func (m *MockManager) CertificateDao() dao.CertificateDao {
	ret := m.ctrl.Call(m, "CertificateDao")
	ret0, _ := ret[0].(dao.CertificateDao)
	return ret0
}

// CertificateDao indicates an expected call of CertificateDao
func (mr *MockManagerMockRecorder) CertificateDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CertificateDao", reflect.TypeOf((*MockManager)(nil).CertificateDao))
}

// CertificateDaoTransactions mocks base method
func (m *MockManager) CertificateDaoTransactions(db *gorm.DB) dao.CertificateDao {
	ret := m.ctrl.Call(m, "CertificateDaoTransactions", db)
	ret0, _ := ret[0].(dao.CertificateDao)
	return ret0
}

// CertificateDaoTransactions indicates an expected call of CertificateDaoTransactions
func (mr *MockManagerMockRecorder) CertificateDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CertificateDaoTransactions", reflect.TypeOf((*MockManager)(nil).CertificateDaoTransactions), db)
}

// RuleExtensionDao mocks base method
func (m *MockManager) RuleExtensionDao() dao.RuleExtensionDao {
	ret := m.ctrl.Call(m, "RuleExtensionDao")
	ret0, _ := ret[0].(dao.RuleExtensionDao)
	return ret0
}

// RuleExtensionDao indicates an expected call of RuleExtensionDao
func (mr *MockManagerMockRecorder) RuleExtensionDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RuleExtensionDao", reflect.TypeOf((*MockManager)(nil).RuleExtensionDao))
}

// RuleExtensionDaoTransactions mocks base method
func (m *MockManager) RuleExtensionDaoTransactions(db *gorm.DB) dao.RuleExtensionDao {
	ret := m.ctrl.Call(m, "RuleExtensionDaoTransactions", db)
	ret0, _ := ret[0].(dao.RuleExtensionDao)
	return ret0
}

// RuleExtensionDaoTransactions indicates an expected call of RuleExtensionDaoTransactions
func (mr *MockManagerMockRecorder) RuleExtensionDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RuleExtensionDaoTransactions", reflect.TypeOf((*MockManager)(nil).RuleExtensionDaoTransactions), db)
}

// HTTPRuleDao mocks base method
func (m *MockManager) HTTPRuleDao() dao.HTTPRuleDao {
	ret := m.ctrl.Call(m, "HTTPRuleDao")
	ret0, _ := ret[0].(dao.HTTPRuleDao)
	return ret0
}

// HTTPRuleDao indicates an expected call of HTTPRuleDao
func (mr *MockManagerMockRecorder) HTTPRuleDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HTTPRuleDao", reflect.TypeOf((*MockManager)(nil).HTTPRuleDao))
}

// HTTPRuleDaoTransactions mocks base method
func (m *MockManager) HTTPRuleDaoTransactions(db *gorm.DB) dao.HTTPRuleDao {
	ret := m.ctrl.Call(m, "HTTPRuleDaoTransactions", db)
	ret0, _ := ret[0].(dao.HTTPRuleDao)
	return ret0
}

// HTTPRuleDaoTransactions indicates an expected call of HTTPRuleDaoTransactions
func (mr *MockManagerMockRecorder) HTTPRuleDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HTTPRuleDaoTransactions", reflect.TypeOf((*MockManager)(nil).HTTPRuleDaoTransactions), db)
}

// TCPRuleDao mocks base method
func (m *MockManager) TCPRuleDao() dao.TCPRuleDao {
	ret := m.ctrl.Call(m, "TCPRuleDao")
	ret0, _ := ret[0].(dao.TCPRuleDao)
	return ret0
}

// TCPRuleDao indicates an expected call of TCPRuleDao
func (mr *MockManagerMockRecorder) TCPRuleDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TCPRuleDao", reflect.TypeOf((*MockManager)(nil).TCPRuleDao))
}

// TCPRuleDaoTransactions mocks base method
func (m *MockManager) TCPRuleDaoTransactions(db *gorm.DB) dao.TCPRuleDao {
	ret := m.ctrl.Call(m, "TCPRuleDaoTransactions", db)
	ret0, _ := ret[0].(dao.TCPRuleDao)
	return ret0
}

// TCPRuleDaoTransactions indicates an expected call of TCPRuleDaoTransactions
func (mr *MockManagerMockRecorder) TCPRuleDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TCPRuleDaoTransactions", reflect.TypeOf((*MockManager)(nil).TCPRuleDaoTransactions), db)
}

// GwRuleConfigDao mocks base method
func (m *MockManager) GwRuleConfigDao() dao.GwRuleConfigDao {
	ret := m.ctrl.Call(m, "GwRuleConfigDao")
	ret0, _ := ret[0].(dao.GwRuleConfigDao)
	return ret0
}

// GwRuleConfigDao indicates an expected call of GwRuleConfigDao
func (mr *MockManagerMockRecorder) GwRuleConfigDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GwRuleConfigDao", reflect.TypeOf((*MockManager)(nil).GwRuleConfigDao))
}

// GwRuleConfigDaoTransactions mocks base method
func (m *MockManager) GwRuleConfigDaoTransactions(db *gorm.DB) dao.GwRuleConfigDao {
	ret := m.ctrl.Call(m, "GwRuleConfigDaoTransactions", db)
	ret0, _ := ret[0].(dao.GwRuleConfigDao)
	return ret0
}

// GwRuleConfigDaoTransactions indicates an expected call of GwRuleConfigDaoTransactions
func (mr *MockManagerMockRecorder) GwRuleConfigDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GwRuleConfigDaoTransactions", reflect.TypeOf((*MockManager)(nil).GwRuleConfigDaoTransactions), db)
}

// EndpointsDao mocks base method
func (m *MockManager) EndpointsDao() dao.EndpointsDao {
	ret := m.ctrl.Call(m, "EndpointsDao")
	ret0, _ := ret[0].(dao.EndpointsDao)
	return ret0
}

// EndpointsDao indicates an expected call of EndpointsDao
func (mr *MockManagerMockRecorder) EndpointsDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EndpointsDao", reflect.TypeOf((*MockManager)(nil).EndpointsDao))
}

// EndpointsDaoTransactions mocks base method
func (m *MockManager) EndpointsDaoTransactions(db *gorm.DB) dao.EndpointsDao {
	ret := m.ctrl.Call(m, "EndpointsDaoTransactions", db)
	ret0, _ := ret[0].(dao.EndpointsDao)
	return ret0
}

// EndpointsDaoTransactions indicates an expected call of EndpointsDaoTransactions
func (mr *MockManagerMockRecorder) EndpointsDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EndpointsDaoTransactions", reflect.TypeOf((*MockManager)(nil).EndpointsDaoTransactions), db)
}

// ThirdPartySvcDiscoveryCfgDao mocks base method
func (m *MockManager) ThirdPartySvcDiscoveryCfgDao() dao.ThirdPartySvcDiscoveryCfgDao {
	ret := m.ctrl.Call(m, "ThirdPartySvcDiscoveryCfgDao")
	ret0, _ := ret[0].(dao.ThirdPartySvcDiscoveryCfgDao)
	return ret0
}

// ThirdPartySvcDiscoveryCfgDao indicates an expected call of ThirdPartySvcDiscoveryCfgDao
func (mr *MockManagerMockRecorder) ThirdPartySvcDiscoveryCfgDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ThirdPartySvcDiscoveryCfgDao", reflect.TypeOf((*MockManager)(nil).ThirdPartySvcDiscoveryCfgDao))
}

// ThirdPartySvcDiscoveryCfgDaoTransactions mocks base method
func (m *MockManager) ThirdPartySvcDiscoveryCfgDaoTransactions(db *gorm.DB) dao.ThirdPartySvcDiscoveryCfgDao {
	ret := m.ctrl.Call(m, "ThirdPartySvcDiscoveryCfgDaoTransactions", db)
	ret0, _ := ret[0].(dao.ThirdPartySvcDiscoveryCfgDao)
	return ret0
}

// ThirdPartySvcDiscoveryCfgDaoTransactions indicates an expected call of ThirdPartySvcDiscoveryCfgDaoTransactions
func (mr *MockManagerMockRecorder) ThirdPartySvcDiscoveryCfgDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ThirdPartySvcDiscoveryCfgDaoTransactions", reflect.TypeOf((*MockManager)(nil).ThirdPartySvcDiscoveryCfgDaoTransactions), db)
}

// TenantServceAutoscalerRulesDao mocks base method
func (m *MockManager) TenantServceAutoscalerRulesDao() dao.TenantServceAutoscalerRulesDao {
	ret := m.ctrl.Call(m, "TenantServceAutoscalerRulesDao")
	ret0, _ := ret[0].(dao.TenantServceAutoscalerRulesDao)
	return ret0
}

// TenantServceAutoscalerRulesDao indicates an expected call of TenantServceAutoscalerRulesDao
func (mr *MockManagerMockRecorder) TenantServceAutoscalerRulesDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServceAutoscalerRulesDao", reflect.TypeOf((*MockManager)(nil).TenantServceAutoscalerRulesDao))
}

// TenantServceAutoscalerRulesDaoTransactions mocks base method
func (m *MockManager) TenantServceAutoscalerRulesDaoTransactions(db *gorm.DB) dao.TenantServceAutoscalerRulesDao {
	ret := m.ctrl.Call(m, "TenantServceAutoscalerRulesDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantServceAutoscalerRulesDao)
	return ret0
}

// TenantServceAutoscalerRulesDaoTransactions indicates an expected call of TenantServceAutoscalerRulesDaoTransactions
func (mr *MockManagerMockRecorder) TenantServceAutoscalerRulesDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServceAutoscalerRulesDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServceAutoscalerRulesDaoTransactions), db)
}

// TenantServceAutoscalerRuleMetricsDao mocks base method
func (m *MockManager) TenantServceAutoscalerRuleMetricsDao() dao.TenantServceAutoscalerRuleMetricsDao {
	ret := m.ctrl.Call(m, "TenantServceAutoscalerRuleMetricsDao")
	ret0, _ := ret[0].(dao.TenantServceAutoscalerRuleMetricsDao)
	return ret0
}

// TenantServceAutoscalerRuleMetricsDao indicates an expected call of TenantServceAutoscalerRuleMetricsDao
func (mr *MockManagerMockRecorder) TenantServceAutoscalerRuleMetricsDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServceAutoscalerRuleMetricsDao", reflect.TypeOf((*MockManager)(nil).TenantServceAutoscalerRuleMetricsDao))
}

// TenantServceAutoscalerRuleMetricsDaoTransactions mocks base method
func (m *MockManager) TenantServceAutoscalerRuleMetricsDaoTransactions(db *gorm.DB) dao.TenantServceAutoscalerRuleMetricsDao {
	ret := m.ctrl.Call(m, "TenantServceAutoscalerRuleMetricsDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantServceAutoscalerRuleMetricsDao)
	return ret0
}

// TenantServceAutoscalerRuleMetricsDaoTransactions indicates an expected call of TenantServceAutoscalerRuleMetricsDaoTransactions
func (mr *MockManagerMockRecorder) TenantServceAutoscalerRuleMetricsDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServceAutoscalerRuleMetricsDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServceAutoscalerRuleMetricsDaoTransactions), db)
}

// TenantServiceScalingRecordsDao mocks base method
func (m *MockManager) TenantServiceScalingRecordsDao() dao.TenantServiceScalingRecordsDao {
	ret := m.ctrl.Call(m, "TenantServiceScalingRecordsDao")
	ret0, _ := ret[0].(dao.TenantServiceScalingRecordsDao)
	return ret0
}

// TenantServiceScalingRecordsDao indicates an expected call of TenantServiceScalingRecordsDao
func (mr *MockManagerMockRecorder) TenantServiceScalingRecordsDao() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceScalingRecordsDao", reflect.TypeOf((*MockManager)(nil).TenantServiceScalingRecordsDao))
}

// TenantServiceScalingRecordsDaoTransactions mocks base method
func (m *MockManager) TenantServiceScalingRecordsDaoTransactions(db *gorm.DB) dao.TenantServiceScalingRecordsDao {
	ret := m.ctrl.Call(m, "TenantServiceScalingRecordsDaoTransactions", db)
	ret0, _ := ret[0].(dao.TenantServiceScalingRecordsDao)
	return ret0
}

// TenantServiceScalingRecordsDaoTransactions indicates an expected call of TenantServiceScalingRecordsDaoTransactions
func (mr *MockManagerMockRecorder) TenantServiceScalingRecordsDaoTransactions(db interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TenantServiceScalingRecordsDaoTransactions", reflect.TypeOf((*MockManager)(nil).TenantServiceScalingRecordsDaoTransactions), db)
}