Rainbond/db/dao/dao_mock.go

// Automatically generated by MockGen. DO NOT EDIT!
// Source: dao.go

package dao

import (
	model "github.com/goodrain/rainbond/db/model"
	time "time"
	gomock "github.com/rafrombrc/gomock/gomock"
)

// Mock of Dao interface
type MockDao struct {
	ctrl     *gomock.Controller
	recorder *_MockDaoRecorder
}

// Recorder for MockDao (not exported)
type _MockDaoRecorder struct {
	mock *MockDao
}

func NewMockDao(ctrl *gomock.Controller) *MockDao {
	mock := &MockDao{ctrl: ctrl}
	mock.recorder = &_MockDaoRecorder{mock}
	return mock
}

func (_m *MockDao) EXPECT() *_MockDaoRecorder {
	return _m.recorder
}

func (_m *MockDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

// Mock of DelDao interface
type MockDelDao struct {
	ctrl     *gomock.Controller
	recorder *_MockDelDaoRecorder
}

// Recorder for MockDelDao (not exported)
type _MockDelDaoRecorder struct {
	mock *MockDelDao
}

func NewMockDelDao(ctrl *gomock.Controller) *MockDelDao {
	mock := &MockDelDao{ctrl: ctrl}
	mock.recorder = &_MockDelDaoRecorder{mock}
	return mock
}

func (_m *MockDelDao) EXPECT() *_MockDelDaoRecorder {
	return _m.recorder
}

func (_m *MockDelDao) DeleteModel(serviceID string, arg ...interface{}) error {
	_s := []interface{}{serviceID}
	for _, _x := range arg {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteModel", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockDelDaoRecorder) DeleteModel(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0}, arg1...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModel", _s...)
}

// Mock of TenantDao interface
type MockTenantDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantDaoRecorder
}

// Recorder for MockTenantDao (not exported)
type _MockTenantDaoRecorder struct {
	mock *MockTenantDao
}

func NewMockTenantDao(ctrl *gomock.Controller) *MockTenantDao {
	mock := &MockTenantDao{ctrl: ctrl}
	mock.recorder = &_MockTenantDaoRecorder{mock}
	return mock
}

func (_m *MockTenantDao) EXPECT() *_MockTenantDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantDao) GetTenantByUUID(uuid string) (*model.Tenants, error) {
	ret := _m.ctrl.Call(_m, "GetTenantByUUID", uuid)
	ret0, _ := ret[0].(*model.Tenants)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantDaoRecorder) GetTenantByUUID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantByUUID", arg0)
}

func (_m *MockTenantDao) GetTenantIDByName(tenantName string) (*model.Tenants, error) {
	ret := _m.ctrl.Call(_m, "GetTenantIDByName", tenantName)
	ret0, _ := ret[0].(*model.Tenants)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantDaoRecorder) GetTenantIDByName(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantIDByName", arg0)
}

func (_m *MockTenantDao) GetALLTenants() ([]*model.Tenants, error) {
	ret := _m.ctrl.Call(_m, "GetALLTenants")
	ret0, _ := ret[0].([]*model.Tenants)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantDaoRecorder) GetALLTenants() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetALLTenants")
}

func (_m *MockTenantDao) GetTenantByEid(eid string) ([]*model.Tenants, error) {
	ret := _m.ctrl.Call(_m, "GetTenantByEid", eid)
	ret0, _ := ret[0].([]*model.Tenants)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantDaoRecorder) GetTenantByEid(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantByEid", arg0)
}

func (_m *MockTenantDao) GetPagedTenants(offset int, len int) ([]*model.Tenants, error) {
	ret := _m.ctrl.Call(_m, "GetPagedTenants", offset, len)
	ret0, _ := ret[0].([]*model.Tenants)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantDaoRecorder) GetPagedTenants(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPagedTenants", arg0, arg1)
}

func (_m *MockTenantDao) GetTenantIDsByNames(names []string) ([]string, error) {
	ret := _m.ctrl.Call(_m, "GetTenantIDsByNames", names)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantDaoRecorder) GetTenantIDsByNames(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantIDsByNames", arg0)
}

func (_m *MockTenantDao) GetTenantLimitsByNames(names []string) (map[string]int, error) {
	ret := _m.ctrl.Call(_m, "GetTenantLimitsByNames", names)
	ret0, _ := ret[0].(map[string]int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantDaoRecorder) GetTenantLimitsByNames(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantLimitsByNames", arg0)
}

func (_m *MockTenantDao) GetTenantByUUIDIsExist(uuid string) bool {
	ret := _m.ctrl.Call(_m, "GetTenantByUUIDIsExist", uuid)
	ret0, _ := ret[0].(bool)
	return ret0
}

func (_mr *_MockTenantDaoRecorder) GetTenantByUUIDIsExist(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantByUUIDIsExist", arg0)
}

// Mock of AppDao interface
type MockAppDao struct {
	ctrl     *gomock.Controller
	recorder *_MockAppDaoRecorder
}

// Recorder for MockAppDao (not exported)
type _MockAppDaoRecorder struct {
	mock *MockAppDao
}

func NewMockAppDao(ctrl *gomock.Controller) *MockAppDao {
	mock := &MockAppDao{ctrl: ctrl}
	mock.recorder = &_MockAppDaoRecorder{mock}
	return mock
}

func (_m *MockAppDao) EXPECT() *_MockAppDaoRecorder {
	return _m.recorder
}

func (_m *MockAppDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockAppDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockAppDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockAppDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockAppDao) GetByEventId(eventID string) (*model.AppStatus, error) {
	ret := _m.ctrl.Call(_m, "GetByEventId", eventID)
	ret0, _ := ret[0].(*model.AppStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockAppDaoRecorder) GetByEventId(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetByEventId", arg0)
}

func (_m *MockAppDao) DeleteModelByEventId(eventID string) error {
	ret := _m.ctrl.Call(_m, "DeleteModelByEventId", eventID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockAppDaoRecorder) DeleteModelByEventId(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModelByEventId", arg0)
}

// Mock of LicenseDao interface
type MockLicenseDao struct {
	ctrl     *gomock.Controller
	recorder *_MockLicenseDaoRecorder
}

// Recorder for MockLicenseDao (not exported)
type _MockLicenseDaoRecorder struct {
	mock *MockLicenseDao
}

func NewMockLicenseDao(ctrl *gomock.Controller) *MockLicenseDao {
	mock := &MockLicenseDao{ctrl: ctrl}
	mock.recorder = &_MockLicenseDaoRecorder{mock}
	return mock
}

func (_m *MockLicenseDao) EXPECT() *_MockLicenseDaoRecorder {
	return _m.recorder
}

func (_m *MockLicenseDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockLicenseDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockLicenseDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockLicenseDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockLicenseDao) ListLicenses() ([]*model.LicenseInfo, error) {
	ret := _m.ctrl.Call(_m, "ListLicenses")
	ret0, _ := ret[0].([]*model.LicenseInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockLicenseDaoRecorder) ListLicenses() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListLicenses")
}

// Mock of TenantServiceDao interface
type MockTenantServiceDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceDaoRecorder
}

// Recorder for MockTenantServiceDao (not exported)
type _MockTenantServiceDaoRecorder struct {
	mock *MockTenantServiceDao
}

func NewMockTenantServiceDao(ctrl *gomock.Controller) *MockTenantServiceDao {
	mock := &MockTenantServiceDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceDao) EXPECT() *_MockTenantServiceDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceDao) GetServiceByID(serviceID string) (*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServiceByID", serviceID)
	ret0, _ := ret[0].(*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServiceByID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceByID", arg0)
}

func (_m *MockTenantServiceDao) GetServiceByServiceAlias(serviceAlias string) (*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServiceByServiceAlias", serviceAlias)
	ret0, _ := ret[0].(*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServiceByServiceAlias(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceByServiceAlias", arg0)
}

func (_m *MockTenantServiceDao) GetServiceByIDs(serviceIDs []string) ([]*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServiceByIDs", serviceIDs)
	ret0, _ := ret[0].([]*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServiceByIDs(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceByIDs", arg0)
}

func (_m *MockTenantServiceDao) GetServiceAliasByIDs(uids []string) ([]*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServiceAliasByIDs", uids)
	ret0, _ := ret[0].([]*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServiceAliasByIDs(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceAliasByIDs", arg0)
}

func (_m *MockTenantServiceDao) GetServiceByTenantIDAndServiceAlias(tenantID string, serviceName string) (*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServiceByTenantIDAndServiceAlias", tenantID, serviceName)
	ret0, _ := ret[0].(*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServiceByTenantIDAndServiceAlias(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceByTenantIDAndServiceAlias", arg0, arg1)
}

func (_m *MockTenantServiceDao) SetTenantServiceStatus(serviceID string, status string) error {
	ret := _m.ctrl.Call(_m, "SetTenantServiceStatus", serviceID, status)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDaoRecorder) SetTenantServiceStatus(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetTenantServiceStatus", arg0, arg1)
}

func (_m *MockTenantServiceDao) GetServicesByTenantID(tenantID string) ([]*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServicesByTenantID", tenantID)
	ret0, _ := ret[0].([]*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServicesByTenantID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServicesByTenantID", arg0)
}

func (_m *MockTenantServiceDao) GetServicesByTenantIDs(tenantIDs []string) ([]*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServicesByTenantIDs", tenantIDs)
	ret0, _ := ret[0].([]*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServicesByTenantIDs(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServicesByTenantIDs", arg0)
}

func (_m *MockTenantServiceDao) GetServicesAllInfoByTenantID(tenantID string) ([]*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServicesAllInfoByTenantID", tenantID)
	ret0, _ := ret[0].([]*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServicesAllInfoByTenantID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServicesAllInfoByTenantID", arg0)
}

func (_m *MockTenantServiceDao) DeleteServiceByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteServiceByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDaoRecorder) DeleteServiceByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteServiceByServiceID", arg0)
}

func (_m *MockTenantServiceDao) GetServiceMemoryByTenantIDs(tenantIDs []string, serviceIDs []string) (map[string]map[string]interface{}, error) {
	ret := _m.ctrl.Call(_m, "GetServiceMemoryByTenantIDs", tenantIDs, serviceIDs)
	ret0, _ := ret[0].(map[string]map[string]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServiceMemoryByTenantIDs(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceMemoryByTenantIDs", arg0, arg1)
}

func (_m *MockTenantServiceDao) GetServiceMemoryByServiceIDs(serviceIDs []string) (map[string]map[string]interface{}, error) {
	ret := _m.ctrl.Call(_m, "GetServiceMemoryByServiceIDs", serviceIDs)
	ret0, _ := ret[0].(map[string]map[string]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServiceMemoryByServiceIDs(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceMemoryByServiceIDs", arg0)
}

func (_m *MockTenantServiceDao) GetPagedTenantService(offset int, len int, serviceIDs []string) ([]map[string]interface{}, int, error) {
	ret := _m.ctrl.Call(_m, "GetPagedTenantService", offset, len, serviceIDs)
	ret0, _ := ret[0].([]map[string]interface{})
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

func (_mr *_MockTenantServiceDaoRecorder) GetPagedTenantService(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPagedTenantService", arg0, arg1, arg2)
}

func (_m *MockTenantServiceDao) GetAllServices() ([]*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetAllServices")
	ret0, _ := ret[0].([]*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetAllServices() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAllServices")
}

func (_m *MockTenantServiceDao) GetAllServicesID() ([]*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetAllServicesID")
	ret0, _ := ret[0].([]*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetAllServicesID() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAllServicesID")
}

// Mock of TenantServiceDeleteDao interface
type MockTenantServiceDeleteDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceDeleteDaoRecorder
}

// Recorder for MockTenantServiceDeleteDao (not exported)
type _MockTenantServiceDeleteDaoRecorder struct {
	mock *MockTenantServiceDeleteDao
}

func NewMockTenantServiceDeleteDao(ctrl *gomock.Controller) *MockTenantServiceDeleteDao {
	mock := &MockTenantServiceDeleteDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceDeleteDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceDeleteDao) EXPECT() *_MockTenantServiceDeleteDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceDeleteDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDeleteDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceDeleteDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDeleteDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceDeleteDao) GetTenantServicesDeleteByCreateTime(createTime time.Time) ([]*model.TenantServicesDelete, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServicesDeleteByCreateTime", createTime)
	ret0, _ := ret[0].([]*model.TenantServicesDelete)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDeleteDaoRecorder) GetTenantServicesDeleteByCreateTime(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServicesDeleteByCreateTime", arg0)
}

func (_m *MockTenantServiceDeleteDao) DeleteTenantServicesDelete(record *model.TenantServicesDelete) error {
	ret := _m.ctrl.Call(_m, "DeleteTenantServicesDelete", record)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDeleteDaoRecorder) DeleteTenantServicesDelete(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteTenantServicesDelete", arg0)
}

// Mock of TenantServicesPortDao interface
type MockTenantServicesPortDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServicesPortDaoRecorder
}

// Recorder for MockTenantServicesPortDao (not exported)
type _MockTenantServicesPortDaoRecorder struct {
	mock *MockTenantServicesPortDao
}

func NewMockTenantServicesPortDao(ctrl *gomock.Controller) *MockTenantServicesPortDao {
	mock := &MockTenantServicesPortDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServicesPortDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServicesPortDao) EXPECT() *_MockTenantServicesPortDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServicesPortDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesPortDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServicesPortDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesPortDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServicesPortDao) DeleteModel(serviceID string, arg ...interface{}) error {
	_s := []interface{}{serviceID}
	for _, _x := range arg {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteModel", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesPortDaoRecorder) DeleteModel(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0}, arg1...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModel", _s...)
}

func (_m *MockTenantServicesPortDao) GetPortsByServiceID(serviceID string) ([]*model.TenantServicesPort, error) {
	ret := _m.ctrl.Call(_m, "GetPortsByServiceID", serviceID)
	ret0, _ := ret[0].([]*model.TenantServicesPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicesPortDaoRecorder) GetPortsByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPortsByServiceID", arg0)
}

func (_m *MockTenantServicesPortDao) GetOuterPorts(serviceID string) ([]*model.TenantServicesPort, error) {
	ret := _m.ctrl.Call(_m, "GetOuterPorts", serviceID)
	ret0, _ := ret[0].([]*model.TenantServicesPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicesPortDaoRecorder) GetOuterPorts(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetOuterPorts", arg0)
}

func (_m *MockTenantServicesPortDao) GetInnerPorts(serviceID string) ([]*model.TenantServicesPort, error) {
	ret := _m.ctrl.Call(_m, "GetInnerPorts", serviceID)
	ret0, _ := ret[0].([]*model.TenantServicesPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicesPortDaoRecorder) GetInnerPorts(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetInnerPorts", arg0)
}

func (_m *MockTenantServicesPortDao) GetPort(serviceID string, port int) (*model.TenantServicesPort, error) {
	ret := _m.ctrl.Call(_m, "GetPort", serviceID, port)
	ret0, _ := ret[0].(*model.TenantServicesPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicesPortDaoRecorder) GetPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPort", arg0, arg1)
}

func (_m *MockTenantServicesPortDao) DELPortsByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DELPortsByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesPortDaoRecorder) DELPortsByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELPortsByServiceID", arg0)
}

// Mock of TenantPluginDao interface
type MockTenantPluginDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantPluginDaoRecorder
}

// Recorder for MockTenantPluginDao (not exported)
type _MockTenantPluginDaoRecorder struct {
	mock *MockTenantPluginDao
}

func NewMockTenantPluginDao(ctrl *gomock.Controller) *MockTenantPluginDao {
	mock := &MockTenantPluginDao{ctrl: ctrl}
	mock.recorder = &_MockTenantPluginDaoRecorder{mock}
	return mock
}

func (_m *MockTenantPluginDao) EXPECT() *_MockTenantPluginDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantPluginDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantPluginDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantPluginDao) GetPluginByID(pluginID string, tenantID string) (*model.TenantPlugin, error) {
	ret := _m.ctrl.Call(_m, "GetPluginByID", pluginID, tenantID)
	ret0, _ := ret[0].(*model.TenantPlugin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginDaoRecorder) GetPluginByID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPluginByID", arg0, arg1)
}

func (_m *MockTenantPluginDao) DeletePluginByID(pluginID string, tenantID string) error {
	ret := _m.ctrl.Call(_m, "DeletePluginByID", pluginID, tenantID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDaoRecorder) DeletePluginByID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeletePluginByID", arg0, arg1)
}

func (_m *MockTenantPluginDao) GetPluginsByTenantID(tenantID string) ([]*model.TenantPlugin, error) {
	ret := _m.ctrl.Call(_m, "GetPluginsByTenantID", tenantID)
	ret0, _ := ret[0].([]*model.TenantPlugin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginDaoRecorder) GetPluginsByTenantID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPluginsByTenantID", arg0)
}

// Mock of TenantPluginDefaultENVDao interface
type MockTenantPluginDefaultENVDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantPluginDefaultENVDaoRecorder
}

// Recorder for MockTenantPluginDefaultENVDao (not exported)
type _MockTenantPluginDefaultENVDaoRecorder struct {
	mock *MockTenantPluginDefaultENVDao
}

func NewMockTenantPluginDefaultENVDao(ctrl *gomock.Controller) *MockTenantPluginDefaultENVDao {
	mock := &MockTenantPluginDefaultENVDao{ctrl: ctrl}
	mock.recorder = &_MockTenantPluginDefaultENVDaoRecorder{mock}
	return mock
}

func (_m *MockTenantPluginDefaultENVDao) EXPECT() *_MockTenantPluginDefaultENVDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantPluginDefaultENVDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantPluginDefaultENVDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantPluginDefaultENVDao) GetDefaultENVByName(pluginID string, name string, versionID string) (*model.TenantPluginDefaultENV, error) {
	ret := _m.ctrl.Call(_m, "GetDefaultENVByName", pluginID, name, versionID)
	ret0, _ := ret[0].(*model.TenantPluginDefaultENV)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) GetDefaultENVByName(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDefaultENVByName", arg0, arg1, arg2)
}

func (_m *MockTenantPluginDefaultENVDao) GetDefaultENVSByPluginID(pluginID string, versionID string) ([]*model.TenantPluginDefaultENV, error) {
	ret := _m.ctrl.Call(_m, "GetDefaultENVSByPluginID", pluginID, versionID)
	ret0, _ := ret[0].([]*model.TenantPluginDefaultENV)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) GetDefaultENVSByPluginID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDefaultENVSByPluginID", arg0, arg1)
}

func (_m *MockTenantPluginDefaultENVDao) DeleteDefaultENVByName(pluginID string, name string, versionID string) error {
	ret := _m.ctrl.Call(_m, "DeleteDefaultENVByName", pluginID, name, versionID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) DeleteDefaultENVByName(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteDefaultENVByName", arg0, arg1, arg2)
}

func (_m *MockTenantPluginDefaultENVDao) DeleteAllDefaultENVByPluginID(PluginID string) error {
	ret := _m.ctrl.Call(_m, "DeleteAllDefaultENVByPluginID", PluginID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) DeleteAllDefaultENVByPluginID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteAllDefaultENVByPluginID", arg0)
}

func (_m *MockTenantPluginDefaultENVDao) DeleteDefaultENVByPluginIDAndVersionID(pluginID string, versionID string) error {
	ret := _m.ctrl.Call(_m, "DeleteDefaultENVByPluginIDAndVersionID", pluginID, versionID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) DeleteDefaultENVByPluginIDAndVersionID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteDefaultENVByPluginIDAndVersionID", arg0, arg1)
}

func (_m *MockTenantPluginDefaultENVDao) GetALLMasterDefultENVs(pluginID string) ([]*model.TenantPluginDefaultENV, error) {
	ret := _m.ctrl.Call(_m, "GetALLMasterDefultENVs", pluginID)
	ret0, _ := ret[0].([]*model.TenantPluginDefaultENV)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) GetALLMasterDefultENVs(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetALLMasterDefultENVs", arg0)
}

func (_m *MockTenantPluginDefaultENVDao) GetDefaultEnvWhichCanBeSetByPluginID(pluginID string, versionID string) ([]*model.TenantPluginDefaultENV, error) {
	ret := _m.ctrl.Call(_m, "GetDefaultEnvWhichCanBeSetByPluginID", pluginID, versionID)
	ret0, _ := ret[0].([]*model.TenantPluginDefaultENV)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) GetDefaultEnvWhichCanBeSetByPluginID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDefaultEnvWhichCanBeSetByPluginID", arg0, arg1)
}

// Mock of TenantPluginBuildVersionDao interface
type MockTenantPluginBuildVersionDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantPluginBuildVersionDaoRecorder
}

// Recorder for MockTenantPluginBuildVersionDao (not exported)
type _MockTenantPluginBuildVersionDaoRecorder struct {
	mock *MockTenantPluginBuildVersionDao
}

func NewMockTenantPluginBuildVersionDao(ctrl *gomock.Controller) *MockTenantPluginBuildVersionDao {
	mock := &MockTenantPluginBuildVersionDao{ctrl: ctrl}
	mock.recorder = &_MockTenantPluginBuildVersionDaoRecorder{mock}
	return mock
}

func (_m *MockTenantPluginBuildVersionDao) EXPECT() *_MockTenantPluginBuildVersionDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantPluginBuildVersionDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantPluginBuildVersionDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantPluginBuildVersionDao) DeleteBuildVersionByVersionID(versionID string) error {
	ret := _m.ctrl.Call(_m, "DeleteBuildVersionByVersionID", versionID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) DeleteBuildVersionByVersionID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBuildVersionByVersionID", arg0)
}

func (_m *MockTenantPluginBuildVersionDao) DeleteBuildVersionByPluginID(pluginID string) error {
	ret := _m.ctrl.Call(_m, "DeleteBuildVersionByPluginID", pluginID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) DeleteBuildVersionByPluginID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBuildVersionByPluginID", arg0)
}

func (_m *MockTenantPluginBuildVersionDao) GetBuildVersionByPluginID(pluginID string) ([]*model.TenantPluginBuildVersion, error) {
	ret := _m.ctrl.Call(_m, "GetBuildVersionByPluginID", pluginID)
	ret0, _ := ret[0].([]*model.TenantPluginBuildVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) GetBuildVersionByPluginID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBuildVersionByPluginID", arg0)
}

func (_m *MockTenantPluginBuildVersionDao) GetBuildVersionByVersionID(pluginID string, versionID string) (*model.TenantPluginBuildVersion, error) {
	ret := _m.ctrl.Call(_m, "GetBuildVersionByVersionID", pluginID, versionID)
	ret0, _ := ret[0].(*model.TenantPluginBuildVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) GetBuildVersionByVersionID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBuildVersionByVersionID", arg0, arg1)
}

func (_m *MockTenantPluginBuildVersionDao) GetLastBuildVersionByVersionID(pluginID string, versionID string) (*model.TenantPluginBuildVersion, error) {
	ret := _m.ctrl.Call(_m, "GetLastBuildVersionByVersionID", pluginID, versionID)
	ret0, _ := ret[0].(*model.TenantPluginBuildVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) GetLastBuildVersionByVersionID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetLastBuildVersionByVersionID", arg0, arg1)
}

func (_m *MockTenantPluginBuildVersionDao) GetBuildVersionByDeployVersion(pluginID string, versionID string, deployVersion string) (*model.TenantPluginBuildVersion, error) {
	ret := _m.ctrl.Call(_m, "GetBuildVersionByDeployVersion", pluginID, versionID, deployVersion)
	ret0, _ := ret[0].(*model.TenantPluginBuildVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) GetBuildVersionByDeployVersion(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBuildVersionByDeployVersion", arg0, arg1, arg2)
}

// Mock of TenantPluginVersionEnvDao interface
type MockTenantPluginVersionEnvDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantPluginVersionEnvDaoRecorder
}

// Recorder for MockTenantPluginVersionEnvDao (not exported)
type _MockTenantPluginVersionEnvDaoRecorder struct {
	mock *MockTenantPluginVersionEnvDao
}

func NewMockTenantPluginVersionEnvDao(ctrl *gomock.Controller) *MockTenantPluginVersionEnvDao {
	mock := &MockTenantPluginVersionEnvDao{ctrl: ctrl}
	mock.recorder = &_MockTenantPluginVersionEnvDaoRecorder{mock}
	return mock
}

func (_m *MockTenantPluginVersionEnvDao) EXPECT() *_MockTenantPluginVersionEnvDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantPluginVersionEnvDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginVersionEnvDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantPluginVersionEnvDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginVersionEnvDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantPluginVersionEnvDao) DeleteEnvByEnvName(envName string, pluginID string, serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteEnvByEnvName", envName, pluginID, serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginVersionEnvDaoRecorder) DeleteEnvByEnvName(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteEnvByEnvName", arg0, arg1, arg2)
}

func (_m *MockTenantPluginVersionEnvDao) DeleteEnvByPluginID(serviceID string, pluginID string) error {
	ret := _m.ctrl.Call(_m, "DeleteEnvByPluginID", serviceID, pluginID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginVersionEnvDaoRecorder) DeleteEnvByPluginID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteEnvByPluginID", arg0, arg1)
}

func (_m *MockTenantPluginVersionEnvDao) DeleteEnvByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteEnvByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginVersionEnvDaoRecorder) DeleteEnvByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteEnvByServiceID", arg0)
}

func (_m *MockTenantPluginVersionEnvDao) GetVersionEnvByServiceID(serviceID string, pluginID string) ([]*model.TenantPluginVersionEnv, error) {
	ret := _m.ctrl.Call(_m, "GetVersionEnvByServiceID", serviceID, pluginID)
	ret0, _ := ret[0].([]*model.TenantPluginVersionEnv)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginVersionEnvDaoRecorder) GetVersionEnvByServiceID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetVersionEnvByServiceID", arg0, arg1)
}

func (_m *MockTenantPluginVersionEnvDao) GetVersionEnvByEnvName(serviceID string, pluginID string, envName string) (*model.TenantPluginVersionEnv, error) {
	ret := _m.ctrl.Call(_m, "GetVersionEnvByEnvName", serviceID, pluginID, envName)
	ret0, _ := ret[0].(*model.TenantPluginVersionEnv)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginVersionEnvDaoRecorder) GetVersionEnvByEnvName(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetVersionEnvByEnvName", arg0, arg1, arg2)
}

// Mock of TenantServicePluginRelationDao interface
type MockTenantServicePluginRelationDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServicePluginRelationDaoRecorder
}

// Recorder for MockTenantServicePluginRelationDao (not exported)
type _MockTenantServicePluginRelationDaoRecorder struct {
	mock *MockTenantServicePluginRelationDao
}

func NewMockTenantServicePluginRelationDao(ctrl *gomock.Controller) *MockTenantServicePluginRelationDao {
	mock := &MockTenantServicePluginRelationDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServicePluginRelationDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServicePluginRelationDao) EXPECT() *_MockTenantServicePluginRelationDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServicePluginRelationDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServicePluginRelationDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServicePluginRelationDao) DeleteRelationByServiceIDAndPluginID(serviceID string, pluginID string) error {
	ret := _m.ctrl.Call(_m, "DeleteRelationByServiceIDAndPluginID", serviceID, pluginID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) DeleteRelationByServiceIDAndPluginID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteRelationByServiceIDAndPluginID", arg0, arg1)
}

func (_m *MockTenantServicePluginRelationDao) DeleteALLRelationByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteALLRelationByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) DeleteALLRelationByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteALLRelationByServiceID", arg0)
}

func (_m *MockTenantServicePluginRelationDao) DeleteALLRelationByPluginID(pluginID string) error {
	ret := _m.ctrl.Call(_m, "DeleteALLRelationByPluginID", pluginID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) DeleteALLRelationByPluginID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteALLRelationByPluginID", arg0)
}

func (_m *MockTenantServicePluginRelationDao) GetALLRelationByServiceID(serviceID string) ([]*model.TenantServicePluginRelation, error) {
	ret := _m.ctrl.Call(_m, "GetALLRelationByServiceID", serviceID)
	ret0, _ := ret[0].([]*model.TenantServicePluginRelation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) GetALLRelationByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetALLRelationByServiceID", arg0)
}

func (_m *MockTenantServicePluginRelationDao) GetRelateionByServiceIDAndPluginID(serviceID string, pluginID string) (*model.TenantServicePluginRelation, error) {
	ret := _m.ctrl.Call(_m, "GetRelateionByServiceIDAndPluginID", serviceID, pluginID)
	ret0, _ := ret[0].(*model.TenantServicePluginRelation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) GetRelateionByServiceIDAndPluginID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetRelateionByServiceIDAndPluginID", arg0, arg1)
}

func (_m *MockTenantServicePluginRelationDao) CheckSomeModelPluginByServiceID(serviceID string, pluginModel string) (bool, error) {
	ret := _m.ctrl.Call(_m, "CheckSomeModelPluginByServiceID", serviceID, pluginModel)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) CheckSomeModelPluginByServiceID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CheckSomeModelPluginByServiceID", arg0, arg1)
}

func (_m *MockTenantServicePluginRelationDao) CheckSomeModelLikePluginByServiceID(serviceID string, pluginModel string) (bool, error) {
	ret := _m.ctrl.Call(_m, "CheckSomeModelLikePluginByServiceID", serviceID, pluginModel)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) CheckSomeModelLikePluginByServiceID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CheckSomeModelLikePluginByServiceID", arg0, arg1)
}

// Mock of TenantServiceRelationDao interface
type MockTenantServiceRelationDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceRelationDaoRecorder
}

// Recorder for MockTenantServiceRelationDao (not exported)
type _MockTenantServiceRelationDaoRecorder struct {
	mock *MockTenantServiceRelationDao
}

func NewMockTenantServiceRelationDao(ctrl *gomock.Controller) *MockTenantServiceRelationDao {
	mock := &MockTenantServiceRelationDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceRelationDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceRelationDao) EXPECT() *_MockTenantServiceRelationDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceRelationDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceRelationDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceRelationDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceRelationDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceRelationDao) DeleteModel(serviceID string, arg ...interface{}) error {
	_s := []interface{}{serviceID}
	for _, _x := range arg {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteModel", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceRelationDaoRecorder) DeleteModel(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0}, arg1...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModel", _s...)
}

func (_m *MockTenantServiceRelationDao) GetTenantServiceRelations(serviceID string) ([]*model.TenantServiceRelation, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceRelations", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceRelation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceRelationDaoRecorder) GetTenantServiceRelations(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceRelations", arg0)
}

func (_m *MockTenantServiceRelationDao) GetTenantServiceRelationsByDependServiceID(dependServiceID string) ([]*model.TenantServiceRelation, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceRelationsByDependServiceID", dependServiceID)
	ret0, _ := ret[0].([]*model.TenantServiceRelation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceRelationDaoRecorder) GetTenantServiceRelationsByDependServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceRelationsByDependServiceID", arg0)
}

func (_m *MockTenantServiceRelationDao) HaveRelations(serviceID string) bool {
	ret := _m.ctrl.Call(_m, "HaveRelations", serviceID)
	ret0, _ := ret[0].(bool)
	return ret0
}

func (_mr *_MockTenantServiceRelationDaoRecorder) HaveRelations(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "HaveRelations", arg0)
}

func (_m *MockTenantServiceRelationDao) DELRelationsByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DELRelationsByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceRelationDaoRecorder) DELRelationsByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELRelationsByServiceID", arg0)
}

func (_m *MockTenantServiceRelationDao) DeleteRelationByDepID(serviceID string, depID string) error {
	ret := _m.ctrl.Call(_m, "DeleteRelationByDepID", serviceID, depID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceRelationDaoRecorder) DeleteRelationByDepID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteRelationByDepID", arg0, arg1)
}

// Mock of TenantServicesStreamPluginPortDao interface
type MockTenantServicesStreamPluginPortDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServicesStreamPluginPortDaoRecorder
}

// Recorder for MockTenantServicesStreamPluginPortDao (not exported)
type _MockTenantServicesStreamPluginPortDaoRecorder struct {
	mock *MockTenantServicesStreamPluginPortDao
}

func NewMockTenantServicesStreamPluginPortDao(ctrl *gomock.Controller) *MockTenantServicesStreamPluginPortDao {
	mock := &MockTenantServicesStreamPluginPortDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServicesStreamPluginPortDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServicesStreamPluginPortDao) EXPECT() *_MockTenantServicesStreamPluginPortDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServicesStreamPluginPortDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesStreamPluginPortDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServicesStreamPluginPortDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesStreamPluginPortDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServicesStreamPluginPortDao) GetPluginMappingPorts(serviceID string, pluginModel string) ([]*model.TenantServicesStreamPluginPort, error) {
	ret := _m.ctrl.Call(_m, "GetPluginMappingPorts", serviceID, pluginModel)
	ret0, _ := ret[0].([]*model.TenantServicesStreamPluginPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicesStreamPluginPortDaoRecorder) GetPluginMappingPorts(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPluginMappingPorts", arg0, arg1)
}

func (_m *MockTenantServicesStreamPluginPortDao) SetPluginMappingPort(tenantID string, serviceID string, pluginModel string, containerPort int) (int, error) {
	ret := _m.ctrl.Call(_m, "SetPluginMappingPort", tenantID, serviceID, pluginModel, containerPort)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicesStreamPluginPortDaoRecorder) SetPluginMappingPort(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetPluginMappingPort", arg0, arg1, arg2, arg3)
}

func (_m *MockTenantServicesStreamPluginPortDao) DeletePluginMappingPortByContainerPort(serviceID string, pluginModel string, containerPort int) error {
	ret := _m.ctrl.Call(_m, "DeletePluginMappingPortByContainerPort", serviceID, pluginModel, containerPort)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesStreamPluginPortDaoRecorder) DeletePluginMappingPortByContainerPort(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeletePluginMappingPortByContainerPort", arg0, arg1, arg2)
}

func (_m *MockTenantServicesStreamPluginPortDao) DeleteAllPluginMappingPortByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteAllPluginMappingPortByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesStreamPluginPortDaoRecorder) DeleteAllPluginMappingPortByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteAllPluginMappingPortByServiceID", arg0)
}

func (_m *MockTenantServicesStreamPluginPortDao) GetPluginMappingPortByServiceIDAndContainerPort(serviceID string, pluginModel string, containerPort int) (*model.TenantServicesStreamPluginPort, error) {
	ret := _m.ctrl.Call(_m, "GetPluginMappingPortByServiceIDAndContainerPort", serviceID, pluginModel, containerPort)
	ret0, _ := ret[0].(*model.TenantServicesStreamPluginPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicesStreamPluginPortDaoRecorder) GetPluginMappingPortByServiceIDAndContainerPort(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPluginMappingPortByServiceIDAndContainerPort", arg0, arg1, arg2)
}

// Mock of TenantServiceEnvVarDao interface
type MockTenantServiceEnvVarDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceEnvVarDaoRecorder
}

// Recorder for MockTenantServiceEnvVarDao (not exported)
type _MockTenantServiceEnvVarDaoRecorder struct {
	mock *MockTenantServiceEnvVarDao
}

func NewMockTenantServiceEnvVarDao(ctrl *gomock.Controller) *MockTenantServiceEnvVarDao {
	mock := &MockTenantServiceEnvVarDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceEnvVarDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceEnvVarDao) EXPECT() *_MockTenantServiceEnvVarDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceEnvVarDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceEnvVarDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceEnvVarDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceEnvVarDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceEnvVarDao) DeleteModel(serviceID string, arg ...interface{}) error {
	_s := []interface{}{serviceID}
	for _, _x := range arg {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteModel", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceEnvVarDaoRecorder) DeleteModel(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0}, arg1...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModel", _s...)
}

func (_m *MockTenantServiceEnvVarDao) GetDependServiceEnvs(serviceIDs []string, scopes []string) ([]*model.TenantServiceEnvVar, error) {
	ret := _m.ctrl.Call(_m, "GetDependServiceEnvs", serviceIDs, scopes)
	ret0, _ := ret[0].([]*model.TenantServiceEnvVar)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceEnvVarDaoRecorder) GetDependServiceEnvs(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDependServiceEnvs", arg0, arg1)
}

func (_m *MockTenantServiceEnvVarDao) GetServiceEnvs(serviceID string, scopes []string) ([]*model.TenantServiceEnvVar, error) {
	ret := _m.ctrl.Call(_m, "GetServiceEnvs", serviceID, scopes)
	ret0, _ := ret[0].([]*model.TenantServiceEnvVar)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceEnvVarDaoRecorder) GetServiceEnvs(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceEnvs", arg0, arg1)
}

func (_m *MockTenantServiceEnvVarDao) GetEnv(serviceID string, envName string) (*model.TenantServiceEnvVar, error) {
	ret := _m.ctrl.Call(_m, "GetEnv", serviceID, envName)
	ret0, _ := ret[0].(*model.TenantServiceEnvVar)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceEnvVarDaoRecorder) GetEnv(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetEnv", arg0, arg1)
}

func (_m *MockTenantServiceEnvVarDao) DELServiceEnvsByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DELServiceEnvsByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceEnvVarDaoRecorder) DELServiceEnvsByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELServiceEnvsByServiceID", arg0)
}

// Mock of TenantServiceMountRelationDao interface
type MockTenantServiceMountRelationDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceMountRelationDaoRecorder
}

// Recorder for MockTenantServiceMountRelationDao (not exported)
type _MockTenantServiceMountRelationDaoRecorder struct {
	mock *MockTenantServiceMountRelationDao
}

func NewMockTenantServiceMountRelationDao(ctrl *gomock.Controller) *MockTenantServiceMountRelationDao {
	mock := &MockTenantServiceMountRelationDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceMountRelationDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceMountRelationDao) EXPECT() *_MockTenantServiceMountRelationDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceMountRelationDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceMountRelationDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceMountRelationDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceMountRelationDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceMountRelationDao) GetTenantServiceMountRelationsByService(serviceID string) ([]*model.TenantServiceMountRelation, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceMountRelationsByService", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceMountRelation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceMountRelationDaoRecorder) GetTenantServiceMountRelationsByService(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceMountRelationsByService", arg0)
}

func (_m *MockTenantServiceMountRelationDao) DElTenantServiceMountRelationByServiceAndName(serviceID string, mntDir string) error {
	ret := _m.ctrl.Call(_m, "DElTenantServiceMountRelationByServiceAndName", serviceID, mntDir)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceMountRelationDaoRecorder) DElTenantServiceMountRelationByServiceAndName(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DElTenantServiceMountRelationByServiceAndName", arg0, arg1)
}

func (_m *MockTenantServiceMountRelationDao) DELTenantServiceMountRelationByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DELTenantServiceMountRelationByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceMountRelationDaoRecorder) DELTenantServiceMountRelationByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELTenantServiceMountRelationByServiceID", arg0)
}

func (_m *MockTenantServiceMountRelationDao) DElTenantServiceMountRelationByDepService(serviceID string, depServiceID string) error {
	ret := _m.ctrl.Call(_m, "DElTenantServiceMountRelationByDepService", serviceID, depServiceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceMountRelationDaoRecorder) DElTenantServiceMountRelationByDepService(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DElTenantServiceMountRelationByDepService", arg0, arg1)
}

// Mock of TenantServiceVolumeDao interface
type MockTenantServiceVolumeDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceVolumeDaoRecorder
}

// Recorder for MockTenantServiceVolumeDao (not exported)
type _MockTenantServiceVolumeDaoRecorder struct {
	mock *MockTenantServiceVolumeDao
}

func NewMockTenantServiceVolumeDao(ctrl *gomock.Controller) *MockTenantServiceVolumeDao {
	mock := &MockTenantServiceVolumeDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceVolumeDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceVolumeDao) EXPECT() *_MockTenantServiceVolumeDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceVolumeDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceVolumeDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceVolumeDao) DeleteModel(serviceID string, arg ...interface{}) error {
	_s := []interface{}{serviceID}
	for _, _x := range arg {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteModel", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) DeleteModel(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0}, arg1...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModel", _s...)
}

func (_m *MockTenantServiceVolumeDao) GetTenantServiceVolumesByServiceID(serviceID string) ([]*model.TenantServiceVolume, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceVolumesByServiceID", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceVolume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) GetTenantServiceVolumesByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceVolumesByServiceID", arg0)
}

func (_m *MockTenantServiceVolumeDao) DeleteTenantServiceVolumesByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteTenantServiceVolumesByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) DeleteTenantServiceVolumesByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteTenantServiceVolumesByServiceID", arg0)
}

func (_m *MockTenantServiceVolumeDao) DeleteByServiceIDAndVolumePath(serviceID string, volumePath string) error {
	ret := _m.ctrl.Call(_m, "DeleteByServiceIDAndVolumePath", serviceID, volumePath)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) DeleteByServiceIDAndVolumePath(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteByServiceIDAndVolumePath", arg0, arg1)
}

func (_m *MockTenantServiceVolumeDao) GetVolumeByServiceIDAndName(serviceID string, name string) (*model.TenantServiceVolume, error) {
	ret := _m.ctrl.Call(_m, "GetVolumeByServiceIDAndName", serviceID, name)
	ret0, _ := ret[0].(*model.TenantServiceVolume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) GetVolumeByServiceIDAndName(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetVolumeByServiceIDAndName", arg0, arg1)
}

func (_m *MockTenantServiceVolumeDao) GetAllVolumes() ([]*model.TenantServiceVolume, error) {
	ret := _m.ctrl.Call(_m, "GetAllVolumes")
	ret0, _ := ret[0].([]*model.TenantServiceVolume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) GetAllVolumes() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAllVolumes")
}

// Mock of TenantServiceLBMappingPortDao interface
type MockTenantServiceLBMappingPortDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceLBMappingPortDaoRecorder
}

// Recorder for MockTenantServiceLBMappingPortDao (not exported)
type _MockTenantServiceLBMappingPortDaoRecorder struct {
	mock *MockTenantServiceLBMappingPortDao
}

func NewMockTenantServiceLBMappingPortDao(ctrl *gomock.Controller) *MockTenantServiceLBMappingPortDao {
	mock := &MockTenantServiceLBMappingPortDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceLBMappingPortDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceLBMappingPortDao) EXPECT() *_MockTenantServiceLBMappingPortDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceLBMappingPortDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceLBMappingPortDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceLBMappingPortDao) GetTenantServiceLBMappingPort(serviceID string, containerPort int) (*model.TenantServiceLBMappingPort, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceLBMappingPort", serviceID, containerPort)
	ret0, _ := ret[0].(*model.TenantServiceLBMappingPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) GetTenantServiceLBMappingPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceLBMappingPort", arg0, arg1)
}

func (_m *MockTenantServiceLBMappingPortDao) GetTenantServiceLBMappingPortByService(serviceID string) ([]*model.TenantServiceLBMappingPort, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceLBMappingPortByService", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceLBMappingPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) GetTenantServiceLBMappingPortByService(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceLBMappingPortByService", arg0)
}

func (_m *MockTenantServiceLBMappingPortDao) GetLBPortsASC() ([]*model.TenantServiceLBMappingPort, error) {
	ret := _m.ctrl.Call(_m, "GetLBPortsASC")
	ret0, _ := ret[0].([]*model.TenantServiceLBMappingPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) GetLBPortsASC() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetLBPortsASC")
}

func (_m *MockTenantServiceLBMappingPortDao) CreateTenantServiceLBMappingPort(serviceID string, containerPort int) (*model.TenantServiceLBMappingPort, error) {
	ret := _m.ctrl.Call(_m, "CreateTenantServiceLBMappingPort", serviceID, containerPort)
	ret0, _ := ret[0].(*model.TenantServiceLBMappingPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) CreateTenantServiceLBMappingPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateTenantServiceLBMappingPort", arg0, arg1)
}

func (_m *MockTenantServiceLBMappingPortDao) DELServiceLBMappingPortByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DELServiceLBMappingPortByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) DELServiceLBMappingPortByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELServiceLBMappingPortByServiceID", arg0)
}

func (_m *MockTenantServiceLBMappingPortDao) DELServiceLBMappingPortByServiceIDAndPort(serviceID string, lbPort int) error {
	ret := _m.ctrl.Call(_m, "DELServiceLBMappingPortByServiceIDAndPort", serviceID, lbPort)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) DELServiceLBMappingPortByServiceIDAndPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELServiceLBMappingPortByServiceIDAndPort", arg0, arg1)
}

func (_m *MockTenantServiceLBMappingPortDao) GetLBPortByTenantAndPort(tenantID string, lbport int) (*model.TenantServiceLBMappingPort, error) {
	ret := _m.ctrl.Call(_m, "GetLBPortByTenantAndPort", tenantID, lbport)
	ret0, _ := ret[0].(*model.TenantServiceLBMappingPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) GetLBPortByTenantAndPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetLBPortByTenantAndPort", arg0, arg1)
}

// Mock of TenantServiceLabelDao interface
type MockTenantServiceLabelDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceLabelDaoRecorder
}

// Recorder for MockTenantServiceLabelDao (not exported)
type _MockTenantServiceLabelDaoRecorder struct {
	mock *MockTenantServiceLabelDao
}

func NewMockTenantServiceLabelDao(ctrl *gomock.Controller) *MockTenantServiceLabelDao {
	mock := &MockTenantServiceLabelDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceLabelDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceLabelDao) EXPECT() *_MockTenantServiceLabelDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceLabelDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLabelDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceLabelDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLabelDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceLabelDao) DeleteModel(serviceID string, arg ...interface{}) error {
	_s := []interface{}{serviceID}
	for _, _x := range arg {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteModel", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLabelDaoRecorder) DeleteModel(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0}, arg1...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModel", _s...)
}

func (_m *MockTenantServiceLabelDao) GetTenantServiceLabel(serviceID string) ([]*model.TenantServiceLable, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceLabel", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceLable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLabelDaoRecorder) GetTenantServiceLabel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceLabel", arg0)
}

func (_m *MockTenantServiceLabelDao) DeleteLabelByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteLabelByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLabelDaoRecorder) DeleteLabelByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteLabelByServiceID", arg0)
}

func (_m *MockTenantServiceLabelDao) GetTenantServiceNodeSelectorLabel(serviceID string) ([]*model.TenantServiceLable, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceNodeSelectorLabel", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceLable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLabelDaoRecorder) GetTenantServiceNodeSelectorLabel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceNodeSelectorLabel", arg0)
}

func (_m *MockTenantServiceLabelDao) GetTenantServiceAffinityLabel(serviceID string) ([]*model.TenantServiceLable, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceAffinityLabel", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceLable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLabelDaoRecorder) GetTenantServiceAffinityLabel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceAffinityLabel", arg0)
}

func (_m *MockTenantServiceLabelDao) GetTenantServiceTypeLabel(serviceID string) (*model.TenantServiceLable, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceTypeLabel", serviceID)
	ret0, _ := ret[0].(*model.TenantServiceLable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLabelDaoRecorder) GetTenantServiceTypeLabel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceTypeLabel", arg0)
}

func (_m *MockTenantServiceLabelDao) DELTenantServiceLabelsByLabelvaluesAndServiceID(serviceID string, labelValues []string) error {
	ret := _m.ctrl.Call(_m, "DELTenantServiceLabelsByLabelvaluesAndServiceID", serviceID, labelValues)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLabelDaoRecorder) DELTenantServiceLabelsByLabelvaluesAndServiceID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELTenantServiceLabelsByLabelvaluesAndServiceID", arg0, arg1)
}

// Mock of LocalSchedulerDao interface
type MockLocalSchedulerDao struct {
	ctrl     *gomock.Controller
	recorder *_MockLocalSchedulerDaoRecorder
}

// Recorder for MockLocalSchedulerDao (not exported)
type _MockLocalSchedulerDaoRecorder struct {
	mock *MockLocalSchedulerDao
}

func NewMockLocalSchedulerDao(ctrl *gomock.Controller) *MockLocalSchedulerDao {
	mock := &MockLocalSchedulerDao{ctrl: ctrl}
	mock.recorder = &_MockLocalSchedulerDaoRecorder{mock}
	return mock
}

func (_m *MockLocalSchedulerDao) EXPECT() *_MockLocalSchedulerDaoRecorder {
	return _m.recorder
}

func (_m *MockLocalSchedulerDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockLocalSchedulerDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockLocalSchedulerDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockLocalSchedulerDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockLocalSchedulerDao) GetLocalScheduler(serviceID string) ([]*model.LocalScheduler, error) {
	ret := _m.ctrl.Call(_m, "GetLocalScheduler", serviceID)
	ret0, _ := ret[0].([]*model.LocalScheduler)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockLocalSchedulerDaoRecorder) GetLocalScheduler(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetLocalScheduler", arg0)
}

// Mock of ServiceProbeDao interface
type MockServiceProbeDao struct {
	ctrl     *gomock.Controller
	recorder *_MockServiceProbeDaoRecorder
}

// Recorder for MockServiceProbeDao (not exported)
type _MockServiceProbeDaoRecorder struct {
	mock *MockServiceProbeDao
}

func NewMockServiceProbeDao(ctrl *gomock.Controller) *MockServiceProbeDao {
	mock := &MockServiceProbeDao{ctrl: ctrl}
	mock.recorder = &_MockServiceProbeDaoRecorder{mock}
	return mock
}

func (_m *MockServiceProbeDao) EXPECT() *_MockServiceProbeDaoRecorder {
	return _m.recorder
}

func (_m *MockServiceProbeDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockServiceProbeDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockServiceProbeDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockServiceProbeDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockServiceProbeDao) DeleteModel(serviceID string, arg ...interface{}) error {
	_s := []interface{}{serviceID}
	for _, _x := range arg {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteModel", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockServiceProbeDaoRecorder) DeleteModel(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0}, arg1...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModel", _s...)
}

func (_m *MockServiceProbeDao) GetServiceProbes(serviceID string) ([]*model.TenantServiceProbe, error) {
	ret := _m.ctrl.Call(_m, "GetServiceProbes", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceProbe)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockServiceProbeDaoRecorder) GetServiceProbes(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceProbes", arg0)
}

func (_m *MockServiceProbeDao) GetServiceUsedProbe(serviceID string, mode string) (*model.TenantServiceProbe, error) {
	ret := _m.ctrl.Call(_m, "GetServiceUsedProbe", serviceID, mode)
	ret0, _ := ret[0].(*model.TenantServiceProbe)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockServiceProbeDaoRecorder) GetServiceUsedProbe(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceUsedProbe", arg0, arg1)
}

func (_m *MockServiceProbeDao) DELServiceProbesByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DELServiceProbesByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockServiceProbeDaoRecorder) DELServiceProbesByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELServiceProbesByServiceID", arg0)
}

// Mock of CodeCheckResultDao interface
type MockCodeCheckResultDao struct {
	ctrl     *gomock.Controller
	recorder *_MockCodeCheckResultDaoRecorder
}

// Recorder for MockCodeCheckResultDao (not exported)
type _MockCodeCheckResultDaoRecorder struct {
	mock *MockCodeCheckResultDao
}

func NewMockCodeCheckResultDao(ctrl *gomock.Controller) *MockCodeCheckResultDao {
	mock := &MockCodeCheckResultDao{ctrl: ctrl}
	mock.recorder = &_MockCodeCheckResultDaoRecorder{mock}
	return mock
}

func (_m *MockCodeCheckResultDao) EXPECT() *_MockCodeCheckResultDaoRecorder {
	return _m.recorder
}

func (_m *MockCodeCheckResultDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockCodeCheckResultDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockCodeCheckResultDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockCodeCheckResultDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockCodeCheckResultDao) GetCodeCheckResult(serviceID string) (*model.CodeCheckResult, error) {
	ret := _m.ctrl.Call(_m, "GetCodeCheckResult", serviceID)
	ret0, _ := ret[0].(*model.CodeCheckResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockCodeCheckResultDaoRecorder) GetCodeCheckResult(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetCodeCheckResult", arg0)
}

// Mock of EventDao interface
type MockEventDao struct {
	ctrl     *gomock.Controller
	recorder *_MockEventDaoRecorder
}

// Recorder for MockEventDao (not exported)
type _MockEventDaoRecorder struct {
	mock *MockEventDao
}

func NewMockEventDao(ctrl *gomock.Controller) *MockEventDao {
	mock := &MockEventDao{ctrl: ctrl}
	mock.recorder = &_MockEventDaoRecorder{mock}
	return mock
}

func (_m *MockEventDao) EXPECT() *_MockEventDaoRecorder {
	return _m.recorder
}

func (_m *MockEventDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockEventDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockEventDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockEventDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockEventDao) GetEventByEventID(eventID string) (*model.ServiceEvent, error) {
	ret := _m.ctrl.Call(_m, "GetEventByEventID", eventID)
	ret0, _ := ret[0].(*model.ServiceEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockEventDaoRecorder) GetEventByEventID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetEventByEventID", arg0)
}

func (_m *MockEventDao) GetEventByEventIDs(eventIDs []string) ([]*model.ServiceEvent, error) {
	ret := _m.ctrl.Call(_m, "GetEventByEventIDs", eventIDs)
	ret0, _ := ret[0].([]*model.ServiceEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockEventDaoRecorder) GetEventByEventIDs(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetEventByEventIDs", arg0)
}

func (_m *MockEventDao) GetEventByServiceID(serviceID string) ([]*model.ServiceEvent, error) {
	ret := _m.ctrl.Call(_m, "GetEventByServiceID", serviceID)
	ret0, _ := ret[0].([]*model.ServiceEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockEventDaoRecorder) GetEventByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetEventByServiceID", arg0)
}

func (_m *MockEventDao) DelEventByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DelEventByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockEventDaoRecorder) DelEventByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DelEventByServiceID", arg0)
}

// Mock of VersionInfoDao interface
type MockVersionInfoDao struct {
	ctrl     *gomock.Controller
	recorder *_MockVersionInfoDaoRecorder
}

// Recorder for MockVersionInfoDao (not exported)
type _MockVersionInfoDaoRecorder struct {
	mock *MockVersionInfoDao
}

func NewMockVersionInfoDao(ctrl *gomock.Controller) *MockVersionInfoDao {
	mock := &MockVersionInfoDao{ctrl: ctrl}
	mock.recorder = &_MockVersionInfoDaoRecorder{mock}
	return mock
}

func (_m *MockVersionInfoDao) EXPECT() *_MockVersionInfoDaoRecorder {
	return _m.recorder
}

func (_m *MockVersionInfoDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVersionInfoDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockVersionInfoDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVersionInfoDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockVersionInfoDao) GetVersionByEventID(eventID string) (*model.VersionInfo, error) {
	ret := _m.ctrl.Call(_m, "GetVersionByEventID", eventID)
	ret0, _ := ret[0].(*model.VersionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVersionInfoDaoRecorder) GetVersionByEventID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetVersionByEventID", arg0)
}

func (_m *MockVersionInfoDao) GetVersionByDeployVersion(version string, serviceID string) (*model.VersionInfo, error) {
	ret := _m.ctrl.Call(_m, "GetVersionByDeployVersion", version, serviceID)
	ret0, _ := ret[0].(*model.VersionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVersionInfoDaoRecorder) GetVersionByDeployVersion(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetVersionByDeployVersion", arg0, arg1)
}

func (_m *MockVersionInfoDao) GetVersionByServiceID(serviceID string) ([]*model.VersionInfo, error) {
	ret := _m.ctrl.Call(_m, "GetVersionByServiceID", serviceID)
	ret0, _ := ret[0].([]*model.VersionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVersionInfoDaoRecorder) GetVersionByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetVersionByServiceID", arg0)
}

func (_m *MockVersionInfoDao) DeleteVersionByEventID(eventID string) error {
	ret := _m.ctrl.Call(_m, "DeleteVersionByEventID", eventID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVersionInfoDaoRecorder) DeleteVersionByEventID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteVersionByEventID", arg0)
}

func (_m *MockVersionInfoDao) DeleteVersionByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteVersionByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVersionInfoDaoRecorder) DeleteVersionByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteVersionByServiceID", arg0)
}

func (_m *MockVersionInfoDao) GetVersionInfo(timePoint time.Time, serviceIdList []string) ([]*model.VersionInfo, error) {
	ret := _m.ctrl.Call(_m, "GetVersionInfo", timePoint, serviceIdList)
	ret0, _ := ret[0].([]*model.VersionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVersionInfoDaoRecorder) GetVersionInfo(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetVersionInfo", arg0, arg1)
}

func (_m *MockVersionInfoDao) DeleteVersionInfo(obj *model.VersionInfo) error {
	ret := _m.ctrl.Call(_m, "DeleteVersionInfo", obj)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVersionInfoDaoRecorder) DeleteVersionInfo(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteVersionInfo", arg0)
}

func (_m *MockVersionInfoDao) DeleteFailureVersionInfo(timePoint time.Time, status string, serviceIdList []string) error {
	ret := _m.ctrl.Call(_m, "DeleteFailureVersionInfo", timePoint, status, serviceIdList)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVersionInfoDaoRecorder) DeleteFailureVersionInfo(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteFailureVersionInfo", arg0, arg1, arg2)
}

func (_m *MockVersionInfoDao) SearchVersionInfo() ([]*model.VersionInfo, error) {
	ret := _m.ctrl.Call(_m, "SearchVersionInfo")
	ret0, _ := ret[0].([]*model.VersionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVersionInfoDaoRecorder) SearchVersionInfo() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SearchVersionInfo")
}

// Mock of RegionUserInfoDao interface
type MockRegionUserInfoDao struct {
	ctrl     *gomock.Controller
	recorder *_MockRegionUserInfoDaoRecorder
}

// Recorder for MockRegionUserInfoDao (not exported)
type _MockRegionUserInfoDaoRecorder struct {
	mock *MockRegionUserInfoDao
}

func NewMockRegionUserInfoDao(ctrl *gomock.Controller) *MockRegionUserInfoDao {
	mock := &MockRegionUserInfoDao{ctrl: ctrl}
	mock.recorder = &_MockRegionUserInfoDaoRecorder{mock}
	return mock
}

func (_m *MockRegionUserInfoDao) EXPECT() *_MockRegionUserInfoDaoRecorder {
	return _m.recorder
}

func (_m *MockRegionUserInfoDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRegionUserInfoDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockRegionUserInfoDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRegionUserInfoDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockRegionUserInfoDao) GetALLTokenInValidityPeriod() ([]*model.RegionUserInfo, error) {
	ret := _m.ctrl.Call(_m, "GetALLTokenInValidityPeriod")
	ret0, _ := ret[0].([]*model.RegionUserInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockRegionUserInfoDaoRecorder) GetALLTokenInValidityPeriod() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetALLTokenInValidityPeriod")
}

func (_m *MockRegionUserInfoDao) GetTokenByEid(eid string) (*model.RegionUserInfo, error) {
	ret := _m.ctrl.Call(_m, "GetTokenByEid", eid)
	ret0, _ := ret[0].(*model.RegionUserInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockRegionUserInfoDaoRecorder) GetTokenByEid(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTokenByEid", arg0)
}

func (_m *MockRegionUserInfoDao) GetTokenByTokenID(token string) (*model.RegionUserInfo, error) {
	ret := _m.ctrl.Call(_m, "GetTokenByTokenID", token)
	ret0, _ := ret[0].(*model.RegionUserInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockRegionUserInfoDaoRecorder) GetTokenByTokenID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTokenByTokenID", arg0)
}

// Mock of RegionAPIClassDao interface
type MockRegionAPIClassDao struct {
	ctrl     *gomock.Controller
	recorder *_MockRegionAPIClassDaoRecorder
}

// Recorder for MockRegionAPIClassDao (not exported)
type _MockRegionAPIClassDaoRecorder struct {
	mock *MockRegionAPIClassDao
}

func NewMockRegionAPIClassDao(ctrl *gomock.Controller) *MockRegionAPIClassDao {
	mock := &MockRegionAPIClassDao{ctrl: ctrl}
	mock.recorder = &_MockRegionAPIClassDaoRecorder{mock}
	return mock
}

func (_m *MockRegionAPIClassDao) EXPECT() *_MockRegionAPIClassDaoRecorder {
	return _m.recorder
}

func (_m *MockRegionAPIClassDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRegionAPIClassDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockRegionAPIClassDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRegionAPIClassDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockRegionAPIClassDao) GetPrefixesByClass(apiClass string) ([]*model.RegionAPIClass, error) {
	ret := _m.ctrl.Call(_m, "GetPrefixesByClass", apiClass)
	ret0, _ := ret[0].([]*model.RegionAPIClass)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockRegionAPIClassDaoRecorder) GetPrefixesByClass(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPrefixesByClass", arg0)
}

func (_m *MockRegionAPIClassDao) DeletePrefixInClass(apiClass string, prefix string) error {
	ret := _m.ctrl.Call(_m, "DeletePrefixInClass", apiClass, prefix)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRegionAPIClassDaoRecorder) DeletePrefixInClass(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeletePrefixInClass", arg0, arg1)
}

// Mock of RegionProcotolsDao interface
type MockRegionProcotolsDao struct {
	ctrl     *gomock.Controller
	recorder *_MockRegionProcotolsDaoRecorder
}

// Recorder for MockRegionProcotolsDao (not exported)
type _MockRegionProcotolsDaoRecorder struct {
	mock *MockRegionProcotolsDao
}

func NewMockRegionProcotolsDao(ctrl *gomock.Controller) *MockRegionProcotolsDao {
	mock := &MockRegionProcotolsDao{ctrl: ctrl}
	mock.recorder = &_MockRegionProcotolsDaoRecorder{mock}
	return mock
}

func (_m *MockRegionProcotolsDao) EXPECT() *_MockRegionProcotolsDaoRecorder {
	return _m.recorder
}

func (_m *MockRegionProcotolsDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRegionProcotolsDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockRegionProcotolsDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRegionProcotolsDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockRegionProcotolsDao) GetAllSupportProtocol(version string) ([]*model.RegionProcotols, error) {
	ret := _m.ctrl.Call(_m, "GetAllSupportProtocol", version)
	ret0, _ := ret[0].([]*model.RegionProcotols)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockRegionProcotolsDaoRecorder) GetAllSupportProtocol(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAllSupportProtocol", arg0)
}

func (_m *MockRegionProcotolsDao) GetProtocolGroupByProtocolChild(version string, protocolChild string) (*model.RegionProcotols, error) {
	ret := _m.ctrl.Call(_m, "GetProtocolGroupByProtocolChild", version, protocolChild)
	ret0, _ := ret[0].(*model.RegionProcotols)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockRegionProcotolsDaoRecorder) GetProtocolGroupByProtocolChild(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetProtocolGroupByProtocolChild", arg0, arg1)
}

// Mock of NotificationEventDao interface
type MockNotificationEventDao struct {
	ctrl     *gomock.Controller
	recorder *_MockNotificationEventDaoRecorder
}

// Recorder for MockNotificationEventDao (not exported)
type _MockNotificationEventDaoRecorder struct {
	mock *MockNotificationEventDao
}

func NewMockNotificationEventDao(ctrl *gomock.Controller) *MockNotificationEventDao {
	mock := &MockNotificationEventDao{ctrl: ctrl}
	mock.recorder = &_MockNotificationEventDaoRecorder{mock}
	return mock
}

func (_m *MockNotificationEventDao) EXPECT() *_MockNotificationEventDaoRecorder {
	return _m.recorder
}

func (_m *MockNotificationEventDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockNotificationEventDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockNotificationEventDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockNotificationEventDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockNotificationEventDao) GetNotificationEventByHash(hash string) (*model.NotificationEvent, error) {
	ret := _m.ctrl.Call(_m, "GetNotificationEventByHash", hash)
	ret0, _ := ret[0].(*model.NotificationEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockNotificationEventDaoRecorder) GetNotificationEventByHash(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetNotificationEventByHash", arg0)
}

func (_m *MockNotificationEventDao) GetNotificationEventByKind(kind string, kindID string) ([]*model.NotificationEvent, error) {
	ret := _m.ctrl.Call(_m, "GetNotificationEventByKind", kind, kindID)
	ret0, _ := ret[0].([]*model.NotificationEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockNotificationEventDaoRecorder) GetNotificationEventByKind(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetNotificationEventByKind", arg0, arg1)
}

func (_m *MockNotificationEventDao) GetNotificationEventByTime(start time.Time, end time.Time) ([]*model.NotificationEvent, error) {
	ret := _m.ctrl.Call(_m, "GetNotificationEventByTime", start, end)
	ret0, _ := ret[0].([]*model.NotificationEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockNotificationEventDaoRecorder) GetNotificationEventByTime(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetNotificationEventByTime", arg0, arg1)
}

func (_m *MockNotificationEventDao) GetNotificationEventNotHandle() ([]*model.NotificationEvent, error) {
	ret := _m.ctrl.Call(_m, "GetNotificationEventNotHandle")
	ret0, _ := ret[0].([]*model.NotificationEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockNotificationEventDaoRecorder) GetNotificationEventNotHandle() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetNotificationEventNotHandle")
}

// Mock of AppBackupDao interface
type MockAppBackupDao struct {
	ctrl     *gomock.Controller
	recorder *_MockAppBackupDaoRecorder
}

// Recorder for MockAppBackupDao (not exported)
type _MockAppBackupDaoRecorder struct {
	mock *MockAppBackupDao
}

func NewMockAppBackupDao(ctrl *gomock.Controller) *MockAppBackupDao {
	mock := &MockAppBackupDao{ctrl: ctrl}
	mock.recorder = &_MockAppBackupDaoRecorder{mock}
	return mock
}

func (_m *MockAppBackupDao) EXPECT() *_MockAppBackupDaoRecorder {
	return _m.recorder
}

func (_m *MockAppBackupDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockAppBackupDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockAppBackupDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockAppBackupDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockAppBackupDao) CheckHistory(groupID string, version string) bool {
	ret := _m.ctrl.Call(_m, "CheckHistory", groupID, version)
	ret0, _ := ret[0].(bool)
	return ret0
}

func (_mr *_MockAppBackupDaoRecorder) CheckHistory(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CheckHistory", arg0, arg1)
}

func (_m *MockAppBackupDao) GetAppBackups(groupID string) ([]*model.AppBackup, error) {
	ret := _m.ctrl.Call(_m, "GetAppBackups", groupID)
	ret0, _ := ret[0].([]*model.AppBackup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockAppBackupDaoRecorder) GetAppBackups(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAppBackups", arg0)
}

func (_m *MockAppBackupDao) DeleteAppBackup(backupID string) error {
	ret := _m.ctrl.Call(_m, "DeleteAppBackup", backupID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockAppBackupDaoRecorder) DeleteAppBackup(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteAppBackup", arg0)
}

func (_m *MockAppBackupDao) GetAppBackup(backupID string) (*model.AppBackup, error) {
	ret := _m.ctrl.Call(_m, "GetAppBackup", backupID)
	ret0, _ := ret[0].(*model.AppBackup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockAppBackupDaoRecorder) GetAppBackup(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAppBackup", arg0)
}

func (_m *MockAppBackupDao) GetDeleteAppBackup(backupID string) (*model.AppBackup, error) {
	ret := _m.ctrl.Call(_m, "GetDeleteAppBackup", backupID)
	ret0, _ := ret[0].(*model.AppBackup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockAppBackupDaoRecorder) GetDeleteAppBackup(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDeleteAppBackup", arg0)
}

func (_m *MockAppBackupDao) GetDeleteAppBackups() ([]*model.AppBackup, error) {
	ret := _m.ctrl.Call(_m, "GetDeleteAppBackups")
	ret0, _ := ret[0].([]*model.AppBackup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockAppBackupDaoRecorder) GetDeleteAppBackups() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDeleteAppBackups")
}

// Mock of ServiceSourceDao interface
type MockServiceSourceDao struct {
	ctrl     *gomock.Controller
	recorder *_MockServiceSourceDaoRecorder
}

// Recorder for MockServiceSourceDao (not exported)
type _MockServiceSourceDaoRecorder struct {
	mock *MockServiceSourceDao
}

func NewMockServiceSourceDao(ctrl *gomock.Controller) *MockServiceSourceDao {
	mock := &MockServiceSourceDao{ctrl: ctrl}
	mock.recorder = &_MockServiceSourceDaoRecorder{mock}
	return mock
}

func (_m *MockServiceSourceDao) EXPECT() *_MockServiceSourceDaoRecorder {
	return _m.recorder
}

func (_m *MockServiceSourceDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockServiceSourceDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockServiceSourceDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockServiceSourceDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockServiceSourceDao) GetServiceSource(serviceID string) ([]*model.ServiceSourceConfig, error) {
	ret := _m.ctrl.Call(_m, "GetServiceSource", serviceID)
	ret0, _ := ret[0].([]*model.ServiceSourceConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockServiceSourceDaoRecorder) GetServiceSource(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceSource", arg0)
}

// Mock of CertificateDao interface
type MockCertificateDao struct {
	ctrl     *gomock.Controller
	recorder *_MockCertificateDaoRecorder
}

// Recorder for MockCertificateDao (not exported)
type _MockCertificateDaoRecorder struct {
	mock *MockCertificateDao
}

func NewMockCertificateDao(ctrl *gomock.Controller) *MockCertificateDao {
	mock := &MockCertificateDao{ctrl: ctrl}
	mock.recorder = &_MockCertificateDaoRecorder{mock}
	return mock
}

func (_m *MockCertificateDao) EXPECT() *_MockCertificateDaoRecorder {
	return _m.recorder
}

func (_m *MockCertificateDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockCertificateDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockCertificateDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockCertificateDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockCertificateDao) GetCertificateByID(certificateID string) (*model.Certificate, error) {
	ret := _m.ctrl.Call(_m, "GetCertificateByID", certificateID)
	ret0, _ := ret[0].(*model.Certificate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockCertificateDaoRecorder) GetCertificateByID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetCertificateByID", arg0)
}

func (_m *MockCertificateDao) DeleteCertificateByID(certificateID string) error {
	ret := _m.ctrl.Call(_m, "DeleteCertificateByID", certificateID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockCertificateDaoRecorder) DeleteCertificateByID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteCertificateByID", arg0)
}

// Mock of RuleExtensionDao interface
type MockRuleExtensionDao struct {
	ctrl     *gomock.Controller
	recorder *_MockRuleExtensionDaoRecorder
}

// Recorder for MockRuleExtensionDao (not exported)
type _MockRuleExtensionDaoRecorder struct {
	mock *MockRuleExtensionDao
}

func NewMockRuleExtensionDao(ctrl *gomock.Controller) *MockRuleExtensionDao {
	mock := &MockRuleExtensionDao{ctrl: ctrl}
	mock.recorder = &_MockRuleExtensionDaoRecorder{mock}
	return mock
}

func (_m *MockRuleExtensionDao) EXPECT() *_MockRuleExtensionDaoRecorder {
	return _m.recorder
}

func (_m *MockRuleExtensionDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRuleExtensionDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockRuleExtensionDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRuleExtensionDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockRuleExtensionDao) GetRuleExtensionByRuleID(ruleID string) ([]*model.RuleExtension, error) {
	ret := _m.ctrl.Call(_m, "GetRuleExtensionByRuleID", ruleID)
	ret0, _ := ret[0].([]*model.RuleExtension)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockRuleExtensionDaoRecorder) GetRuleExtensionByRuleID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetRuleExtensionByRuleID", arg0)
}

func (_m *MockRuleExtensionDao) DeleteRuleExtensionByRuleID(ruleID string) error {
	ret := _m.ctrl.Call(_m, "DeleteRuleExtensionByRuleID", ruleID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRuleExtensionDaoRecorder) DeleteRuleExtensionByRuleID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteRuleExtensionByRuleID", arg0)
}

// Mock of HTTPRuleDao interface
type MockHttpRuleDao struct {
	ctrl     *gomock.Controller
	recorder *_MockHttpRuleDaoRecorder
}

// Recorder for MockHttpRuleDao (not exported)
type _MockHttpRuleDaoRecorder struct {
	mock *MockHttpRuleDao
}

func NewMockHttpRuleDao(ctrl *gomock.Controller) *MockHttpRuleDao {
	mock := &MockHttpRuleDao{ctrl: ctrl}
	mock.recorder = &_MockHttpRuleDaoRecorder{mock}
	return mock
}

func (_m *MockHttpRuleDao) EXPECT() *_MockHttpRuleDaoRecorder {
	return _m.recorder
}

func (_m *MockHttpRuleDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockHttpRuleDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockHttpRuleDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockHttpRuleDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockHttpRuleDao) GetHttpRuleByID(id string) (*model.HTTPRule, error) {
	ret := _m.ctrl.Call(_m, "GetHttpRuleByID", id)
	ret0, _ := ret[0].(*model.HTTPRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockHttpRuleDaoRecorder) GetHttpRuleByID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetHttpRuleByID", arg0)
}

func (_m *MockHttpRuleDao) GetHttpRuleByServiceIDAndContainerPort(serviceID string, containerPort int) (*model.HTTPRule, error) {
	ret := _m.ctrl.Call(_m, "GetHttpRuleByServiceIDAndContainerPort", serviceID, containerPort)
	ret0, _ := ret[0].(*model.HTTPRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockHttpRuleDaoRecorder) GetHttpRuleByServiceIDAndContainerPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetHttpRuleByServiceIDAndContainerPort", arg0, arg1)
}

func (_m *MockHttpRuleDao) DeleteHttpRuleByServiceIDAndContainerPort(serviceID string, containerPort int) (*model.HTTPRule, error) {
	ret := _m.ctrl.Call(_m, "DeleteHttpRuleByServiceIDAndContainerPort", serviceID, containerPort)
	ret0, _ := ret[0].(*model.HTTPRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockHttpRuleDaoRecorder) DeleteHttpRuleByServiceIDAndContainerPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteHttpRuleByServiceIDAndContainerPort", arg0, arg1)
}

func (_m *MockHttpRuleDao) DeleteHttpRuleByID(id string) error {
	ret := _m.ctrl.Call(_m, "DeleteHttpRuleByID", id)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockHttpRuleDaoRecorder) DeleteHttpRuleByID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteHttpRuleByID", arg0)
}

// Mock of TCPRuleDao interface
type MockTcpRuleDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTcpRuleDaoRecorder
}

// Recorder for MockTcpRuleDao (not exported)
type _MockTcpRuleDaoRecorder struct {
	mock *MockTcpRuleDao
}

func NewMockTcpRuleDao(ctrl *gomock.Controller) *MockTcpRuleDao {
	mock := &MockTcpRuleDao{ctrl: ctrl}
	mock.recorder = &_MockTcpRuleDaoRecorder{mock}
	return mock
}

func (_m *MockTcpRuleDao) EXPECT() *_MockTcpRuleDaoRecorder {
	return _m.recorder
}

func (_m *MockTcpRuleDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTcpRuleDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTcpRuleDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTcpRuleDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTcpRuleDao) GetTcpRuleByServiceIDAndContainerPort(serviceID string, containerPort int) (*model.TCPRule, error) {
	ret := _m.ctrl.Call(_m, "GetTcpRuleByServiceIDAndContainerPort", serviceID, containerPort)
	ret0, _ := ret[0].(*model.TCPRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTcpRuleDaoRecorder) GetTcpRuleByServiceIDAndContainerPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTcpRuleByServiceIDAndContainerPort", arg0, arg1)
}

func (_m *MockTcpRuleDao) GetTcpRuleByID(id string) (*model.TCPRule, error) {
	ret := _m.ctrl.Call(_m, "GetTcpRuleByID", id)
	ret0, _ := ret[0].(*model.TCPRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTcpRuleDaoRecorder) GetTcpRuleByID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTcpRuleByID", arg0)
}

func (_m *MockTcpRuleDao) DeleteTcpRule(tcpRule *model.TCPRule) error {
	ret := _m.ctrl.Call(_m, "DeleteTcpRule", tcpRule)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTcpRuleDaoRecorder) DeleteTcpRule(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteTcpRule", arg0)
}